From 0162b4600fe35de87cbe397d3a3babfc92fc86d0 Mon Sep 17 00:00:00 2001
From: Romain Beauxis <toots@rastageeks.org>
Date: Wed, 26 Jun 2024 08:27:51 +0200
Subject: [PATCH] Add 2.2.5 doc.

---
 website/Makefile                              |     4 +-
 website/content/doc-2.2.5/beets.md            |   179 +
 website/content/doc-2.2.5/blank.md            |    50 +
 website/content/doc-2.2.5/book.md             |    11 +
 website/content/doc-2.2.5/build.md            |   112 +
 website/content/doc-2.2.5/clocks.md           |   312 +
 website/content/doc-2.2.5/complete_case.md    |    81 +
 website/content/doc-2.2.5/cookbook.md         |   518 +
 website/content/doc-2.2.5/crossfade.md        |    98 +
 website/content/doc-2.2.5/custom-path.md      |    77 +
 website/content/doc-2.2.5/documentation.md    |    88 +
 website/content/doc-2.2.5/dynamic_sources.md  |    72 +
 website/content/doc-2.2.5/encoding_formats.md |   278 +
 .../content/doc-2.2.5/external_decoders.md    |   215 +
 .../content/doc-2.2.5/external_encoders.md    |    60 +
 website/content/doc-2.2.5/external_streams.md |    49 +
 website/content/doc-2.2.5/faq.md              |   224 +
 website/content/doc-2.2.5/ffmpeg.md           |   324 +
 website/content/doc-2.2.5/ffmpeg_cookbook.md  |   211 +
 website/content/doc-2.2.5/ffmpeg_encoder.md   |   175 +
 website/content/doc-2.2.5/ffmpeg_filters.md   |   251 +
 website/content/doc-2.2.5/flows_devel.md      |    39 +
 website/content/doc-2.2.5/frequence3.md       |    13 +
 website/content/doc-2.2.5/geekradio.md        |    43 +
 .../content/doc-2.2.5/gstreamer_encoder.md    |   154 +
 website/content/doc-2.2.5/harbor.md           |   126 +
 website/content/doc-2.2.5/harbor_http.md      |   263 +
 website/content/doc-2.2.5/help.md             |   134 +
 website/content/doc-2.2.5/hls_output.md       |   156 +
 website/content/doc-2.2.5/http_input.md       |    17 +
 website/content/doc-2.2.5/icy_metadata.md     |    75 +
 .../doc-2.2.5/images/basic-radio-graph.png    |   Bin 0 -> 14953 bytes
 .../doc-2.2.5/images/design/background.png    |   Bin 0 -> 777 bytes
 .../images/design/background_page.png         |   Bin 0 -> 316 bytes
 .../content/doc-2.2.5/images/design/logo.png  |   Bin 0 -> 9081 bytes
 website/content/doc-2.2.5/images/grab.png     |   Bin 0 -> 821 bytes
 .../content/doc-2.2.5/images/graph_clocks.png |   Bin 0 -> 16474 bytes
 website/content/doc-2.2.5/images/liqgraph.png |   Bin 0 -> 16746 bytes
 .../images/schema-webradio-inkscape.png       |   Bin 0 -> 38585 bytes
 website/content/doc-2.2.5/images/stream.png   |   Bin 0 -> 10336 bytes
 .../content/doc-2.2.5/images/tabs/tab_API.png |   Bin 0 -> 1014 bytes
 .../doc-2.2.5/images/tabs/tab_about.png       |   Bin 0 -> 1363 bytes
 .../doc-2.2.5/images/tabs/tab_developers.png  |   Bin 0 -> 1975 bytes
 .../doc-2.2.5/images/tabs/tab_docs.png        |   Bin 0 -> 1159 bytes
 .../doc-2.2.5/images/tabs/tab_snippets.png    |   Bin 0 -> 1611 bytes
 website/content/doc-2.2.5/in_production.md    |    25 +
 website/content/doc-2.2.5/index.md            |    61 +
 website/content/doc-2.2.5/install.md          |   113 +
 website/content/doc-2.2.5/json.md             |   333 +
 website/content/doc-2.2.5/ladspa.md           |    42 +
 website/content/doc-2.2.5/language.md         |  1377 +
 website/content/doc-2.2.5/memory.md           |   135 +
 website/content/doc-2.2.5/metadata.md         |   118 +
 website/content/doc-2.2.5/migrating.md        |   487 +
 website/content/doc-2.2.5/multitrack.md       |   357 +
 website/content/doc-2.2.5/on2.md              |    28 +
 website/content/doc-2.2.5/on2_part1.md        |   301 +
 website/content/doc-2.2.5/on2_part2.md        |   849 +
 website/content/doc-2.2.5/on2_part3.md        |   321 +
 website/content/doc-2.2.5/phases.md           |    23 +
 website/content/doc-2.2.5/playlist_parsers.md |    50 +
 website/content/doc-2.2.5/presentations.md    |    30 +
 website/content/doc-2.2.5/profiling.md        |    33 +
 website/content/doc-2.2.5/prometheus.md       |   146 +
 .../doc-2.2.5/protocols-presentation.md       |    59 +
 website/content/doc-2.2.5/protocols.md        |   120 +
 website/content/doc-2.2.5/publications.md     |    28 +
 website/content/doc-2.2.5/quick_start.md      |   240 +
 website/content/doc-2.2.5/radiopi.md          |   342 +
 .../content/doc-2.2.5/reference-deprecated.md |  2364 ++
 website/content/doc-2.2.5/reference-extras.md | 32869 ++++++++++++++++
 website/content/doc-2.2.5/reference-header.md |    15 +
 website/content/doc-2.2.5/reference.md        | 21668 ++++++++++
 website/content/doc-2.2.5/release-assets.md   |     9 +
 website/content/doc-2.2.5/replay_gain.md      |    85 +
 website/content/doc-2.2.5/request_sources.md  |    99 +
 website/content/doc-2.2.5/requests.md         |    53 +
 website/content/doc-2.2.5/rolling-release.md  |    10 +
 website/content/doc-2.2.5/script_loading.md   |    29 +
 website/content/doc-2.2.5/seek.md             |    67 +
 website/content/doc-2.2.5/server.md           |   265 +
 website/content/doc-2.2.5/settings.md         |  5624 +++
 website/content/doc-2.2.5/shoutcast.md        |    39 +
 website/content/doc-2.2.5/sources.md          |   138 +
 website/content/doc-2.2.5/split-cue.md        |    32 +
 website/content/doc-2.2.5/stereotool.md       |    54 +
 website/content/doc-2.2.5/stream_content.md   |   208 +
 website/content/doc-2.2.5/strings_encoding.md |    18 +
 website/content/doc-2.2.5/video-static.md     |    35 +
 website/content/doc-2.2.5/video.md            |   269 +
 website/content/doc-2.2.5/yaml.md             |    29 +
 website/template-2.2.5.html                   |   423 +
 92 files changed, 74427 insertions(+), 2 deletions(-)
 create mode 100644 website/content/doc-2.2.5/beets.md
 create mode 100644 website/content/doc-2.2.5/blank.md
 create mode 100644 website/content/doc-2.2.5/book.md
 create mode 100644 website/content/doc-2.2.5/build.md
 create mode 100644 website/content/doc-2.2.5/clocks.md
 create mode 100644 website/content/doc-2.2.5/complete_case.md
 create mode 100644 website/content/doc-2.2.5/cookbook.md
 create mode 100644 website/content/doc-2.2.5/crossfade.md
 create mode 100644 website/content/doc-2.2.5/custom-path.md
 create mode 100644 website/content/doc-2.2.5/documentation.md
 create mode 100644 website/content/doc-2.2.5/dynamic_sources.md
 create mode 100644 website/content/doc-2.2.5/encoding_formats.md
 create mode 100644 website/content/doc-2.2.5/external_decoders.md
 create mode 100644 website/content/doc-2.2.5/external_encoders.md
 create mode 100644 website/content/doc-2.2.5/external_streams.md
 create mode 100644 website/content/doc-2.2.5/faq.md
 create mode 100644 website/content/doc-2.2.5/ffmpeg.md
 create mode 100644 website/content/doc-2.2.5/ffmpeg_cookbook.md
 create mode 100644 website/content/doc-2.2.5/ffmpeg_encoder.md
 create mode 100644 website/content/doc-2.2.5/ffmpeg_filters.md
 create mode 100644 website/content/doc-2.2.5/flows_devel.md
 create mode 100644 website/content/doc-2.2.5/frequence3.md
 create mode 100644 website/content/doc-2.2.5/geekradio.md
 create mode 100644 website/content/doc-2.2.5/gstreamer_encoder.md
 create mode 100644 website/content/doc-2.2.5/harbor.md
 create mode 100644 website/content/doc-2.2.5/harbor_http.md
 create mode 100644 website/content/doc-2.2.5/help.md
 create mode 100644 website/content/doc-2.2.5/hls_output.md
 create mode 100644 website/content/doc-2.2.5/http_input.md
 create mode 100644 website/content/doc-2.2.5/icy_metadata.md
 create mode 100644 website/content/doc-2.2.5/images/basic-radio-graph.png
 create mode 100644 website/content/doc-2.2.5/images/design/background.png
 create mode 100644 website/content/doc-2.2.5/images/design/background_page.png
 create mode 100644 website/content/doc-2.2.5/images/design/logo.png
 create mode 100644 website/content/doc-2.2.5/images/grab.png
 create mode 100644 website/content/doc-2.2.5/images/graph_clocks.png
 create mode 100644 website/content/doc-2.2.5/images/liqgraph.png
 create mode 100644 website/content/doc-2.2.5/images/schema-webradio-inkscape.png
 create mode 100644 website/content/doc-2.2.5/images/stream.png
 create mode 100644 website/content/doc-2.2.5/images/tabs/tab_API.png
 create mode 100644 website/content/doc-2.2.5/images/tabs/tab_about.png
 create mode 100644 website/content/doc-2.2.5/images/tabs/tab_developers.png
 create mode 100644 website/content/doc-2.2.5/images/tabs/tab_docs.png
 create mode 100644 website/content/doc-2.2.5/images/tabs/tab_snippets.png
 create mode 100644 website/content/doc-2.2.5/in_production.md
 create mode 100644 website/content/doc-2.2.5/index.md
 create mode 100644 website/content/doc-2.2.5/install.md
 create mode 100644 website/content/doc-2.2.5/json.md
 create mode 100644 website/content/doc-2.2.5/ladspa.md
 create mode 100644 website/content/doc-2.2.5/language.md
 create mode 100644 website/content/doc-2.2.5/memory.md
 create mode 100644 website/content/doc-2.2.5/metadata.md
 create mode 100644 website/content/doc-2.2.5/migrating.md
 create mode 100644 website/content/doc-2.2.5/multitrack.md
 create mode 100644 website/content/doc-2.2.5/on2.md
 create mode 100644 website/content/doc-2.2.5/on2_part1.md
 create mode 100644 website/content/doc-2.2.5/on2_part2.md
 create mode 100644 website/content/doc-2.2.5/on2_part3.md
 create mode 100644 website/content/doc-2.2.5/phases.md
 create mode 100644 website/content/doc-2.2.5/playlist_parsers.md
 create mode 100644 website/content/doc-2.2.5/presentations.md
 create mode 100644 website/content/doc-2.2.5/profiling.md
 create mode 100644 website/content/doc-2.2.5/prometheus.md
 create mode 100644 website/content/doc-2.2.5/protocols-presentation.md
 create mode 100644 website/content/doc-2.2.5/protocols.md
 create mode 100644 website/content/doc-2.2.5/publications.md
 create mode 100644 website/content/doc-2.2.5/quick_start.md
 create mode 100644 website/content/doc-2.2.5/radiopi.md
 create mode 100644 website/content/doc-2.2.5/reference-deprecated.md
 create mode 100644 website/content/doc-2.2.5/reference-extras.md
 create mode 100644 website/content/doc-2.2.5/reference-header.md
 create mode 100644 website/content/doc-2.2.5/reference.md
 create mode 100644 website/content/doc-2.2.5/release-assets.md
 create mode 100644 website/content/doc-2.2.5/replay_gain.md
 create mode 100644 website/content/doc-2.2.5/request_sources.md
 create mode 100644 website/content/doc-2.2.5/requests.md
 create mode 100644 website/content/doc-2.2.5/rolling-release.md
 create mode 100644 website/content/doc-2.2.5/script_loading.md
 create mode 100644 website/content/doc-2.2.5/seek.md
 create mode 100644 website/content/doc-2.2.5/server.md
 create mode 100644 website/content/doc-2.2.5/settings.md
 create mode 100644 website/content/doc-2.2.5/shoutcast.md
 create mode 100644 website/content/doc-2.2.5/sources.md
 create mode 100644 website/content/doc-2.2.5/split-cue.md
 create mode 100644 website/content/doc-2.2.5/stereotool.md
 create mode 100644 website/content/doc-2.2.5/stream_content.md
 create mode 100644 website/content/doc-2.2.5/strings_encoding.md
 create mode 100644 website/content/doc-2.2.5/video-static.md
 create mode 100644 website/content/doc-2.2.5/video.md
 create mode 100644 website/content/doc-2.2.5/yaml.md
 create mode 100644 website/template-2.2.5.html

diff --git a/website/Makefile b/website/Makefile
index 9d92bdcb..4f493356 100644
--- a/website/Makefile
+++ b/website/Makefile
@@ -6,8 +6,8 @@ GENERATED_INTERPRETER_DIR := $(PWD)/../liquidsoap/_build/default/src/js
 NODE := $(shell which node)
 
 # Versions for which documentation should be built and included
-VERSIONS := dev 1.4.4 2.0.7 2.1.0 2.1.1 2.1.2 2.1.3 2.1.4 2.2.0 2.2.1 2.2.2 2.2.3 2.2.4
-DEFAULT_VERSION := 2.2.4
+VERSIONS := dev 1.4.4 2.0.7 2.1.0 2.1.1 2.1.2 2.1.3 2.1.4 2.2.0 2.2.1 2.2.2 2.2.3 2.2.4 2.2.5
+DEFAULT_VERSION := 2.2.5
 # DEFAULT_VERSION := dev
 
 # Static content
diff --git a/website/content/doc-2.2.5/beets.md b/website/content/doc-2.2.5/beets.md
new file mode 100644
index 00000000..51c32b2e
--- /dev/null
+++ b/website/content/doc-2.2.5/beets.md
@@ -0,0 +1,179 @@
+# Integrating a music library: an example with Beets
+
+Liquidsoap's native sources can read from files and folders,
+but if your radio uses an important music library
+(more than a thousand tracks)
+sorting by folders may not be enough.
+You will also need to adjust the playout gain per track (ReplayGain).
+In that case you would better have a music library
+queried by Liquidsoap.
+In this section we'll do this with [Beets](http://beets.io/).
+Beets holds your music catalog,
+cleans tracks' tags before importing,
+can compute each track's ReplayGain,
+and most importantly has a command-line interface we can leverage from Liquidsoap.
+The following examples may also inspire you to integrate another library or your own scripts.
+
+After installing Beets,
+enable the `random` plug-in
+(see [Beets documentation on plug-ins](https://beets.readthedocs.io/en/stable/plugins/index.html#using-plugins)).
+To enable gain normalization, install and configure the
+[`replaygain`](https://beets.readthedocs.io/en/stable/plugins/replaygain.html) plug-in.
+To easily add single tracks to you library,
+you might also be interested in the
+[drop2beets](https://github.com/martinkirch/drop2beets#drop2beets) plug-in.
+The following examples suppose you defined a `BEET` constant,
+which contains the complete path to your `beet` executable (on UNIX systems, find it with `which beet`). For example:
+
+```
+BEET = "/home/radio/.local/bin/beet"
+```
+
+Before creating a Liquidsoap source,
+let's see why Beets queries are interesting for a radio.
+
+## Beets queries
+
+Queries are parameters that you usually provide to the `beet ls` command :
+Beets will find matching tracks.
+The `random` plug-in works the same, except that it returns only one track matching the query
+(see [the plug-in's documentation](https://beets.readthedocs.io/en/stable/plugins/random.html)).
+Once your library is imported,
+you can try the following queries on the command line
+by typing `beet ls [query]` or `beet random [query]`.
+To test quickly, add the `-t 60` option to `beet random`
+so it will select an hour worth of tracks matching your query.
+
+Without selectors, queries search in a track’s title, artist, album name,
+album artist, genre and comments. Typing an artist name or a complete title
+usually match the exact track, and you could do a lovely playlist just by querying `love`.
+
+But in a radio you'll usually query on other fields.
+You can select tracks by genre with the `genre:` selector.
+Be careful that `genre:Rock` also matches `Indie Rock`, `Punk Rock`, etc.
+To select songs having english lyrics, use `language:eng`.
+Or pick 80s songs with `year:1980..1990`.
+
+Beets also holds internal meta-data, like `added`:
+the date and time when you imported each song.
+You can use it to query tracks inserted over the past month with `added:-1m..`.
+Or you can query track imported more than a year ago with `added:..-1y`.
+Beets also lets you
+[set your own tags](https://beets.readthedocs.io/en/stable/guides/advanced.html#store-any-data-you-like).
+
+You can use the `info` plug-in to see everything Beets knows about title(s) matching a query
+by typing `beet info -l [query]`.
+See also [the Beets' documentation](https://beets.readthedocs.io/en/stable/reference/query.html)
+for more details on queries operators.
+All these options should allow you to create both general and specialiazed Liquidsoap sources.
+
+## A source querying each next track from Beets
+
+As of Liquidsoap 2.x we can create a function that creates a dynamic source,
+given its `id` and a Beet query.
+We rely on `request.dynamic` to call `beet random`
+(with `-f '$path'` option so beets only returns the matching track's path)
+every time the source must prepare a new track:
+
+```liquidsoap
+def beets(id, query) =
+  beets_src =
+    request.dynamic(id=id, retry_delay=1., {
+      request.create(
+        string.trim(
+          process.read("#{BEET} random -f '$path' #{query}")
+        )
+      )
+    })
+  (beets_src:source)
+end
+
+all_music = beets("all_music", "")
+recent_music = beets("recent_music", "added:-1m..")
+rock_music = beets("rock_music", "genre:Rock")
+```
+
+Note that
+
+- `query` can be empty, it will match all tracks in the library.
+- we set `retry_delay` to a second, to avoid looping on `beet` calls if something goes wrong.
+- The final type hint (`:source`) will avoid false typing errors when the source is integrated in complex operators.
+
+## Applying ReplayGain
+
+When the [`replaygain` plug-in](https://beets.readthedocs.io/en/stable/plugins/replaygain.html)
+is enabled, all tracks will have an additional metadata field called `replaygain_track_gain`.
+Check that Beet is configured to
+[write ID3 tags](https://beets.readthedocs.io/en/stable/reference/config.html#importer-options)
+so Liquidsoap will be able to read this metadata -
+your Beet configuration should include something like:
+
+```
+import:
+    write: yes
+```
+
+Then we only need to add `amplify` to our source creation function. In the example below we also add `blank.eat`, to automatically cut silence at the beginning or end of tracks.
+
+```liquidsoap
+def beets(id, query) =
+  beets_src =
+    blank.eat(id="#{id}_", start_blank=true, max_blank=1.0, threshold=-45.0,
+      amplify(override="replaygain_track_gain", 1.0,
+        request.dynamic(id=id, retry_delay=1., {
+          request.create(
+            string.trim(
+              process.read("#{BEET} random -f '$path' #{query}")
+            )
+          )
+        })
+      )
+    )
+  (beets_src:source)
+end
+```
+
+This is the recommended Beets integration ;
+such source will provide music continuously,
+at a regular volume.
+
+## Beets as a requests protocol
+
+If you're queueing tracks with `request.queue`,
+you may prefer to integrate Beets as a protocol.
+In that case,
+the list of paths returned by `beet random -f '$path'` fits directly
+what's needed by protocol resolution:
+
+```liquidsoap
+def beets_protocol(~rlog,~maxtime,arg) =
+  timeout = maxtime - time()
+  command = "#{BEET} random -f '$path' #{arg}"
+  p = process.run(timeout=timeout, command)
+  if p.status == "exit" and p.status.code == 0 then
+    [string.trim(p.stdout)]
+  else
+    rlog("Failed to execute #{command}: #{p.status} (#{p.status.code}) #{p.stderr}")
+    []
+  end
+end
+protocol.add("beets", beets_protocol,
+  syntax = "same arguments as beet's random module, see https://beets.readthedocs.io/en/stable/reference/query.html"
+)
+```
+
+Once this is done,
+you can push a beets query from [the telnet server](server.html):
+if you created `request.queue(id="userrequested")`,
+the server command
+`userrequested.push beets:All along the watchtower`
+will push the Jimi Hendrix's song.
+
+With this method, you can benefit from replay gain metadata too, by wrapping
+the recipient queue in an `amplify` operator, like
+
+```liquidsoap
+userrequested = amplify(override="replaygain_track_gain", 1.0,
+  request.queue(id="userrequested")
+)
+```
diff --git a/website/content/doc-2.2.5/blank.md b/website/content/doc-2.2.5/blank.md
new file mode 100644
index 00000000..6a1f5a97
--- /dev/null
+++ b/website/content/doc-2.2.5/blank.md
@@ -0,0 +1,50 @@
+# Blank detection
+
+[Liquidsoap](index.html) has three operators for dealing with blanks.
+
+On GeekRadio, we play many files, some of which include bonus tracks, which
+means that they end with a very long blank and then a little extra music. It's
+annoying to get that on air. The `blank.skip` operator skips the
+current track when a too long blank is detected, which avoids that. The typical
+usage is simple:
+
+```liquidsoap
+# Wrap it with a blank skipper
+source = blank.skip(source)
+```
+
+At [RadioPi](http://www.radiopi.org/) they have another problem: sometimes they
+have technical problems, and while they think they are doing a live show,
+they're making noise only in the studio, while only blank is on air; sometimes,
+the staff has so much fun (or is it something else ?) doing live shows that they
+leave at the end of the show without thinking to turn off the live, and the
+listeners get some silence again. To avoid that problem we made the
+`blank.strip` operators which hides the stream when it's too blank
+(i.e. declare it as unavailable), which perfectly suits the typical setup used
+for live shows:
+
+```liquidsoap
+interlude = single("/path/to/sorryfortheblank.ogg")
+# After 5 sec of blank the microphone stream is ignored,
+# which causes the stream to fallback to interlude.
+# As soon as noise comes back to the microphone the stream comes
+# back to the live -- thanks to track_sensitive=false.
+stream = fallback(track_sensitive=false,
+                  [ blank.strip(max_blank=5.,live) , interlude ])
+
+# Put that stream to a local file
+output.file(%vorbis, "/tmp/hop.ogg", stream)
+```
+
+If you don't get the difference between these two operators, you should learn
+more about liquidsoap's notion of [source](sources.html).
+
+Finally, if you need to do some custom action when there's too much blank, we
+have `blank.detect`:
+
+```liquidsoap
+def handler()
+  system("/path/to/your/script to do whatever you want")
+end
+source = blank.detect(handler,source)
+```
diff --git a/website/content/doc-2.2.5/book.md b/website/content/doc-2.2.5/book.md
new file mode 100644
index 00000000..b9c4ab24
--- /dev/null
+++ b/website/content/doc-2.2.5/book.md
@@ -0,0 +1,11 @@
+# The Liquidsoap book
+
+Together with the release of Liquidsoap 2.0, we have written _the Liquidsoap
+book_ which covers in details the language and the process of building a
+radio. It complements the online documentation by providing a homogeneous and
+progressive presentation of Liquidsoap.
+
+[![The Liquidsoap book](/assets/img/book.svg){height=600px}](https://www.amazon.com/dp/B095PVTYR3)
+
+It can be [ordered from Amazon](https://www.amazon.com/dp/B095PVTYR3)
+(or [read online](http://www.liquidsoap.info/book/book.pdf)).
diff --git a/website/content/doc-2.2.5/build.md b/website/content/doc-2.2.5/build.md
new file mode 100644
index 00000000..e7a94c6a
--- /dev/null
+++ b/website/content/doc-2.2.5/build.md
@@ -0,0 +1,112 @@
+# Building Liquidsoap
+
+## Forewords
+
+Installing liquidsoap can be a difficult task. The software relies on a up-to date
+OCaml compiler, as well as a bunch of OCaml modules and, for most of them, corresponding
+C library dependencies.
+
+Our recommended way of installing liquidsoap is via [opam](http://opam.ocaml.org/). `opam` can take
+care of installing the correct OCaml compiler, optional and required dependencies as well as system-specific
+package dependencies.
+
+The `opam` method is described in details in the [documentation](doc/content/install.md).
+We recommend that any interested user head over to this link to install the software via `opam`.
+
+The remainder of this document describes how to compile liquidsoap locally for developers.
+
+## Overview
+
+Liquidsoap is compiled using [dune](https://dune.readthedocs.io/en/stable/), which is the most popular
+OCaml build system at the moment. `dune` is tightly integrated with `opam` so, even if you are installing
+from source using `dune`, `opam` remains an important tool.
+
+Generally speaking, compiling from source may require the latest version of the liquidsoap code as well as its
+dependencies. Some of its dependencies are optional and can be ignored at first and some are not.
+
+Keep in mind that, although `opam` is generally aware of required minimal version for dependencies, `dune` is not.
+If a dependency is outdated, `dune` compilation will simply fail, at which point your may have to figure out if
+you need to update a dependency.
+
+Each branch of liquidsoap is compiled using [github actions](https://github.com/savonet/liquidsoap/actions). When trying
+to build a specific branch, if the CI passes with it then, most likely, you are missing a dependency or it is not
+the latest version.
+
+## `opam` pinning
+
+`opam` pinning is a mechanism to update `opam` with the latest version of a package, even before it is published to
+the official opam repository. This is the easiest way to update a dependency to its latest version.
+
+You can pin directly from a local git repository checkout:
+
+```shell
+git clone https://github.com/savonet/ocaml-metadata.git
+cd ocaml-metadata
+opam pin -ny .
+```
+
+You can also pin directly using a git url:
+
+```shell
+opam pin -ny git+https://github.com/savonet/ocaml-cry
+```
+
+See `opam pin --help` for more defails about the available options.
+
+## Dependencies
+
+The best way to figure out what dependencies are required or optional and their versions is to use the latest `opam`
+package. Since `liquidsoap` development is using `dune` and `opam`, the dependencies are kept in sync via the
+local liquidsoap opam package(s) and this serves as the de-facto list of dependencies and their versions.
+
+First, you should pin the latest liquidsoap code:
+
+```shell
+opam pin -ny git+https://github.com/savonet/liquidsoap
+```
+
+Then, ask `opam` to list all the dependencies for `liquidsoap`:
+
+```shell
+opam info liquidsoap
+opam info liquidsoap-core
+opam info liquidsoa-lang
+```
+
+This should give you a (long!) list of all dependencies. Then, you can query `opam` to see
+what each dependency does. This is particularly useful for optional dependencies on `liquidsoap-core`
+which provide opt-in features. For instance `opam info soundtouch` will let you know that this
+package provides functions for changing pitch and timestretching audio data.
+
+Lastly, there are two types of dependencies:
+
+- Dependencies maintained by us
+- Dependencies not maintained by us
+
+For dependencies not maintained by us, most of the time, we rely on the latest published version. Very rarely should you
+have to fetch/pin the latest version of these dependencies.
+
+For dependencies maintained by us, we may break their API during our development cycle and you maybe have to fetch/pin
+the latest version when compilign the latest `liquidsoap` code. You may also have to check out a specific
+branch when compiling `liquidsoap` from a specific development branch when the changes in the liquidsoap code are paired with
+changes in one of our dependencies. Typically, this happens a lof with the `ffmpeg` binding.
+
+## Compiling
+
+Once you have all dependencies installed, you should be able to compile via:
+
+```shell
+dune build
+```
+
+If an error occurs, you may need to see if you need to update a dependency. Hopefully, with a short iteration of this cycle,
+you will end up with a successful build!
+
+Once you have a successful build, you can also use the top-level `liquidsoap` script. This script builds the latest code and
+executes it right away. It works as if you were calling the `liquidsoap` binary after installing it:
+
+```shell
+./liquidsoap -h output.ao
+```
+
+From here, you can start changing code, testing script etc. Happy hacking!
diff --git a/website/content/doc-2.2.5/clocks.md b/website/content/doc-2.2.5/clocks.md
new file mode 100644
index 00000000..4f5820dd
--- /dev/null
+++ b/website/content/doc-2.2.5/clocks.md
@@ -0,0 +1,312 @@
+# Clocks
+
+In the [quickstart](quick_start.html) and in the introduction to liquidsoap
+[sources](sources.html), we have described a simple world in which sources
+communicate with each other, creating and transforming data that
+composes multimedia streams.
+In this simple view, all sources produce data at the same rate,
+animated by a single clock: at every cycle of the clock,
+a fixed amount of data is produced.
+
+While this simple picture is useful to get a fair idea of what's going on
+in liquidsoap, the full picture is more complex: in fact, a streaming
+system might involve _multiple clocks_, or in other words several
+time flows.
+
+It is only in very particular cases that liquidsoap scripts
+need to mention clocks explicitly. Otherwise, you won't even notice
+how many clocks are involved in your setup: indeed, liquidsoap can figure
+out the clocks by itself, much like it infers types.
+Nevertheless, there will sometimes be cases where your script cannot
+be assigned clocks in a correct way, in which case liquidsoap will
+complain. For that reason, every user should eventually get a minimum
+understanding of clocks.
+
+In the following, we first describe why we need clocks.
+Then we go through the possible errors that any user might encounter
+regarding clocks.
+Finally, we describe how to explicitly use clocks,
+and show a few striking examples of what can be achieved that way.
+
+## Why multiple clocks
+
+The first reason is **external** to liquidsoap: there is simply
+not a unique notion of time in the real world.
+Your computer has an internal clock which indicates
+a slightly different time than your watch or another computer's clock.
+Moreover, when communicating with a remote computer, network
+latency causes extra time distortions.
+Even within a single computer there are several clocks: notably, each
+soundcard has its own clock, which will tick at a slightly different
+rate than the main clock of the computer.
+Since liquidsoap communicates with soundcards and remote computers,
+it has to take those mismatches into account.
+
+There are also some reasons that are purely **internal** to liquidsoap:
+in order to produce a stream at a given speed,
+a source might need to obtain data from another source at
+a different rate. This is obvious for an operator that speeds up or
+slows down audio (`stretch`). But it also holds more subtly
+for `cross`, `cross` as well as the
+derived operators: during the lapse of time where the operator combines
+data from an end of track with the beginning of the other other,
+the crossing operator needs twice as much stream data. After ten tracks,
+with a crossing duration of six seconds, one more minute will have
+passed for the source compared to the time of the crossing operator.
+
+In order to avoid inconsistencies caused by time differences,
+while maintaining a simple and efficient execution model for
+its sources, liquidsoap works under the restriction that
+one source belongs to a unique clock,
+fixed once for all when the source is created.
+
+The graph representation of streaming systems can be adapted
+into a good representation of what clocks mean.
+One simply needs to add boxes representing clocks:
+a source can belong to only one box,
+and all sources of a box produce streams at the same rate.
+For example,
+
+```liquidsoap
+output.icecast(fallback([crossfade(playlist(...)),jingles]))
+```
+
+yields the following graph:
+
+![Graph representation with clocks](/assets/img/graph_clocks.png)
+
+Here, clock_2 was created specifically for the crossfading
+operator; the rate of that clock is controlled by that operator,
+which can hence accelerate it around track changes without any
+risk of inconsistency.
+The other clock is simply a CPU-based clock, so that the main stream
+is produced following the ``real'' time rate.
+
+## Error messages
+
+Most of the time you won't have to do anything special about clocks:
+operators that have special requirements regarding clocks will do
+what's necessary themselves, and liquidsoap will check that everything is
+fine. But if the check fails, you'll need to understand the error,
+which is what this section is for.
+
+### Disjoint clocks
+
+On the following example, liquidsoap will issue the fatal error
+`a source cannot belong to two clocks`:
+
+```liquidsoap
+s = playlist("~/media/audio")
+output.alsa(s) # perhaps for monitoring
+output.icecast(mount="radio.ogg",%vorbis,crossfade(s))
+```
+
+Here, the source `s` is first assigned the ALSA clock,
+because it is tied to an ALSA output.
+Then, we attempt to build a `crossfade` over `s`.
+But this operator requires its source to belong to a dedicated
+internal clock (because crossfading requires control over the flow
+of the of the source, to accelerate it around track changes).
+The error expresses this conflict:
+`s` must belong at the same time to the ALSA clock
+and `crossfade`'s clock.
+
+### Nested clocks
+
+On the following example, liquidsoap will issue the fatal error
+`cannot unify two nested clocks`:
+
+```liquidsoap
+jingles = playlist("jingles.lst")
+music = rotate([1,10],[jingles,playlist("remote.lst")])
+safe = rotate([1,10],[jingles,single("local.ogg")])
+q = fallback([crossfade(music),safe])
+```
+
+Let's see what happened.
+The `rotate` operator, like most operators, operates
+within a single clock, which means that `jingles`
+and our two `playlist` instances must belong to the same clock.
+Similarly, `music` and `safe` must belong to that
+same clock.
+When we applied crossfading to `music`,
+the `crossfade` operator created its own internal clock,
+call it `cross_clock`,
+to signify that it needs the ability to accelerate at will the
+streaming of `music`.
+So, `music` is attached to `cross_clock`,
+and all sources built above come along.
+Finally, we build the fallback, which requires that all of its
+sources belong to the same clock.
+In other words, `crossfade(music)` must belong
+to `cross_clock` just like `safe`.
+The error message simply says that this is forbidden: the internal
+clock of our crossfade cannot be its external clock -- otherwise
+it would not have exclusive control over its internal flow of time.
+
+The same error also occurs on `add([crossfade(s),s])`,
+the simplest example of conflicting time flows, described above.
+However, you won't find yourself writing this obviously problematic
+piece of code. On the other hand, one would sometimes like to
+write things like our first example.
+
+The key to the error with our first example is that the same
+`jingles` source is used in combination with `music`
+and `safe`. As a result, liquidsoap sees a potentially
+nasty situation, which indeed could be turned into a real mess
+by adding just a little more complexity. To obtain the desired effect
+without requiring illegal clock assignments, it suffices to
+create two jingle sources, one for each clock:
+
+```liquidsoap
+music = rotate([1,10],[playlist("jingles.lst"),
+                       playlist("remote.lst")])
+safe  = rotate([1,10],[playlist("jingles.lst"),
+                       single("local.ogg")])
+q = fallback([crossfade(music),safe])
+```
+
+There is no problem anymore: `music` belongs to
+`crossfade`'s internal clock, and `crossfade(music)`,
+`safe` and the `fallback` belong to another clock.
+
+## The clock API
+
+There are only a couple of operations dealing explicitly with clocks.
+
+The function `clock.assign_new(l)` creates a new clock
+and assigns it to all sources from the list `l`.
+For convenience, we also provide a wrapper, `clock(s)`
+which does the same with a single source instead of a list,
+and returns that source.
+With both functions, the new clock will follow (the computer's idea of)
+real time, unless `sync=false` is passed, in which case
+it will run as fast as possible.
+
+The old (pre-1.0.0) setting `root.sync` is superseded
+by `clock.assign_new()`.
+If you want to run an output as fast as your CPU allows,
+just attach it to a new clock without synchronization:
+
+```liquidsoap
+clock.assign_new(sync="none",[source])
+```
+
+This will automatically attach the appropriate sources to that clock.
+
+Another important use case of this operator is if your script involves multiple sources from the same external clock, typically multiple ALSA input or output from the same sound card or multiple jack input and output. By default (the so-called `clock_safe` mode), liquidsoap will assign a dedicated clock to each of those sources, leading either to an error or forcing the use of an unnecessary `buffer` (see below). Instead, you can allocate each source with `clock_safe=false` and assign them a single clock:
+
+```
+s1 = input.jack(clock_safe=false, ...)
+s2 = input.jack(clock_safe=false, ...)
+
+clock.assign_new([s1,s2])
+```
+
+However, you may need to do it for other operators if they are totally
+unrelated to the first one.
+
+The `buffer()` operator can be used to communicate between
+any two clocks: it takes a source in one clock and builds a source
+in another. The trick is that it uses a buffer: if one clock
+happens to run too fast or too slow, the buffer may empty or overflow.
+
+Finally, `get_clock_status` provides information on
+existing clocks and track their respective times:
+it returns a list containing for each clock a pair
+`(name,time)` indicating
+the clock id its current time in _clock cycles_ --
+a cycle corresponds to the duration of a frame,
+which is given in ticks, displayed on startup in the logs.
+The helper function `log_clocks` built
+around `get_clock_status` can be used to directly
+obtain a simple log file, suitable for graphing with gnuplot.
+Those functions are useful to debug latency issues.
+
+## External clocks: decoupling latencies
+
+The first reason to explicitly assign clocks is to precisely handle
+the various latencies that might occur in your setup.
+
+Most input/output operators (ALSA, AO, Jack, OSS, etc)
+require their own clocks. Indeed, their processing rate is constrained
+by external sound APIs or by the hardware itself.
+Sometimes, it is too much of an inconvenience,
+in which case one can set `clock_safe=false` to allow
+another clock assignment --
+use at your own risk, as this might create bad latency interferences.
+
+Currently, `output.icecast` does not require to belong
+to any particular clock. This allows to stream according to the
+soundcard's internal clock, like in most other tools:
+in `output.icecast(%vorbis,mount="live.ogg",input.alsa())`,
+the ALSA clock will drive the streaming of the soundcard input via
+icecast.
+
+Sometimes, the external factors tied to Icecast output cannot be
+disregarded: the network may lag. If you stream a soundcard input
+to Icecast and the network lags, there will be a glitch in the
+soundcard input -- a long enough lag will cause a disconnection.
+This might be undesirable, and is certainly disappointing if you
+are recording a backup of your precious soundcard input using
+`output.file`: by default it will suffer the same
+latencies and glitches, while in theory it could be perfect.
+To fix this you can explicitly separate Icecast (high latency,
+low quality acceptable) from the backup and soundcard input (low latency,
+high quality wanted):
+
+```liquidsoap
+input = input.oss()
+
+# Icecast source, with its own clock:
+icecast_source = mksafe(buffer(input))
+clock.assign_new(id="icecast", [icecast_source])
+
+# Output to icecast:
+output.icecast(%mp3,mount="blah",icecast_source)
+
+# File output:
+output.file(
+  %mp3,"record-%Y-%m-%d-%H-%M-%S.mp3",
+  input)
+```
+
+Here, the soundcard input and file output end up in the OSS
+clock. The icecast output
+goes to the explicitly created `"icecast"` clock,
+and a buffer is used to
+connect it to the soundcard input. Small network lags will be
+absorbed by the buffer. Important lags and possible disconnections
+will result in an overflow of the buffer.
+In any case, the OSS input and file output won't be affected
+by those latencies, and the recording should be perfect.
+The Icecast quality is also better with that setup,
+since small lags are absorbed by the buffer and do not create
+a glitch in the OSS capture, so that Icecast listeners won't
+notice the lag at all.
+
+## Internal clocks: exploiting multiple cores
+
+Clocks can also be useful even when external factors are not an issue.
+Indeed, several clocks run in several threads, which creates an opportunity
+to exploit multiple CPU cores.
+The story is a bit complex because OCaml has some limitations on
+exploiting multiple cores, but in many situations most of the computing
+is done in C code (typically decoding and encoding) so it parallelizes
+quite well.
+
+Typically, if you run several outputs that do not share much (any) code,
+you can put each of them in a separate clock.
+For example the following script takes one file and encodes it as MP3
+twice. You should run it as `liquidsoap EXPR -- FILE`
+and observe that it fully exploits two cores:
+
+```liquidsoap
+def one()
+  s = single(argv(1))
+  clock.assign_new(sync="none",[s])
+  output.file(%mp3,"/dev/null",s)
+end
+one()
+one()
+```
diff --git a/website/content/doc-2.2.5/complete_case.md b/website/content/doc-2.2.5/complete_case.md
new file mode 100644
index 00000000..ddc1b2c2
--- /dev/null
+++ b/website/content/doc-2.2.5/complete_case.md
@@ -0,0 +1,81 @@
+# A complete case analysis
+
+We will develop here a more complex example, according to the following specifications:
+
+- play different playlists during the day;
+- play user requests -- done via the telnet server;
+- insert about 1 jingle every 5 songs;
+- add one special jingle at the beginning of every hour, mixed on top of the normal stream;
+- relay live shows as soon as one is available;
+- and set up several outputs.
+
+Once you've managed to describe what you want in such a modular way, you're half the way. More precisely, you should think of a diagram such as the following, through which the audio streams flow, following the arrows. The nodes can modify the stream using some basic operators: switching and mixing in our case. The final nodes, the ends of the paths, are outputs: they are in charge of pulling the data out of the graph and send it to the world. In our case, we only have outputs to icecast, using two different formats.
+
+![Graph for 'radio.liq'](/assets/img/liqgraph.png)
+
+Now here is how to write that in [Liquidsoap](index.html).
+
+```liquidsoap
+#!/usr/bin/liquidsoap
+
+# Lines starting with # are comments, they are ignored.
+
+# Put the log file in some directory where
+# you have permission to write.
+log.file.path := "/tmp/<script>.log"
+# Print log messages to the console,
+# can also be done by passing the -v option to liquidsoap.
+log.stdout := true
+# Use the telnet server for requests
+settings.server.telnet := true
+
+# A bunch of files and playlists,
+# supposedly all located in the same base dir.
+
+default = single("~/radio/default.ogg")
+
+day     = playlist("~/radio/day.pls")
+night   = playlist("~/radio/night.pls")
+jingles = playlist("~/radio/jingles.pls")
+clock   = single("~/radio/clock.ogg")
+
+# Play user requests if there are any,
+# otherwise one of our playlists,
+# and the default file if anything goes wrong.
+radio = fallback([ request.queue(id="request"),
+                    switch([({ 6h-22h }, day),
+                            ({ 22h-6h }, night)]),
+                    default])
+# Add the normal jingles
+radio = random(weights=[1,5],[ jingles, radio ])
+# And the clock jingle
+radio = add([radio, switch([({0m0s},clock)])])
+
+# Add the ability to relay live shows
+full =
+  fallback(track_sensitive=false,
+           [input.http("http://localhost:8000/live.ogg"),
+            radio])
+
+# Output the full stream in OGG and MP3
+output.icecast(%mp3,
+  host="localhost",port=8000,password="hackme",
+  mount="radio",full)
+output.icecast(%vorbis,
+  host="localhost",port=8000,password="hackme",
+  mount="radio.ogg",full)
+
+# Output the stream without live in OGG
+output.icecast(%vorbis,
+  host="localhost",port=8000,password="hackme",
+  mount="radio_nolive.ogg",radio)
+```
+
+To try this example you need to edit the file names. In order to witness the switch from one playlist to another you can change the time intervals. If it is 16:42, try the intervals `0h-16h45` and `16h45-24h` instead of `6h-22h` and `22h-6h`. To witness the clock jingle, you can ask for it to be played every minute by using the `0s` interval instead of `0m0s`.
+
+To try the transition to a live show you need to start a new stream on the `live.ogg` mount of your server. You can send a playlist to it using examples from the [quickstart](quick_start.html). To start a real live show from soundcard input you can use `darkice`, or simply liquidsoap if you have a working ALSA input, with:
+
+```liquidsoap
+liquidsoap 'output.icecast(%vorbis, \
+  mount="live.ogg",host="...",password="...",input.alsa())'
+```
diff --git a/website/content/doc-2.2.5/cookbook.md b/website/content/doc-2.2.5/cookbook.md
new file mode 100644
index 00000000..0ac3c1eb
--- /dev/null
+++ b/website/content/doc-2.2.5/cookbook.md
@@ -0,0 +1,518 @@
+# Cookbook
+
+The recipes show how to build a source with a particular feature. You can try short snippets by wrapping the code in an `output(..)` operator and passing it directly to liquidsoap:
+
+```liquidsoap
+liquidsoap -v 'output(recipe)'
+```
+
+For longer recipes, you might want to create a short script:
+
+```liquidsoap
+#!/usr/bin/liquidsoap -v
+
+log.file.path := "/tmp/<script>.log"
+log.stdout := true
+
+recipe = # <fill this>
+output(recipe)
+```
+
+See the [quickstart guide](quick_start.html) for more information on how to run [Liquidsoap](index.html), on what is this `output(..)` operator, etc.
+
+See also the [ffmpeg cookbook](ffmpeg_cookbook.html) for examples specific to the ffmpeg support.
+
+## Files
+
+A source which infinitely repeats the same URI:
+
+```liquidsoap
+single("/my/default.ogg")
+```
+
+A source which plays a playlist of requests -- a playlist is a file with an URI per line.
+
+```liquidsoap
+# Shuffle, play every URI, start over.
+playlist("/my/playlist.txt")
+# Do not randomize
+playlist(mode="normal", "/my/pl.m3u")
+# The playlist can come from any URI,
+# can be reloaded every 10 minutes.
+playlist(reload=600,"http://my/playlist.txt")
+```
+
+When building your stream, you'll often need to make it unfallible. Usually, you achieve that using a fallback switch (see below) with a branch made of a safe `single`. Roughly, a single is safe when it is given a valid local audio file.
+
+## Transcoding
+
+[Liquidsoap](index.html) can achieve basic streaming tasks like transcoding with ease. You input any number of "source" streams using `input.http`, and then transcode them to any number of formats / bitrates / etc. The only limitation is your hardware: encoding and decoding are both heavy on CPU. If you want to get the best use of CPUs (multicore, memory footprint etc.) when encoding media with Liquidsoap, we recommend using the `%ffmpeg` encoders.
+
+```liquidsoap
+# Input the stream,
+# from an Icecast server or any other source
+url = "https://icecast.radiofrance.fr/fip-hifi.aac"
+input = mksafe(input.http(url))
+
+# First transcoder: MP3 32 kbps
+# We also degrade the samplerate, and encode in mono
+# Accordingly, a mono conversion is performed on the input stream
+output.icecast(
+  %mp3(bitrate=32, samplerate=22050, stereo=false),
+  mount="/your-stream-32.mp3",
+  host="streaming.example.com", port=8000, password="xxx",
+  mean(input))
+
+# Second transcoder : MP3 128 kbps using %ffmpeg
+output.icecast(
+  %ffmpeg(format="mp3", %audio(codec="libmp3lame", b="128k")),
+  mount="/your-stream-128.mp3",
+  host="streaming.example.com", port=8000, password="xxx",
+  input)
+```
+
+## Re-encoding a file
+
+As a simple example using a fallible output, we shall consider
+re-encoding a file.
+We start by building a source that plays our file only once.
+That source is obviously fallible.
+We pass it to a file output, which has to be in fallible mode.
+We also disable the `sync` parameter on the source's clock,
+to encode the file as quickly as possible.
+Finally, we use the `on_stop` handler to shutdown
+liquidsoap when streaming is finished.
+
+```liquidsoap
+# The input file,
+# any format supported by liquidsoap
+input = "/tmp/input.mp3"
+
+# The output file
+output = "/tmp/output.ogg"
+
+# A source that plays the file once
+source = once(single(input))
+
+# We use a clock with disabled synchronization
+clock.assign_new(sync="none",[source])
+
+# Finally, we output the source to an
+# ogg/vorbis file
+output.file(%vorbis, output,fallible=true,
+                     on_stop=shutdown,source)
+```
+
+## RTMP server
+
+With our [FFmpeg support](ffmpeg.html), it is possible to create a simple RTMP server with no re-encoding:
+
+```liquidsoap
+s = playlist("...")
+
+enc = %ffmpeg(
+  format="flv",
+  listen=1,
+  %audio.copy,
+  %video.copy
+)
+
+output.url(url="rtmp://host/app/instance", enc, s)
+```
+
+## Transmitting signal
+
+It is possible to send raw PCM signal between two instances using the [FFmpeg encoder](ffmpeg.html). Here's an example using
+the SRT transport protocol:
+
+Sender:
+
+```liquidsoap
+enc = %ffmpeg(
+  format="s16le",
+  %audio(
+    codec="pcm_s16le",
+    ac=2,
+    ar=48000
+  )
+)
+output.srt(enc, s)
+```
+
+Receiver:
+
+```liquidsoap
+s = input.srt(
+  content_type="application/ffmpeg;format=s16le,ch_layout=stereo,sample_rate=48000"
+)
+```
+
+## Scheduling
+
+```liquidsoap
+# A fallback switch
+fallback([playlist("http://my/playlist"),
+          single("/my/jingle.ogg")])
+
+# A scheduler,
+# assuming you have defined the night and day sources
+switch([ ({0h-7h}, night), ({7h-24h}, day) ])
+```
+
+## Generating playlists from a media library
+
+In order to store all the metadata of the files in a given directory and use
+those to generate playlists, you can use the `medialib` operator which takes as
+argument the directory to index. On first run, it will index all the files of
+the given folder, which can take some time (you are advised to use the
+`persistency` parameter in order to specify a file where metadata will be
+stored to avoid reindexing at each run). The resulting object can then
+be queried with the `find` method in order to return all files matching the given
+conditions and thus generate a playlist:
+
+```liquidsoap
+m = medialib(persistency="/tmp/medialib.json", "~/Music/")
+l = m.find(artist_contains="Brassens")
+l = list.shuffle(l)
+output(playlist.list(l))
+```
+
+The parameter of the `find` method follow the following convention:
+
+- `artist="XXX"` looks for files where the artist tag is exactly the given one
+- `artist_contains="XXX"` looks for files where the artist tag contains the
+  given string as substring
+- `artist_matches="XXX"` looks for files where the artist tag matches the given
+  regular expression (for instance `artist_matches="(a)+.*(b)+"` looks for files
+  where the artist contains an `a` followed by a `b`).
+
+The tags for which such parameters are provided are: `artist`, `title`, `album`
+and `filename` (feel free to ask if you need more).
+
+Some numeric tags are also supported:
+
+- `year=1999` looks for files where the year is exactly the given one
+- `year_ge=1999` looks for files where the year at least the given one
+- `year_lt=1999` looks for files where the year at most the given one
+
+The following numeric tags are supported: `bpm`, `year`.
+
+If multiple arguments are passed, the function finds files with tags matching
+the conjunction of the corresponding condition.
+
+Finally, if you need more exotic search functions, the argument `predicate` can
+be used. It takes as argument a _predicate_ which is a function taking the
+metadata of a file and returning whether the file should be selected. For
+instance, the following looks for files where the name of the artist is of
+length 5:
+
+```liquidsoap
+def p(m)
+  string.length(m["artist"]) == 5
+end
+l = m.find(predicate=p)
+```
+
+## Force a file/playlist to be played at least every XX minutes
+
+It can be useful to have a special playlist that is played at least every 20 minutes for instance (3 times per hour).
+You may think of a promotional playlist for instance.
+Here is the recipe:
+
+```liquidsoap
+# (1200 sec = 20 min)
+timed_promotions = delay(1200.,promotions)
+main_source = fallback([timed_promotions,other_source])
+```
+
+Where promotions is a source selecting the file to be promoted.
+
+## Play a jingle at a fixed time
+
+Suppose that we have a playlist `jingles` of jingles and we want to play one
+within the 5 first minutes of every hour, without interrupting the current
+song. We can think of doing something like
+
+```liquidsoap
+radio = switch([({ 0m-5m }, jingles), ({ true }, playlist)])
+```
+
+but the problem is that it is likely to play many jingles. In order to play
+exactly one jingle, we can use the function `predicate.activates` which detects
+when a predicate (here `{ 0m-5m }`) becomes true:
+
+```liquidsoap
+radio = switch([(predicate.activates({ 0m-5m }), jingles), ({ true }, playlist)])
+```
+
+## Handle special events: mix or switch
+
+```liquidsoap
+# Add a jingle to your normal source
+# at the beginning of every hour:
+add([normal,switch([({0m0s},jingle)])])
+```
+
+Switch to a live show as soon as one is available. Make the show unavailable when it is silent, and skip tracks from the normal source if they contain too much silence.
+
+```liquidsoap
+stripped_stream =
+  blank.strip(input.http("http://myicecast:8080/live.ogg"))
+
+fallback(track_sensitive=false,
+         [stripped_stream,blank.strip(normal)])
+```
+
+Without the `track_sensitive=false` the fallback would wait the end of a track to switch to the live. When using the blank detection operators, make sure to fine-tune their `threshold` and `length` (float) parameters.
+
+## Unix interface, dynamic requests
+
+Liquidsoap can create a source that uses files provided by the result of the execution of any arbitrary function of your own.
+This is explained in the documentation for [request-based sources](request_sources.html).
+
+For instance, the following snippet defines a source which repeatedly plays the first valid URI in the playlist:
+
+```liquidsoap
+request.dynamic.list(
+  { [request.create("bar:foo",
+      indicators=
+        process.read.lines("cat "^quote("playlist.pls")))] })
+```
+
+Of course a more interesting behaviour is obtained with a more interesting program than `cat`, see [Beets](beet.html) for example.
+
+Another way of using an external program is to define a new protocol which uses it to resolve URIs. `protocol.add` takes a protocol name, a function to be used for resolving URIs using that protocol. The function will be given the URI parameter part and the time left for resolving -- though nothing really bad happens if you don't respect it. It usually passes the parameter to an external program ; it is another way to integrate [Beets](beet.html), for example:
+
+```liquidsoap
+protocol.add("beets", fun(~rlog,~maxtime,arg) ->
+  process.read.lines(
+    "/home/me/path/to/beet random -f '$path' #{arg}"
+  )
+)
+```
+
+When resolving the URI `beets:David Bowie`, liquidsoap will call the function, which will call `beet random -f '$path' David Bowie` which will output the path to a David Bowie song.
+
+## Dynamic input with harbor
+
+The operator `input.harbor` allows you to receive a source stream directly inside a running liquidsoap.
+
+It starts a listening server on where any Icecast2-compatible source client can connect. When a source is connected, its input if fed to the corresponding source in the script, which becomes available.
+
+This can be very useful to relay a live stream without polling the Icecast server for it.
+
+An example can be:
+
+```liquidsoap
+# Serveur settings
+settings.harbor.bind_addrs := ["0.0.0.0"]
+
+# An emergency file
+emergency = single("/path/to/emergency/single.ogg")
+
+# A playlist
+playlist = playlist("/path/to/playlist")
+
+# A live source
+live = input.harbor("live",port=8080,password="hackme")
+
+# fallback
+radio = fallback(track_sensitive=false,
+                 [live,playlist,emergency])
+
+# output it
+output.icecast(
+  %vorbis,
+  mount="test",
+  host="host",
+  radio)
+```
+
+This script, when launched, will start a local server, here bound to "0.0.0.0". This means that it will listen on any IP address available on the machine for a connection coming from any IP address. The server will wait for any source stream on mount point "/live" to login.
+Then if you start a source client and tell it to stream to your server, on port 8080, with password "hackme", the live source will become available and the radio will stream it immediately.
+
+## Play a short silence when transitioning out of `input.harbor`
+
+If the live connection is unstable, for instance when streaming through a roaming phone device, it can be interesting
+to add an extra `5s` of silence when transitioning out of a live `input.harbor` to give the input some chance to reconnect.
+
+This can be done with the `append` operator:
+
+```liquidsoap
+# The live source. We use a short buffer to switch
+# more quickly to the source when reconnecting
+live_source = input.harbor("mount-point-name", buffer=3.)
+
+# A playlist source.
+playlist_source = playlist("/path/to/playlist")
+
+# Set to `true` when we should be adding
+# silence
+should_append = ref(false)
+
+# Append 5. of silence when needed.
+fallback_source = append(
+  playlist_source, fun (_) ->
+    if should_append() then
+      should_append := false
+      blank(duration=5.)
+    else
+      source.fail()
+    end
+)
+
+# Transition to live
+def to_live(playlist, live) =
+  sequence([playlist,live])
+end
+
+# Transition back to playlist
+def to_playlist(live, playlist) =
+  # Ask to insert a silent track.
+  should_append := true
+
+  # Cancel current track. This will also set the playlist
+  # to play a new track. If needed, `cancel_pending` can
+  # be used to for a new silent track without skipping the
+  # playlist current track.
+  fallback_source.skip()
+
+  sequence([live, playlist])
+end
+
+radio = fallback(
+  track_sensitive=false,
+  transitions=[to_live, to_playlist],
+  [live_source, fallback_source]
+)
+```
+
+## Dump a stream into segmented files
+
+It is sometimes useful (or even legally necessary) to keep a backup of an audio
+stream. Storing all the stream in one file can be very impractical. In order to
+save a file per hour in wav format, the following script can be used:
+
+```liquidsoap
+# A source to dump
+# s = ...
+
+# Dump the stream
+output.file(%wav, '/archive/%Y-%m-%d/%Y-%m-%d-%H_%M_%S.mp3', s, reopen_when={0m})
+```
+
+In the following variant we write a new mp3 file each time new metadata is
+coming from `s`:
+
+```liquidsoap
+file_name = '/archive/$(if $(title),"$(title)","Unknown archive")-%Y-%m-%d/%Y-%m-%d-%H_%M_%S.mp3'
+output.file(%mp3, filename, s, reopen_on_metadata=true)
+```
+
+In the two examples we use [string interpolation](language.html) and time
+literals to generate the output file name.
+
+In order to limit the disk space used by this archive, on unix systems we can
+regularly call `find` to cleanup the folder ; if we can to keep 31 days of
+recording :
+
+```liquidsoap
+thread.when(every=3600., pred={ true },
+    fun () -> list.iter(fun(msg) -> log(msg, label="archive_cleaner"),
+        list.append(
+            process.read.lines("find /archive/* -type f -mtime +31 -delete"),
+            process.read.lines("find /archive/* -type d -empty -delete")
+        )
+    )
+)
+```
+
+## Transitions
+
+There are two kinds of transitions. Transitions between two different children of a switch or fallback and transitions between tracks of the same source.
+
+### Switch-based transitions
+
+The switch-based operators (`switch`, `fallback` and `random`) support transitions. For every child, you can specify a transition function computing the output stream when moving from one child to another. This function is given two `source` parameters: the child which is about to be left, and the new selected child. The default transition is `fun (a,b) -> b`, it simply relays the new selected child source.
+
+One limitation of these transitions, however, is that if the transition happen right at the end of a track, which is the default with `track_sensitive=true`, then there is no more data available for the old source, which makes it impossible to fade it out. If that is what you are expecting, you should look at crossfade-based transitions
+
+### Crossfade-based transitions
+
+Crossfade-based transitions are more complex and involve buffering source data in advance to be able to compute a transition where ending and starting track potentially overlap. This does not work with all type of sources since some of them, such as `input.http` may only receive data at real-time rate and cannot be accelerated to buffer their data or else we risk running out of data.
+
+We provide a default operator named `smart_cross` which may be suitable for most usage. But you can also create your own customized crossfade transitions. This is in particular true if you are expecting crossfade transitions between tracks of your `music` source but not between a `music` track and e.g. some jingles. Here's how to do it in this case:
+
+```liquidsoap
+# A function to add a source_tag metadata to a source:
+def source_tag(s,tag) =
+  def f(_)
+    [("source_tag",(tag:string))]
+  end
+  metadata.map(id=tag,insert_missing=true,f,s)
+end
+
+# Tag our sources
+music = source_tag(..., "music")
+jingles = source_tag(..., "jingles")
+
+# Combine them with one jingle every 3 music tracks
+radio = rotate(weights = [1,3],[jingles,music])
+
+# Now a custom crossfade transition:
+def transition(a,b)
+  # If old or new source is not music, no fade
+  if a.metadata["source_tag"] != "music" or a.metadata["source_tag"] != "music" then
+    sequence([a.source, b.source])
+  else
+    # Else, apply the standard smart transition
+    cross.smart(a, b)
+  end
+end
+
+# Apply it!
+radio = cross(duration=5., transition, radio)
+```
+
+## Alsa unbuffered output
+
+You can use [Liquidsoap](index.html) to capture and play through alsa with a minimal delay. This particularly useful when you want to run a live show from your computer. You can then directly capture and play audio through external speakers without delay for the DJ !
+
+This configuration is not trivial since it relies on your hardware. Some hardware will allow both recording and playing at the same time, some only one at once, and some none at all.. Those note to configure are what works for us, we don't know if they'll fit all hardware.
+
+First launch liquidsoap as a one line program
+
+```
+liquidsoap -v --debug 'input.alsa(bufferize=false)'
+```
+
+Unless you're lucky, the logs are full of lines like the following:
+
+```
+Could not set buffer size to 'frame.size' (1920 samples), got 2048.
+```
+
+The solution is then to set liquidsoap's internal frame size to this value, which is most likely specific to your hardware. Let's try this script:
+
+```liquidsoap
+# Set correct frame size:
+# This makes it possible to set any audio frame size.
+# Make sure that you do NOT use video in this case!
+video.frame.rate := 0
+
+# Now set the audio frame size exactly as required:
+settings.frame.audio.size := 2048
+
+input = input.alsa(bufferize=false)
+output.alsa(bufferize=false,input)
+```
+
+The setting will be acknowledged in the log as follows:
+
+```
+Targeting 'frame.audio.size': 2048 audio samples = 2048 ticks.
+```
+
+If everything goes right, you may hear on your output the captured sound without any delay! If you want to test the difference, just run the same script with `bufferize=true`.
+
+If you experience problems it might be a good idea to double the value of the frame size. This increases stability, but also latency.
diff --git a/website/content/doc-2.2.5/crossfade.md b/website/content/doc-2.2.5/crossfade.md
new file mode 100644
index 00000000..e85c89ca
--- /dev/null
+++ b/website/content/doc-2.2.5/crossfade.md
@@ -0,0 +1,98 @@
+# Smart crossfade
+
+## Basic operator
+
+Liquidsoap includes an advanced crossfading operator. Using it, you can code which transition you want for your songs, according to the average volume level (in dB) computed on the end of the ending track and the beginning of the new one.
+
+The low level operator is `cross`. With it, you can register a function that returns the transition you like. The arguments passed to this function are:
+
+- volume level for previous track
+- volume level for next track
+- metadata chunk for previous track
+- metadata chunk for next track
+- source corresponding to previous track
+- source corresponding to next track
+
+You can find its documentation in the [language reference](reference.html).
+
+## Example
+
+Liquidsoap also includes a ready-to-use operator defined using `cross`, it is called `crossfade` and is defined in the pervasive helper script `utils.liq`. Its code is:
+
+```liquidsoap
+# Smart transition for crossfade
+# @category Source / Track Processing
+# @param ~log Default logger
+# @param ~fade_in  Fade-in duration, if any.
+# @param ~fade_out Fade-out duration, if any.
+# @param ~high     Value, in dB, for loud sound level.
+# @param ~medium   Value, in dB, for medium sound level.
+# @param ~margin   Margin to detect sources that have too different sound level for crossing.
+# @param ~default Smart crossfade: transition used when no rule applies (default: sequence).
+# @param a Ending track
+# @param b Starting track
+def cross.smart(~log=log(label="cross.smart"),
+                ~fade_in=3.,~fade_out=3.,
+                ~default=(fun (a,b) -> (sequence([a, b]):source)),
+                ~high=-15., ~medium=-32., ~margin=4.,
+                a, b)
+  let fade.out = fade.out(type="sin",duration=fade_out)
+  let fade.in  = fade.in(type="sin",duration=fade_in)
+  add = fun (a,b) -> add(normalize=false,[b, a])
+
+  # This is for the type system..
+  ignore(a.metadata["foo"])
+  ignore(b.metadata["foo"])
+
+  if
+    # If A and B are not too loud and close, fully cross-fade them.
+    a.db_level <= medium and b.db_level <= medium and abs(a.db_level - b.db_level) <= margin
+    then
+      log("Old <= medium, new <= medium and |old-new| <= margin.")
+      log("Old and new source are not too loud and close.")
+      log("Transition: crossed, fade-in, fade-out.")
+      add(fade.out(a.source),fade.in(b.source))
+
+  elsif
+    # If B is significantly louder than A, only fade-out A.
+    # We don't want to fade almost silent things, ask for >medium.
+    b.db_level >= a.db_level + margin and a.db_level >= medium and b.db_level <= high
+  then
+    log("new >= old + margin, old >= medium and new <= high.")
+    log("New source is significantly louder than old one.")
+    log("Transition: crossed, fade-out.")
+    add(fade.out(a.source),b.source)
+
+  elsif
+    # Opposite as the previous one.
+    a.db_level >= b.db_level + margin and b.db_level >= medium and a.db_level <= high
+    then
+    log("old >= new + margin, new >= medium and old <= high")
+    log("Old source is significantly louder than new one.")
+    log("Transition: crossed, fade-in.")
+    add(a.source,fade.in(b.source))
+
+  elsif
+    # Do not fade if it's already very low.
+    b.db_level >= a.db_level + margin and a.db_level <= medium and b.db_level <= high
+  then
+    log("new >= old + margin, old <= medium and new <= high.")
+    log("Do not fade if it's already very low.")
+    log("Transition: crossed, no fade.")
+    add(a.source,b.source)
+
+  # What to do with a loud end and a quiet beginning ?
+  # A good idea is to use a jingle to separate the two tracks,
+  # but that's another story.
+
+  else
+    # Otherwise, A and B are just too loud to overlap nicely, or the
+    # difference between them is too large and overlapping would completely
+    # mask one of them.
+    log("No transition: using default.")
+    default(a.source, b.source)
+  end
+end
+```
+
+You can use it directly in your script, or use this code to define yours!
diff --git a/website/content/doc-2.2.5/custom-path.md b/website/content/doc-2.2.5/custom-path.md
new file mode 100644
index 00000000..1b513689
--- /dev/null
+++ b/website/content/doc-2.2.5/custom-path.md
@@ -0,0 +1,77 @@
+# Basics
+
+Starting with version `1.0.1`, it is possible to build a liquidsoap binary that can load
+all its dependencies from any arbitrary path. This is very useful to distribute a liquidsoap
+bundled binary, independent of the distribution used.
+
+You can enable custom path at configure time, by passing the `--enable-custom-path` configuration option.
+A custom loading path is a directory that contains the following file/directories:
+
+- `./camomile`: Camomile shared data. They are usually located in `/usr/(local/)share/camomile`
+- `./libs`: pervasive scripts. Their are located in `liquidsoap/scripts` in liquidsoap's sources
+- `./log`: default log directories
+- `./magic`: directory for magic files. See below for more details.
+- `./plugins`: default plugins directory (most likely empty)
+- `./run`: default runtime files directory
+
+# Adding liquidsoap binary
+
+In order to ship a liquidsoap binary which is independent of the distribution it will
+be run on, one need to also include its dynamic libraries, except for the most common.
+The following command may be used to list them:
+
+```
+ldd ./liquidsoap | grep usr | cut -d' ' -f 3
+```
+
+Those libraries are usually copied into a `./ld` directory. Then, the `LD_LIBRARY_PATH`
+is used to point the dynamic loader to this directory.
+
+Finally, the `liquidsoap` library is usually added in `./bin/liquidsoap`
+
+# Configuration variables
+
+In the following, configuration variables may refer to either absolute or relative paths. If referring to
+a relative path, the path is resolved relatively to the directory where the `liquidsoap` binary
+is located at.
+
+In order to tell liquidsoap where its custom path is located, you need to set the
+`LIQUIDSOAP_BASE_DIR`.
+
+Another important variable is `MAGIC`. It tells liquidsoap where to load the libmagic's
+definitions and defaults to `../magic/magic.mgc`. Older versions of libmagic may
+require to use `magic/magic.mime` instead.
+
+# Full example
+
+For a fully-functional example, you can check our [heroku buildpack](https://github.com/savonet/heroku-buildpack-liquidsoap).
+Its layout is:
+
+```
+./bin
+./bin/liquidsoap
+./camomile
+./camomile/charmaps
+(...)
+./ld
+./ld/libao.so.2
+(...)
+./libs
+./libs/externals.liq
+(...)
+./log
+./magic
+./magic/magic.mime
+./plugins
+./run
+```
+
+Its configuration variables are set to:
+
+```
+LD_LIBRARY_PATH=/path/to/ld
+LIQUIDSOAP_BASE_DIR=..
+MAGIC=../magic/magic.mime
+```
+
+As you can see, we use an old version of `libmagic` so we need to load `magic.mime` instead of `magic.mgc`.
diff --git a/website/content/doc-2.2.5/documentation.md b/website/content/doc-2.2.5/documentation.md
new file mode 100644
index 00000000..7d3fbf49
--- /dev/null
+++ b/website/content/doc-2.2.5/documentation.md
@@ -0,0 +1,88 @@
+# Documentation index
+
+**How to use**: Start with the [quickstart](quick_start.html) and make sure you
+learn [how to find help](help.html). Then it's as you like: go for another
+[general tutorial](#general), or a [specific example](#specific), pick a [basic
+notion](#core), or some examples from the [cookbook](cookbook.html). If you've
+understood all you need, just browse the [reference](reference.html) and compose
+your dream stream.
+
+If you downloaded a source tarball of liquidsoap, you may first read the
+[build instructions](build.html).
+
+If you are migrating from a previous version, you might want to checkout
+[this page](migrating.html).
+
+## General tutorials
+
+- [The book](bool.html): The Liquidsoap book
+- [Video presentations](presentations.html): some presentations we did about liquidsoap
+- [How to find help](help.html) about operators, settings, server commands, etc.
+- [Frequently Asked Questions, Troubleshooting](faq.html)
+- [Quickstart](quick_start.html): where anyone should start.
+- [Complete case analysis](complete_case.html): an example that is not a toy.
+- [Cookbook](cookbook.html): contains lots of idiomatic examples.
+
+## Reference
+
+- [Script language](language.html): A more detailed presentation.
+- [Core API](reference.html): The core liquidsoap API
+- [Extra API](reference-extra.html): Extra functions and libraries.
+- [Protocols](protocols.html): List of protocols supported by liquidsoap.
+- [Settings](settings.html): The list of available settings for liquidsoap.
+- [FFmpeg](ffmpeg.html): FFmpeg support documentation.
+- [Encoding formats](encoding_formats.html): The available formats for encoding outputs.
+- [Videos streams](video.html): Use `liquidsoap` for video streams
+- [JSON import/export](json.html): Importing and exporting language values in JSON.
+- [Playlist parsers](playlist_parsers.html): Supported playlist formats.
+- [LADSPA plugins](ladspa.html): Using LADSPA plugins.
+
+## Core
+
+- Basic concepts: [sources](sources.html), [clocks](clocks.html) and [requests](requests.html).
+- [Stream contents](stream_content.html): what kind of streams are supported, and how.
+- [Script loading](script_loading.html): load several scripts, learn about the script library.
+- [Execution phases](phases.html)
+
+## Specific tutorials
+
+- [Blank detection](blank.html)
+- [Customize metadata](metadata.html)
+- [Dynamic source creation](dynamic_sources.html): dynamically create sources using server requests.
+- [External decoders](external_decoders.html): use an external program for decoding audio files.
+- [External encoders](external_encoders.html): use an external audio encoding program.
+- [External streams](external_streams.html): use an external program for streaming audio data.
+- [HLS output](hls_output.html): output your stream as HTTP Live Stream.
+- [HTTP input](http_input.html): relay external streams.
+- [Harbor input](harbor.html): receive streams from icecast and shoutcast source clients.
+- [ICY metadata update](icy_metadata.html): manipulate and configure metadata update in Icecast.
+- [Interaction with the Harbor](harbor_http.html): interact with a running Liquidsoap using the Harbor server.
+- [Interaction with the server](server.html) interact with a running Liquidsoap instance using the telnet server.
+- [Normalization and replay gain](replay_gain.html): normalize audio data.
+- [Profiling](profiling.html): profiling your scripts.
+- [Prometheus reporting](prometheus.html): metrics reporting via prometheus.
+- [Requests-based sources](request_sources.html): create advanced sources using requests.
+- [Seek and cue support](seek.html): seek and set cue-in and cue-out points in sources.
+- [Shoutcast output](shoutcast.html): output to shoutcast.
+- [Smart crossfading](smartcrossfade.html): define custom crossfade transitions.
+- [Using in production](in_production.html): integrate liquidsoap scripts in a production environment.
+
+## User scripts
+
+- [Beets](beets.html): an example of a music database integration.
+- [Geekradio](geekradio.html)
+- [RadioPi](radiopi.html)
+- [Frequence3](frequence3.html)
+- [Video with a single static image](video-static.html)
+- [Split a CUE sheet](split-cue.html)
+
+## Code snippets
+
+- [Code example index](scripts/index.html)
+
+## Behind the curtains
+
+- [Some presentations and publications](../publications.html) explaining the theory underlying Liquidsoap
+- [OCaml libraries](../modules.html) used in Liquidsoap, that can be reused in other projects
+- [Documentation of some internals](../modules/liquidsoap/index.html) of Liquidsoap
+- [Documentation for previous versions](../previously.html)
diff --git a/website/content/doc-2.2.5/dynamic_sources.md b/website/content/doc-2.2.5/dynamic_sources.md
new file mode 100644
index 00000000..39a45e58
--- /dev/null
+++ b/website/content/doc-2.2.5/dynamic_sources.md
@@ -0,0 +1,72 @@
+Liquidsoap supports dynamic creation and destruction of sources
+during the execution of a script. The following gives an example
+of this.
+
+First some outlines:
+
+- This example is meant to create a new source and outputs. It is not easy currently to change a source being streamed
+- The idea is to create a new output using a telnet/server command.
+- In order for a Liquidsoap script to run without an active source at startup, it is necessary to include `settings.init.force_start := true` at the start of the script.
+
+In this example, we will register a command that dynamically create a new output based on an encoded stream
+and output it to an arbitrary url, as supported by the ffmpeg copy encoder. This script can be used to create
+a dynamic restreaming platform.
+
+Here's the code:
+
+```liquidsoap
+settings.init.force_start := true
+settings.server.telnet := true
+
+# Replace the path here with a path to some video files:
+s = playlist("/path/to/files")
+
+streams = ref([])
+count = ref(0)
+
+enc = %ffmpeg(
+  format="flv",
+  %audio.copy,
+  %video.copy
+)
+
+def create_stream(url) =
+  if list.assoc.mem(url, !streams) then
+    "Stream for url #{url} already exists!"
+  else
+    out = output.url(id="restream-#{!count}", fallible=true, url=url, enc, s)
+    count := !count + 1
+    streams := [...!streams, (url, out.shutdown)]
+    "OK!"
+  end
+end
+
+def delete_stream(url) =
+  if not list.assoc.mem(url, !streams) then
+    "Stream for url #{url} does not exists!"
+  else
+    shutdown = list.assoc(url, !streams)
+    shutdown()
+    streams := list.filter((fun (el) -> fst(el) != url), !streams)
+    "OK!"
+  end
+end
+
+server.register(namespace="restream",
+                description="Redirect a stream.",
+                usage="start <url>",
+                "start",
+                create_stream)
+server.register(namespace="restream",
+                description="Stop a dynamic playlist.",
+                usage="stop <url>",
+                "stop",
+                delete_stream)
+```
+
+After executing this script, you should see two telnet commands:
+
+- `restream.start <uri>`
+- `restream.stop <uri>`
+
+which you can use to create/destroy dynamically your sources.
diff --git a/website/content/doc-2.2.5/encoding_formats.md b/website/content/doc-2.2.5/encoding_formats.md
new file mode 100644
index 00000000..bc5a4462
--- /dev/null
+++ b/website/content/doc-2.2.5/encoding_formats.md
@@ -0,0 +1,278 @@
+# Encoding formats
+
+Encoders are used to define formats into which raw sources should be encoded by
+an output. Syntax for encoder is: `%encoder(parameters...)` or, if you use
+default parameters, `%encoder`.
+
+Please note that not all encoding formats are available at all time. Most of
+them require optional dependencies. If a format is not available, you should see
+an error like this:
+
+```shell
+Error 12: Unsupported encoder: %sine().
+You must be missing an optional dependency.
+```
+
+In particular, due to limitations with static linking on windows, only the
+`%ffmpeg` encoder is available with our windows build. However, this encoder provides
+a lot of codecs and formats, and it is quite likely that it can provide what you need.
+
+## Formats determine the stream content
+
+In most liquidsoap scripts, the encoding format determines what
+kind of data is streamed.
+
+The type of an encoding format depends on its parameter.
+For example, `%mp3` has type `format(audio=pcm(stereo))`.
+
+The type of an output like `output.icecast`
+or `output.file` is something like
+`(...,format('a),...,source('a))->source('a)`.
+This means that your source will have to have the same type as your format.
+
+For example if you write
+
+```liquidsoap
+output.file(%mp3,"/tmp/foo.mp3",playlist("~/audio"))
+```
+
+then the playlist source will have to stream stereo audio.
+
+In the case of audio format, liquidsoap tries its best to convert the format whenever
+possible. For instance, in the above, liquidsoap will convert mono files
+from the playlist to stereo files by duplicating the single audio channel
+in a mono file. Likewise, if the encoder requires mono audio, it will compute
+the mean of a stereo files.
+
+# List of formats and their syntax
+
+All parameters are optional, and the parenthesis are not needed
+when no parameter is passed. In the following default values
+are shown.
+As a special case, the keywords `mono` and `stereo` can be used to indicate
+the number of channels (whether is is passed as an integer or a boolean).
+
+## MP3
+
+Mp3 encoder comes in 3 flavors:
+
+- `%mp3` or `%mp3.cbr`: Constant bitrate encoding
+- `%mp3.vbr`: Variable bitrate, quality-based encoding.
+- `%mp3.abr`: Average bitrate based encoding.
+
+Parameters common to each flavor are:
+
+- `stereo=true/false`, `mono=true/false`: Encode stereo or mono data (default: `stereo`).
+- `stereo_mode`: One of: `"stereo"`, `"joint_stereo"` or `"default"` (default: `"default"`). Default means that the underlying library (`libmp3lame`) will pick the stereo mode based on compression ration and input channels.
+- `samplerate=44100`: Encoded data samplerate (default: `44100`)
+- `internal_quality=2`: Lame algorithms internal quality. A value between `0` and `9`, `0` being highest quality and `9` the worst (default: `2`).
+- `id3v2=true`: Add an `id3v2` tag to encoded data (default: `false`). This option is only valid if liquidsoap has been compiled with taglib support.
+
+Parameters for `%mp3` are:
+
+- `bitrate`: Encoded data fixed bitrate
+
+Parameters for `%mp3.vbr` are:
+
+- `quality`: Quality of encoded data; ranges from `0` (highest quality) to `9` (worst quality).
+
+Parameters for `%mp3.abr` are:
+
+- `bitrate`: Average bitrate
+- `min_bitrate`: Minimum bitrate
+- `max_bitrate`: Maximum bitrate
+- `hard_min`: Enforce minimal bitrate
+
+Examples:
+
+- Constant `128` kbps bitrate encoding: `%mp3(bitrate=128)`
+- Variable bitrate with quality `6` and samplerate of `22050` Hz: `%mp3.vbr(quality=7,samplerate=22050)`
+- Average bitrate with mean of `128` kbps, maximum bitrate `192` kbps and `id3v2` tags: `%mp3.abr(bitrate=128,max_bitrate=192,id3v2=true)`
+
+Optionally, liquidsoap can insert a message within mp3 data. You can set its value using the `msg` parameter.
+Setting it to `""` disables this feature. This is its default value.
+
+## Shine
+
+Shine is the fixed-point mp3 encoder. It is useful on architectures without a FPU, such as ARM.
+It is named `%shine` or `%mp3.fxp` and its parameters are:
+
+```liquidsoap
+%shine(channels=2,samplerate=44100,bitrate=128)
+```
+
+## WAV
+
+```liquidsoap
+%wav(stereo=true, channels=2, samplesize=16, header=true, duration=10.)
+```
+
+If `header` is `false`, the encoder outputs raw PCM. `duration` is optional
+and is used to set the WAV length header.
+
+Because Liquidsoap encodes a possibly infinite stream, there
+is no way to know in advance the duration of encoded data. Since WAV header
+has to be written first, by default its length is set to the maximum possible
+value. If you know the expected duration of the encoded data and you actually
+care about the WAV length header then you should use this parameter.
+
+## FFmpeg
+
+See detailed [ffmpeg encoders](ffmpeg_encoder.html) article.
+
+## Ogg
+
+The following formats can be put together in an Ogg container.
+The syntax for doing so is `%ogg(x,y,z)` but it is also
+possible to just write `%vorbis(...)`, for example, instead
+of `%ogg(%vorbis(...))`.
+
+All ogg encoders have a `bytes_per_page` parameter, which can be used to
+try to limit ogg logical pages size. For instance:
+
+```liquidsoap
+# Try to limit vorbis pages size to 1024 bytes
+%vorbis(bytes_per_page=1024)
+```
+
+### Vorbis
+
+```liquidsoap
+# Variable bitrate
+%vorbis(samplerate=44100, channels=2, quality=0.3)
+% Average bitrate
+%vorbis.abr(samplerate=44100, channels=2, bitrate=128, max_bitrate=192, min_bitrate=64)
+# Constant bitrate
+%vorbis.cbr(samplerate=44100, channels=2, bitrate=128)
+```
+
+Quality ranges from -0.2 to 1,
+but quality -0.2 is only available with the aotuv implementation of libvorbis.
+
+### Opus
+
+Opus is a lossy audio compression made especially suitable for interactive real-time applications
+over the Internet. Liquidsoap supports Opus data encapsulated into Ogg streams.
+
+The encoder is named `%opus` and its parameters are as follows. Please refer
+to the [Opus documentation](http://www.opus-codec.org/docs/) for information about
+their meanings and values.
+
+- `vbr`: one of `"none"`, `"constrained"` or `"unconstrained"`
+- `application`: One of `"audio"`, `"voip"` or `"restricted_lowdelay"`
+- `complexity`: Integer value between `0` and `10`.
+- `max_bandwidth`: One of `"narrow_band"`, `"medium_band"`, `"wide_band"`, `"super_wide_band"` or `"full_band"`
+- `samplerate`: input samplerate. Must be one of: `8000`, `12000`, `16000`, `24000` or `48000`
+- `frame_size`: encoding frame size, in milliseconds. Must be one of: `2.5`, `5.`, `10.`, `20.`, `40.` or `60.`.
+- `bitrate`: encoding bitrate, in `kbps`. Must be a value between `5` and `512`. You can also set it to `"auto"`.
+- `channels`: currently, only `1` or `2` channels are allowed.
+- `mono`, `stereo`: equivalent to `channels=1` and `channels=2`.
+- `signal`: one of `"voice"` or `"music"`
+
+### Theora
+
+```liquidsoap
+%theora(quality=40,width=640,height=480,
+        picture_width=255,picture_height=255,
+        picture_x=0, picture_y=0,
+        aspect_numerator=1, aspect_denominator=1,
+        keyframe_frequency=64, vp3_compatible=false,
+        soft_target=false, buffer_delay=5,
+        speed=0)
+```
+
+You can also pass `bitrate=x` explicitly instead of a quality.
+The default dimensions are liquidsoap's default,
+from the settings `frame.video.height/width`.
+
+### Speex
+
+```liquidsoap
+%speex(stereo=false, samplerate=44100, quality=7,
+       mode=wideband, # One of: wideband|narrowband|ultra-wideband
+       frames_per_packet=1,
+       complexity=5)
+```
+
+You can also control quality using `abr=x` or `vbr=y`.
+
+### Flac
+
+The flac encoding format comes in two flavors:
+
+- `%flac` is the native flac format, useful for file output but not for streaming purpose
+- `%ogg(%flac,...)` is the ogg/flac format, which can be used to broadcast data with icecast
+
+The parameters are:
+
+```liquidsoap
+%flac(samplerate=44100,
+      channels=2,
+      compression=5,
+      bits_per_sample=16)
+```
+
+`compression` ranges from 0 to 8 and `bits_per_sample` should be one of: `8`, `16`, `24` or `32`.
+Please note that `32` bits per sample is currently not supported by the underlying `libflac`.
+
+## FDK-AAC
+
+This encoder can do both AAC and AAC+.
+
+Its syntax is:
+
+```liquidsoap
+%fdkaac(channels=2, samplerate=44100, bandwidth="auto", bitrate=64, afterburner=false, aot="mpeg2_he_aac_v2", transmux="adts", sbr_mode=false)
+```
+
+Where `aot` is one of: `"mpeg4_aac_lc"`, `"mpeg4_he_aac"`, `"mpeg4_he_aac_v2"`,
+`"mpeg4_aac_ld"`, `"mpeg4_aac_eld"`, `"mpeg2_aac_lc"`, `"mpeg2_he_aac"` or
+`"mpeg2_he_aac_v2"`
+
+`bandwidth` is one of: `"auto"`, any supported integer value.
+
+`transmux` is one of: `"raw"`, `"adif"`, `"adts"`, `"latm"`, `"latm_out_of_band"` or `"loas"`.
+
+Bitrate can be either constant by passing: `bitrate=64` or variable: `vbr=<1-5>`
+
+You can consult the [Hydrogenaudio knowledge base](http://wiki.hydrogenaud.io/index.php?title=Fraunhofer_FDK_AAC) for more details
+on configuration values and meanings.
+
+## Gstreamer
+
+The `%gstreamer` encoder can be used to encode streams using the `gstreamer` multimedia framework.
+This encoder extends liquidsoap with all available GStreamer formats which includes most, if not all,
+formats available to your operating system.
+
+The encoder's parameters are as follows:
+
+```liquidsoap
+%gstreamer(channels=2,
+           audio="lamemp3enc",
+           has_video=true,
+           video="x264enc",
+           muxer="mpegtsmux",
+           metadata="metadata",
+           log=5,
+           pipeline="")
+```
+
+Please refer to the [Gstreamer encoder](gstreamer_encoder.html) page for a detailed explanation
+of this encoder.
+
+## External encoders
+
+For a detailed presentation of external encoders, see [this page](external_encoders.html).
+
+```liquidsoap
+%external(channels=2,samplerate=44100,header=true,
+          restart_on_crash=false,
+          restart_on_metadata,
+          restart_after_delay=30,
+          process="progname")
+```
+
+Only one of `restart_on_metadata` and `restart_after_delay` should
+be passed. The delay is specified in seconds.
+The encoding process is mandatory, and can also be passed directly
+as a string, without `process=`.
diff --git a/website/content/doc-2.2.5/external_decoders.md b/website/content/doc-2.2.5/external_decoders.md
new file mode 100644
index 00000000..02c3b9e3
--- /dev/null
+++ b/website/content/doc-2.2.5/external_decoders.md
@@ -0,0 +1,215 @@
+## Introduction
+
+You can use external programs in liquidsoap to decode audio files. The program must be able to
+output WAV data to its standard output (`stdout`) and, posssibly, read encoded data from its
+standard input.
+
+Please note that this feature is not available under Windows.
+
+## Basic operators
+
+External decoders are registered using the `decoder.add` and `decoder.oblivious.add` operators.
+They are invoked the following way:
+
+### `decoder.add`
+
+```liquidsoap
+decoder.add(name="my_decoder",description="My custom decoder",
+            test,decoder)
+```
+
+`decoder.add` is used for external decoders that can read the encoded data from their standard
+input (stdin) and write the decoded data as WAV to their standard output (stdout). This operator
+is recommended because its estimation of the remaining time is better than the estimation done
+by the decoders registered using `decoder.oblivious.add`. The important parameters are:
+
+- `test` is a function used to determine if the file should be decoded by the decoder. Returned values are:
+
+  - `0`: no decodable audio,
+  - `-1`: decodable audio but number of audio channels unknown,
+  - `x`: fixed number of decodable audio channels.
+
+- `decoder` is the string containing the shell command to run to execute the decoding process.
+
+### `decoder.oblivious.add`
+
+`decoder.oblivious.add` is very similar to `decoder.add`. The main difference is that the
+decoding program reads encoded data directly from the local files and not its standard input.
+Decoders registered using this operator do not have a reliable estimation of the remaining
+time. You should use `decoder.oblivious.add` only if your decoding program is not able
+to read the encoded data from its standard input.
+
+```liquidsoap
+decoder.oblivious.add(name="my_decoder",description="My custom decoder",
+                      buffer=5., test,decoder)
+```
+
+`decoder.add` is used for external decoders that can read the encoded data from their standard
+input (stdin) and write the decoded data as WAV to their standard output (stdout). This operator
+is recommended because its estimation of the remaining time is better than the estimation done
+by the decoders registered using `decoder.oblivious.add`. The important parameters are:
+
+- `test` is a function used to determine if the file should be decoded by the decoder. Returned values are:
+
+  - `0`: no decodable audio,
+  - `-1`: decodable audio but number of audio channels unknown,
+  - `x`: fixed number of decodable audio channels.
+
+- `decoder` is a function that receives the name of the file that should be decoded and returns a string containing the shell command to run to execute the decoding process.
+
+### `decoder.metadata.add`
+
+You may also register new metadata resolvers using the `decoder.metadata.add` operator. It is invoked the
+following way: `decoder.metadata.add(format,resolver)`, where:
+
+- `format` is the name of the resolved format. It is only informative.
+- `resolver` is a function `f` that returns a list of metadata of the form: `(label, value)`. It is invoked the following way: `f(format=name,file)`, where:
+
+  - `format` contains the name of the format, as returned by the decoder that accepted to decode the file. `f` may return immediately if this is not an expected value.
+  - `file` is the name of the file to decode.
+
+## Wrappers
+
+On top of the basic operators, wrappers have been written for some common decoders. This includes the `flac` and
+`faad` decoders, by default. All the operators are defined in `externals.liq`.
+
+### The FLAC decoder
+
+The flac decoder uses the `flac` command line. It is enabled if the binary can be found in the current `$PATH`.
+
+Its code is the following:
+
+```liquidsoap
+  def test_flac(file) =
+    if process.test("which metaflac") then
+      channels = list.hd(default="",process.read.lines("metaflac \
+                                            --show-channels #{quote(file)} \
+                                            2>/dev/null"))
+      # If the value is not an int, this returns 0 and we are ok :)
+      int_of_string(channels)
+    else
+      # Try to detect using mime test..
+      mime = get_mime(file)
+      if string.match(pattern="flac",file) then
+        # We do not know the number of audio channels
+        # so setting to -1
+        (-1)
+      else
+        # All tests failed: no audio decodable using flac..
+        0
+      end
+    end
+  end
+  decoder.add(name="FLAC",description="Decode files using the flac \
+              decoder binary.", test=test_flac,flac_p)
+```
+
+Additionally, a metadata resolver is registered when the `metaflac` command can be found in the `$PATH`:
+
+```liquidsoap
+if process.test("which metaflac") then
+  log(level=3,"Found metaflac binary: \
+               enabling flac external metadata resolver.")
+  def flac_meta(file)
+    ret = process.read.lines("metaflac --export-tags-to=- \
+                            #{quote(file)} 2>/dev/null")
+    ret = list.map(string.split(separator="="),ret)
+    # Could be made better..
+    def f(l',l)=
+      if list.length(l) >= 2 then
+        list.append([(list.hd(default="",l),list.nth(default="",l,1))],l')
+      else
+        if list.length(l) >= 1 then
+          list.append([(list.hd(default="",l),"")],l')
+        else
+          l'
+        end
+      end
+    end
+  list.fold(f,[],ret)
+  end
+  decoder.metadata.add("FLAC",flac_meta)
+end
+```
+
+### The faad decoder
+
+The faad decoder uses the `faad` program, if found in the `$PATH`.
+It can decode AAC and AAC+ audio files. This program does not support
+reading encoded data from its standard input so the decoder is
+registered using `decoder.oblivious.add`.
+
+Its code is the following:
+
+```liquidsoap
+  aac_mimes = ["audio/aac", "audio/aacp", "audio/3gpp", "audio/3gpp2", "audio/mp4",
+               "audio/MP4A-LATM", "audio/mpeg4-generic", "audio/x-hx-aac-adts"]
+  aac_filexts = ["m4a", "m4b", "m4p", "m4v",
+                 "m4r", "3gp", "mp4", "aac"]
+
+  # Faad is not very selective so
+  # We are checking only file that
+  # end with a known extension or mime type
+  def faad_test(file) =
+    # Get the file's mime
+    mime = get_mime(file)
+    # Test mime
+    if list.mem(mime,aac_mimes) then
+      true
+    else
+      # Otherwise test file extension
+      ret = string.extract(pattern='\.(.+)$',file)
+        if list.length(ret) != 0 then
+          ext = ret["1"]
+          list.mem(ext,aac_filexts)
+        else
+          false
+        end
+    end
+  end
+
+  if process.test("which faad") then
+    log(level=3,"Found faad binary: enabling external faad decoder and \
+                 metadata resolver.")
+    faad_p = (fun (f) -> "faad -w #{quote(f)} 2>/dev/null")
+    def test_faad(file) =
+      if faad_test(file) then
+        channels = list.hd(default="",process.read.lines("faad -i #{quote(file)} 2>&1 | \
+                                                         grep 'ch,'"))
+        ret = string.extract(pattern=", (\d) ch,",channels)
+        ret =
+          if list.length(ret) == 0 then
+          # If we pass the faad_test, chances are
+          # high that the file will contain aac audio data..
+            "-1"
+          else
+            ret["1"]
+          end
+        int_of_string(default=(-1),ret)
+      else
+        0
+      end
+    end
+    decoder.oblivious.add(name="FAAD",description="Decode files using \
+                          the faad binary.", test=test_faad, faad_p)
+    def faad_meta(file) =
+      if faad_test(file) then
+        ret = process.read.lines("faad -i \
+                     #{quote(file)} 2>&1")
+        # Yea, this is tuff programming (again) !
+        def get_meta(l,s)=
+          ret = string.extract(pattern="^(\w+):\s(.+)$",s)
+          if list.length(ret) > 0 then
+            list.append([(ret["1"],ret["2"])],l)
+          else
+            l
+          end
+        end
+        list.fold(get_meta,[],ret)
+      else
+        []
+      end
+    end
+    decoder.metadata.add("FAAD",faad_meta)
+  end
+```
diff --git a/website/content/doc-2.2.5/external_encoders.md b/website/content/doc-2.2.5/external_encoders.md
new file mode 100644
index 00000000..018a6f65
--- /dev/null
+++ b/website/content/doc-2.2.5/external_encoders.md
@@ -0,0 +1,60 @@
+## Introduction
+
+You can use any external program that accepts wav or raw PCM data to encode audio data and use the resulting compressed
+stream as an output, either to a file, a pipe, or even icecast.
+
+When using an external encoding process, uncompressed PCM data will be sent to the process through its standard input (`stdin`), and encoded data will be read through its standard output (`stdout`). When using a process that does only file input or output, `/dev/stdin` and `/dev/stdout` can be used, though this may generate issues if the encoding process expects to be able to go backward/forward in the file.
+
+## External encoders
+
+The main operators that can be used with external encoders are:
+
+- `output.file`
+- `output.icecast`
+
+In order to use external encoders with these operators, you have to use the
+`%external` [encoding format](encoding_formats.html).
+Its syntax is:
+
+```liquidsoap
+%external(channels=2,samplerate=44100,header=true,
+          restart_on_crash=false,
+          restart_on_metadata,
+          restart_after_delay=30,
+          process="progname")
+```
+
+The available options are:
+
+- `process`: this parameter is a function that takes the current metadata and return the process to start.
+- `header`: if set to `false` then no WAV header will be added to the data fed to the encoding process, thus the encoding process shall operate on RAW data.
+- `restart_on_crash`: whether to restart the encoding process if it crashed. Useful when the external process fails to encode properly data after some time.
+- `restart_on_metadata`: restart encoding process on each new metadata. Useful in conjunction with the `process` parameter for audio formats that need a new header, possibly with metadatas, for each new track. This is the case for the ogg container.
+- `restart_encoder_delay`: Restart the encoder after some delay. This can be useful for encoders that cannot operate on infinite streams, or are buggy after some time, like the `lame` binary. The default for `lame` and `accplusenc`-based encoders is to restart the encoder every hour.
+
+Only one of `restart_encoder_delay` or `restart_on_new_track` should be used.
+
+The restart mechanism strongly relies on the good behaviour of the encoding process. The restart operation will
+close the standard input of the encoding process. The encoding process is then expected to finish its own operations and
+close its standard output. If it does not close its standard output, the encoding task will not finish.
+
+If your encoding process has this issue, you should turn the `restart_on_crash` option to `true` and kill the encoding
+process yourself.
+
+If you use an external encoder with the `output.icecast` operator,
+you should also use the following options of `output.icecast`:
+
+- `icy_metadata`: send new metadata as ICY update. This is the case for headerless formats, such as MP3 or AAC, and it appears to work also for ogg/vorbis streams.
+- `format`: Content-type (mime) of the data sent to icecast. For instance, for ogg data, it is one of `"application/ogg"`, `"audio/ogg"` or `"video/ogg"` and for mp3 data it is `"audio/mpeg"`.
+
+## Video support
+
+Videos can also be encoded by programs able to read files in avi format from
+standard input. To use it, the flag `video=true` of `%external` should be
+used. For instance, a compressed avi file can be generated with `ffmpeg` using
+
+```liquidsoap
+output.file(
+  %external(process="ffmpeg -i pipe:0 -f avi pipe:1",video=true),
+  "/tmp/test.avi", s)
+```
diff --git a/website/content/doc-2.2.5/external_streams.md b/website/content/doc-2.2.5/external_streams.md
new file mode 100644
index 00000000..2d40cdc8
--- /dev/null
+++ b/website/content/doc-2.2.5/external_streams.md
@@ -0,0 +1,49 @@
+## Introduction
+
+You can use an external program to create a source that will read data coming out
+of the standard output (`stdout`) of this program. Contrary to the external file decoders,
+data will be buffered and played when a sufficient amount was accumulated.
+
+The program should output data in signed 16 bits little endian PCM (s16le). Number of
+channels and samplerate can be specified. There is no need of any wav header in the data,
+though it should work too.
+
+## Basic operator
+
+The basic operator for creating an external stream is `input.external`. Its parameters are:
+
+- `buffer`: Duration of the pre-buffered data.
+- `max`: Maximum duration of the buffered data.
+- `channels`: Number of channels.
+- `samplerate`: Sample rate.
+- `restart`: Restart the process when it has exited normally.
+- `restart_on_error`: Restart the process when it has exited with error.
+
+The last parameter is unlabeled. It is a string containing the command that will be executed to
+run the external program.
+
+## Wrappers
+
+A wrapper, `input.mplayer`, is defined to use mplayer as the external decoder.
+Its code is:
+
+```liquidsoap
+# Stream data from mplayer
+# @category Source / Input
+# @param s data URI.
+# @param ~restart restart on exit.
+# @param ~restart_on_error restart on exit with error.
+# @param ~buffer Duration of the pre-buffered data.
+# @param ~max Maximum duration of the buffered data.
+def input.mplayer(~id="input.mplayer",
+         ~restart=true,~restart_on_error=false,
+         ~buffer=0.2,~max=10.,s) =
+  input.external(id=id,restart=restart,
+      restart_on_error=restart_on_error,
+      buffer=buffer,max=max,
+      "mplayer -really-quiet \
+              -ao pcm:file=/dev/stdout \
+              -vc null -vo null #{quote(s)} \
+                    2>/dev/null")
+end
+```
diff --git a/website/content/doc-2.2.5/faq.md b/website/content/doc-2.2.5/faq.md
new file mode 100644
index 00000000..d184dcc2
--- /dev/null
+++ b/website/content/doc-2.2.5/faq.md
@@ -0,0 +1,224 @@
+# Frequently Asked Questions
+
+## What does this message means?
+
+### Type error
+
+Liquidsoap might also reject a script with a series of errors of the form ` this value has type ... but it should be a subtype of ...`
+. Usually the last error tells you what the problem is, but the previous errors might provide a better information as to where the error comes from.
+
+For example, the error might indicate that a value of type `int` has been passed where a float was expected, in which case you should use a conversion, or more likely change an integer value such as `13` into a float `13.`.
+
+A type error can also show that you're trying to use a source of a certain content type (e.g., audio) in a place where another content type (e.g., pure video) is required. In that case the last error in the list is not the most useful one, but you will read something like this above:
+
+```
+At ...:
+Error 5: this value has type
+  source(video=canvas(_),...)
+but it should be a subtype of
+  source(audio=pcm(_),...)
+```
+
+Sometimes, the type error actually indicates a mistake in the order or labels of arguments. For example, given `output.icecast(mount="foo.ogg",source)` liquidsoap will complain that the second argument is a source (`source(?A)`) but should be a format (`format(?A)`): indeed, the first unlabelled argument is expected to be the encoding format, e.g., `%vorbis`, and the source comes only second.
+
+Finally, a type error can indicate that you have forgotten to pass a mandatory parameter to some function. For example, on the code `fallback([source.mux.audio(x),...])`, liquidsoap will complain as follows:
+
+```
+At line ...:
+Error 5: this value has type
+  [(?id : _, audio : _) -> _]
+but it should be a subtype of the type of the value at ../libs/switches.liq, line 11, char 11-18
+  [source(_)] (inferred at ../libs/list.liq, line 102, char 29)
+```
+
+Indeed, `fallback` expects a source, but `source.mux.audio(x)` is still a function expecting the `audio` parameter.
+
+### That source is fallible!
+
+See the [quickstart](quick_start.html), or read more about
+[sources](sources.html).
+
+### Clock error
+
+Read about [clocks](clocks.html) for the errors
+`a source cannot belong to two clocks`
+and
+`cannot unify two nested clocks`.
+
+### We must catchup x.xx!
+
+This error means that a clock is getting late in liquidsoap. This can
+be caused by an overloaded CPU, if your script is doing too much encoding
+or processing: in that case, you should reduce the load on your machine
+or simplify your liquidsoap script. The latency may also be caused by
+some lag, for example a network lag will cause the icecast output to
+hang, making the clock late.
+
+The first kind of latency is problematic because it tends to accumulate,
+eventually leading to the restarting of outputs:
+
+```
+Too much latency!
+Resetting active source...
+```
+
+The second kind of latency can often be ignored: if you are streaming to
+an icecast server, there are several buffers between you and your
+listeners which make this problem invisible to them. But in more realtime
+applications, even small lags will result in glitches.
+
+In some situations, it is possible to isolate some parts of a script
+from the latency caused by other parts. For example, it is possible to
+produce a clean script and back it up into a file, independently of
+its output to icecast (which again is sensitive to network lags).
+For more details on those techniques, read about [clocks](clocks.html).
+
+### Unable to decode ``file'' as {audio=pcm}!
+
+This log message informs you that liquidsoap failed to decode a file, not
+necessarily because it cannot handle the file, but also possibly because
+the file does not contain the expected media type. For example, if audio and video
+is expected, an audio file with no video will be rejected.
+
+Liquidsoap is also able to convert audio channels in most situations. Typically,
+if stereo data is expected but the file contains mono audio, liquidsoap will use
+the single audio channel as both left and right channels.
+
+### Runtime exceptions
+
+Liquidsoap scripts can raise runtime errors of the form:
+
+```
+At line 3, char 45:
+Error 14: Uncaught runtime error:
+type: not_found, message: "File not found!"
+```
+
+These are errors that the script programmer can catch and decide what to do when they
+occur. Such errors will typically occur when trying to read a file that does not
+exist and etc.
+
+The [language page](language.html) has more details about errors, how to raise them
+and how to catch them. You can head over there to get more information.
+
+### Crashes
+
+Liquidsoap dies with messages such as these by the end of the log:
+
+```
+... [threads:1] Thread "XXX" aborts with exception YYY!
+... [stderr:3] Thread 2 killed on uncaught exception YYY.
+... [stderr:3] Raised at file ..., line ..., etc.
+```
+
+Those internal errors can be of two sorts:
+
+- **Bug**: Normally, this means that you've found a bug, which you should report on the mailing list or bug tracker.
+- **User error**: In some cases, we let an exception go on user errors, instead of nicely reporting and handling it. By looking at the surrounding log messages, you might realize that liquidsoap crashed for a good reason, that you are responsible for fixing. You can still report a bug: you should not have seen an exception and its backtrace.
+
+In any case, once that kind of error happens, there is no way for the
+user to prevent liquidsoap from crashing. Those exceptions cannot be
+caught or handled in any way at the level of liquidsoap scripts.
+
+## Troubleshooting
+
+### Pulseaudio
+
+When using ALSA input or output or, more generally any audio input or output
+that is not using pulseaudio, you should disable pulseaudio, which is often installed
+by default. Pulseaudio emulates ALSA but this also generates bugs,
+in particular errors of this form:
+
+```
+Alsa.Unknown_error(1073697252)!
+```
+
+There are two things you may do:
+
+- Make sure your alsa input/output does not use pulseaudio
+- Disable pulseaudio on your system
+
+In the first case, you should first find out which sound card you want to use,
+with the command `aplay -l`. An example of its output is:
+
+```
+**** List of PLAYBACK Hardware Devices ****
+card 0: Intel [HDA Intel], device 0: STAC92xx Analog [STAC92xx Analog]
+  Subdevices: 1/1
+  Subdevice #0: subdevice #0
+```
+
+In this case, the card we want to use is: device `0`, subdevice `0`, thus:
+`hw:0,0`. We now create a file `/etc/asound.conf` (or `~/.asoundrc` for single-user
+configuration) that contains the following:
+
+```liquidsoap
+pcm.liquidsoap {
+        type plug
+        slave { pcm "hw:0,0" }
+}
+```
+
+This creates a new alsa device that you can use with liquidsoap. The `plug` operator
+in ALSA is used to work-around any hardware limitations in your device (mixing multiple
+outputs, resampling etc.). In some cases you may need to read more about ALSA and define
+your own PCM device.
+
+Once you have created this device, you can use it in liquidsoap as follows:
+
+```liquidsoap
+input.alsa(device="pcm.liquidsoap", ...)
+```
+
+In the second case -- disabling pulseaudio, you can edit the file `/etc/pulse/client.conf` and
+change or add this line:
+
+```
+autospawn = no
+```
+
+And kill any running pulseaudio process:
+
+```
+killall pulseaudio
+```
+
+Otherwise you may simply remove pulseaudio's packages, if you use Debian or Ubuntu:
+
+```
+apt-get remove pulseaudio libasound2-plugins
+```
+
+### Listeners are disconnected at the end of every track
+
+Several media players, including renowned ones, do not properly support
+Ogg/Vorbis streams: they treat the end of a track as an end of file,
+resulting in the disconnection.
+
+Players that are affected by this problem include VLC.
+Players that are not affected include ogg123, liquidsoap.
+
+One way to work around this problem is to not use Ogg/Vorbis (which we
+do not recommend) or to not produce tracks within a Vorbis stream.
+This is done by merging liquidsoap tracks (for example using
+`add(normalize=false,[blank(),source])`)
+and also not passing any metadata
+(which is also a result of the previous snippet).
+
+### Encoding blank
+
+Encoding pure silence is often too effective for streaming: data is so
+compressed that there is nothing to send to listeners, whose clients
+eventually disconnect. Therefore, it is a good idea to use a non-silent
+jingle instead of `blank()` to fill in the blank. You can
+also achieve various effects using synthesis sources such as
+`noise()`, `sine()`, etc.
+
+### Temporary files
+
+Liquidsoap relies on OCaml's `Filename.tmp_dir_name` variable to store temporary
+files. It is documented as follows:
+
+The name of the temporary directory: Under Unix, the value of the `TMPDIR` environment
+variable, or `"/tmp"` if the variable is not set. Under Windows, the value of the `TEMP`
+environment variable, or `"."` if the variable is not set.
diff --git a/website/content/doc-2.2.5/ffmpeg.md b/website/content/doc-2.2.5/ffmpeg.md
new file mode 100644
index 00000000..5a2633e8
--- /dev/null
+++ b/website/content/doc-2.2.5/ffmpeg.md
@@ -0,0 +1,324 @@
+# FFmpeg Support
+
+Since the `2.0.x` release cycle, liquidsoap integrates a tight support of ffmpeg. This includes:
+
+- [Decoders](#decoders)
+- [Encoders](#encoders)
+- [Filters](#filters)
+- [Bitstream filters](#bitstream-filters)
+- [Encoded data tweaks](#encoded-data-tweaks)
+- [Examples](#examples)
+
+Ffmpeg support includes 3 types of content:
+
+- **Internal content**, that is content available to all liquidsoap operators: `PCM` audio and `YUV420p` video
+- **Raw content**, that is decoded content but stored as ffmpeg internal frame.
+  This type of content is only available to ffmpeg filters and raw encoders. It can be used to avoid data copies back and forth between liquidsoap and ffmpeg.
+- **Copy content**, that is encoded content stored as ffmpeg internal packets.
+  This type of content is only available to ffmpeg copy encoder and bitstream filters and requires a fairly good understanding of media codecs and containers.
+  Copy contents can be used to avoid transcoding and pass encoded data end-to-end inside liquidsoap scripts.
+
+## Enabling ffmpeg support
+
+FFmpeg support is available via the external [ocaml-ffmpeg](https://github.com/savonet/ocaml-ffmpeg) binding package. If you are using any binary asset from
+our release pages or via docker, this should already be included.
+
+If you are installing via [opam](https://opam.ocaml.org/), installing the `ffmpeg` package should do the trick:
+
+```sh
+% opam install ffmpeg
+```
+
+### fdk-aac support in ffmpeg
+
+One common question is how to install `ffmpeg` with `fdk-aac` support. This can get tricky because you need the _ffmpeg shared libraries_ compiled with `libfdk-aac`.
+This means that installing `libfdk-aac` alone will not be enough, you might also need to recompile `ffmpeg` to take advantage of it.
+
+When recompiling `ffmpeg`, make sure that the `--enable-shared` argument is passed to the `configure` script. Also, compiling the shared libraries is different
+than downloading the `ffmpeg` command line. Most `ffmpeg` downloads include a _static build_ of ffmpeg that is, one that does not use or provide shared libraries.
+
+On linux platforms, you can check what dynamic libraries liquidsoap is using using
+
+```shell
+ldd /path/to/liquidsopap
+```
+
+On macos, you can use `otool -L`. In the list of libraries, you should see `libavcodec`. In turn, you should be able to use the same command to inspect the libraries required by the `libavcodec` used by the `liquidsoap` binary. If this includes `libfdk-aac`, you're good to go!
+
+On debian, you might be able to use [deb-multimedia.org](https://www.deb-multimedia.org/) to install a build of `ffmpeg` with `libfdk-aac` enabled. You are advised
+to follow the instructions on the website for the latest up-to date guide. You may also refer to [this conversation](https://github.com/savonet/liquidsoap/discussions/3027#discussioncomment-6072338).
+
+## Decoders
+
+For the most part, you should never have to worry about the `ffmpeg` decoder. When enabled, it should be the preferred decoder for all supported media.
+When using raw or copied content, the decoder is able to produce the required content without the need of any intervention on the user part.
+
+Should you need to tweak it, here are a couple of pointers:
+
+The `settings.decoder.decoders` settings controls which decoders are to be used when trying to decode media files.
+You can use it to restrict which decoders are being used, for instance making sure only the ffmpeg decoder is used:
+
+```liquidsoap
+settings.decoder.decoders := ["FFMPEG"]
+```
+
+Priority for the decoder is set via:
+
+```liquidsoap
+settings.decoder.priorities.ffmpeg := 10
+```
+
+You can use this setting to adjust whether or not the ffmpeg decoder should be tried first when decoding media files, in particular in
+conjunction with the other `settings.decoder.priorities.*` settings.
+
+For each type of media codec, the `settings.decoder.ffmpeg.codecs.*` settings can be used to tell `ffmpeg` which decoder to use to
+decode this type of content (there could more than one decoder for a given codec).
+
+For instance, for the `aac` codec:
+
+- `settings.decoder.ffmpeg.codecs.aac.available()` returns the list of available decoders, typically `["aac", "aac_fixed"]`.
+- `settings.decoder.ffmpeg.codecs.aac` can be used to choose which decoder should be used, typically: `settings.decoder.ffmpeg.codecs.aac := "aac"`
+
+When debugging issues with `ffmpeg`, it can be useful to increase the log verbosity.
+
+```liquidsoap
+settings.ffmpeg.log.verbosity := "warning"
+```
+
+This settings sets the verbosity of `ffmpeg` logs. Possible values, from less verbose to more verbose are:
+`"quiet"`, `"panic"`, `"fatal"`, `"error"`, `"warning"`, `"info"`, `"verbose"` or `"debug"`
+
+Please note that, due to a technical limitation, we are not yet able to route `ffmpeg` logs through
+the liquidsoap logging facilities, which means that `ffmpeg` logs are currently only printed to the
+process's standard output and that the `settings.ffmpeg.log.level` is currently not used.
+
+### Decoder arguments
+
+In some cases, for instance when sending raw PCM data, it might be required to pass some arguments to
+the ffmpeg decoder to let it know what kind of format, codec, etc. it should decode.
+
+There are two ways to do that:
+
+- For _streams_, the `content_type` argument can be used. The convention is to use `"application/ffmpeg;<arguments>"`.
+- For _files_, the `ffmpeg_options` metadata can be used, for instance using the `annotate` protocol: `annotate:ffmpeg_options="<arguments>":/path/to/file.raw`
+
+Here's an example of a SRT input and output that can be used to send raw PCM data between two instances:
+
+Sender:
+
+```liquidsoap
+enc = %ffmpeg(
+  format="s16le",
+  %audio(
+    codec="pcm_s16le",
+    ac=2,
+    ar=48000
+  )
+)
+
+output.srt(enc, s)
+```
+
+Receiver:
+
+```liquidsoap
+s = input.srt(
+  content_type="application/ffmpeg;format=s16le,ch_layout=stereo,sample_rate=48000"
+)
+```
+
+If, instead of using `output.srt` above, we were using `output.file` and saving to a file
+named `bla.raw`, this file could be read with a `single` source this way:
+
+```liquidsoap
+s = single("annotate:ffmpeg_options='format=s16le,ch_layout=stereo,sample_rate=44100':/tmp/bla.raw")
+```
+
+This could also be done in a `playlist` or `request.dynamic` and etc.
+
+## Encoders
+
+See detailed [ffmpeg encoders](ffmpeg_encoder.html) article.
+
+## Filters
+
+See detailed [ffmpeg filters](ffmpeg_filters.html) article.
+
+## Bitstream filters
+
+FFmpeg bitstream filters are filters that modify the binary content of _encoded data_. They can be used to adjust certain aspects of
+media codecs and containers to make them fit some specific use, for instance a rtmp/flv output etc. They are particularly important
+when dealing with live switches of encoded content (see [Examples](#examples) section).
+
+The list of all bitstream filters is documented on [FFmpeg](https://www.ffmpeg.org/ffmpeg-bitstream-filters.html) online doc and
+our [extra API reference](reference-extras.html). Here's one such filter:
+
+```liquidsoap
+% liquidsoap -h ffmpeg.filter.bitstream.h264_mp4toannexb
+
+FFmpeg h264_mp4toannexb bitstream filter. See ffmpeg documentation for more
+details.
+
+Type: (?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+
+Category: Source / FFmpeg filter
+
+Arguments:
+
+ * id : string?
+     Force the value of the source ID.
+
+ * (unlabeled) : source(video=ffmpeg.copy('a), 'b)
+
+Methods:
+...
+```
+
+Please consult the FFmpeg documentation for more details about that each filter do and why/how to use them.
+
+## Encoded data tweaks
+
+Manipulating encoded content is powerful but can sometimes require some specific knowledge of internals aspects of media codecs and containers. This section
+lists some specific cases.
+
+### Relaxed copy content compatibility check
+
+By default, liquidsoap keeps track of the content passed in a stream containing ffmpeg encoded content (`ffmpeg.copy`) and only allows file and stream decoders to return strictly compatible
+content, e.g. same video resolution or audio samplerate.
+
+Some containers such as `mp4`, however, do allow stream where video resolution or audio samplerate changes between tracks. In this case, you can
+relax those compatibility checks using the following setting:
+
+```liquidsoap
+settings.ffmpeg.content.copy.relaxed_compatibility_check := true
+```
+
+This is a global setting for now and could be refined per-stream in the future if the needs arises.
+
+### Shared encoders
+
+`liquisoap` provides operators to encode data using `%ffmpeg` and re-use it across output. This is called _inline encoding_. Here's an example:
+
+```liquidsoap
+audio_source = single(audio_url)
+video_source = single(image)
+
+stream = source.mux.video(video=video_source, audio_source)
+
+stream = ffmpeg.encode.audio_video(
+    %ffmpeg(
+        %audio(codec="aac", b="128k"),
+        %video(codec="libx264", b="4000k")
+    ),
+    stream
+)
+
+flv = %ffmpeg(
+    format="flv",
+    %audio.copy,
+    %video.copy,
+)
+
+# Send to one youtube output:
+output.youtube.live.rtmp(
+    encoder = flv,
+    stream,
+    ...
+)
+
+mpegts = %ffmpeg(
+    format="mpegts",
+    %audio.copy,
+    %video.copy,
+)
+
+# And to a hls one:
+output.file.hls(
+  ["mpegts", mpegts],
+  stream,
+  ...
+)
+```
+
+Working with encoded data, however, requires a bit of knowledge of ffmpeg internal and media codecs and containers. Here, for instance, this stream
+will have issues because the `flv` format requires global data, something that in ffmpeg terms is called `extradata`.
+
+When working with a single encoder such as:
+
+```liquidsoap
+%ffmpeg(
+  format="flv",
+  %audio(codec="aac", b="128k"),
+  %video(codec="libx264", b="4000k")
+)
+```
+
+We are aware when initializing the encoders that it is aimed for a `flv` container so the code implicitly enables the global header for each encoder.
+
+However, when encoding inline, we do not know at the time of encoding the container that will be used to encapsulate the stream, even worst, it can be
+used potentially with different containers with different requirements!
+
+In our case here, you have two ways to solve the issue:
+
+If you know that all the containers will be okay with global header, you can enable the corresponding flag in the encoder:
+
+```liquidsoap
+stream = ffmpeg.encode.audio_video(
+    %ffmpeg(
+        %audio(codec="aac", b="128k", flags="+global_header"),
+        %video(codec="libx264", b="4000k", flags="+global_header")
+    ),
+    stream
+)
+```
+
+However, it is also possible that one stream needs global header but not the other one, which is the case here with `mpegts`. In this case, you can
+use the _bitstream filter_ `ffmpeg.filter.bitstream.extract_extradata` to extract global data to only one stream:
+
+```
+audio_source = single(audio_url)
+video_source = single(image)
+
+stream = source.mux.video(video=video_source, audio_source)
+
+stream = ffmpeg.encode.audio_video(
+    %ffmpeg(
+        %audio(codec="aac", b="128k"),
+        %video(codec="libx264", b="4000k")
+    ),
+    stream
+)
+
+flv = %ffmpeg(
+    format="flv",
+    %audio.copy,
+    %video.copy,
+)
+
+flv_stream = ffmpeg.filter.bitstream.extract_extradata(stream)
+
+# Send to one youtube output:
+output.youtube.live.rtmp(
+    encoder = flv,
+    flv_stream,
+    ...
+)
+
+mpegts = %ffmpeg(
+    format="mpegts",
+    %audio.copy,
+    %video.copy,
+)
+
+# And to a hls one:
+output.file.hls(
+  ["mpegts", mpegts],
+  stream,
+  ...
+)
+```
+
+## Examples
+
+See detailed [ffmpeg cookbook](ffmpeg_cookbook.html) article.
diff --git a/website/content/doc-2.2.5/ffmpeg_cookbook.md b/website/content/doc-2.2.5/ffmpeg_cookbook.md
new file mode 100644
index 00000000..304d8fe1
--- /dev/null
+++ b/website/content/doc-2.2.5/ffmpeg_cookbook.md
@@ -0,0 +1,211 @@
+# FFmpeg cookbook
+
+Here are some examples of what is possible to do with the ffmpeg support in liquidsoap:
+
+## Relaying without re-encoding
+
+With ffmpeg support, Liquidsoap can relay encoded streams without re-encoding them, making it possible to re-send a stream to multiple destinations. Here's an example:
+
+```liquidsoap
+# Input the stream,
+# from an Icecast server or any other source
+encoded_source = input.http("https://icecast.radiofrance.fr/fip-hifi.aac")
+
+# Send to one server here:
+output.icecast(
+  %ffmpeg(format="adts", %audio.copy),
+  fallible=true,
+  mount="/restream",
+  host="streaming.example.com", port=8000, password="xxx",
+  encoded_source)
+
+# An another one here:
+output.icecast(
+  %ffmpeg(format="adts", %audio.copy),
+  fallible=true,
+  mount="/restream",
+  host="streaming2.example.com", port=8000, password="xxx",
+  encoded_source)
+```
+
+We cannot use `mksafe` here because the content is not plain `pcm` samples, which this operator is designed to produce. There
+are several ways to make the source infallible, however, either by providing a `single(...)` source with the same encoded content
+as we expect from `encoded_source` or by creating an infallible source using `ffmpeg.encode.audio`.
+
+## On-demand relaying without re-encoding
+
+Another refinement on the previous example is the capacity to relay a stream only when listeners are connected to it,
+all without re-encoding the content.
+
+To make it work, you will need a format that can be handled by `ffmpeg` for that purpose. `mp3` is a good example.
+
+In the script below, you need to match the encoded format of the stream with a blank file (or any other file).
+The `output.harbor` will then relay the data from the file if no one is connected and start/stop the underlying
+input when there are listeners:
+
+```liquidsoap
+stream = input.http(start = false, "https://wwoz-sc.streamguys1.com/wwoz-hi.mp3")
+
+listeners_count = ref(0)
+
+def on_connect(~headers, ~uri, ~protocol, _) =
+  listeners_count := !listeners_count + 1
+  if !listeners_count > 0 and not stream.is_started() then
+    log("Starting input")
+    stream.start()
+  end
+end
+
+def on_disconnect(_) =
+  listeners_count := !listeners_count - 1
+  if !listeners_count == 0 and stream.is_started() then
+    log("Stopping input")
+    stream.stop()
+  end
+end
+
+blank = single("/tmp/blank.mp3")
+
+stream = fallback(track_sensitive=false, [stream, blank])
+
+output.harbor(
+  %ffmpeg(format="mp3", %audio.copy),
+  format="audio/mpeg",
+  mount="relay",
+  on_connect=on_connect,
+  on_disconnect=on_disconnect,
+  stream)
+```
+
+## Shared encoding
+
+Liquidsoap can also encode in one place and share the encoded with data with multiple outputs, making it possible to
+minimize CPU resources. Here's an example adapted from the previous one:
+
+```liquidsoap
+# Input the stream,
+# from an Icecast server or any other source
+source = input.http("https://icecast.radiofrance.fr/fip-hifi.aac")
+
+# Make it infallible:
+source = mksafe(source)
+
+# Encode it in mp3:
+source = ffmpeg.encode.audio(
+  %ffmpeg(%audio(codec="libmp3lame")),
+  source)
+
+# Send to one server here:
+output.icecast(
+  %ffmpeg(format="mp3", %audio.copy),
+  mount="/restream",
+  host="streaming.example.com", port=8000, password="xxx",
+  source)
+
+# An another one here:
+output.icecast(
+  %ffmpeg(format="mp3", %audio.copy),
+  mount="/restream",
+  host="streaming2.example.com", port=8000, password="xxx",
+  source)
+```
+
+Shared encoding is even more useful when dealing with video encoding, which is very costly. Here's a fun example
+sharing audio and video encoding and sending to different destinations, both via Icecast and to YouTube/Facebook
+via the rtmp protocol:
+
+```liquidsoap
+# An audio source
+audio = ...
+
+# Encode it in mp3
+audio = ffmpeg.encode.audio(
+  %ffmpeg(%audio(codec="libmp3lame")),
+  audio)
+
+# Send it to icecast
+output.icecast(
+  %ffmpeg(format="mp3", %audio.copy),
+  host = "...",
+  password = "...",
+  mount = "/stream",
+  audio
+)
+
+# A video source, for instance a static image
+video = ...
+
+# Encode it in h264 format
+video = ffmpeg.encode.video(
+  %ffmpeg(%video(codec="libx264")),
+  video)
+
+# Mux it with the audio
+stream = source.mux.video(video=video, audio)
+
+# Copy encoder for the rtmp stream
+enc = %ffmpeg(
+  format="flv",
+  %audio.copy,
+  %video.copy)
+
+# Send to YouTube
+key = "..."
+url = "rtmp://a.rtmp.youtube.com/live2/#{key}"
+output.url(url=url, enc, stream)
+
+# Send to Facebook
+key = "..."
+url = "rtmps://live-api-s.facebook.com:443/rtmp/#{key}"
+output.url(self_sync=true, url=url, enc, stream)
+```
+
+## Add transparent logo and video
+
+See: https://github.com/savonet/liquidsoap/discussions/1862
+
+## Live switch between encoded content
+
+_This is an ongoing development effort. Please refer to the online support channels if you are experiencing issues with this kind of feature._
+
+Starting with liquidsoap `2.1.x`, it is gradually becoming possible to do proper live switches on encoded content and send the
+result to different outputs.
+
+Please note that this requires a solid knowledge of media codecs, containers and ffmpeg bitstream filters. Different input and output
+containers store codec binary data in different ways and those are not always compatible. This requires the use of bitstream filters
+to adapt the binary data and, it's possible some new filters will need to be written to support more combinations of input/output and codecs.
+
+Here's a use case that has been tested: live switch between a playlist of mp4 files and a rtmp flv input:
+
+```liquidsoap
+s1 = input.rtmp(listen=false,"rtmp://....")
+s1 = ffmpeg.filter.bitstream.h264_mp4toannexb(s1)
+
+s2 = playlist("/path/to/playlist")
+s2 = ffmpeg.filter.bitstream.h264_mp4toannexb(s2)
+
+s = fallback(track_sensitive=false, [s1, s2])
+
+mpegts = %ffmpeg(
+  format="mpegts",
+  fflags="-autobsf",
+  %audio.copy, %video.copy)
+
+streams = [
+  ("mpegts",mpegts),
+]
+
+output_dir = "/tmp/hls"
+
+output.file.hls(playlist="live.m3u8",
+                fallible=true,
+                segment_duration=5.,
+                output_dir,
+                streams,
+                s)
+```
+
+- We need the `h264_mp4toannexb` on each stream to make sure that the mp4 data conforms to what the mpegts container expect
+- We need to disable ffmpeg's automatic insertion of bitstream filters via `-autobsf`. FFmpeg does not support this kind of live switch at the moment and its automatically inserted filters won't work, which is why we're doing it ourselves.
+
+That's it! In the future we want to extend this use-case to also be able to output to a `rtmp` output from the same data. And more!
diff --git a/website/content/doc-2.2.5/ffmpeg_encoder.md b/website/content/doc-2.2.5/ffmpeg_encoder.md
new file mode 100644
index 00000000..a8d048a1
--- /dev/null
+++ b/website/content/doc-2.2.5/ffmpeg_encoder.md
@@ -0,0 +1,175 @@
+# FFmpeg encoder
+
+The `%ffmpeg` encoder should support all the options for `ffmpeg`'s [muxers](https://ffmpeg.org/ffmpeg-formats.html#Muxers)
+and [encoders](https://www.ffmpeg.org/ffmpeg-codecs.html), including private configuration options. Configuration value are passed as
+key/values, with values being of types: `string`, `int`, or `float`. If an option is not recognized (or: unused), it will raise an error
+during the instantiation of the encoder. Here are some configuration examples:
+
+- **AAC encoding at `22050kHz` using `fdk-aac` encoder and `mpegts` muxer**
+
+```liquidsoap
+%ffmpeg(format="mpegts",
+  %audio(
+    codec="libfdk_aac",
+    samplerate=22050,
+    b="32k",
+    afterburner=1,
+    profile="aac_he_v2"
+  )
+)
+```
+
+- **Mp3 encoding using `libshine` at `48000kHz`**
+
+```liquidsoap
+%ffmpeg(format="mp3", %audio(codec="libshine", samplerate=48000))
+```
+
+- **AC3 audio and H264 video encapsulated in an MPEG-TS stream**
+
+```liquidsoap
+%ffmpeg(
+  format="mpegts",
+  %audio(codec="ac3", channel_coupling=0),
+  %video(
+    codec="libx264",
+    b="2600k",
+    "x264-params"="scenecut=0:open_gop=0:min-keyint=150:keyint=150",
+    preset="ultrafast"
+  )
+)
+```
+
+- **AC3 audio and H264 video encapsulated in an MPEG-TS stream using ffmpeg raw frames**
+
+```liquidsoap
+%ffmpeg(
+  format="mpegts",
+  %audio.raw(codec="ac3", channel_coupling=0),
+  %video.raw(
+    codec="libx264",
+    b="2600k",
+    "x264-params"="scenecut=0:open_gop=0:min-keyint=150:keyint=150",
+    preset="ultrafast"
+  )
+)
+```
+
+- **Mp3 encoding using `libmp3lame` and video copy**
+
+```liquidsoap
+%ffmpeg(
+  format="mp3",
+  %audio(codec="libmp3lame"),
+  %video.copy
+)
+```
+
+The full syntax is as follows:
+
+```liquidsoap
+%ffmpeg(
+  format=<format>,
+  # Audio section
+  %audio(codec=<codec>, <option_name>=<option_value>, ...),
+  # Or:
+  %audio.raw(codec=<codec>, <option_name>=<option_value>, ...),
+  # Or:
+  %audio.copy(<option>),
+  # Video section
+  %video(codec=<codec>, <option_name>=<option_value>, ...),
+  # Or:
+  %video.raw(codec=<codec>, <option_name>=<option_value>, ...),
+  # Or:
+  %video.copy(<option>),
+  # Generic options
+  <option_name>=<option_value>, ...
+)
+```
+
+Where:
+
+- `<format>` is either a string value (e.g. `"mpegts"`), as returned by the `ffmpeg -formats` command or `none`. When set to `none` or
+  simply no specified, the encoder will try to auto-detect it.
+- `<codec>` is a string value (e.g. `"libmp3lame"`), as returned by the `ffmpeg -codecs` command.
+- `<option_name>` can be any syntactically valid variable name or string. Strings are typically used when the option name is of the
+  form: `foo-bar`.
+- `%audio(...)` is for options specific to the audio codec. Unused options will raise an exception. Any option supported by `ffmpeg` can be
+  passed here. Streams encoded using `%audio` are using liquidsoap internal frame format and are fully handled on the liquidsoap side.
+- `%audio.raw(...)` behaves like `%audio` except that the audio data is kept as ffmpeg's internal format. This can avoid data copy and is
+  also the format required to use [ffmpeg filters](ffmpeg_filters.html).
+- `%audio.copy` copies data without decoding or encoding it. This is great to avoid using the CPU, but in this case, the data cannot be
+  processed with operators that modify it, such as `fade.{in,out}` or `smart_cross`. Also, all streams must agree on the same data format.
+- `%video(...)` is for options specific to the video codec. Unused options will raise an exception. Any option supported by `ffmpeg` can be
+  passed here.
+- `%video.raw` and `%video.copy` have the same meaning as their `%audio` counterpart.
+- Generic options are passed to audio, video and format (container) setup. Unused options will raise an exception. Any option supported
+  by `ffmpeg` can be passed here.
+
+### HLS output
+
+The `%ffmpeg` encoder is the prime encoder for HLS output as it is the only one of our collection of encoder which can produce Mpeg-ts muxed
+data, which is required by most HLS clients.
+
+### File output
+
+Some encoding formats, for instance `mp4`, require to rewind their stream and write a header after the fact, when encoding of the current
+track has finished. For historical reasons, such formats cannot be used with `output.file`. To remedy that, we have introduced
+the `output.url` operator. When using this operator, the encoder is fully in charge of the output file and can thus write headers after the
+fact. The `%ffmpeg` encoder is one such encoder that can be used with this operator.
+
+### Copy options
+
+The `%audio.copy` and `%video.copy` encoders have two mutually exclusive options to handle keyframes:
+
+- `%audio.copy(wait_for_keyframe)` and `%video.copy(wait_for_keyframe)`: Wait until at least one keyframe has been passed to start passing
+  encoded packets from a new stream.
+- `%audio.copy(ignore_keyframe)` and `%video.copy(ignore_keyframe)`: Ignore all keyframes.
+
+These options are useful when switching from one encoded stream to the next.
+
+With option `wait_for_keyframe`, the encoder discards any new packet at the beginning of a stream until a keyframe is passed. This means
+that playback will be paused until it can be resumed properly with no decoding glitches. This option is implemented globally when possible,
+i.e. in case of a video track with keyframes and an audio track with no keyframes, the audio track will discard packets until a video
+keyframe has been passed. This is the default option.
+
+With option `ignore_keyframe`, the encoder starts passing encoded data right away. Content is immediately added but playback might get stuck
+until a new keyframe is passed.
+
+It is worth noting that some audio encoders may also have keyframes.
+
+### Hardware acceleration
+
+The `%ffmpeg` encoder supports multiple hardware acceleration provided by `ffmpeg`.
+
+If you are lucky and the encoder you are using provides support for hardware acceleration without any specific configuration, all you might
+have to do is select `codec="..."` (for instance on macOS, `codec="h264_videotoolbox"`) and it should work immediately.
+
+The type of hardware acceleration provided by ffmpeg are:
+
+1. Internal hardware acceleration that works without any specific configuration. This is the happy path described above!
+2. Device-based hardware acceleration that works with a specific device.
+3. Frame-based hardware acceleration that work with a specific pixel format.
+
+The type of hardware acceleration to use for a given stream can be specified using the `hwaccel` option. Its value is one of: `"auto"`,
+`"none"`, `"internal"`, `"device"` or `"frame"`.
+
+For device-based hardware acceleration, the device to use can be specified using `hwaccel_device`. For frame-based hardware acceleration,
+the pixel format can be specified using `hwaccel_pixel_format`. In most cases, liquidsoap should be able to guess these values from the
+codec.
+
+Here's an example:
+
+```liquidsoap
+enc = %ffmpeg(
+  format="mpegts",
+  %video(
+    hwaccel="device",
+    hwaccel_devic="/dev/...",
+    ...
+  )
+)
+```
+
+Hardware acceleration support is, of course, very hardware dependent, so we might not have tested all possible combinations. If you are
+having issues setting it up, do not hesitate to get in touch with us to see if your use-case is properly covered.
diff --git a/website/content/doc-2.2.5/ffmpeg_filters.md b/website/content/doc-2.2.5/ffmpeg_filters.md
new file mode 100644
index 00000000..d70189b4
--- /dev/null
+++ b/website/content/doc-2.2.5/ffmpeg_filters.md
@@ -0,0 +1,251 @@
+# FFmpeg filters
+
+[FFmpeg filters](https://ffmpeg.org/ffmpeg-filters.html) provide audio and video filters that can be used
+to transform content using the ffmpeg library. They are enabled in liquidsoap when compiled with the
+optional [ffmpeg-avfilter](https://github.com/savonet/ocaml-ffmpeg).
+
+## Filter as operators
+
+If enabled, the filters should appear as operators, prefixed with `ffmpeg.filter`. For instance:
+
+```
+Ffmpeg filter: Add echoing to the audio.
+
+Type: (?in_gain : float?, ?out_gain : float?,
+ ?delays : string?, ?decays : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+
+Category: Liquidsoap
+
+Parameters:
+
+ * in_gain : float? (default: null)
+     set signal input gain. (default: 0.6)
+
+ * out_gain : float? (default: null)
+     set signal output gain. (default: 0.3)
+
+ * delays : string? (default: null)
+     set list of signal delays. (default: "1000")
+
+ * decays : string? (default: null)
+     set list of signal decays. (default: "0.5")
+
+ * (unlabeled) : ffmpeg.filter.graph (default: None)
+
+ * (unlabeled) : ffmpeg.filter.audio (default: None)
+```
+
+Filters input and output are abstract values of type `ffmpeg.filter.audio` and `ffmpeg.filter.video`. They can be created
+using `ffmpeg.filter.audio.input`, `ffmpeg.filter.video.input`. These operators take [media tracks](multitrack.html) as input.
+
+Conversely, tracks can be created from them using `ffmpeg.filter.audio.output` and `ffmpeg.filter.video.output`.
+
+Filters are configured within the closure of a function. Here's an example:
+
+```liquidsoap
+def flanger_highpass(audio_track) =
+  def mkfilter(graph) =
+    audio_track = ffmpeg.filter.audio.input(graph, audio_track)
+    audio_track = ffmpeg.filter.flanger(graph, audio_track, delay=10.)
+    audio_track = ffmpeg.filter.highpass(graph, audio_track, frequency=4000.)
+    ffmpeg.filter.audio.output(graph, audio_track)
+  end
+
+  ffmpeg.filter.create(mkfilter)
+end
+```
+
+This filter receives an audio input, creates a `ffmpeg.filter.audio.input` with it that can be passed
+to filters, applies a flanger effect and then a high pass effect, creates an audio output from it and returns it.
+
+Here's another example for video:
+
+```liquidsoap
+def hflip(video_track) =
+  def mkfilter(graph) =
+    video_track = ffmpeg.filter.video.input(graph, video_track)
+    video_track = ffmpeg.filter.hflip(graph, video_track)
+    ffmpeg.filter.video.output(graph, video_track)
+  end
+
+  ffmpeg.filter.create(mkfilter)
+end
+```
+
+This filter receives a video input, creates a `ffmpeg.filter.video.input` with it that can be passed to filters,
+applies a `hflip` filter (flips the video vertically), creates a video output from it and returns it.
+
+## Applying filters to a source
+
+When applying a filter, the input is placed in a clock that is driven by the output. This means that you cannot share other tracks from the
+input to the output. This can be an annoying source of confusion.
+
+Thus, when applying FFMpeg filters to sources with audio and video tracks, it is recommended to pass all the tracks through the filter, even
+if they are simply copied.
+
+Here's an example with the previous filter:
+
+```liquidsoap
+def hflip(s) =
+  def mkfilter(graph) =
+    let { audio = audio_track, video = video_track} = source.tracks(s)
+
+    video_track = ffmpeg.filter.video.input(graph, video_track)
+    video_track = ffmpeg.filter.hflip(graph, video_track)
+
+    audio_track = ffmpeg.filter.audio.input(graph, audio_track)
+    audio_track = ffmpeg.filter.acopy(graph, audio)
+
+    video_track = ffmpeg.filter.video.output(graph, video_track)
+    audio_track = ffmpeg.filter.audio.output(graph, audio_track)
+
+    source({
+      audio = audio_track,
+      video = video_track,
+      metadata = track.metadata(audio_track),
+      track_marks = track.track_marks(audio_track)
+   })
+  end
+
+  ffmpeg.filter.create(mkfilter)
+end
+```
+
+FFmpeg filters are very powerful, they can also convert audio to video, for instance displaying information about the
+stream, and they can combined into powerful graph processing filters.
+
+## Filter commands
+
+Some filters support [changing options at runtime](https://ffmpeg.org/ffmpeg-filters.html#Changing-options-at-runtime-with-a-command) with a command. These are also
+supported in liquidsoap.
+
+In order to do so, you have to use a slightly different API:
+
+```liquidsoap
+def dynamic_volume(s) =
+  def mkfilter(graph) =
+    filter = ffmpeg.filter.volume.create(graph)
+
+    def set_volume(v) =
+      ignore(filter.process_command("volume", "#{v}"))
+    end
+
+    let {audio = audio_track} = source.tracks(s)
+
+    audio_track = ffmpeg.filter.audio.input(graph, audio_track)
+    filter.set_input(audio_track)
+    audio_track = filter.output
+    audio_track = ffmpeg.filter.audio.output(graph, audio_track)
+
+    s = source({
+      audio = audio_track,
+      metadata = track.metadata(audio_track),
+      track_marks = track.track_marks(audio_track)
+    }
+
+    (s, set_volume)
+  end
+
+  ffmpeg.filter.create(mkfilter)
+end
+
+let (s, set_volume) = dynamic_volume(s)
+```
+
+First, we instantiate a volume filter via `ffmpeg.filter.volume.create`. The filter instance has a `process_command`, which we use to create the `set_volume` function. Then,
+we apply the expected input to the filter and return the pair `(s, set_volume)` of source and function.
+
+The `ffmpeg.filter.<filter>.create` API is intended for advanced use if you want to use filter commands. Otherwise, `ffmpeg.filter.<filter>` provides a more straight forward
+API to filters.
+
+## Filters with dynamic inputs or outputs
+
+Filters with dynamic inputs or outputs can have multiple inputs or outputs, decided at run-time. Typically, `ffmpeg.filter.split`
+splits a video stream into multiple streams and `ffmpeg.filter.merge` merges multiple video streams into a single one.
+
+For these filters, the operators' signature is a little different. Here's an example for dynamic outputs:
+
+```
+% liquidsoap -h ffmpeg.filter.asplit
+
+Ffmpeg filter: Pass on the audio input to N audio outputs. This filter has
+dynamic outputs: returned value is a tuple of audio and video outputs. Total
+number of outputs is determined at runtime.
+
+Type: (?outputs : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+
+Category: Liquidsoap
+Flag: extra
+
+Parameters:
+
+ * outputs : int? (default: null)
+     set number of outputs. (default: 2)
+
+ * (unlabeled) : ffmpeg.filter.graph (default: None)
+
+ * (unlabeled) : ffmpeg.filter.audio (default: None)
+```
+
+This filter returns a tuple `(audio, video)` of possible dynamic outputs.
+
+Likewise, with dynamic inputs:
+
+```
+% liquidsoap -h ffmpeg.filter.amerge
+
+Ffmpeg filter: Merge two or more audio streams into a single multi-channel
+stream. This filter has dynamic inputs: last two arguments are lists of audio
+and video inputs. Total number of inputs is determined at runtime.
+
+Type: (?inputs : int?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+ffmpeg.filter.audio
+
+Category: Liquidsoap
+Flag: extra
+
+Parameters:
+
+ * inputs : int? (default: null)
+     specify the number of inputs. (default: 2)
+
+ * (unlabeled) : ffmpeg.filter.graph (default: None)
+
+ * (unlabeled) : [ffmpeg.filter.audio] (default: None)
+
+ * (unlabeled) : [ffmpeg.filter.video] (default: None)
+```
+
+This filter receives an array of possible `audio` inputs as well as an array of possible `video` inputs.
+
+Put together, this can be used as such:
+
+```liquidsoap
+def parallel_flanger_highpass(s) =
+  def mkfilter(graph) =
+    audio_track = ffmpeg.filter.audio.input(graph, audio_track)
+
+    let (audio, _) = ffmpeg.filter.asplit(outputs=2, graph, audio_track)
+
+    let [a1, a2] = audio
+
+    a1 = ffmpeg.filter.flanger(graph, a1, delay=10.)
+    a2 = ffmpeg.filter.highpass(graph, a2, frequency=4000.)
+
+    # For some reason, we need to enforce the format here.
+    a1 = ffmpeg.filter.aformat(sample_fmts="s16", sample_rates="44100", channel_layouts="stereo", graph, a1)
+    a2 = ffmpeg.filter.aformat(sample_fmts="s16", sample_rates="44100", channel_layouts="stereo", graph, a2)
+
+    audio_track = ffmpeg.filter.amerge(inputs=2, graph, [a1, a2], [])
+
+    ffmpeg.filter.audio.output(graph, audio_track)
+  end
+
+  ffmpeg.filter.create(mkfilter)
+end
+```
diff --git a/website/content/doc-2.2.5/flows_devel.md b/website/content/doc-2.2.5/flows_devel.md
new file mode 100644
index 00000000..a0cdb7bf
--- /dev/null
+++ b/website/content/doc-2.2.5/flows_devel.md
@@ -0,0 +1,39 @@
+# Developping Flows
+
+[Flows](flows.html) is handled on the [Heroku](https://www.heroku.com/) platform.
+
+## Getting started
+
+First steps to get started.
+
+- Create an account on [Heroku](https://www.heroku.com/).
+- Install the [Heroku utilities](https://toolbelt.heroku.com/).
+- Ask a Liquidsoap administrator to give you access to the repositories.
+
+The repositories of the main components are organized as follows.
+
+- `savonet-flows` is the python handler to submit metadata:
+  - the associated [github repository](https://github.com/savonet/flows-submit)
+  - the Heroku repository is `git@heroku.com:savonet-liquidsoap.git`
+- `savonet-flows-socket` is the node application to serve the webpage and client stuff.
+  - the associated [github repository](https://github.com/savonet/flows-push)
+  - the [test Heroku webpage](http://savonet-flows-socket.herokuapp.com/) is updated by pushing on `git@heroku.com:savonet-flows-socket-next.git`
+  - the [prod Heroku webpage](http://savonet-flows-socket.herokuapp.com/) is updated by pushing on `git@heroku.com:savonet-flows-socket.git`
+
+Some more experimental repositories include:
+
+- a [command-line client](https://github.com/savonet/flows-client)
+
+## Useful commands
+
+Getting the environment variables:
+
+```
+heroku config -s --app savonet-flows
+```
+
+Seeing the logs of the socket application:
+
+```
+heroku logs -t --app savonet-flows-socket
+```
diff --git a/website/content/doc-2.2.5/frequence3.md b/website/content/doc-2.2.5/frequence3.md
new file mode 100644
index 00000000..6c5c2458
--- /dev/null
+++ b/website/content/doc-2.2.5/frequence3.md
@@ -0,0 +1,13 @@
+# Fréquence 3
+
+[Fréquence 3](http://www.frequence3.fr) uses Liquidsoap mainly on the backstage,
+for different purposes:
+
+- transcoding for different formats (OGG, weird MP3 relays...)
+- scheduling and playlist for audio backup streams, and test streams
+- blank detection
+
+They look forward to using Liquidsoap even more, and work with the Savonet team
+to make sure this tool can ease the work of webradios :)
+
+They provide an MP3 stream [here](http://streams.frequence3.net/mp3-128.m3u).
diff --git a/website/content/doc-2.2.5/geekradio.md b/website/content/doc-2.2.5/geekradio.md
new file mode 100644
index 00000000..40c0ebfe
--- /dev/null
+++ b/website/content/doc-2.2.5/geekradio.md
@@ -0,0 +1,43 @@
+# Geek Radio
+
+The historical webradio, founded by David Baelde and Samuel Mimram at the ENS
+Lyon.
+
+The very first version was, as many other radios, a Perl function called by
+Ices. It played files, one by one. On the campus, there was plenty of audio
+files available, so they soon wanted to index them and be able to ask easily for
+one file to be streamed. Samuel made a dirty campus indexer in OCaml, and David
+made an ugly Perl hack for adding user requests to the original system. It
+probably kind of worked for a while. Then they wanted something more, and
+realized it was all too ugly.
+
+So they made the binding of libshout for OCaml and built the first streamer in
+pure OCaml. It had a simple telnet interface so an IRC bot could send user
+requests easily to it, same for the website. There were two request queues, one
+for users, one for admins. But it was still not so nicely designed, and they
+felt it when they needed more. They wanted scheduling, especially techno music
+at night.
+
+Around that time students had to set up a project for one of their
+courses. David and Samuel proposed to build a complete flexible webradio system,
+that's Savonet. To give jobs to everybody, they had planned a complete rewriting
+of every part, with grand goals. A new website with so much features, a new
+intelligent multilingual bot, a new network libraries for glueing that,
+etc. Most died. But still, Liquidsoap was born, and they had plenty of new
+libraries for OCaml. Since then, Liquidsoap has been greatly enhanced, and is
+now spreading outside the ENS Lyon.
+
+## Features
+
+The liquidsoap script schedules several static (but periodically reloaded)
+playlists played on different times, adds jingle to the usual stream every hour,
+adds short live interventions, or completely switches to live shows when
+available. It accepts user requests, which have priority over static playlists
+but not live shows, and adds speech-synthetized metadata information at the end
+of requests.
+
+Geek Radio used to have a Strider daemon running to fill our database. Since
+that project is now dead, a simple hack is now used instead: bubble.
+
+The usual way of sending a request is via an IRC bot, which queries the database
+and sends the chosen URI to liquidsoap.
diff --git a/website/content/doc-2.2.5/gstreamer_encoder.md b/website/content/doc-2.2.5/gstreamer_encoder.md
new file mode 100644
index 00000000..92f4f8b9
--- /dev/null
+++ b/website/content/doc-2.2.5/gstreamer_encoder.md
@@ -0,0 +1,154 @@
+# The Gstreamer encoder
+
+The `%gstreamer` encoder can be used to encode streams using the `gstreamer` multimedia framework.
+This encoder extends liquidsoap with all available GStreamer formats (provided they are
+compatible with liquidsoap's model of streams, see Caveats section below), which includes a
+huge array of encoders.
+
+## Presentation
+
+A basic understanding of gstreamer's pipelines and configuration should be expected in order to
+understand the following documentation.
+
+The encoder's parameters are as follows:
+
+```
+%gstreamer(channels=2,
+           audio="lamemp3enc",
+           has_video=true,
+           video="x264enc",
+           muxer="mpegtsmux",
+           metadata="metadata",
+           log=5,
+           pipeline="")
+```
+
+Without using the `pipeline` argument, the `audio` and `video` arguments are used to build the
+gstreamer pipeline used to encode. By setting the `log` parameter to a lower value or by using
+`log.level := ...`, you should be able to see some example.
+
+## Basic examples
+
+Here are a couple of examples:
+
+An MP3 encoder that expects sources of type `audio=2, video=0, midi=0`:
+
+```
+% liquidsoap 'output.file(%gstreamer(audio="lamemp3enc",
+                                     muxer="",
+                                     video="",
+                                     log=3),...)'
+(...)
+2012/12/13 19:16:23 [encoder.gstreamer:3] Gstreamer encoder pipeline: appsrc
+  name="audio_src" block=true caps="audio/x-raw,format=S16LE,layout=interleaved,
+  channels=2,rate=44100" format=time ! queue ! audioconvert ! audioresample !
+  lamemp3enc ! appsink name=sink sync=false emit-signals=true
+```
+
+A x264 encoder that expects sources of type `audio=0, video=1, midi=0`:
+
+```
+% liquidsoap 'output.file(%gstreamer(audio="",
+                                     muxer="mpegtsmux",
+                                     video="x264enc",
+                                     log=3),...)'
+(...)
+2012/12/13 19:14:43 [encoder.gstreamer:3] Gstreamer encoder pipeline:  appsrc
+  name="video_src" block=true caps="video/x-raw,format=RGBA,width=320,height=240,
+  framerate=25/1,pixel-aspect-ratio=1/1" format=time blocksize=307200 ! queue !
+  videoconvert ! videoscale add-borders=true ! videorate ! x264enc !
+  mpegtsmux name=muxer ! appsink name=sink sync=false emit-signals=true
+```
+
+An MPEG TS encoder that expects sources of type `audio=2, video=1, midi=0`:
+
+```
+% liquidsoap 'output.file(%gstreamer(audio="lamemp3enc",
+                                     muxer="mpegtsmux",
+                                     video="x264enc",
+                                     log=3),...)'
+(...)
+2012/12/13 19:18:09 [encoder.gstreamer:3] Gstreamer encoder pipeline: appsrc
+  name="audio_src" block=true caps="audio/x-raw,format=S16LE,
+  layout=interleaved,channels=2,rate=44100" format=time ! queue ! audioconvert
+  ! audioresample ! lamemp3enc ! muxer. appsrc name="video_src" block=true
+  caps="video/x-raw,format=RGBA,width=320,height=240,framerate=25/1,
+  pixel-aspect-ratio=1/1" format=time blocksize=307200 ! queue ! videoconvert
+  ! videoscale add-borders=true ! videorate ! x264enc ! muxer. mpegtsmux
+  name=muxer ! appsink name=sink sync=false emit-signals=true
+```
+
+An ogg/vorbis+theora encoder that expects source of type `audio=1, video=1, midi=0`:
+
+```
+% liquidsoap 'output.file(%gstreamer(audio="vorbisenc",
+                                     muxer="oggmux",
+                                     video="theoraenc",
+                                     channels=1,
+                                     log=3),...)'
+(...)
+2012/12/13 19:21:17 [encoder.gstreamer:3] Gstreamer encoder pipeline: appsrc
+  name="audio_src" block=true caps="audio/x-raw,format=S16LE,layout=interleaved,
+  channels=1,rate=44100" format=time ! queue ! audioconvert ! audioresample !
+  vorbisenc ! muxer. appsrc name="video_src" block=true caps="video/x-raw,
+  format=RGBA,width=320,height=240,framerate=25/1,pixel-aspect-ratio=1/1"
+  format=time blocksize=307200 ! queue ! videoconvert ! videoscale add-borders=true
+  ! videorate ! theoraenc ! muxer. oggmux name=muxer ! appsink name=sink
+  sync=false emit-signals=true
+```
+
+For advanced users, the `pipeline` argument can be used to override the whole pipeline. For instance:
+
+```
+% liquidsoap 'output.file(%gstreamer(pipeline="appsrc name=\"audio_src\"
+    block=true caps=\"audio/x-raw,format=S16LE,layout=interleaved,
+    channels=1,rate=44100\" format=time ! lamemp3enc ! appsink name=sink
+    sync=false emit-signals=true",channels=1,log=3),...)'
+(...)
+```
+
+## Content type inference
+
+When starting its sources and outputs, liquidsoap determines the content type of each source (audio, video and midi channels).
+During that process, encoders have to inform liquidsoap what type of sources they are expecting. It works as follows for the `%gstreamer`
+encoder:
+
+- If the `audio` parameter is a string different than `""` then the encoder expects a stream with `channels` audio channels.
+- If the `video` parameter is a string different than `""` then the encoder expects a stream with `1` video channel.
+- If the `pipeline` parameter is a string different than `""` then the encoder expects a stream with `channels` audio channels and a video channels only if `has_video` is true.
+
+The `has_video` parameter is only used when using the `pipeline` parameter.
+
+## Metadata
+
+The `%gstreamer` encoder tries to also encode metadata attached to the stream. This requires that you specify a pipeline element
+named according to the `metadata` parameter (default: `"metadata"`) that can be used with GStreamer's `tag_setter` API. Here are two such examples:
+
+An ogg/vorbis encoder with vorbis tags:
+
+```
+% liquidsoap 'output.file(%gstreamer(audio="vorbisenc ! vorbistag name='metadata'",
+                                     muxer="oggmux",
+                                     video=""),...)'
+```
+
+An MP3 encoder with id3v2 tags:
+
+```
+% liquidsoap 'output.file(%gstreamer(audio="lamemp3enc",
+                                     muxer="id3v2mux",
+                                     video="",
+                                     metadata="muxer"),...)'
+```
+
+In the last example, we tell the `%gstreamer` encoder that the element for injecting metadata is named
+`"muxer"` because, for id3v2 tags, the gstreamer muxer element is also the element used to inject metadata
+and the `"muxer"` name is implicitly added by liquidsoap to the muxer element. You can see that by printing
+out the constructed pipeline, as shown before.
+
+## Caveats
+
+When using the `%gstreamer` encoder, one must think of it as an encoder for an infinite stream. This, in particular,
+means that not all containers (muxers) will work. For instance, the AVI and MP4 containers need to write in their
+header information that are only known with finite streams, such as the stream total's time and etc.. These containers
+are usually not fit for streaming, which is liquidsoap's main functionality.
diff --git a/website/content/doc-2.2.5/harbor.md b/website/content/doc-2.2.5/harbor.md
new file mode 100644
index 00000000..92b6d928
--- /dev/null
+++ b/website/content/doc-2.2.5/harbor.md
@@ -0,0 +1,126 @@
+# Harbor input
+
+Liquidsoap is also able to receive a source using icecast or shoutcast source protocol with
+the `input.harbor` operator. Using this operator, the running liquidsoap will open
+a network socket and wait for an incoming connection.
+
+This operator is very useful to seamlessly add live streams
+into your final streams:
+you configure the live source client to connect directly to liquidsoap,
+and manage the switch to and from the live inside your script.
+
+Additionally, liquidsoap can handle many simultaneous harbor sources on different ports,
+with finer-grained authentication schemes that can be particularly useful when used with
+source clients designed for the shoutcast servers.
+
+SSL support in harbor can be enabled using of of the following `opam` packages: `ssl`, `osx-secure-transport`.
+If enabled using `ssl`, `input.harbor.ssl` will be available. If enabled with `osx-secure-transport`, it will be
+`input.harbor.secure_transport`.
+
+## Parameters
+
+The global parameters for harbor can be retrieved using
+`liquidsoap --list-settings`. They are:
+
+- `harbor.bind_addr`: IP address on which the HTTP stream receiver should listen. The default is `"0.0.0.0"`. You can use this parameter to restrict connections only to your LAN.
+- `harbor.timeout`: Timeout for source connection, in seconds. Defaults to `30.`.
+- `harbor.verbose`: Print password used by source clients in logs, for debugging purposes. Defaults to: `false`
+- `harbor.reverse_dns`: Perform reverse DNS lookup to get the client's hostname from its IP. Defaults to: `true`
+- `harbor.icy_formats`: Content-type (mime) of formats which allow shout (ICY) metadata update. Defaults to: ` ["audio/mpeg"; "audio/aacp"; "audio/aac"; "audio/x-aac"; "audio/wav"; "audio/wave"]`
+
+If SSL support was enabled via `ssl`, you will have the following additional settings:
+
+- `harbor.ssl.certificate`: Path to the SSL certificate.
+- `harbor.ssl.private_key`: Path to the SSL private key (openssl only).
+- `harbor.ssl.password`: Optional password to unlock the private key.
+
+Obtaining a proper SSL certificate can be tricky. You may want to start with a self-signed certificate first.
+You can obtain a free, valid certificate at: [https://letsencrypt.org/](https://letsencrypt.org/)
+
+If SSL support is enable via `osx-secure-transport`, you will have the same settings but named: `harbor.secure_transport.*`.
+
+To create a self-signed certificate for local testing you can use the following one-liner:
+
+```
+openssl req -x509 -newkey rsa:4096 -sha256 -nodes -keyout server.key -out server.crt -subj "/CN=localhost" -days 3650
+```
+
+You also have per-source parameters. You can retrieve them using the command
+`liquidsoap -h input.harbor`. The most important one are:
+
+- `user`, `password`: set a permanent login and password for this harbor source.
+- `auth`: Authenticate the user according to a specific function.
+- `port`: Use a custom port for this input.
+- `icy`: Enable ICY (shoutcast) source connections.
+- `id`: The mountpoint registered for the source is also the id of the source.
+
+When using different ports with different harbor inputs, mountpoints are attributed
+per-port. Hence, there can be a harbor input with mountpoint `"foo"` on port `1356`
+and a harbor input with mountpoint `"foo"` on port `3567`. Additionally, if an harbor
+source uses custom port `n` with shoutcast (ICY) source protocol enabled, shoutcast
+source clients should set their connection port to `n+1`.
+
+The `auth` function is a function, that takes a record `{user, password, address}` and returns a boolean representing whether the user
+should be granted access or not. Typical example can be:
+
+```liquidsoap
+def auth(args) =
+  # Call an external process to check
+  # the credentials:
+  # The script will return the string
+  # "true" of "false"
+  #
+  # First call the script. Make sure to apply proper escaping
+  # of the arguments to prevent command injection!
+  ret = process.read.lines("/path/to/script \
+         --user=#{args.user} --password=#{args.password}")
+  # Then get the first line of its output
+  ret = list.hd(default="",ret)
+  # Finally returns the boolean represented
+  # by the output (bool_of_string can also
+  # be used)
+  if ret == "true" then
+    true
+  else
+    false
+  end
+end
+```
+
+In the case of the `ICY` (shoutcast) source protocol, there is no `user` parameter
+for the source connection. Thus, the user used will be the `user` parameter passed
+to the `input.harbor` source.
+
+When using a custom authentication function, in case of a `ICY` (shoutcast) connection,
+the function will receive this value for the username.
+
+## Usage
+
+When using harbor inputs, you first set the required settings, as described above. Then, you define each source using `input.harbor("mountpoint")`. This source is faillible and will become available when a source client is connected.
+
+The unlabeled parameter is the mount point that the source client may connect
+to. It should be `"/"` for shoutcast source clients.
+
+The source client may use any of the recognized audio input codec. Hence, when using shoucast source clients, you need to have compiled liquidsoap with mp3 decoding support (`ocaml-mad`)
+
+A sample code can be:
+
+```liquidsoap
+settings.harbor.bind_addrs := ["0.0.0.0"]
+
+# Some code...
+
+# This defines a source waiting on mount point
+# /test-harbor
+live = input.harbor("test-harbor",port=8080,password="xxx")
+
+# This is the final stream.
+# Uses the live source as soon as available,
+# and don't wait for an end of track, since
+# we don't want to cut the beginning of the live
+# stream.
+#
+# You may insert a jingle transition here...
+radio = fallback(track_sensitive=false,
+                 [live,files])
+```
diff --git a/website/content/doc-2.2.5/harbor_http.md b/website/content/doc-2.2.5/harbor_http.md
new file mode 100644
index 00000000..5ee02907
--- /dev/null
+++ b/website/content/doc-2.2.5/harbor_http.md
@@ -0,0 +1,263 @@
+# Harbor as HTTP server
+
+The harbor server can be used as a HTTP server. We provide two type of APIs for this:
+
+## Simple API
+
+The `harbor.http.register.simple` function provides a simple, easy to use registration API for quick
+HTTP response implementation. This function receives a record describing the request and returns
+the HTTP response.
+
+The request passed to the function contains all expected information from the underlying HTTP
+query.
+
+The `data` method on a request is a _string getter_, that is a function of type: `() -> string`
+which returns the empty string `""` when all data has been consumed. You can use this function
+to e.g. write the request data to a file using `file.write.stream`.
+
+The `body` method can be used to read all of the request's data and store it in
+memory. Make sure to only use it if you know that the response should be small enough!
+
+For convenience, a HTTP response builder is provided via `harbor.http.response`. Here's an example:
+
+```liquidsoap
+def handler(request) =
+  log("Got a request on path #{request.path}, protocol version: #{request.http_version}, \
+       method: #{request.method}, headers: #{request.headers}, query: #{request.query}, \
+       body: #{request.body()}")
+
+  harbor.http.response(
+    content_type="text/html",
+    data="<p>ok, this works!</p>"
+  )
+end
+
+harbor.http.register.simple(port=8080, method="GET", path, handler)
+```
+
+where:
+
+- `port` is the port where to receive incoming connections
+- `method` is for the http method (or verb), one of: `"GET"`, `"PUT"`, `"POST"`, `"DELETE"`, `"OPTIONS"` and `"HEAD"`
+- `path` is the matched path. It can include named fragments, e.g. `"/users/:id/collabs/:cid"`. Named named fragments are passed via `request.query`, for instance: `req.query["cid"]`.
+
+## Node/express API
+
+The `harbor.http.register` function offers a higher-level API for advanced HTTP response implementation.
+Its API is very similar to the node/express API. Here's an example:
+
+```liquidsoap
+def handler(request, response) =
+  log("Got a request on path #{request.path}, protocol version: #{request.http_version}, \
+       method: #{request.method}, headers: #{request.headers}, query: #{request.query}, \
+       body: #{request.body()}")
+
+  # Set response code. Defaults to 200
+  response.status_code(201)
+
+  # Set response status message. Uses `status_code` if not specified
+  response.status_message("Created")
+
+  # Replaces response headers
+  response.headers(["X-Foo", "bar"])
+
+  # Set a single header
+  response.header("X-Foo", "bar")
+
+  # Set http protocol version
+  response.http_version("1.1")
+
+  # Same as setting the "Content-Type" header
+  response.content_type("application/liquidsoap")
+
+  # Set response data. Can be a `string` or a function of type `()->string` returning an empty string
+  # when done such as `file.read`
+  response.data("foo")
+
+  # Advanced wrappers:
+
+  # Sets content-type to json and data to `json.stringify({foo = "bla"})`
+  response.json({foo = "bla"})
+
+  # Sets `status_code` and `Location:` header for a HTTP redirect response. Takes an optional `status_code` argument.
+  response.redirect("http://...")
+
+  # Sets content-type to html and data to `"<p>It works!</p>"`
+  response.html("<p>It works!</p>")
+end
+
+harbor.http.register(port=8080, method="GET", path, handler)
+```
+
+where:
+
+- `port` is the port where to receive incoming connections
+- `method` is for the http method (or verb), one of: `"GET"`, `"PUT"`, `"POST"`, `"DELETE"`, `"OPTIONS"` and `"HEAD"`
+- `path` is the matched path. It can include named fragments, e.g. `"/users/:id/collabs/:cid"`. Matched named fragments are passed via `request.query`, for instance: `req.query["cid"]`.
+
+The handler function receives a record containing all the information about the request and fills
+up the details about the response, which is then used to write a proper HTTP response to the client.
+
+Named fragments from the request path are passed to the response `query` list.
+
+Middleware _a la_ node/express are also supported and registered via `http.harbor.middleware.register`. See `http.harbor.middleware.cors` for an example of how to implement one such middleware.
+
+Here's how you would enable the `cors` middleware:
+
+```
+harbor.http.middleware.register(harbor.http.middleware.cors(origin="example.com"))
+```
+
+## Https support
+
+`https` is supported using either `libssl` or `ocaml-tls`. When compiled with either of them, a `http.transport.ssl` or `http.transport.tls`
+is available and can be passed to each `harbor` operator:
+
+```liquidsoap
+transport = http.transport.ssl(
+  # Server mode: required,
+  # client mode: optional, add certificate to trusted pool
+  certificate="/path/to/certificate/file",
+
+  # Server mode: required, client mode: ignored
+  key="/path/to/secret/key/file",
+
+  # Required if key file requires one.
+  # TLS does not support password encrypted keys!
+  password="optional password"
+)
+
+harbor.http.register(transport=transport, port=8000, ...)
+
+input.harbor(transport=..., port=8000, ...)
+
+output.harbor(transport=..., port=8000, ...)
+
+output.icecast(transport=..., port=8000, ...)
+```
+
+A given port can only support one type of transport at a time and registering handlers, sources or outputs on the same port with different transports
+will raise a `error.http` error.
+
+## Advanced usage
+
+All registration functions have a `.regexp` counter part, e.g. `harbor.http.register.simple.regexp`. These function accept
+a full regular expression for their `path` argument. Named matches on the regular expression are also passed via the request's `query`
+parameter.
+
+It is also possible to directly interact with the underlying socket using the `simple` API:
+
+```liquidsoap
+  # Custom response
+  def handler(req) =
+    req.socket.write("HTTP/1.0 201 YYR\r\nFoo: bar\r\n\r\n")
+    req.socket.close()
+
+    # Null indicates that we're using the socket directly.
+    null()
+  end
+
+  harbor.http.register.simple("/custom", port=3456, handler)
+```
+
+## Examples
+
+These functions can be used to create your own HTTP interface. Some examples
+are:
+
+## Redirect Icecast's pages
+
+Some source clients using the harbor may also request pages that
+are served by an icecast server, for instance listeners statistics.
+In this case, you can register the following handler:
+
+```liquidsoap
+# Redirect all files other
+# than /admin.* to icecast,
+# located at localhost:8000
+def redirect_icecast(request, response) =
+  response.redirect("http://localhost:8000#{request.path}")
+end
+
+# Register this handler at port 8005
+# (provided harbor sources are also served
+#  from this port).
+harbor.http.register.regexp(
+  port=8005,
+  method="GET",
+  r/^\/(?!admin)/,
+  redirect_icecast
+)
+```
+
+## Get metadata
+
+You can use harbor to register HTTP services to
+fecth/set the metadata of a source.
+
+```liquidsoap
+meta = ref([])
+
+# s = some source
+s.on_metadata(fun (m) -> meta := m)
+
+# Return the json content of meta
+def get_meta(_, response) =
+  response.json(!meta)
+end
+
+# Register get_meta at port 700
+harbor.http.register(port=7000,method="GET","/getmeta",get_meta)
+```
+
+Once the script is running,
+a GET request for `/getmeta` at port `7000`
+returns the following:
+
+```
+HTTP/1.1 200 OK
+Content-Type: application/json; charset=utf-8
+
+{
+  "genre": "Soul",
+  "album": "The Complete Stax-Volt Singles: 1959-1968 (Disc 8)",
+  "artist": "Astors",
+  "title": "Daddy Didn't Tell Me"
+}
+```
+
+## Set metadata
+
+Using `insert_metadata`, you can register a GET handler that
+updates the metadata of a given source. For instance:
+
+```liquidsoap
+# s = some source
+
+# Create a source equipped with a `insert_metadata` method:
+s = insert_metadata(s)
+
+# The handler
+def set_meta(request, response) =
+  # Filter out unusual metadata
+  meta = metadata.export(request.query)
+
+  # Grab the returned message
+  ret =
+    if meta != [] then
+      s.insert_metadata(meta)
+      "OK!"
+    else
+      "No metadata to add!"
+  end
+
+  response.html("<html><body><b>#{ret}</b></body></html>")
+end
+
+# Register handler on port 700
+harbor.http.register(port=7000,method="GET","/setmeta",set_meta)
+```
+
+Now, a request of the form `http://server:7000/setmeta?title=foo`
+will update the metadata of source `s` with `[("title","foo")]`. You
+can use this handler, for instance, in a custom HTML form.
diff --git a/website/content/doc-2.2.5/help.md b/website/content/doc-2.2.5/help.md
new file mode 100644
index 00000000..278fa75a
--- /dev/null
+++ b/website/content/doc-2.2.5/help.md
@@ -0,0 +1,134 @@
+# Get help
+
+Liquidsoap is a self-documented application,
+which means that it can provide help about several of its aspects.
+You will learn here how to get help by yourself, by asking liquidsoap.
+If you do not succeed in asking the tool, you can of course get help from
+humans. We maintain the following communication channels:
+
+- Slack: [slack.liquidsoap.info](http://slack.liquidsoap.info/)
+- IRC: #savonet on [irc.libera.chat](https://libera.chat/) (through a slack bridge)
+- Mailing list: [savonet-users@lists.sourceforge.net](mailto:savonet-users@lists.sourceforge.net)
+
+## Scripting API
+
+When scripting in liquidsoap, one uses functions that are either _builtin_
+(_e.g._ `input.http` or `output.icecast`)
+or defined in the [script library](script_loading.html) (_e.g_ `output`).
+All these functions come with a documentation, that you can access by
+executing `liquidsoap -h FUNCTION` on the command-line. For example:
+
+```
+$ liquidsoap -h sine
+
+Generate a sine wave.
+
+Type: (?id : string?, ?amplitude : {float}, ?duration : float,
+ ?{float}) -> source(audio=internal('a),
+video=internal('b), midi=internal('c))
+
+Category: Source / Input
+
+Parameters:
+
+ * id : string? (default: null)
+     Force the value of the source ID.
+
+ * amplitude : {float} (default: 1.)
+     Maximal value of the waveform.
+
+ * duration : float (default: -1.)
+     Duration in seconds (negative means infinite).
+
+ * (unlabeled) : {float} (default: 440.)
+     Frequency of the sine.
+
+Methods:
+
+ * fallible : bool
+     Indicate if a source may fail, i.e. may not be ready to stream.
+
+ * id : () -> string
+     Identifier of the source.
+
+ * is_active : () -> bool
+     `true` if the source is active, i.e. it is continuously animated by its
+     own clock whenever it is ready. Typically, `true` for outputs and
+     sources such as `input.http`.
+
+ * is_ready : () -> bool
+     Indicate if a source is ready to stream. This does not mean that the
+     source is currently streaming, just that its resources are all properly
+     initialized.
+
+ * is_up : () -> bool
+     Indicate that the source can be asked to produce some data at any time.
+     This is `true` when the source is currently being used or if it could be
+     used at any time, typically inside a `switch` or `fallback`.
+
+ * on_leave : ((() -> unit)) -> unit
+     Register a function to be called when source is not used anymore by
+     another source.
+
+ * on_metadata : ((([string * string]) -> unit)) -> unit
+     Call a given handler on metadata packets.
+
+ * on_shutdown : ((() -> unit)) -> unit
+     Register a function to be called when source shuts down.
+
+ * on_track : ((([string * string]) -> unit)) -> unit
+     Call a given handler on new tracks.
+
+ * remaining : () -> float
+     Estimation of remaining time in the current track.
+
+ * seek : (float) -> float
+     Seek forward, in seconds (returns the amount of time effectively
+     seeked).
+
+ * self_sync : () -> bool
+     Is the source currently controlling its own real-time loop.
+
+ * skip : () -> unit
+     Skip to the next track.
+
+ * time : () -> float
+     Get a source's time, based on its assigned clock.
+```
+
+Of course if you do not know what function you need, you'd better go
+through the [API reference](reference.html).
+
+Please note that some functions
+in that list are optional and may not be available with your local `liquidsoap`
+install unless you install the optional dependency that enables it. The list of
+optional dependencies is listed via `opam info liquidsoap` if you have installed
+it this way or can in our [build page](build.html).
+
+## Settings
+
+Liquidsoap scripts contain expression like `settings.log.stdout := true`.
+These are _settings_, global variables affecting the behaviour of the
+application.
+
+Some common settings have shortcut for convenience. These are all shortcuts to their respective `settings` values:
+
+```liquidsoap
+log.level :=4
+log.file := true
+log.stdout := true
+init.daemon := true
+audio.samplerate := 48000
+audio.channels := 2
+video.frame.width := 720
+video.frame.height := 1280
+```
+
+You can have a list of available settings, with their documentation,
+by running `liquidsoap --list-settings`.
+
+The output of these commands is a valid liquidsoap script,
+which you can edit to set the values that you want,
+and load it ([implicitly](script_loading.html) or not) before you other scripts.
+
+You can browse online the [list of available settings](settings.html).
diff --git a/website/content/doc-2.2.5/hls_output.md b/website/content/doc-2.2.5/hls_output.md
new file mode 100644
index 00000000..45423d58
--- /dev/null
+++ b/website/content/doc-2.2.5/hls_output.md
@@ -0,0 +1,156 @@
+# HLS Output
+
+Starting with liquidsoap `1.4.0`, it is possible to send your streams as [HLS output](https://en.wikipedia.org/wiki/HTTP_Live_Streaming).
+
+The main operator is `output.file.hls`. Here's an example using it, courtesy of [srt2hls](https://github.com/mbugeia/srt2hls):
+
+```liquidsoap
+aac_lofi = %ffmpeg(format="mpegts",
+                   %audio(
+                     codec="aac",
+                     channels=2,
+                     ar=44100
+                   ))
+
+aac_midfi = %ffmpeg(format="mpegts",
+                    %audio(
+                      codec="aac",
+                      channels=2,
+                      ar=44100,
+                      b="96k"
+                    ))
+
+aac_hifi = %ffmpeg(format="mpegts",
+                   %audio(
+                     codec="aac",
+                     channels=2,
+                     ar=44100,
+                     b="192k"
+                   ))
+
+streams = [("aac_lofi",aac_lofi),
+           ("aac_midfi", aac_midfi),
+           ("aac_hifi", aac_hifi)]
+
+def segment_name(~position,~extname,stream_name) =
+  timestamp = int_of_float(time())
+  duration = 2
+  "#{stream_name}_#{duration}_#{timestamp}_#{position}.#{extname}"
+end
+
+output.file.hls(playlist="live.m3u8",
+                segment_duration=2.0,
+                segments=5,
+                segments_overhead=5,
+                segment_name=segment_name,
+                persist_at="/path/to/state.config",
+                "/path/to/hls/directory",
+                streams,
+                source)
+```
+
+Let's see what's important here:
+
+- `streams` describes the encoded streams. It's a list of: `(stream_name, encoder)`. `stream_name` is used to generate
+  the corresponding media playlists. Encoders can be any encoder supported by liquidsoap. However, the [HLS RFC](https://tools.ietf.org/html/rfc8216)
+  limits the list of possible codecs to `mp3` and `aac`. Furthermore, for the best possible compatible, it is recommended
+  to send data encapsulated in a `MPEG-TS` stream. Currently, the only encoder capable of doing this in liquidsoap is `%ffmpeg`.
+- `persist_at` is used to allow liquidsoap to restart while keeping the existing segments and playlists. When
+  shutting down, liquidsoap stores the current configuration at `persist_at` and uses it to restart the HLS stream when
+  restarting.
+- `segments` and `segments_overhead` are used to keep track of the generated segments. Each media playlist will contain
+  a number of segments defined by `segments` and an extra set of segments, defined by `segments_overhead`, is kept past the playlist size for those
+  listeners who are still listening on outdated segments.
+
+There are more useful options, in particular `on_file_change`, which can be used for instance to sync up your segments and playlists
+to a distant storage and hosting service such as S3.
+
+Liquidsoap also provides `output.harbor.hls` which allows to serve HLS streams directly from
+liquidsoap. Their options should be the same as `output.file.hls`, except for harbor-specifc options `port` and `path`. It is
+not recommended for listener-facing setup but can be useful to sync up with a caching system such as cloudfront.
+
+## Metadata
+
+HLS outputs supports metadata in two ways:
+
+- Using the `%ffmpeg` encoder, through a `timed_id3` metadata logical stream with the `mpegts` format.
+- Through regular ID3 frames, as requested by the [HLS specifications](https://datatracker.ietf.org/doc/html/rfc8216#section-3.4) for `adts`, `mp3`, `ac3` and `eac3` formats with the `%ffmpeg` encoder and also natively using the `%mp3`, `%shine` or `%fdkaac` encoders.
+- There is currently no support for in-stream metadata for the `mp4` format.
+
+Metadata parameters are passed through the record methods of the streams' encoders. Here's an example
+
+```liquidsoap
+output.file.hls(
+  "/path/to/directory",
+  [
+   ("aac",
+      %ffmpeg(format="adts", %audio(codec="aac")).{
+        id3_version = 3
+       }),
+   ("ts-with-meta",
+      %ffmpeg(format="mpegts", %audio(codec="aac")).{
+        id3_version = 4
+     }),
+   ("ts",
+      %ffmpeg(format="mpegts", %audio(codec="aac")).{
+        id3 = false
+      }),
+   ("mp3",
+      %ffmpeg(format="mp3", %audio(codec="libmp3lame")).{
+        replay_id3 = false
+      })
+  ],
+  source
+)
+```
+
+Parameters are:
+
+- `id3`: Set to `false` to deactivate metadata on the streams. Defaults to `true`.
+- `id3_version`: Set the `id3v2` version used to export metadata
+- `replay_id3`: By default, the latest metadata is inserted at the beginning of each segment to make sure new listeners always get the latest metadata. Set to `false` to disable it.
+
+Metadata for these formats are activated by default. If you are experiencing any issues with them, you can disable them by setting `id3` to `false`.
+
+## Mp4 format
+
+`mp4` container is supported by requires specific parameters. Here's an example that mixes `aac` and `flac` audio, The parameters
+required for `mp4` are `movflags` and `frag_duration`.
+
+```liquidsoap
+radio = ...
+
+aac_lofi = %ffmpeg(format="mp4",
+                   %audio(
+                     codec="aac",
+                     channels=2,
+                     ar=44100,
+                     b="192k"
+                   ))
+
+flac_hifi = %ffmpeg(format="mp4",
+                    strict="-2",
+                    %audio(
+                      codec="flac",
+                      channels=2,
+                      ar=44100
+                    ))
+
+flac_hires = %ffmpeg(format="mp4",
+                     strict="-2",
+                     %audio(
+                       codec="flac",
+                       channels=2,
+                       ar=48000
+                     ))
+
+streams = [("aac_lofi", aac_lofi),
+           ("flac_hifi", flac_hifi),
+           ("flac_hires", flac_hires)]
+
+
+output.file.hls(playlist="live.m3u8",
+                "/path/to/directory",
+                streams,
+                radio)
+```
diff --git a/website/content/doc-2.2.5/http_input.md b/website/content/doc-2.2.5/http_input.md
new file mode 100644
index 00000000..066e4a5b
--- /dev/null
+++ b/website/content/doc-2.2.5/http_input.md
@@ -0,0 +1,17 @@
+# HTTP input
+
+Liquidsoap can create a source that pulls its data from an HTTP location. This location can
+be a distant file or playlist, or an icecast or shoutcast stream.
+
+To use it in your script, simply create a source that way:
+
+```liquidsoap
+# url is a HTTP location, like
+# http://radiopi.org:8080/reggae
+source = input.http(url)
+```
+
+This operator will pull regularly the given location for its data, so it should be used for
+locations that are assumed to be available most of the time. If not, it might generate unnecessary
+traffic and pollute the logs. In this case, it is perhaps better to inverse the paradigm and
+use the [input.harbor](harbor.html) operator.
diff --git a/website/content/doc-2.2.5/icy_metadata.md b/website/content/doc-2.2.5/icy_metadata.md
new file mode 100644
index 00000000..19b8ff85
--- /dev/null
+++ b/website/content/doc-2.2.5/icy_metadata.md
@@ -0,0 +1,75 @@
+# ICY metadata
+
+_ICY metadata_ is the name for the mechanism used to update
+metadata in icecast's source streams.
+The techniques is primarily intended for data formats that do not support in-stream
+metadata, such as mp3 or AAC. However, it appears that icecast also supports
+ICY metadata update for ogg/vorbis streams.
+
+When using the ICY metadata update mechanism, new metadata are submitted separately from
+the stream's data, via a http GET request. The format of the request depends on the
+protocol you are using (ICY for shoutcast and icecast 1 or HTTP for icecast 2).
+
+Starting with 1.0, you can do several interesting things with icy metadata updates
+in liquidsoap. We list some of those here.
+
+## Enable/disable ICY metadata updates
+
+You can enable or disable icy metadata update in `output.icecast`
+by setting the `send_icy_metadata` parameter to `null(), `true`or`false`. The default value is `null()` and does the following:
+
+- Set `true` for: mp3, aac, aac+, wav
+- Set `false` for any format using the ogg container
+
+In some cases, `liquidsoap` might not be able to detect if
+ICY metadata need to be enabled, in which case it will ask you
+to set a `true` or `false` value for this parameter.
+
+## `song` metadata
+
+Most Icecast listeners expect a `song` metadata to be generated. This metadata
+should combine both artist and title metadata and will be played preferably.
+
+We provide a default implementation that returns `artist` or `title` metadata
+when only one of these two is available and `$(artist) - $(title)` otherwise.
+
+You can use the `icy_song` parameter to use your own implementation. Returning
+`null()` from that function disables the metadata altogether.
+
+## Update metadata manually
+
+The function `icy.update_metadata` implements a manual metadata update
+using the ICY mechanism. It can be used independently from the `icy_metadata`
+parameter described above, provided icecast supports ICY metadata for the intended stream.
+
+For instance the following script registers a telnet command name `metadata.update`
+that can be used to manually update metadata:
+
+```liquidsoap
+def icy_update(v) =
+  # Parse the argument
+  l = string.split(separator=",",v)
+  def split(l,v) =
+    v = string.split(separator="=",v)
+    if list.length(v) >= 2 then
+      list.append(l,[(list.nth(v,0,default=""),list.nth(v,1,default=""))])
+    else
+      l
+    end
+  end
+  meta = list.fold(split,[],l)
+
+  # Update metadata
+  icy.update_metadata(mount="/mystream",password="hackme",
+                      host="myserver.net",meta)
+  "Done !"
+end
+
+server.register("update",namespace="metadata",
+                 description="Update metadata",
+                 usage="update title=foo,album=bar,..",
+                 icy_update)
+```
+
+As usual, `liquidsoap -h icy.update_metadata` lists all the arguments
+of the function.
diff --git a/website/content/doc-2.2.5/images/basic-radio-graph.png b/website/content/doc-2.2.5/images/basic-radio-graph.png
new file mode 100644
index 0000000000000000000000000000000000000000..843ef1e9ff623c8ac4e0538ff37c4b8b311ff644
GIT binary patch
literal 14953
zcmZX*2RM~~{5LKsBOyu3OhO20kmQ(Um643hBve+iGD8wVk|Zl6og_&JaR^C5%E(^H
zjALbFJg?LD`ThUT^*pZYd%hXxKA-#Zd5_n4-=R8ZPHkn_%|Jy(wN+hBMURS#dOQC8
ziH;ht-I;R*_#eHqn(=iiD)GIP|2BAL5Zv)YT37Ycs<dsJc-X0B4UJCkqN3uXQdd#b
z_w4xH?V+%JVVywMRO7qAK%;nDSX1#fKc9DKpXD94t^;mwJFXPEFI~=eUmVR$`7=A}
zn0-E*ft{vZ`2(Hz)Sd)|n*#W{^`)ejcj51^nw(zQ*KhOx%rA-_a~$%mIWg5URkE;6
zl2I9JxJi5R7C-(^Rl5N%_c!82fEF)mOnAA+g_r;Pd%k1%nSu*mZvLeF`v3gi(`a>d
z_0pwFQ58o&H8lL1U3x7+O|^EiwyC9M2P^BFuR)8=&CSHKndV-j`{wVZrKKe%CYD4*
zrP<lqW-g1y)s_1GbyrX*PmB9BGBWaAo3J_*XCZDU5~|`dJy8AnwdDN0pFe*V7Z-cS
zC1_+Qu?X<<4-8a?lhfF!%6o;68N4*w!ycZLn8<#3N5skP;nn8m=3{%5m6h2Th8zc_
zrKL&JA34Wz3}2b5tEus^?p%Ld`}y+~7ng4}HMWXpFJHZS)z0o+NlD}SvGeE8dvK;y
z_H)U3>WIhfrBf1&QC3p=_U)Uc2MyJV+5L-lcAvg{`BGJ7t$3EG|Dv_EwY*$m{$6DW
zvs2f*X~)61hYvT?(hjC9`K(P$yv)s=p3>!)inq76w)WdB_vFo+H`ykIFGyuezY-iB
z9X&XU($gzjTOVp<3|O>fn;04!)0ga}>XQg~`y^LXL}YAi?5JbckM8aREObgrN(R~I
z&*|w&ksjK(xJVs1Q2*n{kMi>Jj~_o)RHWwR<q?UsSk~;Xdf~9-;~taPz+Wy!0<5)N
zU0jMR0Sfox<3rQztgO;xIT;uj4j(?OrKQ#S()g^d?zPqBd7%`aH!oj`2@5~Z&26fv
zP%N!VPEP*zP4CpHQ;d~A?EifI`ZZu9EfypwDEM4|tjzZ>3r*_x(Y<^3avrre%Cm`3
z;9Kku;WhW2Z~5@y!=FEY?%cW4&~Sz)s_<e><fXcYEiElKyuG*6(fIr-EiK)*Z=dEv
zv8LA6p4S&Dzh!7<Wo7+cUY_{<+t<ejE8c10Gd-4-!%BDS*RNkWWy=hTEbQUu^!1;n
zr_WYx*X}#Ci<47SLPCgz&fVR;p`qc%jT<=H+}zyS`ueTR%tFy>D*Vw}g4(A~H`yKj
zv3~<ql<Y)6X!XF{+?*4(K2#|Ao<@fK(c{9xbd|5WOFRk-3I+yWw@-ZiiZe$ro{*E{
zVEowC)fK#D=f|3w6tA)UjFmE64Udmp)nPlWu6|=U$%9N3H-9g4{5a>19U11Wgtckr
z0EP0wY4_h9`(kQor~_hRVwQ7oAF95-rOV?jS%$k9Z-<1?#?)3x+BYVjux&_;t{Y+q
z{_yoHOQob>Onh{-u8s~FNo~dPFgDh$uY3bfR9sw~$IQ>#I14}HR2_XoLm@#yD~>;F
zf2S-;+_$D&H#9WV*MFcUz)DAhIIOI!R7xe!4AuSq{X3`h&+gk7=I7^43LRB--)3cr
z%FFYp>c(o!uP*e4tEAn!MKiy<Z0575OOcPA-3UJQqokH#%+lY#Q4taK5<L>66_>Rr
zYO0&3*sm$>+RnjYWN7HINWO63z=2#NpWz1XT%#|;vxeE{gQKqhnP|Uvk7aj+U|e0S
zMn*yc^0TABq0^(+cP9@|B%j))OBqp7*c@RAiKshw$}<ss1G7uB+J#eHMYA6{o%GM0
zD_vjv`}px=RaMoswY4$QjHlejjT`6NZr;4v(a}-ry>Q;xI8|6yO6rYMue?;e+`)sn
z_U%&d_w138SuB|<>wJIXkooiu7M7c7&q*YI6O+!0AX;^SZxa&}Nyj}{XoxRfd=RbI
zVe=h~kanN!B4RgK=w7~j`K7*o$mNEX))(6pU-s?WgZSuzD#)|5ds*mWV`EcOQ)#F-
zRK6yY$$$R1BMattV~@+`TTM{saCnL=)|Qqx)dU8{pFK-Y$9wwpH&c;~@~@AKjqT>(
zIDF(te|^V}9Xoh<cswS%5Sn{pYK6o2>F&qI2J<GBl$2mA-Q3(zLLNReIDfw5;Q<pC
zn*Aao3`|T9YpszYuU@^<$Y51u;p9ws`t&J+bZ}w!9=e&O;glQ;(prqR{OIVYB8vbL
z@bF<aMHU|)T=2caF563&&Y7F@u(93Z`?R<y6QJ<=?OPR=r$t4_<m5~<^x_{s?kT!{
zN|^1{`Fw`T*QiG*Uvke;Lkx1vv)7J&|NfohcKoA9!m*#*+uJ)j&aeE*#u>Pcw{8nn
z*&T88(4n)2hQot{K^KhF)#=MjWs}M-e;3TqBc`TaaBxVvf1j0?H)rjbVUBrzL4hAO
z{8?t^Hk#VT#)awWJ*=UNjTQT2HBO&C{bMhZ@|;VbP@UJmFX1r3efvsLq_JfeE?jVx
z<@V<fP~hu3z!D!Hzh}>$bLY-k<$5|h>u75?V#OJHv8c0~Hs!Y4Bk-ctnipoIIPRht
zc6FH&^>=e}9+#H(82OsoX5r6GGR%MXPKJ-~X5%pOX)oOyt7-<p7^1l-QD0U@W@KXG
zE}xpO?`lW>)oEpCRn_WOW+g7yub&e+XJ(d^kiZ$O#>K^@e@atXIS603Z{JoE5D^!b
zcb_oQ)C`Y{YeR_1%F2>oAC{IrrF&RZR21#^Or~h;=i9e8+uGW0-MW=0O8V&00-O5X
zMW*6x3^=B<XU}e<*%n@{CHTFgqxk95TXjQ@?QeolrgI;6pCI>FE;4){ox@!gnI<PB
z94GnGIn8fCDkgp${hrC|gRq{6jAYuoHys5EW%<q>I{B1F?2eqdr6pg0!V^7WcXu}u
zNQ_-mJnrh1D_)+SIz;`=L8;l<IG}GmJ!`)boUAxnJ32mFOQA<145wqfQguf9`%`mr
z8m*<~=jN9G{;jF0xp?v7k;8{aT$fQ*yuH1p9Xg(-rYffDh=_>z`1(%gkBy9QaB<y@
ziaN#e^K+~y&dJj&|Lt45D_8ETJw?eoOKkq|LCL}4_xjob$-uw>X+RgavN#xp9avso
zMg)h3hK{%87z(qQnVBK6It!gLb%d>QAJy9wzJ2RlWQy&>Z-j(|a6%Ik_8T__%?>wW
zbAxD^(H#m33PMBackbMI=+L2HrKTT0gjwjQsi{9%ONCT6H8)R8P8x{BBAjTbQ}gp<
z75MH(MpBw{q2UFNhsnuhSKGwh>g1@X<ciswMP}x{YxkD<a+3D5^9H7k%+0+u6*u%B
znq9KW<ygPTJT*RkG1tgcd;#4m^GuRnVPUum|9s*;*3jiFrPN2LUdhP@MEymUc&(#H
zj%2L8&?EMEjUSj-+QAU)<y&Qyt4FLNh{kHjr$nU*hovD3<anH}Tp9Zmy|<{SXps)9
z#Es%-j*e$a1(i~D_@kfiytRIgsE=ys)8OFXU@Go`zn>fZPFNvtlz*l#vV)FhEdCBw
zAyR8Cg}%kc(Bfb1|HNzcAmgA*5wG9kp2H;@sMc87?{T5eR90TRa^*^D9V(orw)U{I
z%=GlMr}76ULtWkIl$7<GduNw?L`AbIDk_lg=-K@t6DS(Aw6tuhJB#h`8`KD(3IRdE
z7l(dHFAs!EyfYP_h@`qnx<#9vtw+>Hq5_00p549Wh5j`UkCf!($%zS{)%mvJ-tF@y
zVislZi;9djHS0co8Y$a*_44JSk`iV{#ycu$==NyVqHJMT+g|Akv!SBl(>5LOs=U25
zJw08FeY`4k`-11lYDG(HD^goxZjTQY)nXpYYm$qHI{sqIiAh2r+H|S|Kr02z_T_Gx
z8m0i$f8Q*q1oC^zSokdsq5Vg4ALruc_K#}l*+A77z3Dd>vpP}#&)l4~jZI`^q}Pob
z=s}9og%lJ_R(Ps+8Kuh6aT0*<SAD`>e*R{sZd_K4$yovshXPq$U43}B1KK&NwT|Gw
z-}rOfKCPuCASC4B?mjj;+TPhIBp~qB?(oPx(1h9zle~LymH-Dhb&U)ud<h6x>n0yt
z4@T|W9r0^mfcg>>@U^E8b|x{AYjaSp>*%-B2}f^udfHvSeBg5;@=`lVHs61J4Q*H0
z7AU>uqMfs|<e@`(0Fx~(M`UGjg3E=?R<%Pjs1>85mpM5(DX3ncW>AZ$U-0&=^`%Sn
z!Ak!A>o;#wojv<K<dOEtlP5hr7w5;@_5kDG<MQ8$@O%6A?UN@rRrsr`suq`*<vkCu
z$JA<RYZtzG^SQAR=_%*4NR}|S$A#~4MICy-r?jlhuR3f;g0xd>ON%f0)kLrN)Cni2
zDKgnv_$1}idn5ITTpS!~nwsO2lc?J0vAVjt3x4V9D3lj3?hRF8pr;SG`fsJZ9e}Mt
z6`yKr_e86qZU7jNRp=-@MUH}H0Zvm=oNR3i{nz~vqa&8vD4WZphI@+Oltz{I@$pGZ
zPwy{srLY)JK8=hw&z=d2iiS51pHfljs~^=7`|q@Hj+-`Z@}vzvc<>+&5qbPSztIvr
zgg7iI@dntIlyv_4=Qk>tPV^=U`B_NS7peL9(MZg|-Te>t_#-~lv5Rhp@qdA1V`DSo
z>UH_@{&=m(u&|l=c|gMdeOX?P+YwPww$|1_2#5_FX6KI|3b_<ARld4E_H$29Pjj<A
zd-x^5vR}X0xw*5`(>Lzh_}_=>2*1e6I>vQIQ86Gnxd)9(PEM|`Na?>@L`@~EuUyA@
zzBre~zjrS;7Z*VO6C=v;^vRPAd!A)v<QlyMsB-8m04^40r@ZeSAzsS>B_JU|Q-HP5
zzJ1_d6JV|e_QP#TA2|}6lw_u>d%@9>hm&)BU_gmK`hPAd$v8eW)!5K5IX-^f&8_?0
zwREHqYQ_Ub$}x3?XbB?A)wQ*GckMcO`0(AkcNyvFQ}u{+fn8<3CaF61-NidJ=qYs5
zuX}FJRZ($6P=!&k>t%cUmw9=!nJIq7Uh`wmp9>3fQHbU{Q8rbeFyIq(wAO4BA@=Zy
zyLTgb2~72SD4f(;0-fwXW^wuQW!BKD+S*aV`chO(%yz5?ban-eRv=VGDZNRO@nT*(
zdijwfN6>FQr>l3SI#cczUu%S~wuq$v;lO=P;dMg=g@xMM+RD0=04v`J7$;G-Xk}|F
z#I}iYSveMlV5uWVhQ`JiR5xHhshFP@7PcXFWhXcFMN>Df2CBC9_WC1wCMPEWqug9w
zN5;oVe<w@m0>NlqU0oj~B%oAG0)PDO$X8ca2h=GmD-&Q<Pt~!uwe?@<_5ebn3k3W}
zd+Pl7Q4k?3CdQa@{p87yeSLfpCpkGdJV8h_G&MPQ@BU={COCN0?F)sD-Cm;^aVU%J
z_U_)^e+?~sH+53q?A@}tJWb=wndHPoS9ka1M~{$<nrF^@lms3Y1Nv0eCF&Q0!yq-$
zng<33@@yM<2!33Zk{NnM7b<TT6dYx&ls$eN@M8GaFC8}Y=j`n4YDuyE`$re22Ss85
zDt-U{iGA>(>)o}z$B!Qu6Vnojwc;qaKHLE6wYgF<SSd9#la>=pVQw}EP(_4y_w<yx
z|2~iU1wsor#ZNagSu!=*OG;7Td);o2a)~tp?f?<VCi(sRw2em5Q!ZIcFfTt}mF4GP
z6ahJwrX#G8;bL$9rKRN@e{>=mRe8Y1MU(G<Tq%uFVPPT?653i?&ELM=ueHY7wdJO1
z%qxa|{o4F*Ap*2U*7_p(2)4tAUDwK&m%RuC0*&H}7cbtwe-8?ZQVgW;EQ9!_3uI$w
zKY8j@y6_8R<BJ!8K|$MS5VNi>E*~WAQFUx=K*u*w2=~|T-v<W=(}_gmvu6j#$HVzP
zm6zW{DT|KY7RZ;MpO4z7l**#2`-2Mse3L{Kt8vcIFl6}FW6+Q2=xBYB(`U~7Sy+$|
z7eA@{wxFQ(`}Y_HK0Z1<eSKGQUj>*QQD5Zx_3PWWZ)a1@F)bRHnzA^5{zXQ{C1jld
zt1jE>@_3E~_&C`2X>INB>VX}i26(%%@hBE!5#8L<vJbt-*0!>Ms?Q_s+Vb3G;Z3ja
z*x1^dn3#A>^<*Okcp%28WqwD6ZF^;QTvE~!h5G7M6Em~l=qgT5QG9?OyLfoa!T+)7
ztgNdSF7)^HJ;}-%CzD?T5M*W!13HendYw8|6ShP2&+pDtd@R70wbm{Q3RHo785tR9
z7v=@_y8<aC8ktjFy=k3+%E<NW;2y|K!2um2NXLI_6bfXzjo&_@+ZXtwM=0gNXK5y-
z#DF@$($0>qfQgDE?RlF^?k)lidkdBktW+^L-O<_E-PI+(*cU`tlDnh!-e>8Jnt-g!
z&pSy;+<tBBRF+MOTaFnaxZAP2j~~k(KK$0E{xMRuudi?Q@4}#T_1Y-ZkHTI*(P*_u
zo)cFb9JVe|@_g~TCC5jrTo5R<49HL0xVarHEy<1kYqLee$tHO=_2~r#I2yv*V!Dp7
z04uU76siadrC8l0L@MwJ0|JVPJ=G)PsFCl`od7ON7kZAnjXfX|NB5TevOj7f%qA!#
zRA>DL>dZGp)yzf;E;)X`ZU}h?_<?GOw;~db96f5Vo?led{^iR=&dgixm|EPaRDi+{
zl0PXw|A@UQrM*}IJPl5JE-fv2wgogbHAS7iT7mPe4&PaAHJz#)0(ogu=Wfa;Bp~3S
z;sCp6=&7eSv9hw7nwp|v@z&YBcOAWNBqr}k=IaTEdU$`M7*$vr#2sm;9=1@G{{H@L
z+qU_~>?EVpXvT@7p+RaeGwU9zi>qw-*KeZmH-P+w`T5X;(EcD8tZy}mg0vxSRxH3m
z2cF&^ypxYWsmP>T7k;2MpzoqX1qWC6lzN+)nm#dNp@~mSTv?fI)MfLfl<ycbN{a}j
zL?iL}bCfh?76FhlF|mnU`^v=#BeB+{+2K$XD?7XAg@w|gG)ZXwwbKhY7?d)n?qWcu
z-7G9DyLRDbpBPOh@B*BntRYte0s^e1c73LyQj4tNO{j0EuRkCx{I#hmH!m+dBEl^H
z$__c2LO!cpnSJ{*h{Vgt5_x&~D79V@$}v|HejMbuyRza#qX;a5Iu>`p<YcPO6Kg-s
z=$`jCVk#^-cJJmn;nm#Q%KqO+1ZZSj0RcFD8oXn%vIjdDY-OwhSPhtq)&Q0)D5&Iz
zBT|bbQADGM55eNb1_oGn?ShDTeEoN?WfO%m6}bd!31V|0Y?>GuDa2C_bthk}1~O4q
zbyGt9(W6Hr!^5w8c!Y3ftVwd*?k}|jAY=%3nH$kXu>~{$m}=T+0JsiJnEC7(VnOTl
zX{d8(SWm3iy67NaI<e3kyD{?=<?I1H4lC+&e`vK81qMJtY-w==Dkdk+rrX%tPh{nk
zeQRn8i1gfm#EGG&2@DLRmQ8ZBv_!9Pe|K<hTN_$r|A$Rd@jj?*lvp|O6`{3q4Ye1N
zqtu~8)mGP3C|^~jSx-TxUcC~3(7D&j*_r$ycneY|go#^9S~`S!1E7uvata+2Z$jBh
zN=h0W7?|vw?0|aH)@FGA{Bre93xy5xdYd<Ieq~-N!p5+bkulkC`SNp1ntNQ92d6#X
zgO;N4L2JfBoX~UYA0J`%v(45QIpIF>gPE{GwQq@TH!ttb@M<LY-e9F0W5moS^fYou
zpC}g+Li9zlAuZL`_RlV1Vf6I$X#L+?TW{aLk=U1i4y^0~ATh3DiMxlKg=Q|i3%kuu
zRrwl9CPZ>%=2p(5i89wdeEGuoSdZ76iHT{dbio|Z7D5$3oEwBV=nVf3X)>s?zw7;t
zyf<&a>*e?C0e#!xMP4)6!$OB@Gu)8G$;GvTqXH6)<T^$j^(2Tiw#N9IizFJa^)MwR
zB|17aD~ogI&f)R#k~?PZg-DO1N6p`RPJ?Hn{_Ax3r)oALW5K$|M@FhXe*6X|W6KD@
zr9#vnX!O1=lX$?Sz`nO^)x+zDN$Jv)&*M3FYOT$SUFk`i#^Y_1bxGk6A3p5cfAi;J
ziGuEfT5Ci;I=36Z4j8CT(pDZ73ya=`UVoBx?S0$i8y~BxenQ#LGR*liKOcM_CmMAi
zRmVtA?|ytd+S;@@9n{&r8&0ovfcBvJBGhn#TI%ZUg-*T8^W&*T6hfpb7z22B$;M`8
zX$7k8&Yf|Ts2c3*litn4(*W%shcG&N%=?eMjt&bYd_A>HNq(j8-u-BAKPD^dHS{_5
z>lZ5aO)w^$`vXnI<7%y;S^N6>PQ9OP$ZM3}QaZ8`C1FEIrSThU`V~S@^*%NRNZ51p
z^T0*m1%Qm_&b2_H$<U1JTNA|zQ+etDq9g3WJqgnPwX`)I=XGYZxl<Cy9%y7}2`cN(
zF+bASTKO6U@_JF1>iRK}SPf`Z`Y&j?NI5w<&!5w|A9*djuHjO&Qg%F3kEp^zqpDkE
z`btN*Ic2(k%PIk_VZmH@QL|inUm0QL$o+H(IxQ{v00oL?=NA^BJGQm75Z7(ZeWt6i
z{Us3uPzV{B=WCA>6Csy4T3Jc?C!(R46}zgNMM{*;eM5&(@@ERK4hs)2LC4(~>4d)D
zOWN{ReDMGT?Z(7o7oD6eOia8BuK{dA>%4(Prcs3M*X#H9H@N*aMHcZm?};C|2zuw#
zEwOb&`}gmMX|O2DBV1Qk$ICAU0OjOF>Qo;-#p|nYVX;p8(%;{o5L0VfwJS^|tx^83
z{ZvosEG^U4t)+iDu149pKyE=<K>B(qo(0O#B{m<q+WI9WDj=Yu`{R0F5Hm%QYs78?
zf316m!cpkyF<*^6nSKDLl}f0AuffMcLrY6o6u`ZL;|B}wBb#7Lc5c|P0mvEpUrDD7
z+KwC#^HkNBA3r>8Yy{=xxYm1-)lj*%m_2{^kUcDo`CxyFqmR$Z&)OK~IIf)cGoP!f
zs&dxUA<TEHf0?3)HP{g2s$B!p6RTEdQEY&NLbQJMnt-ENSq&&<zIgevtHfh!W29J2
zEx;poa5`tFxT&3^<64p*Q%a+Uhlj<8K6cW<&~WGGa%Dx`=FU!UytOC2{>ztl#l-_D
z(6B8n`+oiuSZnX;@q=2ihuycYJODSgx`Du=+N7Fz;mnx^^mm>~-mbbjO)>WM&;%3y
zXislS_NpdkYGj1nxnqY;@u28{P0kfSN;GrG2J}o!@bN&a8c!@FCMTO;yLQlTAgHbI
z*|TS;RC>Z}sXC89AOs<1#2n*lfVA>5I~x&p-NnV+`*%KSC}fNNvpaU~gsA|>#;LPl
zE3Z=K_ZxD_`XcZql9H2Oy?m)J%m(;CK?DT_jt&l|)zlVMBaE>K$cD7MJ_@Ni9E_Xc
zns|#OJ$eK=px;>rTstu_(f-Pnj(68CLi3crfFp#>5*^(H{TEF>BI5Mr%cCIWEkz~<
z2CePwmu+kcAfrI;cyGf8A3`Go0_E?{!a-(w=#cDeY;xA`gGhz7wY9h~fYr>*3~F%S
z)HCRBAoe=KY-|jdyu6nCDuS$~ieA3d>b^Sj>C+v^uxo5;I2mZ#(9~Rtz~13J(gi+v
z_|V<MV;uTs^?*>aXW+^7{#XHsMUYwKc&1>tK>c9cJO~vZk)Qc}l#6M2&x`jwG$EBs
zP)AY7CSip|{f!C<2|<H^p7hRi@=&9kvS18?y50T{)F{w<T+MHJG_%dz`+$VR6r7OR
zxjC2`aKIYt>fmV7F)$#lt@GLwjykxwx}rv6^AH#Ld3j)p8X6j2<JpCvjp1QoVCV2<
zpq>6Q^gt6BbZgK)G0!Id6#R!oN&zadv#YA90oi}{^eG=5<Vmz}SQfX_>~wXT5PLlm
zP52gx2FDD(BHGPUz0tMRzthG$*x4C^l|oela|D7a_*g@ShK8_3v%MlGBqeps&BbGC
zlYRfR<MVM4=mNZoEJS^j-yJ7ToL~>nzgWYxWlK0kxQmRuckdor5=0uf!}@$Ij7&^W
zTA>L7H@bEfICyH3C%a2p40TbcA>E3^dU<;vmyuaf%s&TH0k9OnSB3xJo;?97{ATda
zDqn-=q0smwPL=(A1rO)o!6s<q02BhO#I!UkG$>FKa8<>7kS?eLZfXbfmciC-ZhjCF
za_aJBVsS=laj`6}rzMD*56A)M?%utdw#<P5gpV{bUKld^7mEO~5eP7p>1YC{r>|L9
zSjZ+tI<29qLhVcy-o1T$p5N*+g&L>4E+}YzE0jY;wQGek3-HHceYvf_G6WT52@x}3
zSjM<nnfq2-js;HF`%k;=MJuc3xWe_NMt|7p{QUfg1tIJ+vuTmbB?}8)E}9Buh=L}i
zUPpRD1bH|)Zu=rwAg9&}rI<ozfvnY|4QI_*MdjA=Qz3YvglqeukcEXoifF@DTEMDb
z=^Dp|0A3+Ne1Jm8w&y|WE&NyKv4v1@{bBk-DnyK&Ob76!r=doL1A6YwIrH~-VK0c3
zyx+=V4X?kciAmkywBNx75Uc6Ingv|nd%-b4fjrwt0OaUsZ;w`c3a5=m(Z$6@hb==#
z7_b7h{TMJ8<ep8`0nqOP6h76}brxM8My&Pt%+>>=oy#)VMt2KNGmRp+82R(hzCO!n
zH3~t7neruSYrIzLj~^Vnb`i@u5f}SToLI%}3q-5InGH4-CwR?`z_<WUTU}W}YbIBk
zDJxgP+`gsM4_*|jF@yuaSOFA~Ba)I|J33xORz7_AaB<O-O?AtbEkGdnljIZLSmZ&%
zQAtKoaq&nPsEv)MSgQUB?r^Ss3IO0x<AHl-MRVSNYi|BIG<43wf&kTMaxzky8B*#?
z>?Xh(IHGN1a{Z@I<oWq?!fa!M-+unIhPkbzL>;Vz;#9Qo=lqweOlS)H(ZaDB(=Xl<
zK@~?Yi^pm5N0ZyGK;}PW+W;qOJKe3aGI<0yYbZpfr$i!{0%eWw?~h>!!$;mCL$9B^
z9yRdOr%&4QOV+@sW0&>`3FWm<yaNXMVZ>O;uw@JM+tQ_k8*5qb)dlp_)IN=jJcp?j
zaZ*|Lu$0tHodoG_csQ7rfWT7{sTVDwvy)TtUTdoX*0+*4i4Qsz$(5=j%*AvH;kcgZ
zU~gZgT>^c906Lz2Dr&%&`$gkCzQ^8hZ{I%KVrW4;ZU}q=%fy+5hB*@`(Qo!6ZeTdY
zAFAlBbx}yQ{l|U4C*u#<HrrMK8i=jMS6KQW8(_KD+eAf1ejb`R3xno__d^J{@mes4
zP)XQSwUgy;05=1{adRi(E}$nNs~Ia%1wrdyfbB)@>w=0)PXEDwUrnIbe|;6*#}ax5
zVB)&L1K8Qpf`T6rONuN-rt*@KuieHCPM@wfG{3R$(4p;wOMYuh!`o;^CnrHPKIY&|
z-=ajW&8DpTtW4MJ-n|=z8zc^(9D0God$N+Fqj>Vm#cUcq;@jflWmp^}xoSby^t3b-
z<Y}*9ggzv@{8z8eC@b%UOCTop5;ib!96TUYe<<9Fii$|)-t{#PW#x_0YN)zCGqpma
zuFK`+RDPZlQ&Z@==T3b9?gbG{@f@I+kdTPgP|f^K_&breZYBesL0Dfo<j3!L;legv
z-Y7mbclV=FHI*jju^Ol!DM3NF>Q9#<=o5fbh`z;rzhJEIXJd$};pFBvEA`4ppM_zH
zKzM1sbwyT8TwGjMb~#Fu>EgvfFgyT7>HxTrP|40D%e6N*zjf@EWm5$YcW}tg$k^w1
zNhR|;dYyP&9XcGU_*=hKFOgUgSZd455FB7v;g#HR0Efn=3fZ>@FleQ86FWOQTC}U|
zDgp*v>*wqe{7$q5&vW}jG54Xi$U42FlDQYC0_OW-N!dZhi;^5dXA*TpVkyOVg<SdU
zbOQNm5;!d+VJL*L8l4>-&DREg{!~fT0R)SPh}h2-rj*(@?I{&M@ikR>HV0gHX(T;L
zL{wD5tXM^WwPn3nk2tq8eFM1<=lQF5$Juk|F4@|Kq_DxdMYx)a$IW`m0XvDrLMMEn
zF$A;#m}Dy6*4&(!kWks{Z+`y#*zj;ozcYL_6u6KO4GNM`htC;BSi8e_2Qex?d;k7@
z1oH)s0%)pGV}g|ql0^1{yh};B<oXRFdBHAJ_?t*;^AfzgyohXzxyiFeMxK8rj8|U1
zdhuc`*3dk)$qs-UZ$f=r)Vzj{&c>jM77PInMoQff8kb8Ex;!tb`x%&PV`J3GbX3Z0
z3<#`WJ#`8YBt$87WONihOx?o+XNB1yO?UHh!{?Ne`uzFxGPVU5ym&Dk(!cprHZ=QG
zNJXk}S%lKZWI5p7uJCZJu;8qrxreHxDW$?6ro4-so#!(2`O6nAsJbhQ)2Q$4;nh~T
z7(|HZUCxoG7i6JBm=8CmklcUo4&(zCCp_$db>Q0pVm<czH|oh3OG)U%!z6Y(l2v7t
z4N5Zxf*`D&Idf*L_Z@~rR^E9HRE455csspREh_}vwntxIj6}cR4&72$H}~@QXUNs|
zc4Lv)D;F;Y@!e72v$L}^Dsgwf7)2moeSQ7nlD?Z;K9aYfz#aCWr>E!1lb8bdkW+&C
zk0BPQaM<&A@Ju1FVs1=QOzf_jfPtZ5Nl_7Se!p8VT_E7~`c&N*8Z~CwR<2{WN=p7>
z^ry#M-`qShMdNK@VUBU$Npywd#}m{9cJJDS0sxo#;ltY=#^=q<O0Nxm1my_`*nnz=
zQZny;VE=w-_0XsA1DMA(QM}TJ59>?#LZAV8b*7<V-k{n9br21b81j5QR)*`0wsur{
z`b8W)oMs&z9lU}CFD|}=VGva#x_`eSOI1h5V-<e&jBltl2)xU7c4B75%^=W3{hnes
zQ5hK-At74c=b)nU<obpNN>FXubi>OF`~7*yWrfk~G}dMt4fzllU2c74w%2F&Gz=Zw
z3>-VCRV&pPF6oOnh?xU~qi06$@`$d9358f9r4daa4KSzxAYez(D2|Pf|DKq@)r`c%
zg@rxmTMVZ=IDI}K<FM2CG5#?#;{vL^b!!B0ZGV)!zJb92Z48D2PzMBKFmeSAuUK63
z-@M2x(;~g3>#U(qU%UWMqan$C$hr5quCB!-yQnB06L@YjSf=-%iQN2r-(T^z7`UUO
zQ38oCb{j`P&(6$LSsh&SwzaV#cRT=;^AQB=zy!i<xT*l_(9fUm*Otc@=_@20)6c)L
z4n@_}$dL74TcJ#bp-*5xCVEOaNvo+CM)}X7g+l>g{@B8HHtX=26#3FSC6s9<NazRU
z<q?_F04jiqpN3`ti%^Hq=P}!3Xjn5m3qKd?26%sFW@cz;?fre4V63XB1M90(m@fqI
zg_{nm2B0-%2B5tlKObH&B9BcK;~Ah0WZ#a@pTku6`{^$`I7GyOgiO7;RM(ual`ynU
zu4L9ulnF?oRuj07YvdZezf{K_t@hyY<K?dFjnTE%fK+X5ZJnJZn4f^C$r=jI-rLsZ
zu{1MO*yB})XgPZ}@71fwdK(ya7?MQ!-W+uB=+V}$E?A}Z2nRjl0}WJ5p@jO#s3=3H
zo2bOF#wx;-%au`cku!~Qvv<8b-V_voAhOZX;8W-VF%1G&2KFY30;CJDH?#zp*?sli
zs6Rw~kO2z7L(n1AfDCcaSy@{Ml?jg@pD%LBK(3;DqMuh)sa(IFhZ?UX2ubTlo^2E+
zupo3!OuR%~%bsVCd-ci@Xa~DG+4OsEtR?HLo*o<@TxShfdtjax3qYhu#ow*9e$#Fb
zW9-JP4O2*v^ldO)Ty-6jBw$E_G4Pkl$RD;KITmjLXOGeAvQefJSwlg7L2$u&r4Jsg
zki^g>zCNM8r|Q7xagj;<^hpiql0Ezg5)QEQ+qVG-8NYrRoI6+D?>vc$1EhtaT2xQ8
zJw!NYC#Wdk9&|43aH@_BG81({T6!nUDquyn&o~uyBTvtF@$tKQj=s_(V%Tze_spY5
z92o2Yq?d{pV`Bh$hh~bpFkSBK?v8pfJiB!4*fC54O8Id%V3-QR!Ui82u85POSTKgV
z=I0~A!!i7Z(H%LSM&xfthu7M*mfl`oC&{un)%WA@PX`QrwmgQ4g%km1U3r!Zjk32)
z5UasV#=bRUG4?F|7Z7yOz%ulfSgv#K+BH2p8&hjdx)clCK-44lP3pb=dVD`LV01@7
zXzGmVuLv15t|wgVO;)W2Ep2Tj#l_-ttF;vU38WUfF|s|7G(J$6Qw!sXh2}zDI|}^#
zSPK#dEroDxpvqUG;uq~0kR-~?KGs^w?Jbh~d%vZ6nVE5$ljt)WEft|6W9muY%#3p9
z!Vw{dC|f1vGUcsRp>*K9!;XY{aR~|OHC|@<JrO6bySqC&IThyRCHOBiJN+CRLw&-C
zlpQkq_;JdCJsGy7r}+R;5U?H^5o8+>8J^|t(_BoMsi}L89%b)YqhSv_nSS}ol~)!d
z9;f=vTY{y3Lhb@o|Jzo6la`<)|Iy4!4fRap$oga;AsEWv_wPYlC^Hin-o8oNFSBhk
z95YzegVd@`V9hXaVYm&Nou(oS^C@nlBCG9!U%bA$pv#7FP3(qnSaC^7=F_KNNYcDF
z2|M3jry|=`NNNeNnw9w!0fHl~VYp4S=dm$t(%4KH|Mm-36M#v)JE%g&ed5upSCg@#
zh7C!_3%}YvrMNbIPKy70D_A_gdrCVS8?^;kljLs9V5+<N?+=P+L`C+$zyVu4<>5nk
zXb5hwFY+mW<P{4|fVmW00;<0CAdhE69brt8{+gO%jtZy7pg?)4)F8MdL~@|rTjmET
z_uMBRKRw@OAz}Q6MrtEvb(4^U`c{@^^+ntu-Y*`%@z2{|DTa2CLs~n3>eMh09U7|+
z-@lcNBUZ#M%6t$S5EzD&y_x*49;S-g;Q4{>W;JpZ5DdQA!c?z?uI`3S)P0XPQaKw^
z2k^o0K|KL!gJejSm7oZ`??h8|JO@8UVEhI{s~_ru{@sW<ra^EKI877~P9TtI{ku>6
zn@A{quKxni1brRo8a^4sflrM8E@Wr}sE>|_){0`TYy<y>sys(o7f1!IsHL)UFIt4Q
zHuGnif9H{;FS0sa!~6Z)HxSkQ>%(Wbxw(b6Q?9h=hC+jBOz<0DicN8l;viB@s*14#
zmw{^i?k<rA^Jjp;g&%7Ou&%;Y!x%r9D0EJ;0xxBuT`d@ZY9y?8ef!1=KE=jH!#uZv
z5@I>1?$B0H&M>rf?b<bL#n<G2QxG2YccG!d+l9d3@Z)s_DuUF%kM`pZOM~(S3WND~
zxFdl27@WdgIJbR)C0gqK`!S}4tvCPs+*8KJ?eL!<_``x^WMq7z@Grhzwe5o294BEx
znH~pOf37d`fd1c(GB8#GPB)|wEDQ_^K&3O2y@2B><297k+CoR9_?KFO$9)!GM?`GJ
zyTYk^l$m(6wFGBjIxqwepeduLBR0y9&{8d6EM^>nf~_s>f5RPAHwnAuYAKIO{O{)_
zJWVm@3cv0|peS?(VfOF~8!0=(^ASTl7(`aew90Ew@n2hlEH-)Y4CXNYO>F$V=yyjc
z6$8<R(i0ar+@ns)Lp6cp0k!`JCOv;rZE?p)KKg@%s|WxU8~`HmM&UNl2y}NVE338F
zyp%D{Kb=ll-v_?LA413U;55eP)z!fm+JYxcVD|==qW2&^O-A%NZbK&P8Ql8PRkr*4
z_t_{Pr~4%($Ac=$<L;0mD%;zacm{J!3SSiz7>LJJ%Kx)z+xp939G^IWw#mJe5}6G7
zUzbgl<!Mfi#E~Nyv4A9p5N&C0{*v>1bZiV5sTFWGyjqFH+TQ*yCL$9O2K{4ets(a<
z(k<S5^F~TSB4<f+CmjtqJbDU$G##(hi4#d6MR9RL7+t)I#~hO4<BiXq3r-usAPDXh
z1BQOv&YnLXcHxnZuolK!;ITV7tz!gwnnan|v$lrXxra{A#N;n(%fa|BfGZTYL_||V
z10$+rRaXxWNB}g7(B7bvkjau0928%+<a2%frMz~`U-bGeaHlldN^+o5Bi-P*i^m}=
z;FJ&+x~^lQ1W!|dtbYLQm+wcF(>r?>Q-FB2@a%`l0a`D2;sjhN9x7<$T%jsZ$;2ci
zYJ~b-ihw}IRO^Oj@c05i=GD<}8Bp;L1oDBFt}oUQOwG(TQd2wjmPJ?yV_fAGX6L}J
zAY5SK;6%UyA8V#2CRW-=Yr%YKXU;@o3`<LkF{QB)gh@kVH@4#H)tI^=KxMi>`ya0r
zH8mkViOb9Tp<d&M5b2>|l$wgyNKPbq^z7QTtD@~Qd}e0MF~Nj&qiD=iQ?^p^zz)bk
z+zFrrI1V1mz~Z4Tz&XWq6kxzfU48Mm!KsGv@$tW4ZD$f?6fqSba35*vr=APw<5S>7
zTE!r4C~%azdT4Cy4tY@R2B%Hi7=po<04ErN`7vn%YXUlE4}c~h*tKi9;o(~X`QWx(
zxq20Izr68UXVlc5G}&Pgk0LhYYZ@EJ!;ZuRJNn4f)WXaR6zXNj<ILQ$RYNX?4xN~r
z4{M~=jzfm7<o%O|C+Fr4hpJ%42dhVYSxkXxjmZMb8cM=;wLo|Tih~yq5d*`9bac<N
zvQQt>^@z|E@P$H#%Pi6(^yjfm78-c&z#{lP$89`*LPJ9%%oYZTe|}o}zyVCrIRHw-
z$)cmDUusbWD4%N28%8>2YNxonx`LQu>@Uk88_qNyd@#bSKp-E^#Mji6t4HS==9r+9
zK{JIOT=)!zfn(RZZKS8d;^I)em07CbWFVotyUj2GyyWwKV-_gt%6&QuS3D(!2SVVd
zU|<hu1VbdhNF$*NeC3h<=2G0?iDI@KGKVsDz|HN5yd;{uxHz(#U3&}4!~3xPM~=)R
ziJa{1@$d*2lWljg8(kpKKJE;t1ha?8U_Q0$*AL0_0@;IVVPb7duo6)}jE^o@Nmp7P
zGNJ$a-`)^r-iF3T3k?702;-?1%zlD>qqBmZ+aKjrWRXvq8XF7K#{Em<xdA=B{{$9D
zs~8T7i8*`v^wvN=#?5;%T)CE0*VxFsWeWxdbwy%<%@MxXTZ9f+zv4a2fXICtah2sE
zyaTm!JG+%~oGYwB6;PL0Lj?$gbvVrxw2&avghg2B$YXqNTcZ^CoSmKVG)CIL5gR-m
z1D?LVGE4xYMBl~u7#<e_g_V+0V);4Jln!@5D*olaI>nqbnAT(m<7Kf6i}+!Gv}YN0
z$H~U#7xY@%k5~;_x`&5!ARjFgm!%{JLvR|Axc}I(cr8Jb^XJh-AwbWMox@<Dj0{*P
zejKc1T<ki!V$s&!{ky-vsl6S~OF&P7Uj}sr0DSt0X|C0#ltz3C9)+12?qxm-Q?@~b
zs(ihKJ%oojKvn=Mn!ZTO?X8@QTer5<xC+LM4iAU4{S-4PU?eoZF?tE99RqUjv(vJ(
zBP#nJ#Kl3Vn!_pANWLTzp^NqJFhCF+8iFlDmoPRm>YFFPk;3Q-hF>gn@X3aTZP3Dz
zIn#CsAoO*dBYIFxRutKU^hgVjxuj=jABa|~3VCfL2CO0&vp-txeQ7BeF}BI?TGh@_
z74&7)4$P*jHid;Tpr675%YhnVCCLFO13mb%qhss0Z%Xj3o1`HQ;Bh3OnA+Fglm^Wn
zp(X&IiH?cMK$s287(4cDW0`__hMq5623RD5e(NnMBb`np*j><sI)K<Qq&7W~*Emp#
zNtYs1M{8>V`%6@Qii2=obr||E^`F1GKw4MTJq&<y@ZdHlvL_4lGDwmCW;8|{9fC2m
zkH-VDvNX{}(EJx+IC?@3#~k8XbfXA0RU7b+g@;EWcs6gVTT9SY2M0H2X9V8sh=0J6
zifmF5EA#))jN)Ja=W~(x_W${wGM4^70D|)S|L^<ql;7)A`-^B^`fl-gLHUik>KT<+
IN|u5D3&$$$ng9R*

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/design/background.png b/website/content/doc-2.2.5/images/design/background.png
new file mode 100644
index 0000000000000000000000000000000000000000..ae9cf33eae31c7d308ae8e07b3ce40f41850d048
GIT binary patch
literal 777
zcmV+k1NQuhP)<h;3K|Lk000e1NJLTq0003100LMD0{{R3l+}E#00004XF*Lt006JZ
zHwB960000PbVXQnQ*UN;cVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBUzl~7DnMg9H#
z`uh6&`}_R-{Py<t^78We`T5Do$@lm7_4W1Y>gx0J^X~5M$jHd;?d|dL@!#Ly%gf8x
z*VoO>&G`8E^z`)a@9*pD>+J08=H}+-=jY1G%FfQt-rnBa+}zL4&)C@5*4EbD-QDQu
z=+My6<mBYh(b3Y<(%akH<KyGu;o;!m;MLXD)YR0+$H(yS@agI4;^N}v<>lJi+S%FJ
z%*@Qw)6;hVPtMQIfdE#909l6sT8IE!fB;qc`}=kPPs_~A{{8;-^!3Wh%X9!udH_;$
z08D)VQ+ohXasW((09bqgQ}p!p_4f9408WJfSku$g$jQk4{{4smTHM{-<Kp6Z08w}V
zQ03<3(b3Z3;o^4yP}<qq($mw=(9eSaSl->;g#cN8091egRDA$c{QUdZ*x2Re<oWsd
z@bU2Z`TFqh@PhzX>FDXv(9nqhTj%EI=;!C|?(fac&HVlS^z-!D*x7#oRP*%o)z;N|
z08#w={O|7Wa{x_(09VM!$J^T4>+I{~<Kyb<>vaH4i2z*w{{GNE|9Joa0QyNpK~#9!
z<juo!L}3&F;f`(Fww;M>+qP{zckbe^Q|HcPk!7mV-vczC`~}A}TE=Ox)LT{=rjKO~
zc%shIWLf8$H8$v`pB_57V~T0!sj)a1;)4zz>7w^n$717|AY~LEn*`BLn9@R(5uu!u
zC~7S!Vu?&~M7EeEM=Vlpj8G&B#Vu(fT-hR3Tv2H(P+`1~E0V<o>0*T>5vml3d@)Cv
zF-e|yBTH;kZp;uTPKXz$WQapb4S(gG81YK12v!1>GaiT*`;-{FgeYD%0m==RM2P{~
z@KXlybmD6hsqElwvxl3DX53xevx$e33w~~lR=)nHZvh4X56`D(u$#N{00000NkvXX
Hu0mjfWz)ZI

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/design/background_page.png b/website/content/doc-2.2.5/images/design/background_page.png
new file mode 100644
index 0000000000000000000000000000000000000000..4274638560d030b8eb0cd4b21124fa296e2299ea
GIT binary patch
literal 316
zcmeAS@N?(olHy`uVBq!ia0vp^j0_A+5gg1w)|9I?Yk?F?x}&cn1H<|g=B!;Wfqcml
z*NBqf{Irtt#G+IN$CUh}R0Yr6#Prml)Wnp^!jq{sKt)9XJ|V8t7*fv6{6C!`bpk`e
zREFd}hWJ*7h+c-cPKM|nhS&~<s7VZo^$ek13^7v}lBX~vO=n1HW{7BF2=8Wynaq$h
zgCVV-A$|r!Y6nAf3q!;thNL!z$OeYc28OV1hS*ky$aaRPCWf$y42g{lVKW)h{{R2a
z;{9C}XnTOCi(^Q|tv6?{@-_sB9Jui4-MfANyJE~9^iS9`kMY#W?^;qN6F;SN&1ji4
zuR+%NO2naq$;%WDEj^l^ns9KLvU2+4gd~-kuUC#N)i^c(4igW<@^3*m{?;xAg%5+L
LtDnm{r-UW|7-@4A

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/design/logo.png b/website/content/doc-2.2.5/images/design/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b8898a7cfd814d6e8ae3f85a225e2887dff00ba
GIT binary patch
literal 9081
zcmbWd^;gv27e4xefdOHFK?R3U5Tpf$5Tpl?PU&Xo?(QL_Q%XceN;;%V20@VSZs`t@
zj{E-Hd%yp{cdfI|KId6`uV+2y>>tkB`$VZK%McMz5&!@|Bq#e$4FIq~|E+ED|2LDH
z<SzYZaID0Y!~vl4H$QIl&VPFfcPSlrbtg-AFB4Y_K-}EP)Ph#d!Nkf!&BDao$EDXo
z7yv+ks-lKe2*Un&aknfeJCoG@Ps`*7q;Eq|ffgVT0q71y)}<;2jI{Ufjjy=?ing?B
zxpZDSv{EU^5I-){_W++ipcV%h-Tb?n$n5B>Y%Q@(?fF>0`FlYZ5Y7!spD*cmW6&LI
zAFxLlc6pUr0`IbP!n^_1Pa2^ggW{r8J@2k>+bzFl1tmKJ@}7Y5`mb4gKsL)cP9EU0
z1*B)I`)@CAMl;)e5SGO}!3&KeOT)8L00#=tGzTQg5_0?6ySE3H8#L1@-bJ^Dmly$J
z`9T>2?Z0=1S9JhE!$%TG0P#`W+Z}G$mQ&LfU3PYKnnUMte|N7-@vbl^lLeqk226Z`
z_umr=D?L6>whz|jlvg-s+Cmj$WIe7<FWg~T0SIefReKkNi94YDfzO@?pj&C1Fa;zW
z0r^<K&=*kkLRf4sZ=jtMyS>Vk0p3<ibTEg-N5K5_=)@2Z9V`4P0<c&E(pB$bn{uiY
z0B#GYoC1`8u)R0QIikh#iwS|`!OW&QRM-trTJ4xJr&X2!UN5zdBcW0P0HYN`ce1p{
z6cE2SIP+mMjt7t~Y`WHflm?!l7{ICzh&TXpF0@)da%$Cqx959*8xo2`Wu4s-rY3Mz
zcVe|@go`rn8)IAvbBIg`pdAEgMgsc5fL17=69(v@0IeuMKOL|L2XsCFdeMMEIG~#b
zm}dZ%A%IpSpqCDq#{<S0fJF>o5Ca${0?1UrED1140Ziioqh!GJ<Nt<P0$>~pXh#7C
z5rAGGpmBM4767Q*0WwJd(hE?zJp2~~XpCoKq5;EbK!0~&Ww^aB5ikh@baw`p=Z2@k
z0PRk%lA@qbmq-6n0JEM-%m+Y!zHuZCu-IH)4+Jz5Wxe$uA%X#IdqAc*0gbWD6@hX%
zB8&@pP>FzXTV<02nQFduqBo$Ti!1UK87l*DrURCtfL23Dq3tu}nfBo{z^o&-DhV)M
zs2@IF+B@4gGKI;fY6LwzJY)iva(Sdg06_B~_fA~Hdu~6Q(4VR&U@Q1BD`s2kV^{$h
zQzD&BjMg{6B(hseafNa=kwm;eEh_pSeLOu?U6jatZZd7I#H{1vw`J?OHc%{rEQQ?}
zZzvAdF;>W{7hN#`R!Ba(R4n~`6R+~xl;gOOk5^lNTl2vH$2o3Dt&z*w%L^yM8J{~#
z&&`<G%-Pw3bz`adZAQ{kggK%NI|-|r;2pS&6-oj9zXyUfZ)Id;m?FA^;{cGc<P(fc
zSp`uS03d}k74+5IqTY$-$PN^6@2vm642$fLHbK$RitsDFyQ`KZ)p<o8{rE&f@DVe#
z)Sey=7Zm)cxb-OLZI!CDOW(+MC;PV(g6Yb{QHC90B+}hoIP=r_vp(C>ZuR1Al;)g$
zBpD}BSRs3_3uy=u20)-xKh}Qw!jY$Mk*m1DN9i6pr~OI|%>=b`$mRh!a9HSK=|naO
zAKZJ^Xv$`D{8t)+Or`|-I>Q)P;vY?kfao));3ZtQf6^P0uy5LPd`Kl#f4Tb_m?Hyt
z;DR6fd-@_*sd8wwXO04i-9Fy>oY+<^QNXGd!DTbymB~c=P3gY1xODWMID1*aQRY7)
zeT{B``NM}7u)WKI_v+_N$#kH-%;3=zUM|aDM(7@F8o$HypsW3?oV$Ie#fKwnu;Wc@
zDdp!OrO1Ev6%?}JeUxkIMdS}LLDyRCy$-c4N_{mK{?Vt+Jv;b{1s}S6^@kxS1*{6c
zr0dz?`<SuCg1^?hFVbfx0>p4TWCkKRZ7H7ZIT-T5pO={ioxwd$jyzkSZ}eF6^oTYO
zAH?WDRH4C9uUG3Rm%{QeAKGnxQg5Sz7@xABiPLWaM*h-+dsfV)|I^NmIC>^K6iyE1
z`Gvu2w>T>z<Qc!ZJu`3IcfK1n7QQ|1q!}&7!*>y`;-CP4*jM9eP5!m0hFKP{Xa%p`
zaqzY~H3CYM_B`lH02#Ey{Oj~jEAlxva71pU?nAe$jpK~N6Hwoc`qm76-7PWNYn`t;
zMaM^#%gz@0u~D?@9){AFetlB(vjz1>FRs5RpJKbdg;$SSsy{UR*trqSnP+WNCOfdv
z<?+*_2SCtf(MJ0&l$>lE7<&3}4k9XhWB+N)&GE*w?*0XLc1A}AxeBH};eS#t1g6DC
z!cc;&;I$aefDJaWy@Si)r=WiMD<)&#or21lY>q5)B4*1-Z;1t!dQl1he*kBKuT!%9
zUogqg(9nImN=`29k~837(F;|K(SA7N$>DE-w!%|}BX8uV89>Ol8Ij-;vcH6NEx#H9
zuBitxR~r_-gBhRO+Uq@#@Ag4c3?O>)TyzD@$*Mlq8RG8lAGIiW4BgZ@-ufl-ZZA3b
zt9@(a+(1K6v_TBk=^E!hjY`iw46{E1S2V>Hgjs+PjaDQFCrzxQ$!>&OT=wgy8&42N
z>5Xlmi;POwJ;1<8k<qQm-1WAZKX>_m&Y!Rvt@00^wJY$S<=m-#x9GpP$?y?>5DVI-
zY6was_Vu1D2i1KWvrWiXicMI5eRX-}E}YafB+#|JJ+e#rbD=Bnk0m_Of!(^A-#BmX
z>f}JasW;!=Y6>sbvc@p*{6#Zo<Khm?zRCmOo$=<*3RWo?Ea09s=eFxr`SlY7>I|gI
z`BBmK0h#ehS1HsNpLjD(CI9u#dgP4K0uGov#kWiG2<mhD&>sgLSh1XbRL!UV3%&az
z$8<%(Q^|+%%@Vp}%xzqqr`nW@Pf~H~i4WZ-dug3!t1vvJ{Yxf}YOUf8l^uYCAQ69e
z_sg`4#sL=<Io!JN7F4V{Yx(UQyinh^Y#<Iz5I1Tu9<dnzV~e96uqOb!oqRSwGP7_Q
z&2}LxC{_$(`}#JX!<+1Dk(j}ltvjqxaw1q&)bD_>KaYNAC$h4-d)u2ss*6B0L*EB3
z%;P}nC9wP!<i=I2B*ji7d=cO$6_cx%eWNtP?r#vU+aJ!QF+TY~0>7-Q+&(r9%>U8R
z?dF{HKE|7sj3ieIuPwAl(rZ<SMEH0@(qXdNnpME%U=gu&RKquwA*&Z@S{yyY+RPV6
zMsm6KXN{PD2tgO3t@w~cdBsLVJhI(5cqzJl`=qHt4}TC+<Wb`EGjO#|W!G6swCRtG
z-OG^1ZVS&WMaORnd79d!)91>}&eM`FG`O<crUt>z`fR^ztHJ))U)M)GW;Gd8N&jkq
zM&GHmrUZ0Cp1M3A#5naC?n)@Wm#~FoAhH^iJJ}0qu3^6r3BKM8pcNT?iNKUh@gFPV
zyv-j3ZF)c%p0SOaN-}x$#hJL~WN{~u_eHxI3-{lMo_`sNhAc3HeB!Y*acSba{Ub9i
z&@dHfC^6G7%s!JL5iH}k(ub2iCwMtshr3`WU$+OAZe(FaT_spUN_Ci(a;><CWXJR;
zKx^cpJw9lG2_?@9#9*8{e>}MSMu<wq>Jr&;B{E<ZlFcx&CYD15EFZSd^R(_FA|e=<
z0;E+O94g9k#YM2zEGe8Tesp@oQD>qf`U&lu<7%XPtuX)5he1aCdac2FZNlK6SJ&Y`
zqj*W3-3?9jHX0XEnK`Bg^E>BM1)e1vV>^n1*=vp>r`mqqA8a|ruxVx+u`78;V0e^n
zqbTwe9+Q^Y9oC!cSH6qZsnm8&5?|dJQ{=2t<W>Vz1>uC)<2Jr=t{Ub5Ty>;k5cBZ`
z7mb<ThB7~L#r{C=$9xe>Fk|kLeM+Colax`p+&3yt;xMu@c3nia)$6)79IOfsD@xni
zh}OozGII)NzrH{WP@Y<!uSPyn0fc^)7T}Ikd=!k{eoCrh?n=K;05Zr?wA}pD^;D5R
zyTLq#>W`L>8CcX~5&|h;3h;oq7jMV-Y?)lbC0GTBm+g7fU*q_T8l%zpq&|&+V*6>N
zkv>82CT(HvOWSN4*Ri8t^ZWlOGlfajo{~>cDo*yB0l1J6g?>c8v7dw5<8GrQ`biPE
z1l)RrDqg8uUDvnTrMCWlox~3>K=e+h3YNVD<6O4+4e&Fz5`zuEnio?Ihiw<LmH)g1
z{70MY1;sB384UIi(5|n)`om#KvP?3`3v+4|wNI_dF3;&}pE7$tD{+u!P@zu(Q&vk*
zOw*Bt>d(GJBIB{mS-Igl9O(h!e>D6ZIhJW<X2vAxV-rE6w2_)|#KbZ$X*Jq$<asqA
zA1AdkhV-NYRx@`dz%%?Fe<?5!R*Rmdo}p~L!y^g*`<<>c#jg<UyXFDunkVBnwbn0r
z9pv;I>lorB^~-IaQ~GAh#jR;&w<*)({J|!w(O+uwm&YLJ(zEF4u%6~O*d(&*MM~vW
zH&geAt5VnUq8MJ}hJLop8?|@#p}wT`?;xJ!EGRU?ny}sD$`EhnC<`eHAfQV!ynx;k
zz~D|ze@8`z#oD)8dT7SbtJbyKrMB?D;SLuEOKms5)t|*?l<%@VzS^-4*45|s3}#`N
zvIy(3EK>@dsUj4PTit$DV6t#Ok+hh_-+l+n3Dyx!&4A=;k!;q2zP^a_eF<fr-Y6=*
zrYkSD=bMx#Gz27Qx1+lpi*!bhC#Yd$uhhGob@#YtNQ`|zI7YKx-Nll}61?q)FRgzA
zL5|*WkfP6qo}Ov6#YK3b;omi_()KOA^7hj(&#1yBzdC2?>nArZKHj|KhiCT>Oyh^)
zQqqvaRbMe@RPoF&HOA-_eAg}2Gna~=`X2Io>yeb9iD2dD4&F=5gn^(^TX?U<^7$*O
z%L77imLS|s<U*Klq7{h?vaHFn6H6y!UyIxu2nd<ZY;^%kj#P(KmY8W{9cr*1nNz?i
zn|I$(SMV%b`Uh^2TtUL}cyQ~!*%>oESw@#`Lp%gt2!vwo-v*BK&1BMtpoansDTUwS
zUZR{#<^t1c_gUNuC?ki;|K6zCaj7;DgB7LoqCDgvl%-_1?~Y3Rz6~1AbK%IibYZxU
z7tha+xO=oU{!!`$N1(7;RjCngl*yr|jeXXhIfhB}UCNao@F(z+=9@7Lc9!5{6QrDJ
z3$|NUGeSq2k?%1`{j2zglrK~ztk&zFC=%xnP9^RAU>;xOL-p{K{z%knkxZ|N&5fQg
zyZIL_m+x-z4hZT~ZEo7&Q^2U%gx;pfo<1sQeX!4?=6Y8;$;%39B5{9g<TM-n{Lp~(
z+@Xeuy?gp%5*;6mPx`!ua+~YxqSiT6MJ86me+Ourwjw&Va-ih|^Rwqm&r-VZG+v&6
z4U$ihYf>-jIGVeH)E4(|*lu8Ro{gR_onP?(K8d6%)qr165rqg2Z<jf9xNi1>gH<S~
zudQv(4S9~YP*^^3!F(em@9;`QctOhR-+07iNn7jw*uw9_ANW|Sa?EqZHn@(%60uT7
z%LJFUiLCOw_QxnR?3+clhL23*y$C1(O2=SuPH;3iUiwF;zY<tV348-5jeYh81#s<^
zrA&fpwn?lIW5<91YxlcPuPRjk!XlyS1QXI+$Bha?d;(03Ryh2r#7g+~U8nMoxGH{P
zp4_o&J{(3&{+KuC%TW5TlpUN(DGb&SEY+L0Tz?3>_$>BMv6GtL>*B)8$q_bT<GSlU
zRFfTt#YKyzzclvPYWt%2m`3Yj0;U=qh@!o{-rWj(7+elo-s<T3EL%{BO&o!xC^Yiv
zrZ*9joTe&Ak3>uk*Drgex^7JOcGv%M*o>nNgZ$o*{~_J38k$ArsI>!S|D$#ydGYyr
ziB-VS!D+c!e#E6=ym)TvZP^pggdmyhi!Rmd@?-C5bX2KaOY=zAr}vB%hS26+3hTiq
zzmlg4$Ln5RB6xEutXBT{g8$3Vk@Ed}X8lYj2a)!F?2fz~kxgI_b{vhP?@j0MDa_dh
znq?A`7;H7Wh9@3R^1Z_9=DHExK6iFrNb|iy(sg9kKhq_^Wqf?Ay~l&`gWp7l_cfE`
z-qfpcle!p_m90ioUk<Ti9mJ$<D~`5%O<FI|@&RX@TyK0L+h{1+?LYeY#i6Nv{eb@d
z{(z$`>4)1FK}2BR7C+s%i<~2!!)>7+Zsbp4zU-uy-$5tkGG9a=&~O>@7QEqXv(Ugx
zcNv+U@z*%UhiUyydtEiOhCM!f&QuG18bM2Yy|2nUSo;yU+O>tRuZm@>RPkAJPnz64
zIZC#;Rv5T@NrN{Y-*e|+Ise<7BZ(bN=j4k2CgkhqC$zN5F?^f0<hDD(3c=^C_e8x9
z!t-lK)-3F}QfR1DLF{*dxS{)y1`beQ+U)(qlH1myMSQ!=Baxp3|5#HG%KEN0mX^*%
z`HrKX3_*5>{KD^uX2)J-JL%Dbo6Ody&EZ>5)}tmv_9!B)zNfuw^&nW%Z^(D+olr7c
zc{)k=&0CV!hrb8Y<fh#Tl%MdHeytVC_S|5s|0n3%(lXC^GWWPkbeQ{i#_WP1d<Ly>
zu(;SCyOt@svU@Po$%QI&14m-_pomEt3f-FA8B;$g6pZcI9}-4U(EQ|rW+(={WT~3|
zD<<u5UTU(E^kd_E<A)~9`+lKm%ja)M-3`|Hv+H}uCyi&$>Cp;pcZ^0k$`3Q`(?vAs
zu(!0F?4i<D6mQ!hr|T6jwVSDbsM4hy%%7*QA3Y9TNV<J9+p-R!!03P{P{HQ$b>`gZ
z_|=fxSW|Qb$Jo_xN(kx%6NHp8(Z9LA{vz6Ag^IblHA@g#_KuT9pA7goQ*2dC2#G(d
z*xyJ4@v$vRH{6OI<}Oc<_86Wm3wj-vYl6ws5l6$^&POb8ot3n*-vJqKpxL0U0Mjq8
z3fP76d-Kn5JWjbw950M<l9VOEp1)xi{yh4UO5Di{xIfVokDz-vK7zB@hTq5Cag@n#
zK}i-$y-zS!VhNmlc+f1(Z?(UDnwh_eOSt020#ch<$$03VD00^z_AT;L-jrD>)<@a1
zQY&nkr?%CBpRiJtpTBx7@T2X^g&PD`7CJhy7jkR>7H#4{V!CLCSz4OnuVY98FDaH<
ziR1BRc4n3z4wmml+-^tT@CG*83^O`*-OKtN)n~V|JiJVK!qeDr0)Fu0yCdV*+1^_V
z`{J{Hpp+ooZH8`3*yH@-bKKcl(9O<K?nUsq!T$bT#ZImU<KRX<Q&CF#0YJm_`}qXk
zZ1Vg|vxS>2PVP4oiZ8628fmCi?`fCr4f=0?ftm^p*8}ClQWjsP4${1(O+9Fy`55Y3
zhArC^Y9Apw`0BTB`_p$tHV5A{h?84Bx#DpQ(G*3kE2n%<(}M_FVG!&*=+Vz+e>&`6
zrI`7HjTm0*{wVlcjoUTAjSj+vJi)ch)LP-Y`Kk$1J--Nwvv2(Yf~oc%+4H_^f8u^@
zXXAWcx8d25J1puQ^wY<)Zsy+}h&nM{&>M35g5Mr}$lDkc|KX7WWi7+o<-(YJ-mKIw
zXl0{%`YaJ8wVst{v&oAu`z=Yv4%4nS^@w`&>p+jYmQ<2&YGz}e)wq93vrpq}3H>Yv
zv=u)s!-${K-p*mU6+P#d(=Fexh%s<%fhDC~8IBmnV7q}K@XS$GcS|_cqlKb=ZdG=u
zo6Qf4KS|#sEC8ctJR!&KB_6PgMgee`o&U(cjY$|vX%T5t@x*ic&d$2(+yahi?7Dbs
zH}V#meJ8s%!#4G(>8HW2^%l>uU&ws4vQpE`r@nzBv~r`3+$Uv)3$-5Zl{y7^?JlG5
z3~iF&+cax0p4l$y{cj|)P(LyE&x|BvYJU+CoGoVe2uiT}u0o5g<^Xd@&TGF`uOEfD
zJP{Au1Ij6Q)}%U=*6!39JV?NNMv=)_&y-uC-`u8m0G(=rSON*Qy^C;qXsL^w`ofb7
zJKo}vxWRIvaMDl3YFezA8=K9*8kz9)3EdPl<@Tc3@Su!)cJJ$l3!$#wE88vUt|}PK
zb=sQNly2D>>V^o@BUk==@GKPUjuH=bsju|O=bRYXFw!q7Jntj#Sfx7%_+;Pvx{o{a
z%5p9sQCNwFmpw^={TPMA)$xX!x#~|0Meu&^N3Gme^Y40OJkjt2;jG&5sgR}20gfp@
zF?I>I4#kUUS1`n!I1$fg*)ll}yYKa*9RV-~&G}J9*PBlUmD7}Mf$Yd>z;}qpuk1ke
z+BlbpHWPq6L&w`rUnp;p^F#<V2|ZHD7(nEW9(<NuM5+y2A!D#Qp2^!LG>w)V@imBV
zaTgu7L<gdV5nCqTz(gwd&&^SyYi(*VQge#`M+X0_sqRPJ*EQ~m8?-+B>M}P4>sZH9
zAsOgJ6!vV_R1U)Py*%4{7K`tCPhFjq!1)#v6kZ2*(~q~5qDJK5C--_o><BVA;)XB9
z{^>Ep$qh9G)W?yp@#<7;<uz%7Z>b<zC!luPqb{MKXb4U`o_f^Lit;*wiTV}_jwJ>M
z@@P#no<)uv+Lj_q%u4Ox4LPZdsjcbLP0Lng8Udj2<oa(N2fOsF1Dgn8@c3Z_<hUmc
z8(fbyifVuJ5IV6>=kXIgu3V6|ZD!-f`v0ZaskQC<H2K~%YyL*^s?-TyLJ_&d?N^bh
z%~`^~HEE4Klg6+i7|zTxax<G}cWwA%+`A*p?ALajoILX8oX^47DpRha1R7bES$4?^
zik8O;kIg6=zs=7SPRZn|tK&GRtB<Ner66|`Zaq&yNmF4Xr|RMwor@lA<K|xd2`)Ec
ztdw1$CzOf9DD^F@I6v(>hro33=yt5O)^w4Su$|YZ#lFGYkMXYX$1G_4dTe$SN;)oA
zFKcz5Dvn@$X>mR=*x~$zi~x1^5Yywqb)gl1@nH_!9yRYnncmQ-uEljDZ^-pUUX+wB
zoeR`Aq-s{mh`kr-|M(IG2FZ*u^m!errKox)CF4R=ZOrSsn2KRhQW>3cdTnyP$)mYH
z;*$q8CJbZVB<0n#Y{O5@*|+jk>wMDWU7^=wnH`)_G)9EBM>KE~$^~uwhz~Y|c%fJm
zB{g2^M>Ll_&g|A*7-x!A5hrUeK_5RXuKeguF;sPV4HgJY6;gXLk5kdp$VH@Rx+3zc
z<m(%pn^r-wlHJ|nZErEVkv@FAV-+bgBY&y=00jB;v(|!=L3Hz2lc`Zvi~j6lwX5Rg
zx=BlaFj%tu*r}b#yv9#lU(UquMYf^fCvPj8D91ag-MntVS_Akc$6{|>(v)^S^>!8J
zjmPMum%p>x%V$Yjjc*Fzd@|8v9qnb<d5;BJ0o7g!ac3lxCW)JpheKYa(F$usT|v6e
z^wK~3lJxe(dzHcy>PotG)jPFyE`o9bNqU2Rl@XGvKF5wxVfEK@bSmmvadkPkkjNs(
zeP)ezIoGke3s?>el`fs~g|Ip@9UZQD9=oxp0^US#G9p!82-$W0S1uo=pec%5K(dvB
zlH@`nS<h_qMe7yvraqV@tw>Bp%r-2@JhNoF84p5mXmhwhM%bV#jyx0|_=4n__HpW4
z*Lk|hA78Xd5)dc+B+C%`#C(*ZuyW}*^7Kl`Jl3y1v;1YoF0nTtX7W0Nn)pwe^5&j7
z%Z@M-2<$cg9QJYOYm`8tYlY3Iu~(<WzAw{o<oa?j!|mw%|M#YASqJQQWPCVYTqa+F
zRzg(T6SkXFys`!|Dh4}svW6x%wCbmqWL|mc{v)O1sGTaN@q6E8q1Brz-_*B%YRyYl
zw&}V{ZH+`Cp<de%&#P6351xk$eO5q6Kl8$Ylc4{8++f!7TTdN}sh5p`NJK(Sw5nO+
zSP>A%eiQ#(sQ#d8f%xH?J36HPehAd!MKfQITd1-3!76e}%hWO>-XYiYD72c5*xz}E
zChj^^Oq0HugP$3Ke=P{pz~19;>X^t2%G9U#_1hYfys6KK)yX3JN1lh^4J6e0yI(1*
z^OzDN(mm(bD;n7NOrvGqF@NyTGwZsg{aj2`x;=fM9F#|IN~uGA4+8(ti?Y_K^z?Sm
z=s@k*%W9TS(Y<(f@cmEls;uHFyLJ-6lm$PFpHO3+slav%$S8x{ZBCOlbzZieN{Bit
z3{OA`O=|h(v!xJo_LEXtO?PK|h&zekw^5~nFrRRQ9TvXP``A$d%7b&g{nHFO0-3k>
z&Oo_{CC<>8y{BL{c*Nr$(o$XMC{Vn?0C%kJ<%14oWGnW&Vz-EI{hviV?msf!^adWc
z+pa3oUB{FNDkqSdKbd;9=FWH`l&^GLB<CyhnYe<X{8y|BVeR(qpVnLNSst#nx~V+L
zR})1?Ihhwv?mJE@ok(Z+AA)_vRy}KoF2?Exct$RyLwsv(!-tP-Cart7*jCF3d5xJV
zS;_saC$X;a@`_s$_V56Z5w3Mgi6%&p`ni8cV)MFYn8eFqI+f0nlUmI=;fek;!e}~w
zoXL{nZPqV(^6-pshEI>XBUFgVqhH$Q3z4aLKXYcs4w*whEg~lgz}bgJj@5`_*XB8-
zU;tbq=3cN|?m9}$(cx}QMK<9+nmaM<Cqwzr9nqmkfyCO9y6sO)l~C6Jg$~H=gRJv_
zwnT91nOQip3e$xAs}zF2%0=Uk)UaCjHSlI<er8&|8uA0u{amY5D=u9;yC?VkSGsRs
zIrD7aY+E0HC%KL=B^a65Eg{eS#)<lP77JFk!l||)g6R-qhrgEu(Z9%e6d8$1;`E}Q
zT`xl^DCru*;=>zl#wv$DSrv0(D&>v1)gddCp*uY5bLUAl&gUY+e@`{C+ip(>6!YIw
zQv>AG9MUKjo%A5aYwjwFAaifbjr!$+w@?li?>1f(83?PbQsb1!H#8bQ6@mV3!yK}N
zK?lNDp2OmS<?YyZSlDpX4Ys0ug<{=IXsAX;P$BvGY5)6XcrXS@3q6*g!uRc;i%v2_
z&sVsuh>ACRI3!!|PpZ`ozHYa2z!Al<Tt-IT%DcOUOXXFf?uDMlbPQ{wP7FqwpM+9=
zd{`)2PryU8OW?6E$8^~~3XA>>j+CPy<LqOIt75^m$TjQP{kd)a=B4%5M7rY~US$TS
z4QxfOr`4+2o6T=}V~t4><zzLt;VNbF7`uxHh;rMR$>m;)Xcktx1KfrG%<bl<;gsu$
z3SPKGU=TA7@sd&~*Ayr}|M5_(-@deX?YuEyMki2dPF%YZ)G$^?lM;4|!~t76DNpKN
zdMUmzGBLgzAGS~L>}gQIl^URF4$QmPU~D0|#WIu9_kHuYnQVWGeb&$P@k0WACoYZS
zKh>IRM`YV)ai$Eh&K>VM>PCax>IZO{4zu0-XOjITi2cRk5sX*U82+dI{|`-ug{`!6
zqV@6zEu1N}KT#-FtuEL>Vv`WRRMST?+RqcN?2&<&G@MV*_zA1pUHWfW%I1pdfIx$w
z*IJxAmAGmTH&;Jy_wQO??<8m{OcV{oDQs3gsbqudzo_?i*Ex8nRZblguvx9SaGz?$
z6#3&j-)(93c61>$LILx;s0htyeQd$;MZPUqm-lnQO*aPG25TZ^1NZdVHU_S{d%lkm
zBV1agQg7Au+)LXR;d(@^O+tc47>o;7stD=zY}1@PmU@4DL`BTz_&XxhC_uMdikB}-
zX>H_B0pg{9Xfl7V<6?3f6XRDWQX^tw?+0J#z*s*UL~)@bR@nRM^q6RFqaPF`q9g5s
zp!_w7_F9Q};}pNx%;2Y@__#tBerby}qthlntR32cyzFL&y?%=AdnZv`TZJZx6`wsW
zH)(L}T_Q}uS(c=N!I+=6){?ETuCSZ^4+W(_BI`$${*XE3WpybSpSKxp623sG^o5@P
z8+#ZxHXC3fixDXin3XkvWqon+$&7R-=<eU!DE0AS@zFg^2s1HSg?9@vK3&OCG$dyG
z+1ff0;&vSWh~B%22YOqo(vW++bp2jisi$89YA9(G=(DF1&r+uC9kC=$rWv#0pkap!
xMp;uWz6#BCa8KF(U!VOXs($of83zXRYbeeXzvFWF@9zvCC#C$ZLIN4`{{UQFNz(uT

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/grab.png b/website/content/doc-2.2.5/images/grab.png
new file mode 100644
index 0000000000000000000000000000000000000000..aa333f1d770b5fd5bfc96b4e73214ca36ec05154
GIT binary patch
literal 821
zcmV-51Iqk~P)<h;3K|Lk000e1NJLTq001rk000*V1^@s6bj*EH00001b5ch_0Itp)
z=>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01m_e01oQ`hc`BM00007bV*G`2iOD~
z06PqICE>3C000?uMObu0Z*6U5Zgc=ca%Ew3Wn>_CX>@2HM@dakSAh-}0007zNkl<Z
zSi|j?T}V@57{`BSo3{LjKJ-E}lnf(?2wSd1y)a3$Zqx`w`>?hPiGpZ1V~Q8)E&}g%
zCn%X@s|*Zl7cEJ_+GIgRL7^pN<%K0$xh1;ucA-181<fyl6COD5^6-D2_jms1;W_V-
zgb>2(_2TpSP{U;~7%&=*=t9tDvso43EiEkoNDhZXm`o;u!JsO@{eC}ArxP835CS2D
zD!@aWy2ya4z}4uu=6CRaeOoM+W#uioRVIfAx#u3>-RL+oXh=%gPEJ8F1$(xx*uiDD
ziY&{2O_=`BOY`;Dl%6P~JTn!&M&`@s5eEBjBk#VrZ18CNuDHkhJNq%5wUCn*zYx)q
zye*5PRar`|)oSHTaSlCCUh?(F40gL+iA$11Y(g^mWi=eywNa`2yyqI-o*{IbGdONK
zMOI?W>Q0rxsTnS(tdFXDG@XX|(lHYCIz>DG0D`GcFKBMPOJRMDqW2{lu{KolexRLO
zZBMaX$Y1@bGOwFo+iW%^-qh5jtg8-Zlc1H9dXsPZxasmRHu0S~Ss+Q8u)Qh{?m(-N
z$jq%E@X&z}d5dbTMLWK4Lo9t`eo9i~0BCG%1fZ_2E-W`e6JD#s*^A-idCsLLp%nq@
z8|>kGh0IupMdMiVILs|SfVZukXKz0em<=Ka=a?KHCGw3$<^^P#nAmkl@=snp?)*dF
z^<<dY;4DJ}UFehYmNpI-Ggac#3#l!O<3aBo?%$XoD8;ZPHG?CSwPCrDbt+4;>1b`H
zTj<$oECoiwG<&~!xO$}n?WS}pPVbM(5dxPS4u`0&uEy{8tK!QU2n2AsTq-|gt(^|n
z9RH6UmpmSi@cDcc6&0xh-0gN_Fc^^3`j`I;vxiQ@ucq1j00000NkvXXu0mjflLm26

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/graph_clocks.png b/website/content/doc-2.2.5/images/graph_clocks.png
new file mode 100644
index 0000000000000000000000000000000000000000..fef661519f96965ba82a6141ce1b3c8595eb39d7
GIT binary patch
literal 16474
zcmX}T2RzmN|2}So%BmFEErgIHyQGl4cgWskWD^qEB`Z52SrLUOlC10`Bg)K5S*617
zI``-M|DXGD-#5oO@AE#d*YkNjuj_g~Uw711<*D~D?I9u}qQ0VVNt1|(gcCnUP?F%k
z#wT9n<A22Nn(`NkO1oI*@XKyj1p{{?BAT~^e~A-$X_)aOg~t_@%M`=A8L3WCQf{9#
zz*C1kF6(>9x;QymIeQSvx>;TGu(IUvvh%RzkiVj$t`|(hKt#krbmfwaw)gN-hR+4<
zfsx<K88y#nJBUbI`74e^KE7#mji=CV->Llk)SCOLx2^0#jO-pfNa`3IO;$dm^vw8`
zRbk<g$eSS%?*$hH8{P{FE@UiiZ;LKVEdQJ7qKdjHl-X_CG(9>y=9e@p){TECPEe8r
zU*MpleDpV`f$t{aCt)!<N-~mQP71;w;tP7FD#aKs)7{c}urb;fuu{_Z>&9k=H`)Ci
z#%V7tzd7g4r}e+aHk^0OlYJ#6ld-Kb%utmt=r56`Xc839P<_>GCirdLcjZMcce|yK
z27T4NvcUyva#91D7`fbDTh@Es=H;!+W&Lx}au(ek1^si3x1}EXlgTJ^CYY4H*rX&6
zmC4gA;h$gktv7MWrMQ$MnEJlusA)lesxs%w>l9_qu!}yIHsx|P$_CHZ`tu~Vn+dXM
zybAp@x_guFP|?;>vx%QDQ;c{<S3dvz{!KMQzaZm3kBmknA|Hxp#5S7`@rCU09^?A)
zq0(^a*LaZW)vHpjUoLcn2&XFd_V)h#`E$x>eqmvCb#=hLO2;Wzvv6*1PM2ZbH$X-v
zSe?64(}^>|uHhzed3m|z=Gn7nckS9G8k<n0?dw}RaG9lL@18xEj^0i5&+QepY>khI
zpse`!<jIqe5RwXAb3sNsJ3C#5vrH<1fq_<5Ckz7J+}vz!xeWp@UvB>V(yOf`q|;h0
zQ!+K(Bu{gCdV1jF$9wE|@7<f2owZ3cIldn+i7S3%Y;4S_ny!#krp~>xvhvovJaGeG
z*P<nMePiRfq5%D#y?ghzsYJ9)=H=(#n|@JQIW;|fRz$?G?OdvI_xYW=@bGY*KYe|D
z4<8<_V3E$+8FlZzTXyc;x!LLID|wm~{}@cX8wUmkcml3mY1{hytL;foclUCtP3Dn~
zWW_umAD_<7PRoUri70`JA;+R9S~f{;etu3anmv1%r2Rz=0=2ZXOiWB19Et{bk5JxA
zO0u@fQ|9c)g_IN(TiKZp9TM^Qre5J+uAiQjRi@2TGL_5yAT!fB??jB;WWC=nG7@5g
zK(80Ss;jHFxBezf4}SbOGdp|U*N<J&+tt$2Qow0hm}zN#pr}7z1y^))OF&5Ro7DZD
zFDmo(^)+NN3E>cBiS0D{=206SPO<rVYMb-%FJu1X?%9N*Y8{K`i-x}5-tk2do&4ls
z7q4HxUVd`iI{9$xueG(~di&D0_U;Lrn4cfsy*U+ouYOINXP~oFrJ(;V`?b|XeZHjR
zWQL)sPaSF;<7R^K(<6%qu?7MH0u^nz&~=V+OQE~dBYZ*}S^l4~O8NdwF*D!4tLCV;
z>fTy>m^z(sAR#8fKsv6aNif=fZ;c}I<E!g$|3LZa{yC3|wsNlVj*ckDzG~yr`i<7f
zpRF_$kq@W1LN;u*Ue#}OnF-cb)st?<jg2|g(z7}(YxAs^S9%?aI+5IQV*ecr&m}5S
z2YhN)(Dvq_Y0#2c_Q#5e{bVwwExIpK4peeo51%s1TV7g`_({pVbGm(b<xkI<m6v7G
zO&eoj>rR8ESFuGe<{~5#lS!$n>!Y6zDcLvC7#;tnKCv-+@q5d<{r`^uJ^?pZuKAs_
za1Uu8Zj%Likde&o%WnG*QvN?6nY}{#wx((8$`LxssnZC2$5IM6kp$U-{>jNnr*{$?
zwN<|q7*72Pczf^--ruM3rm3kdYO2`vHiun8+aukg8spN=?6c+i#s&s+6BBRD1dFwU
z)YaoVt3GNLYI7#s)jQ=X%ChoAj!Z_FNkvQRK<wm{(Z!1wTldOShQur8VI4#m<bMDD
z9nYSlS$KT^9o2$kL1wnLk5$|qgqg5h11nN{!uoo8zI^}A#>z@<MEDLDg_)>tUlV5P
zl;Q9!qrFES_4#Ifc`Ap1z;a)n680Bi?8e2N(1v`n>Yw`X;RF4lLx%I$za04e_wR_X
zSV>7qSXh`)>U%c>_Uh*D?(Y1y!s22+BuByWU|E(*!m;EIpacD$umPhSZYCBM$L^{7
z$;rt{Nrt8JO@e$95)#6~^bc6D992&k`K&w_->vy3SUk_$h<+lM`*U@b`K<l@0gha;
z&{lll8Ahs#z2+`Ul~GYjj*i8;MJLA1-F*Zj9|i{pv(SX6kBzN(o;&xVx>_{NBv!>Q
zl!G!+k$U&;>t0?j>cSe$S}lb>NpjFB&=#3<ofdNnxt8+!b&$S(id08*{Kt>JK0ZUE
zU2jc%MbcRJ@1JP+eeBV6<Jj2P2Dy}zbV$ea@EPw7XDsZi{~o$`{%$Ps9*VlQ7a<TQ
zbL2cV`y5Ba#1$jI@e^?uh7FHUky3EbwOSCDcKlzAEHw!oCAu+22#zbd&Glnb+1&O*
zsZ(w~X}N0ug_E>Su{yWoZBenrHW|80h1%c8Uyqv{udXLOlx0Xo9;#Xpx=9p#p*G2V
zwktSyFRMPQ4JErEQ_R7G2RF7QY<sdd91FMB1kD<VN_6+G5|adboH8#@VL7^Ri<3fz
zE=``7<o(wUCpMF{`*ig5WM@$MJjCetG>-|%*qjmD5M*ClFca@MdA6)R&R*^I1rAlM
zuSe7jt;K8F?7Bnr=`Zj6StvuArTVY=y4+GNu(7fll6X{~!Fy}OK;Y#i8pm6z#pnEr
z?`3m8NJw!1(m+hXn}5V<Cg;*ogKF2W@keB9mrpXjw<VK7VbIjl3a4cs%h&ro_2Nfl
zWMqbf7ys4TN}KmS?(WYNj+>Y3cg>5WD(8RuW=qxN+rXC1{bayCDk{p!d24WCC59t{
zn3Q}?zd62R`r5T?%ddA{8J64@FL77rzOQzEi~d1+X3vMx(oz6&{pYEhw+qy{eP;|1
zOk?$a1*#cLqON9XvzBXpfmz1<Wo2bS8$&jJ@2Ey!2krd$+JpjEFSURg?cm_x<g|2a
z_W|F<oW-48^OdS7inThg5>i;6-s#BoxR_ya;^gm0Hs*BVxTwg;2WM<zwd5LmZ7V}U
zLPlP=aGf}@9^KY!U-k9tSC`jY&)Y2L2lAON_YMyayS&=W=Tf0b&sluZ8>RZ|%y97w
z{qV?s`^i=j)2^8t30F($YK*_X3ETT}K&E_in04!roA2tuj-d5g;s94sl7u#o_CpE<
z{eJp?Ef}rcNmooLLK|-`9AM!lo=vM&Qd4{Jg5gyv&0{<I%V}w8gC$1itly_N43<`L
zJ-c8dpQFxaSjjCUq*<ctC4b0*@zCMJbJc^Z5vo*?56MHnz8DW=Mg;Zb$es}rYPG4Z
zl2<S=FwoTOdwQ+uT^zfquCBFMYS8jn{jR--D9J)@Fs*cXE_~U(P=ArPk=7@=Y<O<a
zIgXD0az{tU?E6&ro$aj_bC=pFrKNrJ^dAxlamW_Oz{bXQ;K1bE+|c$*Q5IESU-5*t
z#n{ujJz5tuKIGF}*3jljR6M>ver6x_$hY2HwG8pILEHZ#Bli?)+n0S}p|?~}Xl)Fo
z@cKSF^x=cHk&#1cN~77@Tz`w(+Ph3k`pX5%sVn0<+k<9;DH)G$d}O1)Y$ar%rPZHn
z)0$8`yf`h#rMme26ua%JtfOu;e_OE0-I%H5$^usndYwY;$#*elyvUZO3qr@aBlGj}
zuGaewpumNt1ohiiN(cN&p<Spj;F9p@olz3+VN*)x|NJ`W^`?JW>3o2=Zu3ro!U)TO
zXFMsO84L^zPt)lnn|OkCwjXjo8C-C8bCZi>i}8@{u}sr=joPEdO@GGv{WtZo#H1u1
z`pAfgi1v2H65X`;_zQWOHO9`DE?v^mIT&FobbioQc<gnM>GA!$C@ADFUoO|@t1(7+
zmk!uZPD~gY8qUwp(~%KhG&eT~DcX$Cq`!Qfh2hSnQ>RXW#wCS+Bl0uQ*MB@<Z@{Ok
ztW1^F?c(g5q;TBI$_k4JjL+$x0|QK&4Sas(#*G^m7Ly|`uRr(ZJCtfJT^a4_)h@bD
z?w)uo?!vvOPw7;bdlR_SzJDsut*Tmod*{I2yLUyhoVV{LB&>cka>;x2$bYr-obDN6
zsY4$e#1=kU&)j_QV>;P1Q^L!6wEDWy3+F1szf_t}2IljWlC5oQ7CdUtI($^llsrt;
zbEkQtP^$o`9>TG)ICOxWy==g~KqZYcp-sf`Q+#^*s5NK8PT0e5NvDid(?x%_ab-O!
zC`cPGcu5iEsC(H@_9J)Xyhp8s*LTL4cfq6-wbj)el$shEy*)j2`}Q?X{#;pI1>MS)
z31wnpVw3jQH!;afAk?QJ#~U6Vm2$cJD9IRa`}p~xJiV-`xqRso>cw4!x3jCEp`n+L
zYFJoU;AO}uWljf2NBTRLYHDf#%W}EYOv0^hmF&^?DZ?(-7;gh7e<2z*ujBi?d2=y@
zV`6f$Q}IGU|Mbj^z3_u0vbU>iYeVjHCd_^R{8C3pXM1})l!BH#?^r?`n6V%gv#2YF
zs4gRw0D!&CQiwkpa5A2q&5@^h@~(oSlG1e++P!-%o(%!2u1@ckoZsg(GlCe{vu6*u
zJu+8HN{W|<XaD~F7k)_m9tPaj)z#g+c@vm<liX35Nl8g*dHgjyGcz+QtCJvO#j|JQ
zKC`T3GHjCGL`UznQSf+au`XTm8nYA%*qlzb>CT*X6?JxYb`(i#Hs4z55ZLg4Ddo5E
zZ}$Ao+{lZv3mg$KF`sMPXF=1GPZ{az>3Pk6C>$LfEiNtwmEBqESHt(4qKVMv`CNVd
z*ke}$Q`;+0M^tKB=Y4%?xXMvvq`7%|ap+l^h?8N3Wm^pMxmXslqx5^!u*Fa+Y0CKr
zxKw{^{-X)7;Bx!>wJCf&@b411NoYujI(^kSck9COPT%&5NsGL#&YcQn>j4d+WRA_F
z3dWk671o^(a9>$s?(b}cL!!(`-le}^>BVAqwYUHI{&Jaq&#uSiNy|NFLKig)Jvx$3
z6&4n@wY7POXI#wrB)LXecSkN)%ya%jXWBVhR`InK_8_P}nsAH6Cd!bfLyPa<E0f6_
z;?q~x(a9TJ2yXkiz7A1E6!{QI2aSZ3q9V5dps@S@kO7LixmC1TR`?UU4Gr=2{~GgC
zE7aE2)qNnbF7-wH0NLHFte~}Ty>aKa8PoT;2rST%;bv0LxtJ&^?fq7{H2(U$kkHDP
z#?Y5HmfBlee}4(3)h#pG`n&vkc6QeEmH%e4X<%Vl+4!pf3H2VojYa%yT48y`*}3%P
z%a;WO1)7EFLRO0Y{{Gh1)<ETRE@S>HQ*8%%br*-L9Jc>$>XjOc-B{FzB<szU7cj0S
zs+Eys>s~1VL73@GLxIB&&>yCLOJ{#v2J;!IwA0eo)`l{=bm=W#fv1c#G)_Bw<jd`i
zcxWpt+mw37=3#E`wA<!XTf%_7r=uhG*ye@v=RX@GE-#)xM+Wb^tijHn1tt)P5`4y{
zi;s`*eQT?Fp*GlDGXGWI=|nx?06wM?QJ9{dPC?5?fAHYk`k$*WZ!|YIuRmJ2Bc{u;
z^KZ5L&H=8O_o@ATeHAX_ukPQcKNK}kW_sSe9m+4g*}N0{Vzw(|u*@`Qx&9X&nE@it
z+<c<auHU*Vy~g>oxO7&~!p9Os%FeIXJ0)dhJF{6q>huBIo3nShJjISADq>q3ippLA
zW_`c);P)#3%@yp_Z|sN28J-g-PMkh{nujM+wSepRabxUIqMiwMf9UBoS#9kP5&Mp9
zeE<9x_wvbjM27BGR@QiqY<PQnJ5bH6=BqUz7k7jGYcntZSZr|M&>?GKCN7l+!ghU+
zu1~&$>EMTe$`BmMXmz5$ocr*hkdV-;-xGT?RDS_#3LZTYWTb*;;Q57_&RLMLy`ux7
z@#eKppj>tJ^?<8gB*BIyY{Is5v6G<cjg5_8qL`SOT|U<i6sTqW{_UN8ba#lYlhY|4
z9(!BcFRr4H>8J_N7$D{c4;E_ka3&l+aNqzV<Kw}FT_la*Ti?HaJ#trJ%y*&W@ndc%
ziqX-3cy>aR4WPorq?p@#Qy&zRMG>iTgSyJl>B^NWs5J-|eSOA6#iigqbJNpRjzbkC
zMlVoEEKnB&Uj2Ru;hLy;f<2onq0M=$&S&A{sq^R0b0&x(rf9-*2NwWb;DGgYbrTa4
zl2TH^PDBAVY;iW<58RCGec@s%_}1w;b-<ssuWmIwiBGb#iSF-ZoIlM-mHqnL+}vRX
z1}Obq&ctebr%qWt8^RrB^Uf?Sl?>Qph1jM2ZG}=tKYym6Vfh`ASQ3*;v}afJA%BFW
zhj>8y{gX}Mv@L?~tslR6qEqze*Ya!Mb$gMtEg%RedeG*|w8O{ZeNoMfw@;_OHx1f4
zIQ4#_IchxM*XOry-;z?$T#}a$_1{ZPy)~2Oa_E$yu+PdA?fHLCpFS1j<>lq)cLoX~
z{Ti?P4^>#9rkG_P1%yjU1x&Tx%?j8ULXmY6|0&6a&<>!crcO;wok<GBhd#6E1`@uQ
zY>6u?F23Jp+0a1<Y;d&-s}66;v2-za8WvITw%g57474nwt}U^wlp$E_V}gQoGIWQc
zs+>R9e)^=3;79JffBzl{o0OP%jd26f?^ZL49W}wu$Gn^R@8LBba85|b?dzMcnH#+c
zij3~ri7;YrEPgueGFEr%)~&ui%|lT-8X7VM{j##MG8I)0gYDBRpo!HlUxLDU_C30S
z8{P(Pfu)S0;?$eOP2z8U8XEh;n@)0bQ&LhgLhB_b51#3kBy|i72#`waq@kqreoOq8
zzgx84L@h^MQ&aPTY`|PzG7!f`Ah+81ds_k*%2!5GQW6LvON$C;KMEZWLfOGV!1R@5
z;6HD_GMiTq2Nz0?=7I;`O-$UiW@c~CV{2!9{{4TBoolmwJZ}0h6*)^wn*g4xG&~hM
z$rO{H8>~-EOpI;33i60bw3D^-kK(e1nwlDHF2_%TMa4$11GfMJqCf{!JOF3V`hec%
z=4Lnzt2j0}O5jyWR@U<DtRCDeQ_~$><MsMSqhs>1^ps>U9(K0>E^E*OZ?YgBE*-rS
z8%w@4PcW;H^)^`n@4mVs%)8UYo_Wmm4HW4`HBSJ@z?lXI1_H40l5ESsACzX0$asb0
zAY$wRYrP=CuK^BZG7y&5)-%{ta|;VlPjVU-h1}jLw@sk<&hN>%z^y;K!`?(kQx%0k
zYQc0Y(FMaT%_z_AwMB^e)^Ed4>1=I<$nuvqEz~x&cgpScUY+TrW)_KPHqTH^PE1^1
zeAXSf)+?`vN`y<2l8_i08J(nW2bPIpfmWW1_}uDW*>zuWx;>G1Yir9+_(4=u2V%cr
zcD2m(b>`i>UuS1gn&2_~SznNkWw|r?``!tq(yK2Iv9s?GK0oF3<g;#RcTdk<f4M%_
z`K*5S8b8Yv142+apG4d|Jgp>k^w=>3x4M>=JF4d?qvt)g!tCtqVHb(%qc#@+*qK4w
zK7y`m?Yw3FShGE0AuW>zAN}1kzj=uF6km9r)-sKvc;U|5=H|`6e;MFyls*uW=(n~b
z4<#<vcy^AFh|O{vMBSWG#CcSdOeO?eFf=sy0QPfybhOU<r+Em+rK9^8`6ZxH5_$C+
zB;puPzu~)7G|-hP^|HEJKTi{!ePR92-DC15^}c6;-NM3aFcwp#18QsHtiadha#ah?
zc!j*Y<n&zYpaqS`cccy&>bqFhD2`TUmpWp9Cfv-QU10N&uZAygl)#V+;ecC7CPNwa
zCM)nyVMWC~4oaq&8ykxTxxK#;XV3JDQJyAa&W)Kp8%p3*xkv|pmPN|9vbx$E{7jd#
zAVYRDDU=r6y0I%WgE^M;vwhF<fv9F^vm{yZr21AU=?|7dSL?ic2M4_tKb6m1zwL#z
z1+YQ67(I7Pon8peAu8%7W;nI*Sf9_N(zX`~aQSHOgR>4iyu4@5oM|*8@#epMZD?pn
zl1+ezr`=zJGXdAr$nE`PoCediqrDxr6Y@af$ptLJ#hixgb%lkyi$xL@^R#(9e|%|7
zYE#XWG*DM}#pla}lHa*>l%*wAc_!tw#k=UkAnpW2T%RBK^5qLigeLcW1p77^>M^<K
zo`rSb;y8%&XpQ@{n-8QsP_Vwf9$~kQ^|4^oMJ?L5uiUER5G`$-)5!DSBkkGQ*<co1
z>w~7y5Th@>%6z8W=lb%%U*Q6Q(1CCxGhoDmeS*buMGXH&2EYC@&r8(=I&(KI&F|0J
zTx)A9fl1&hC^AWkru@mKwH}3!A3yHMZP*<Gb|V_A^q;&FWJI>;@aQNjM_cU!+r3WE
zN6#JaDjZKc=R&>{30__0poiNGZ%TzmDto<cZ}od*)q^Q!1GX;;r!2%gFz(Em)tAe!
zK+%TFE#&d?<c<u`JAv2#gxscDff((U6+qtGw{8*54oDK;oUCp%`vIovx8Zo<!cD8m
zfrWKcpSIT4Z!79{p^e$vJh1Auv=TH6$z)E8#=^)*?SHDzN7ZC0bolqP($cQQ;gEe7
zdp=&6?W-7Irn()pvxQ}T)ew%%yAYw6*Jmrt&(F`1x_P7GDsmgFYj$-L;6x^a_DBfF
z`)9XxJF_~iNvS87mubb%!M5v|?wecF$dyw`5hT8>k*7Jgw4{=!i9&zt;x!Ks;joJu
zh1%qyu;;4~y{N|Ea!OaO)cF1Sp62rEN{%|j4+_I`=g)hdA2X=;T}P3=Sx&YLnEpOi
zuau+S@IyKIn{xIaak1oFb#9~<O1R6bhrPB9Uq}-b2j)C3=Jdd@C?*a9Lcmf8zCZ_m
zVrItr#=Gk*-CbP-MR)AzQ6%JFgiffBpnyQxNv-^JNuPVghZ`l+dTk%6b2Hu+`%SL?
zdfj&m5lunO^r33Nu%Mq+%6Dx*&lDJc-s4*jO0qJiRsi8qe=+BAY3U6REq8a^l!rL0
z@N@8*+S=ONx5*2&=h3|Ym#M52#?7#^yOd^odU_g`=$7aX;xRA)2Y`VgIX^!i2$z&}
z2)`z@eR32@X#2MW3kP2Vo|6bj>4_85uu803PH=E!KYH}&$rF2U3`B#7T1sfNikez?
zdwa#Nt03E;eksxczVc^|!})~|MkWKF$QBIb%LLR93?GNoVvs#SK|yJ0HW|8SvQ&zS
zd71(LezutX;DR!NF7vG)8#VBQW+c=#C_?gGyHv8I1KvjL1EYlK3Pfh@BlAJ^hUItf
z-aSC6d<@er^0H3DZd+l)(#t@0$RxCuI1}zPn^!%54i*CKiv%m;ka2Z=T2Nr)?(Xj6
zQ=@QvxX$NH?BxDCWHNL`OPVN?TxyyB;6He7YW6&M@Bk(Deqv&0rj*2~Q`D_+rMuhO
z%H7lfwvA>_wMWgA%GIPdfrt^89>RtQ*-W9SCkkyON?o3q5CTg;wh@J;q@}$CN5vY0
z=Kws8QMy4SfVqdzh%$QpVP6lvmMmau0t$e5YqdBCrugR8ZWtU(ZdzL)PuoA5Xr-m4
zp(@WTcew$k-~}kvpU36T@BBL>E-o%8=n5qU-9yGI&labL2h0E{Li}K4gqD$9j{0x^
zZ6vTOi)p!eGb$u0Dd}mdq9;#C>L2253VD4%T(pXwXhY=lWT@(CYTk>F@9FC!c_)He
z3~q`_xC5Jn&$yZ{CEYY|6Fthh&6zav(46w}eU)qP-pL`<=I6x`n=qAuf=+GsP5=#R
zT))2YTdqIn_~|JKmW_=~L4H0Bqu>|h8!>Av3b^a%T2I*E2+^ThPhJ^1ytC>0=-}Wv
z#92kf%F1+yXzV#*;Zc<AP+I9vXmS1iIVm5_7(7`GTuDVg1RXOi4UM1845r6nl`agH
z6@3ie9d?nHmiEgnk55xi^^1FYdeA{M8_UzQb9UyBoisD&MED5`_O!If10+0ZvC;qj
z{R7xCQ<0;U2h((7B4koj-^vXLfq>*qBtSZZR(?JwU41?zI;m1%tv(<B$&+xr{H3!x
zrqNe<mOF`dRc>zs_wj1I+}=f84@_Ak&A338s8IV!T$~!{VrXN^c@+4~RkbW>si19t
zx?e)z{BTuZbNrla5rC)4%j<wp_m>Xp$(Dftw{vnLaH6Zm#*&hfCV`t)&y<XGbk0I!
z|H$k}7O)XYMT%}<K{wy*6@byiljw`^!X8--Jkf#PAaqZPiWVXd@}iLg$#|QZ`DW1W
z?-|&5d^Igi%`xvu>LPurmJCIf775==X+uF*tLzhpMo2SMR`N-+r9c<qSK10c06st_
zW#-XRQW9B(b40)pXtT7px1U(uMAP~B{$RFf!;%|bUN8(*R8(5v@<PFaC8jD{8yXJ7
zqbe#Y0*ddz#Y1H5x1>x7IQ{o743mGqf1dyMqY2-CAK7(J&t^fYCP6Q+U#P_)!Z9&1
zih28Qg|96Px<J$_b3Uu8LS27wRj%XT2m7k44sMo0L--;OHV&2&5wX7{%mQ#Jr^Ls{
zoB3RY2P%K{Jsauo3mv^_5K!s(A|DF1AYBP$$4ZZNb6jewE%0?BGYqUJMMW~pPxAB0
zsXnuaxlKV&Le|pk-rd&TPU71>GQu3a>h0~#ov0Xgv2k|wG!<-o4qbbYAhXN{p3&@%
zE#`za2-DwicN|Bnd+S2EypPuK1pfXS4h%G@)8|Y80J`Ay4LXFyFE)6_sh0VE+AW-#
z`8m=AbritLXHYS<^=sVA-Q5rNCjr*jpf`2kFs7t1($iPEO}E4MyLJ2a_Rkh}kZ9o8
z>d&8I-ak09y0fJGMAAB8Nj<=|;9G**oUv-B|KW_X3TjSh7ijaSC@H~oe56^3C$So9
zAk;0<hZ9m$H-~Jps1FO>>Yf$2T1)@i9xF6QAkYFP#o9cw7cbuUKDwL!u3T=ah!fN8
zYv@LpF`hYc<Qj~XT=}?-A3whJ7pQr7tl=}!l|hw*qAT~`bVF%~lm64XNYa&dPT<%v
z3p{)0&K<mV)>ZVXjyOUWoktS&WmXz?vvPg(;SWYN!==g7EL6-Bf~G}mcrA~yqSxZ;
zivAq*{n3;IuOMu?G9;Rsn)Z>U3SN7|9`tV?BcuM+t4j+DBVcAzQ<h&OrD5n`48UKS
zosWTpy1_b{F0>I{F0*PdsnAm-!L{kacK5)5<611r^|M(+$TlQ%x~#Z=T%GC4*egfh
z`S}OrN9rg!3{ZTQjptRo?cG1n!nA@pV5pvniF1E2M-(^`n-9tEDS|@-_+gEc8z#Ng
z;Q7IdhL&~*uO3;=1{I(?CFC?*xjNfDUhn7C9C;9!hb}7~7ju5#>Nz<%aLHO)Y$o2`
zLFwAdz|Y6a`*)%2HNuCY=PNJ+ttnMFc;J{35ge2ga6gCOJAEuMN=Qfm3c}N9{Fz@>
zRh5^QCzQH~4wYevh^Q!I%g>uPiSVYszn0NQ2#xsy4;ks<ih>NFhDm^xC0Zm(x_{pT
z1|!60Wo0F7UYKN1-1@tiJmo(nhKIKRJy?=i84KgvEMZcC!s5>1DubU%vc<JoqCyuA
z%;SA1O=#%fRhU{{Hr3OkI4XpK0zVo45yTEOHSkD--pS5x-yS$fVc*d{W@AH}AI=0!
zN^BPJmh^NUNQ^>PclT?rWw!7p{Naj{5^Tc%q%%A^g6K?4Ok_Ui47LP2=;X<hjv{{W
zKD6?ci8XXSzo6a4*oEdC2jiv(ot5)*|HJ=1bUQ&Wgd`-=_;$h=Oaxn^9)$V%`ITLL
z`LVc6W@u@&rhjH(eR+HbOR5{{2>wj`I>6tbZ^uFP05daTEAFMOhG0?n^vyiCnozn>
zmP^PL^osSbm8x1xZ>?#i4Z{)n0eo3Xeg5t3nq}Gnme`Neurw^Kt<i_#OxP_>4=P2t
z%>e!oj(pXO$jNHMlIMH{;0|b2RT)yxj0Mk;{<TIEQ=2~-_)40H=dFZN30yiRNkEZ~
zEUTO1h?B0ip5E-t40c(M?@-#gG5{e;{zir4?;l??^dAafI7!paz~Hd=H45LPi#hS<
z%E1xGYCRX=hyb?04~zRe_)FiL(7VWU5y6vVx1wNZp(WY7H%Y)0Ze>=Mq)*?-h#%xO
z5`DHiYrN9#K+2^dU<M-J)OYR#Phu^&I#?{h^TG0Cp2VzpXkfq-r3-9E+WSW~iVmuh
znE&q|w{PEum;osH<JyRPUfp6!T3P{qev?=J;9wxo*r9Iezl(aN0n@Xy@OEo~84;=l
zewdd5*9Dj0_~VcGM7^7JtAPgKNwnYkvu+x&4xaN7CFa-S(B#5G+TFX?rf+yq==yx)
zP@*Pp3fs#-@Ha)$ROsHql_D5vcK!MFpy3FcvbvSX<YYZtTU#ruX>i?_w!IGl(55wR
zXz*h^A^m)iw3ygos=D`S=hX5vuQ5Ik+Sx`8L5s-;l@%anUhWNuHRkt1JvSp-1wB7V
zNrubr$?B%1rrsqzjkS_V{XX=p1&NIXLZc0)-a0n>zflP+1frkdWnsZPa|`26kJD+2
zN}JmRolMIR`7vT92<mxOSonTYQb?<tJK1@k(}yn_YFe+;`?)x*@>6t<&ht8seK*V5
zzw+ta=Oc@x{(Dzliq5y~ZuJ_fWBq6A>?|Glk5G;3JQsBDDqN}z8`!J=aKN5Hz{GL6
z#%WBI?kyTC0DH0ttw!4h3U+_A#w4##ywxgD-N#x`TPuF{tY>Td5y*5>b5_avy~JBX
zFeaWG<j0<Ql<{r-4|W55e&qV;A;0*}`>`G6?&cDAV`j#Geg8aC<6dCQ&*ggyd~6x1
z^)vitmHcN7pW!S|8qEhgI$Bz*;PwZkn!$$=RAXTz5d6p-g5l*p^FBSDWn#{3xY91;
z)i1<Q4W!tlu)f4!dXc{jA_qP(AAMRe5AblQ`+3{v(-Rd7hvjIcr{9KUXdg<k9<7+H
zxUpm?`1LDc5Q&$Kj?Q&u>I$aLGMl_Feq{6fy3dJq$q?USs*}(0_QrF0$F#qB;@ew~
z4(j@`EX2xHJZ~Yj?Ou-k(^wzT(9pmtaRYLbs!2SDf`gS=f8p!%4>k7o?nf>r*Re5f
zEu=5+*3R_tlPEZUG?}HUH}fZ%U*1qxZEqJ%Wc@k2ZWnj@E3_^gA2VHdx~89sm8%xW
zYJ6a6`N=Idqfld}zbq9(eCe?fc}K&uQor)HIXAYgx^&fU6OR(PZ!uz~Mn=5!doot)
zSa=e7=qUC1bk#CHgVYb+(a~CJu@piZ5N;AEx3iRfS$R49l^4l}0`xqivUuKim}QJk
z_1IQohtEf95^1nseVMX$z3Ko{%*S5FZ}LA~Aazbty$sy)EtA%KPb?ZsaGUCuUA!ij
zmO9M@-z&M-lIHeSJB^6&B>n;O_b}BtovJJv8|w5nlbd4S1mn}{DtFKjag+O#$2r40
ztwY0NGH!T$^Y{ZVUYke9<$S~g4$4C92Pr9^EI130I!BHiQFXofB9w1eZn4yv(ms@F
zG$hK5R{L#**~C2}<Z|nOzGMFEH7}ULJM+_9N{sCU9c9CJn;tih+R(FR4L4QCGao##
zH=*nMO6}r%S1wx}lXLuWLUgCG0w@MImz;bh&~dBtew^mUR-N*>K5}|@p|zCzL*lTD
zbKn1wrIm+FmpidN9ypQs$OiaB5jCGP{cVl$ih~2Me&#?;1^Ebv7{AB+-4$)~;VLR$
z&1w$F&}nFB=sI*|=v=<>mH)BYK+lbCf5&e9syA=m#K+UIv_S25{xw*e_m|!Fnw<S^
zw0}*zw}wVnBKO)!)v}YQW3iKJvdT7o(oduglU#S!aRZ$JwzRe?JRJ;mPxqr<aCd1_
zj_kKFm60J%i4IHLudc1V2GRG1%12xWbuUWccw}_++RvXSPo467szpymq7u6lo3<I=
zxoxPT5~FZD<b+e|5x|)sd!{P7Y3DrWwV&RZz_`iA@;L1(S>Kr_pROp=eERdWs%pT*
z23-2VIk(#lR6gxLfBnh=0ctdZPiq!#oWd1fs@aTcQ#L5EV;rlPC+;>yY0OL&TzSRN
z@PSW(4S%x4wKrshmrcOCL)$E(Nyg7cPz)OI(WAFw)-p%pzhh1ciB@Bq+-CXaHt8G>
zs{ezuG}eOa_kIw&dUNx+QNAV4_*6neVs~Dfr>axu{r!UD$5__>7W?|dN(8W~#Obrp
z_U5c*cwdrm$?3IK@4z^1%OsoV7Q_7dA5<-vWi9px1QXisr=-|QcYLhq2MaSnuVBn@
zyuUx8j+sm}Nt=U?n|=@PUNyS6=vlm%o&ECGif)->{~g>+aUXi_uCaWZ`=Hl2=xl|V
zDykU8+>VQ}5U~iJpx*<ZmoMvLK|e~{=g$sZgbAyYXT^Zhu(i4A-D-@L^x$3%jWnnh
zYDYGkS8P3<Ju~kiUZ_1hI_j9(;Qt_Lv;Dc#h;Fey@y0E6n7!qn=J~WkI2KvcVkWCE
z9WAf0-=Il3&HVJ^N8O?VGe*wj4)kZP4TN9d=$Z160y~O}i)#^#b`)H6qGdUJ*v|bJ
zogb-3W@cu$<Z5(h$^BF8y&pc1^<{H2p=h(QIp<0)-Vy+fIsa?aU4;GG@*$=e5u^&V
z0`D>mx8{{>bO<n+TtG@k2C2H3Vbf(P)G2EuvV3`a=P>RJ?sbN$OOP*5;vRp7mKP~b
zY>^MC$Vpikhr8r&sxV5d9psK2{^$BdLFx~i1BT1Y@0gSY@pN^dIkx=jZ)vASnTU?P
zJgxcs+eQ^uorS9_5&S{C_{i(Zh?;4ic2x(rhJ8*?>;9W$>>~(~zZG4sCNz-`XAC?(
z`QVGkw>*q&R8O$bS)7`kCQMULwP`fdr)WtH?Y)_bF||zV?6x^E>CLGFejUz)amfei
zV^iXy(vQAg@$N?RK}^49HwNQW%OW$b@l*I;OB-pE+W1xZhnVoBtb|2%`qYmQbbK3*
z{`X-D=uB%}_YOv5zRDrFv(t=l$-XlLWeA1Z<>IDJAI7|bxy;tdT}^@%T+O0!|IKD9
zlo1hz3o+rHFlk)5qpkkmx>BqtV5Y2p&P*D2ZtLbN<;2$a<GAZ|`$4!sO)MOA5n7m}
z8Hr}OL7otLO&=al=D%N(Hx^Uma)a0RlLU*NfGMoj>?6iPGYi9w+`%-<l0Br^T!sO&
z<f6RjPms-?lu&ObEE(o)-Q7d`S8%^8j5?>2J1!4L#)tfG%^rnopN`fK#Z4&C606XV
zt-S3m$$g7qN!0=i#*a$l?0rSoZ`ZJVX{oXqUu=oeEebnG)5oSxe>PPawmLKebhX1-
zQ5m|6IqFC6J{@ulZS1LXDb*}|7sJf3e?Q6IpC=c&s^kw^boGi3*q=@A2zc{X7tEX^
zos`7x0QxzbD^_q^TwIp<$4^K}OJ{OKh<KSTvOvO{RM{WoYb<!0^{CfYkP73*UH+Gt
zLpbcK{=mtB1_^j`jFMn$h-Ylyl6RBMWO=MTkGT#y7M9VMCVr61PZu*)L5S($w=y#?
zTxb?+GLBU(;N|A_e$(A?gc7UOsJMHMPBivcEkk~<?b9!rs$?WG78bda!awTL`JZvq
zY+rJ`Om|O>GCZL)e&d61hc8KBLYYVD*c)F;ANpZ;6B_bog+=c(l{qCm=kF^VH+*U)
zqpq&*=ZxV=&IFJ~FW4EVFt<L-Do7M{Vz5L}Q4#FD-TGN$Gx!^@2?`H3D$SKMOfi^b
zkhrl3EelH)GJi3ijPj9e1IHXc)M_qP8Uuy08W;EuMKygjejUg<%&hQti}}APEa$mc
zw8}pW4u)<yE!CV9DMPym-J#h`zpj>+S<LaFX}iJVRUyBN^_W7q)RB~38O}RNvOZtB
zF${=NRp~4j0b;Qm4S+R5v(>Wb<6c=R4v{V97`gsWpWq&RKzIAg#D7js(yd!$Y;hDf
zSY$LR^YSj|sFRVA;SYHH_~H7Dr9{_APmh6#$xv7K_N2G6vhsxs4Mr~Yo={nJb&{@c
zZ`V8&feI8Bz9c6XB6!^OYSDnS|L=IY-0L;QK|w)4lOkRus<W_2whpX)v_Zf{aEo7Z
zF$qA;F3l3Hl+Dd^SK<3;%>n30O!L~gpxKIHs+5!z3~!^M0c!adWAaBSHUFDW%gxQb
zmbK6P0Hzkf{L!ELBFc97Fxn`G>FDA!G6KH!<Wy8tz(F~ol!WiXL5ZHlUE~is!yr+I
zqMFUiVQ6rnw*|Hivkivcg9l7-`|>n>P?TQ<{5?u}F}IhSK60q;tLQ7wg^v*7NQ8v8
z${S0=j~*Q-lj%wqBlHbxaK*%SOlQKxz?epg%dHD6lT-)8I4D_K{4`Z^xqYEx@qP{N
z`!J_rP4t=xVxSAe4J#9GjRBYQ5R0%%;97OVSdi}J;^kdHqCwYyF1t87ey|k=hgMQn
zt^>Y-Aw%6DQCN9@Q5teY)J&Y<<P1bmLQy2NS;8EX!Gy+be{_rm>eucefr|z>rr|DO
zXa?h35I|9AB*1#zOGW}l2d4?HH2m0WuoqE0(JaMq^s_~!RKnPfiOCpl1Z8#>Zhw}z
z=M!iYnRu*r-Nvv3EcEkujjQVqi@4EXNim!e5GgpA-Z<r2Gm4g8fz2O-2CW*nHFz)l
z2126(fjK;ENY&&#{%UD?d3ka&l%o|e8+P$4k{^Rtu!=BPN<m}O@&5gB%A==F#dJ*1
zOktqe(7?b>C>1G>VG4MZ<kU>a|40r6oT}Jdoy7?Hbcji-)_0R!?)jOSLo6&TjEuG>
zx{L6j7Z#Z5=o&y_Pr@=azIqjIhoJY5FR(%QlZ({3F%DH+%yQOV8>b<(wdrLr(YFu7
zcg8O(4V};emyv1243KV#p(o5W0;{ykyc~6C30^LyoCs}k3?EsTo8P3M-AgHixf<|m
z3DrrQ9S~-6!h%LL$uiYGO}j$(7TOb|1DGVDBTI#n^tM%1jm`S+VNx~@j)0~#_46$b
z%7-vWWa6<(FwHT(=_bm;nXtLqef~`9dwe{sd0+@^cX-uYkb-i#gh?&?DsfR!Z#d^b
z-~*h>H&vL-4PLYr_239l&Apo#2)xrWxurIE?;?hT6!SQ_xZ>EPe6i!`CHyV7Xj!ac
zqH8;Zqa@bv8S^w#;q(`%vAfbeeEE_v6{o|KsLnlF?{_ZpAz`TWBkKr9eHcK&ona`G
z=li+|&2LD8VGG3?bTOe3j~*qF{4g+ZP<aevyxG|tB54^gq$VczGcoNE+QJZmvZCTc
z%|cWe2mmvdP{q8JO@Eda4B()*C~5!UF&aG2pFbC3j7EdxrPnfGrTN`EoCAPmUww`E
zkqS;M#mJEo@0uxP%uuE1qC-cX_pXd+prT?s`rC4`EOsY@JFT?}wQ0gZKSLW86coU`
zu$7Rp=ygf?tXO(_o(<tJ_5axn!vw>Zm_4hyfB!yL&_R($E!wByCaZH3D#dLW4!*u2
z&c`Bg!<G1Yd3nuEO~*t<f5Rk|%e~t&8Jv$v*&sN&=m}de&cGX)pSMq1#q<O=5Qu>G
zM9B3UcNIPi4>K_^P`ulXcC=#Np542HH^?V$;;%4NpO=^8=oQe7P}`7Frf4+AvP!tJ
z;CvALI8=zH+td<)|3uR|1DC1>5y3-_8)&3qHiDI&ehu6I8o7vb8#(I#U>v~9MgxHm
zVls39iNua+s3KmyQmVasN!28wr7;N$ju#i#jlIo@BDH(XbK5ho>4$e6dOn1aH@G`3
z*Nr(7V%Vg_MMRRiX9@n=a^0$`zyH7Kj^ysF^Xx1v{s3yANK11wP9@#Dx1WtI5K|Ip
zTi_%VGOK3=Cr*lr9BggB!9qb^H<(4VS&I9veZ$f;#_II+247Vu+GF-zsS90w==z!S
zr>QIi8PTXP!YsoN&uF>aHcPBJV1pe~FlcPa=4qZ~>O>ax_4mW%MmJ&n!w1Vki3{O&
zz+qrtzkL<*w(0B5uxXgc%!!H!T<%EZk9VE;BiRcH{i#Vi7%QP+lhlV<RbBnVTax~=
z20iAmt5gecMOivaR5Nt`ipkHZt)l6V?-x4ujW9FxrdYtFE`mb=Uk4V>!9ADJeWWAP
zC>lUV>rQ0k%CBE#j~`QFSB=!0_#d@d)&}joQaJ95h9vMuo9AFeIC#jE=UXcBCKeU5
z{PObCaAK>6S!lS993j3`eT|X)(3-xECsk8Jb@?>E%9k6fr4$={N1^Rh^$c10lO0TM
zP?Q=u9{`p&gs8id^z24Ugz=y&+;^~x;Pb&3%)*~Tqg<bqV~fL-8#>lZ`}Pq(V+GfA
z8Lj@=E6<MM8s!{y|CKf_ONp;31h=wk&?E}Yl&Gi#h2to>aH6V6k5N3S?c9Bh*MfA3
z8b>g=xG2Ni@~8iZ_(i#%4=JFlH+k)|I-_Uev&%#DLUYfY$I-hAJc)90aya4Q+4@3|
ziyvk$FR#0o7dDOKlUDZLqC>F+PA3KJ2+sFRB36>xouClw>PE$kiPQ3S#ZZ&|X7Lc0
z!Wf6l@*^poB76<Am&9Z=5i+&+QIJt31#8S`ZS?m%(dL0%pwTP6kUlo=;UiB5ro`Ze
zocZ_9zr`-y(&mw~xF!RM4@vzP*En<Nu3sJ`AE!lCNt-A*;<@w!aB>fiwTD$nFfE!N
z{dY)Hp$xR2jGP<;<mC)@t|1(t884hh$fIaUz?u6Ti2TBpvDKKps9)Rq%D3<B4bwf=
z#AGXvdPmmJR-U8dIw$68Ap_#?v*=r`qO(ZF84f*7D@Wkntro%EvqsKu%tuIXgha?C
zw0-F7do%g-3#AY=gCsvDgn?e++e2D}13M|NslV?bg+NiO=DEG_{67gI+YoW~fBJ&(
z2Z#y6vm`!DDzQHNksOqw0=o#WuK)ydQn2(CX%?ClGZ8K=r&HW(i%fukLKy<B#+WQ+
zbUY5;#J98{fzcUYEi#8t7ti27caGt^58?80I2U;j0|HpcMpRo&T4qQ6_xwJpreVob
z2jq%n@bQnrZ~pI0YtIz!h@iZ<=-|A%@Q1S;ADdZW?I6Qg|B+4IIlq_xR3%B;gQ8bn
z)=95L|NCCl{j}ceT7W}$dhHpOODc4?6po8~|1iT5sa{)QQyis~k&(fX8{Ii{126)=
zCrmWf$O_PY7=wG$m+3F#yeQfrPEI8Q?^D_=_kj5B-hHHlA*vZp2acvHN+&9^;-xwm
zALD{-Usz~c0lh|ByKM!(gk3x$MwTg;8v{>^=XC5ONpN;fPNU+hUfbw9cjo#FXbl3L
zoSfi~i&4fmno%)}M5kkF4g9E3TQNtym~9_B`|{kJUE-_STEpY}?=J91HG}aV?a(XK
zhW_JBFd!TT-MxD^EJ)osw9zrQRg;M$msDt<@tNijq+yM*Y7z*LdeN~9>hy%^Rsn$*
z?fxMggxOGPrb|iVeSJsiC=q{cD`?;hIX>6<gXsW_9#;6HV}=p?`00*mx8MtKxr(O_
zke$X99GsO@#>!+I?Qk=P(89!Jg+I>p(oue}KWmT^&3HOQF4uq)jXtaqX1b>0)_?tq
zi;h0tk*shWNRr#D-zKl&0al!}e&{lWr}Qx*prs|7G=678+HFcfNsK#^iHbZ&U0+X6
zKFOu59&L9_g>e<s?+v?Hu0L9`bd{SPZHx{+9IHYb7hPc2z=S6AavbLoI245fAT~%D
zBABWSyF|nV2bLh3bahx*MAf9{f;l4Kc<?4tPr<7gNf`h1NuhLt(fU|ZqtAJGBrC5k
zysFQg{oh%{nn)bZb2EofR13sdmQ%Z4(ExC3ipM#R<rMpo<c<=1F>kWi$&D!^o$DbS
zsE<zV=NPHL81nsbkXp4&v#_=C0h!Dv<!FuwlQLLQc(>&yhDtL1-K5GH3Tda5j_>E)
zB$HvJB6st}VTeOfZJdoJqVcK)fJR-;1Fc-I_sh^J=2hh61Q%;MePkz-L3RG`Piu^h
z?RwnwQ*TH($20$78~`%~C$i9C`FkQ;YPgsRO}t?Lw58A1ewAF~CVn_>qo(ag5mUak
z#9DX0rv8~epWjk_P0bKblpqz(NFPfRc8HoLOM44<Mz?6)SE}YFMjJadF>NdwJM!-a
zO}MP?3H+o@O|WSSMzl}k3^pJ8WexlxaK|~3cCA8X6IG@n%Kqede&N%T?2;rc*OeIh
zsS?_bCr7CkJS*HfNgt_FG;={Zs`)5yY;5~E!rAWcz0)8}X(bRE6Qa)j9OXlfyaVH(
zSAyrN>=aK^J@dH3H$r$f4)^+%bG<Gaw(#l*U#fRsx>`2qF3OUY^+l4ipflk@+w88Y
z*+cFj{K+nfuU>R4zde@yuZ8<{+OU#W$MUN`R3m;~gEm}i|3O(F?@gIL0;K)lIr;y?
i6aw-hsWOeX*~@Yh0u!t9PvG1?(Ur@pmr5_1h5SFfC{ud?

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/liqgraph.png b/website/content/doc-2.2.5/images/liqgraph.png
new file mode 100644
index 0000000000000000000000000000000000000000..c6f65944248e9bf927c85ec7b3e846a4ac37b81c
GIT binary patch
literal 16746
zcmZvE2{@H$__rjCgp72O<&310#K{<YwuB@hAv+04w#2cA5R!~!goGpsN%p;yBuNso
zWlOS?egA&?f8X_8*LQuUY04bV`#$ge-1l#LglTK3?PB6$qM@PLbxK`DmxhK`5P!C0
zq{Z)79oNV4pKaH4)s$&+K5~!XFZ5QY)l_IUxBhulkr9K>{Nb#A;TjE%$bqeYw^7m+
z-0?{Uw^L_MGJM^^x$6+)xe2aT8X6+aDHSC>O6P>HhqFoh^~HtoiCtYcOz)kXqS=<p
z=8&plRD1GeqKm^37w!&TTd_YcCAy5CG7)nT+jm53+_2t|^WcS-B%Q}^=-FxZGv2UM
zF&($ci>S5o&UIR?{I%{f+drtiq7p8sPUBUjAk}xjXe!BjYB}lJWXUkwG3En()dAZX
zSh$T@*+po%rJV8Cb1W>s|8STApWph-|M|ncpsiO*Ilr&@{U!hR4?}CBzn0hDzEu_G
z?7E~}Ll)+W<YWp?qRcM)@Fo@raWIjYd*^4(ay>3y95j;;8)T6_!05_nUVh@sh@02-
z>+=isAw))k5;Jvj>X7reN>WV2(4@;o_pu{Zd4@7ce#D|})M?+RfesQ^$b=lzGMfUU
zqWiAu0-u*>hiz?a+&iZ0tnv)ZJZpz%CsdA8M!y^;dx)Brip$D+x92XcZ}hJHkdzwo
zF-ny8^}2LvsKxI{Onv$Cj|5V<W97dZ>1LiovCdNE%kLTZeEJqw|Db#Q{{8!R@7_)D
zz0EV;%}8hFw>;!6{oiJrvD49`M|(EjPft(#YSu>8R##W!Wf|*jpFU|zasO~FQCRC|
zom#Pc&v#1NuWEC7INAT^iP%P);U7QVSmpINIypGptGCwA`iGmPy|p#3!=b9ziA*Rq
zaXfi4xOXblvN$Kl@#@tx>AKA$ZdJWgt|b~88jp1kGgBoJj>c-#5B-Xd-xpOk=w8-p
zKmUU@J3CvNn<ZWMaID6JyKHikfl#btk#UN)Hi;vyVGkpnkdP3W+4#bR%l7ulI^yhM
z_wL_MC6$(!n~*p<J39-FxHy=Gem1AM$s{Qf=jP_fgxh6)2a~kM++?Qra4+7WhO+M6
zv&Xm7sl!1cp;488UE!Q4SENSz=f=}Rt|eIpxxDf|1Z^$(<U{OX#jiXV_@mV&63&x2
zmVM+om`<hZ_VozH)VE}ujZuHB!oQ754pVt=EyhfLg2<-Azndxe_25iuGby6>msf>B
zu32_wrV`stO~Ifk_v_bjLw!P?6=wX=q__qhj$L%LdP3&~*mpDDRN?QRU3Qb<2~cDV
zRwjjO2(Xh224*Py(RUk$c%y8stsj?_dCv}nsqn`&93$LT7f995>T#4z(u&ha@7q}R
z@guTn3&oy4e_ovHC|9Id{D(58fVDxs%_VtjTd{cgrM~U?9dfd=tB3r59ZE|}lXUF<
z@4x@l1=y{{mVY!RoI7`J&z?P1YeS-0Sy>l^+u9;isr}@HMqK}n6aUD|S5{Vj`}}!e
z-mAxPG4oso3!nU2)aFuDC<{-xYT8~=v+jJ`rnCMlEgKsf>FMd`GPDW`3suu}!c<b*
z$0Q{rq`0;CqpQi!pFaKhHSc0V*80l)*x!HuZE9+&uv~xE{>qhenfJ_caVNQzEB0z?
zb*R3zHJ^(Y56~&$-W?saMB<_%Be8Cgs<RR1YqZnn<amc?myHjFYm>y~<jRYS4fXYH
z#JQT16?#8^7L$^q47>@m6PJ;Z8FiDv9r3W#h5dQRD(`E3%pqfA<EBLEmfl{`X!RWP
zDn~LQu!fkVWlJVVI(-w5*W`>inW?9nsb^yDfagwN4(adj4+#m0Idt}+tcM71lzFjp
ziZ<yH$!lhy_HWyd)nqvtnQ+UmKY!X0*@$e6woMOFDNYsh_w|H^W|x&y*goVK7dajk
z6}?E1Ad|H(T=1M3IBAhd7gU1^x>8^ylO!)Av+^UsiT2vdl#~GFl)khVgVP^nr|4+6
z6?Ij-dd0y=_vFcw$GRg!4RIIq{xiz<8&2}5T&$Qv8DQDXik+1N*dwE&{$!-9FjJ6}
z%xJdr+n7z}lXkVn3UagX$-3XJv0w{(;~-I1TI#hjH{!dxa4Emz&qG?+7(4fhe6o9m
z?}L)DAd_M>)YR0jN+h(5m|&qyP5((~92*<^^Upu8UcD-x?BwQlPdP;@Nh?#&Ykssf
z*LUIyc96Qjla`VB`Fa11VgI%fH}^7MJG-aPo{bt*t(?Db;R2CO%5RM#z>bY07?YWi
zaVS<}*REX!1qH2bZSqUiSb&XbDyy-PkvLc5w+inht>N_3aSuIz>|+m8N!PtB&K0kz
zsw1Az=;+|k9eQvn^O0`mbN#V?YUt*8)5i1X&&S)cjjvz7USgt^t-tkf($WsZYQ)~Z
z&qNovyu7@!;#GabL}c-MeN1Fzq_tSdt5^3l1^<r!(A?bI-*1_%FMI5mj=6bNy=11|
z=zP1m|7d2$z)Z1zR;zu%&Ye5$3p$5f(awZoy$0V#j*i;X20YRxp|6Q^VF~rK3Z6gL
z%xw>)T1Kj#5MV#8p;4&E!5B#5Kw;h_-clqg>fqfB^z<I<X12BIr|a&ERJ~TxeI&P>
z)<#u;{V(>g>V+`Xw7MuhJT)w3y)`<^%#2G>*HO+0mmMAq76cIyk&ia{SiY=QEc4`~
zW3)P*CR4nozKKb9Z!fE!Du48&W;?BnzoXTirMOu_TUuJqUARypUG~A|nz_08>C>mh
z;@^<bFx)*nuod<7^;1b+<6n;jE2rpYesx&DylZP~D>oCBr;}xoPo8=kxgXp5--aR1
zh~TDSwKN^E_;L5L5)(%O_Wl_PQ*fYGM*Ej9q}cZ%A@pg@|J7S#wN&`?x+d`6nu1M@
zjq`JJ)5|`6q?r2eXB2EG6sfodJZv5rw|5p~N`)DH5VlXE)^Kga-Y9PA&uwjju^OQv
zA@YkQP1`Q*_%V#ZhY~z;<j7IZ(^s!%YYJ}Po1vTOAYn{o`|{<BN}5i#ewKa~`XE|g
z!_di-C%qTO(R8tS1=tvIt?!}_WSmW|9BbQH*VYn?XAV}@NO$%1HO<t^dHx)|l{TQy
zwZvL1UR{8To4dQnsrUPL>nm5r^wk_J2rP88Nl8h1LVHf?M62tWnTbTJ6B!4brP#x)
zEiF@0Qv+4_kBW#C78LZ9Ue78hxPJBOE~UG`1|=qUh_~9uD*V=0SpBBAqx>`lC)~^Q
zgsw|*$7|a7`tpQW@<tuvV9GTq`P|dfIOKXrP|(QOcrPdCE2HeXLCZYD*49?5JgJ06
z!I)DrNoFJtv}QV`6z!+4Ug@PZPcN@wiPKZ>)?2fLo=Df7S@tRGF*7!fNF@a;V{X*e
z*2*X6mX~*r%|Fr2eD>_w%*;$-p+qQE$JjWb(T0ab?c~YYjrCQuLR^kG*Kzl8LYT_S
z4u|51YYaD)Q_OOm?CsI*Na6QmW1H>783V<+&gkegfB*h{FiK(4z3h~L?&ZrP<Kqq|
zPEheXnt?diu28B~9wCs(_UBvj2gjnt`FS+xVC8^R5}}47SNZA{YTkliLne4tZ1mLx
z<rxaIhtaGDUbL+la=lz&L?4v*@}=&%bK9w8l%h7N#DpcpGNxWnSC<`Ke%VJR>BsDH
zp5g7fK@830ri@nmZ2c=Jh-N#J3l}n<K4qj20tEZ-Hg8l$X{ii>d31hdVZoh08j}ED
zc!yhB*T4YtJ5kH_)TuwPT}arMdU|?~NTrw-Mn?Ae9pmn+Rcj4Z)nv`I<{Uhj)>brZ
zHo8B8l~wp%E?!K_&fcYMs;0(3r^LY&tim7Agq=GyH1zS~$2fC8PYT5_QxChfO!wnD
zT^pHsc6D8m$2R{09)6?EpJ6vU9B}JK*$dcD2M->cDxdv0+oT}M8BydW{1+o|BYGem
zZ9uJ6biFm3KYF}ayfA0PnX_lHNAJhQoy+{<AaR<=79Jk{#s2!GOX+ok^~1B`T#;HC
zvfM26K{~oyAOC6!b~qGj3N~1a#l*w_!I_9i5||$<`14YdZj9bi;SZ%|K7Wp@CsMPY
zKD|ZlzhVAYOg&myMaA)WO)Qh9-~slqLL=W~1^>#Dk_+j&XSB3_QRL`@j>*bqX_MYJ
zH0+|^9#Q+*PMrAKd$PO4_MxX>a?|jvC&$T4VjaJJiN!TU)>>%_&VI=}ho^{Un4+zo
zu4{6sJ0K<HuSiv@wOGcJC#Z2l;RT9Z^*1@+6>+lLL+?px`D6uoc{5#I*Ri&vVJf<M
zdUOMM=*tO>59K^DeYMV>Ral>ExpL(SDO`-e97^3r+bo|f8rQHpOeIW3Ok7+=fc>h3
z@!7Ly&!68TvdP0B5_d%+;anz1yymwme}(W=zp7;A6u_}~&9^rBv&(Y-DPS`1P|C)(
zh*TY1Ts_7N9$_tZAyZG8?TxkAh?`8jW~JBsGu_PFD*UL$r8c}bnRzeMjxd#h#ns((
z+ni9|%v5wcMdCY~{22=OI5Q?NW;;;Mz<?F1GtUrj7^VVrTI$>%Xq0VcW|otgiLS{R
zF@zn!Mu+bZtFb3iweIa(O!pAW)x{|WGjuUsq1e@hiPi5tY6HIFqSa*KSd9Q{6K3j?
zkDpMivJQu~xkQ4gk&)2Rqw7PW{>x+Ln=1=RpR=ofOgU~yCNyHb`sT2W+s(Wu0DI4z
zIYS7!B({$$5=CEKDRV25MnO2Ho{f=??XSk+SyY{Bnk9jrN-n<F;ovvhD7iT~wQ;9z
zFd*-7vmKeaWyB4z-2a{;k>(&^8>%Q)BiK?Zxhd$v%j?S1UKQxM3M<V~e!pUp(N8VZ
z@(qRit~Za&VYrqYWK{a(Jyo&TGvyaY?SI^InLbD<T{j?ul~F2I<1a?#bY0Y)epH{9
ziZJK)*QW&7H3efd(x2!a7K$yctn|Z-wN3Wrl!_ySoaEmv6l+A{c&aB9Q5#-22r%Dh
zLnU*EsnF3X3B}TeV-DY#;b&uXkl3%p#u$j5!XEYp056J1_U-U&iOFPJBR{usxSr4s
zDv<0GZ4xP*cBO`VTRG)!{dWh6orMA$8&jJb3<^uzf|a)!vv)XfhFFTl-zG99G}1pj
zrfojr_Mp}(AfF9yKqWH<zOxq7w#w8CSK&WKU>1u{)JP{Yr|D+8$sAA8N+X3^626|n
zO9&xYi8FB#H5PZ(A6tvnTjeQoZjaaeXe}npxpR#!qLyp_{+;weYEiuDXtZ3r>`dvD
zZU`=0OLw3B@1eTDx4aY7!5N9o!mbI4gh)+6|HZOiU&c<n>D6DmmZoe9X`N|mR9T9z
zPPc)1O)T#z+N|(Ys@~V9OB`Y*1HM+S>n0df4vuXev0}QERdfR6H7mE$$iQH6xyhfG
zPFkA#BhQKLW*3Z%T&1}6gbMQWW2pV$RU&a^`$Rj-`+l^$_y|k1C`xShIZH7H3X6z*
z#{D#HUD|Gjt~F7#w|eV@{NNf3n&U5}%{Z8L5KdgXc8!g0ix-&<eoZO%T>^dOIn8XR
zhjny6E4gQ!=Tt^f*5T=W7TSUJg(df=3||**&hgZn6m5FU>L!@?mhYNAHvQ+a&$q!D
z5(g7!#18Sb38TfyxtVI?S1F_inu4ekb#EF`&`{t2J-wS<cE;P7sjvIVFP<wb$CQ|e
z#A^m-1`Y3!o7O=^3b2pVI2OGboI!Vs)o}5+)_x#KYrCz7tka`Z5|hMrL*X`G>*+uF
zv<$R!+r1|`|4Gp<_L%zCWtz&fi{s><VJbR0yK~B1`l@H@5`>AjSvPiS`HsuW1}%N!
z(#g<0oZnH7p?vOK%h#{!87&?w`y}a<1P>j`)*r*H6yc2Uh}mBB;)S9BI~vH0TfxMQ
z`ubDsVP8IdqIo@6tmvK<@wd3Rb)Mm`WjQ*fdh1^ay=yk7PdA8oe^`}c^5O%Qb1f+c
zPWSWM05Kzl;{nPR9(U&iAb97zpO@Fn-24z5W5V(;SsvN|3wQT6Yq5X>@)W7LW@TZ{
z{mdaFBO~epv=S7Lxz{x_I*&+P%=AhUHRI#YwMlDZRU22dg=rRDd1?5g-+li4Z-;}t
z*WAyElb76c%CN(7&8t3IkRN)DW}4<VUMcDt9v;RZ%DY&n$V7if?H0<Vu+T;#0gcz+
z-~Y;$Ba=asw3sgVC@GP4zC*FHN(HwBQ9T_|=<|cbK#W#TlyV7d8s?LuXbZ4U%-urM
z1EX_x*3Q(sfB$}9jH0Zsp9O)Fkxs;<7{DHzW9H2G1eu@AeD=(leas=he!22S835@V
z%AXLn&cBe`J~q4jT>pwN=M@JBhbvbu<{3t-3-Ct8#l}ty*!thQx1HeU=?PwsSzX8L
z?XY*8ifNVK;UE_8T4G{u-mAa2#8V3U6aW)wh&}8(G$Kmk)r1ePf`fPDw(pOs8*=r;
z>nikIYG>^F-DIG`5E<DS>8$dK!8P)2-X6Dl-|^iCR7*ml4Qj)eFR#)IMEO`O2zP3&
z9{uvcX7Kb}7WwZy8r@>mW`&8!)aWRCMD3FNf;&xk>WEvXeZieOcR;s3e$*;30v4QU
z?vOV-Omh3~UUrmoXH?zT&!2bI1(@jv^W#TKkCGT@0w3Yppn~Y?zLXvKLI{a({DJkB
zNT|R_8yFZcebfhnXd)74C_FhbQX`pH#L7n3@%1aZUcL3d_0|#+5<;;W-F&{U4p@;1
znu33lTp%J`m+6_v_(vh(tLnY&Zf?Sy3GwkDYaLboRazNkarDex+#L>W6YgiVw4i7_
zdnQz1RFT%faZmO^a&nPTHV+REpb$mQ*0_VN-um-|d(`dQV3QTzi=2D+UX$YXVVF#*
zSBO@BV|6U3=0#p!O3TQztSks935{<<Eo5~+3Z^#yTw0<4w&vtuNOth(1mY$mYL(NP
z@j^Tuj};DJzxEu{6FPbsEv@bCgI6w>{l&)k;lqa;4;eAzpmh|tb;$^@|50JahuKE=
zSF}2a26T+2zh-z&NLL@7UtMp{HIGtF1D1GYBGS8KFqC+!VTkrzenv*dt5<GnWsGFz
z)%6W*P@&k)*4Ba!TeiA|W2J*L#qDDShQff~xw&Ukv>mSR%xYp$%ng9rAT1rQm9d|T
zD?B11SoyEYxWWU68EC$A%X>^FDiZDN?K^jbQfSuvHX9Qpk1@B{iG!KSma>Y6SfU#Y
z4h}*c0aIoVqcb<?YB|Eg%?-4Hi^hj>&v|Q)KTDd1F;0P%d81}2<vBSb+K>0t-N{Hi
zbLI7j8w)EdNEHA;LmBl}HTlEvY`o?ZaNJzK`7GHAYc0%6Q`4lx#PN}l%-q~M$(*9$
zd$V2@?qxkzc{c(>edPK0GQBx?0*R0&ZEW7!iHFw?ynn9|j~QG)E%3lpT{<DHGB3|%
z@a?Vwqn^*7Utal0RZDAzMBrS~Jvuu2^5sh&9)&mL@mK>hu#U6x%K{G*^OHjB9VA$H
z?aI_cm7NEb-ucU|kP*1cDi3fdxhYOlu&c9^i;HXe%!4MnAsXxa4qS73`oR?KrSCCk
zC-0;O5^q7u;)<jX>hG{khE&qqd|D5CkvRlI9VImoaZQ%$SkyJ)USSqx`Sn`U@ldr;
zM>Qf_vDds1x(o+XtVX(~AXW0R{Iz@enQ8N0>mVuDuH|cGbnzUmy)o;zFpidBY+wKu
z;gOSuargG^TRGmd*sCB$cfLLEoTtf@i4!%)LZGa~;vGD!$9#;?JR@oowKAH9p@e`N
zfENpih|u%+&3OKbf5J_}7$_(x*zM?HYikRoH>ZBvyjO)+#kYQEJ$?O!g@ws(yRzP?
z<OdIcULY<*o?9yI`N0|0J7tcI_Vp_<rXHy82teI!<_m%`7|B4onu6zqV&7Z8#EvVs
z7t)gEbNUZt^@u?Zen-Pd*DaA1WTNE6#>S%S{`m0&dM;0ACrd~_Mb2;J^Fi8x>2y)w
zKNKWO*TW9QH5_CQYi`zI48*Iz9h6hP`f9N<Q~RC2PA%qUXD|CyLfHb3mr1%KdGPh&
z;fEZrdK}FS4b=r>Dk>_tB5m3=xp0$*4w;G=KqADLV(}Frgq(dS7iRgj(svb1xpLZ_
z4zpx#PMl5&95p2cB*4MrUP>U*?(*gO5x37M+t715Iw`I8GyQK551%^_*C3tr5nC=y
z<#Ts8kgf;A3>KOtG%hX<Zv(=rkq*i&JK0=)>?>Zz8ByRdWtO6Si!Y@2aDxzmSwvX)
z=e*b5+=CdkoQpK=kUO#HwY4V+A=`pD_w1QyD-@R+lGAGi|C;kU9@lWy$q5*{>_>B8
zP2bnAhAG;RR3Fu#0z!<kzg<W;o}Zr&tW`I7-NR!r(#)Mrv5c;)M@ta6!V&C`ae<R*
zhgf|1@m-9B5D1CbFd}g$*nnRpB_#*f>0RD?PGi0Fv*t0bCnhE=4t*MN1B08I3vwbs
z9c`YUzg}V13+Y0D{Wxz^bDEk*+qHu+_1FM0^>pkk;Cm22T{3Jl*rM9UdT@akF6fXr
zu>K-(;C08rg1W5JSjL0i4!XqDqYA#edS1PH6gqgA%2M8$MAyRZ!F_yuMI8>Hnb3yj
zygGQE9Zk}zTAeJbw|=QjazhL9@R%xAdpG176ciMuLL2x9v-i#&mNkJj7FuR11U|4w
z75-)iiLBPqVX(8^GHj3Dmeg9!tgbiPfe7fGKfl$0#q+ZjH)f*z%Om)rzzXi)2aU~W
zDJd+Zmtg;5KQHoiuzm>Rnt|gF9$sFERWeDAwt0txl@A{|a*<5H3S}34(<N~vCq3`(
z$%AMVttpt0lw@jdt^f@O6bj8to8<Ff(5+NE`D70%Za%-I{@1T*BWl5qU<qL6xR!8B
zS~-gj@2(zk^P8?=AcTOhLIIodo$>~x?m2TRd4{q!+L{F}jPkYZk^aQN!E_K)<KxH5
zxzDG)7bk0*A}5L8XO}5*EMMN?O~tu<*JkSYjFc4uiO{4YA|in4H#gRo1b1mkcL7fR
z6{`V~?JNbgEh>4oQ~yNFmbl{$!f9t$9dpaMyDVaGb{T_?_c--1L*0QFl8_d7mRkrR
z=}=Kcp!$IK=-i|B1HKSKrXF05B&zdATjUuQcLfYq9u14~;>9zelF6)p$3v#m5R4&(
ze=8{e6Uqu520@~QyT~+mifJI&vAFnL^5$|fRJuDw+$?qboywJnY>>76*W3M5NRTw3
z^9PxTc(m{F`|)94L~UTi-nxt(@4A=4);L%~rzj0WuIv4*{-^}A+(nP7Rp?UgW$Q^E
z-%8@HV6j61iHa#M?>o*HQ)b`*(CqlOJ)oLriaw|&&dduB_iC261a@HDSnXc(^0X6N
z(dy9GEC!i`{g{H;qw4-*EFE*?WTt9mTr0b94-~9-W1`owyEyNJ?cVTI(86z5aw`f)
z5-K-0R&%R1Rz!?dFpBK#ey;Xz$|pB%{xk;XQcbHJbm2G&R^4b*7Dso5D^fyI607LK
zQ*bR{@BK{zt{yFg#6eF_Us_g{t~<grE6*EsB=&u%j{&AEH_PzFhK9XN!TTj0iCc_w
zTbi)2@b_6yOea&*3D=U*u`w87z!4Xtj?;^rB(gd7l%79#?nFilv<e8E>H_v#zLJ}Z
z%Wfq$Y(ks-W6Vc5m|y@r&&|!v%q*Frfp(yi)yn#~4+cy|%Se~Tlwr0$IJ$|6&slxm
zFbE2g369X!A#52Ll@8tyYaeU07Q1xm5})sp<R)M$&|>@&jQKO{&6_uLNm`;JBEUg~
zhQg?GYq5^8`M^{E96Q$B)g>!0|E;q#ocQkhcLBUiNXY*3WuPE*V^TO+p?q=_kui`6
z#WN>2w|&H|_~q-vwq*yBoA3?a4$eGyfd1Xq-VUV|nu(sVaaKEa``ERT#I6ZPJ3ClF
zFFG7#l33iNk{>?Ao%s6tHZ(LqMSUN81bTS9?Za(x=#2H&u36cGMZJEq35|gtxB&$_
z-hdG@(a}b#ZdV^b{lL}(BnPg~)(2vMpsbu?A<kt^>EFRj73OTf$R3{ef^m5>6~-6<
z-s*&tzcDsGnOto_h6){f#GtdQ3zJElD_xtEpi}HDmDp&bFp&fa4@T1_TSP5-1V9I#
zPmKkUQA|RDGg4KD10C<I+{~NqZj;~gG+<%hixiD?Xjqt#jg5_Hh<1E2^>eRxilW~D
zvO@APGs75l>M2dv&-ycr&f-8?^Acv}<#Q@2+COsw-mIz$#_S^y(9_q~*OgOV6c-cz
zTOfo47@0BCr@^7A8-z*+SGJ?0qse#jTD&H`_<<_eAyIyF2VQR;-Q1z{No(e!s+wA_
z&uk;CmctxOnR=y{8Gt$%10VYQIwhZ+td-$EpJnbl6JZX@E)tjZ@}(>ERcJTBqdt{b
zK09$Hs`IsLv+;l1f=$1EtqiYBKADe?4;AP?QPA$?<%L&0*FSRiDv=Fx6k}lD=>CjE
z9vbJLJU_t&7`P54%X*+DSiiglnZUNN7Tf0*f86!Ex-h4#-`Y}9<$QKPz_z#sxO-*>
z2JJmP>v$yIF|NN|2rtHC`^tLoG8f*c#l8MBdm&FJ>?T+B_I7ohPS;J_!tP7$l?w$m
zH8ubK`!BE+ERTo?Q;|5;v~Ay^`0U@mA1c1mz><^SYy$HFA94c!lLY{32@hvt3jVdR
zI<>i4wOIzzGBI)d`Y4>;g06|=&9!04BQ3CXy4AFIQ%++x!_a_M+N7{quAFj%$S6=E
zzu0}vvB=xe(b3CmMYebO<7v?fi1oaYs?gJcbna;kp`3tM;YV!@V^Lwq#A>jF&gO2e
z<O0L#X0>83k55coFYDooR3)-?mwV23^=>Tm^*w4B>f~tt{Q0xm#mB5nk8Z~GIBr79
zIuxz`(08E&`ZC-DXDO{@`Sl|I)gsZVwU>HAre<b^M%hir7rWoRyQQC1;j`>2&NVSI
zf(DVmv1JnJ>$~6GHatW5Mj6~yVzL3uyD&F*<0c1t*sJ2=rTJWc^bq(a>AIPC<A}YY
zaG$@9%`*ingVr|Mq%}W<icFD1WAKshbu7A8Vv^Om5-jS||7)m0Ch4Pn0ep?}rGbd*
zGn=)del<4vzVf~2&K@tgtciGo?JBJjTfC-(wDe`M_{!CusRxZV+4}n#=_qo%p;ROQ
z@NMDl0U{{w(LaAafWiTFbar{`F+c~DNI35H^R8L$)a0ZH2NSWQv}EhU^R$zni;E86
z46uoACMH|A-`iawmW;4Rb}!{Br_d~12eKCC9CR&FO^a6H|3^|1Z2li{@pnVN?8ITo
zR?S2@!K-2q1D(QlWKmH{YbG*kr0c@1g0|V->ot}QjsUwY&rp-d=H=}@b>bK%y%0w@
z1Ob-Nd{4U|YX2uY@e-47U%!6s?p~AhpOr+3_z1?JIil+dbIvZWp#<Qu78Mn3am?IY
zAg#)U&MW96E@*k7X?c0g_60yy@tXHF1q+NO@c6VcPUv7qhSyp#Q*W@#QKtLab~Uc8
zl^Y6gyxv<0dzT{j?Z>A?>1!a|A;0zI0;Bcb&GlaY<v9O8l-OWi&QQQ3Hd++cTMUJv
zL)L`s3sb>7!AIxrta|$buE@71LRn@ga?$E;t2f_}Ka98qp0g5Q&wTt?fGZN;)J<l>
zS?a-q2f&d3aP5ky6-#Ku{(=E1$IBUkIR)|Bl7NDs4Z!t0)q4gh)74Bj^NT^{uUJ$M
zuKknp{`Njuma_7dYMvKe6MIEWC<`67VJcRqPKDK2!2V*R+YwZQ)iDvt&=bPY6FPF_
z7;~BH5EJ7Mnss=#xMXe?HU8+IqoWTVK5VlufYU-62)zNZ0qYM|Z$Wm<6}v%Hm*Xum
z6vmc<467-a|Mcm*3HP1QmlYqi+Mg2mS3e894DM}K>#t=W;3YC)%a*xt;V^p`Hw%LW
zZGlm?Zl;OIUJA%fM|=Ar&Il+zx|!uuLEXQNS~y=Io?RYcrvyGDhjRLKgi$tqco~d0
zcXtV-K4N1bC@@oTBM>!;VP>2&Guwc3KDW4t@efW7ZUZOm{(a8h?f@&VoD}NK)D!?r
zA^|&7j(6&>#O2rqjD?{sRoMEQyg2OtbX}|th&qO6R%>TR#~)Tf$c9WULSq8o2E6jt
zv(Hc@abUl|hLlL~T|JjZ8lCq-VuJLV?%&5jHISykaxs3$%-a=W6^Zxm-Loq&y8Eio
ze{%!;0d|0U*>7MuF**5`3}5Wcpo_)j)-PY+;0nctJAEJ5_9^^0BoK3|!mP<!Y!6eg
zq3|8mG<0#?Xdn@_+iWMreW%6(k{LjSO}=z;(-m<pnWW0nQjHXC#e-3b#7|$oe4nBG
zTQ5LaY*v-H!>6Dnz>cnr2!MO{ts9i%)81=-RgE@BgoH3GE%t{2^%NK(4U?jMPXp34
z%+!8oL&2EXxH#;dAG4m2;oz(-u3|<5r#IUPA3X{JgOEqM?(t3;1XEsHka77@b?3~@
zqlmX)YLW>x7BAq&^G3-geN0VFwG;1bYkS-8tj*DAlkf2#hb&8mR+3n}CO`*xF!dkd
zJ5Az4<MNM4_GE$ufxhIpl)JcMranRgEhF$$CcVU6y<c1939yI3)L)}J#**mD2pc8v
zk*xAIDQ7u0BBNDN*I^EgQ>W_JO}9B*G|X;`jNJ8!i^l2j&Fz?tAt<WK%7+^1%=A>m
zHN3r7w}#-=&s~E7G}IS%;_ofU)1%f=beK8)&d@Tg?Cmwun%CBb6*doy8CelRh>%P_
zFD(@VDA^YPh}2s3yMI>O=Y??2)2Gm9GxeVJym|`wTm#btU4WO5&)nF!3*ib(s8>71
zgm=^Z5lV#vd-W=|blu>Llh5G(vdkT$EU(eU`ud3K&Pzb&Pqj(BeWcvy&+&+H16+~r
zb3dCy{pmdu_8aFJBBg=E6?%&W8Hj0ylK`$eu&?CB3#e>=aYmd-`2?S_O4cL*$(|Yp
zJ_z{eDVWht{;OT^iHrBFO=s_`FssVT)6vnfEHFy;TN#OJ^YA1V`k?ew)BeXuN9_^^
zck)d}h5tmn0vo!t)F`VJ5^8|rjnjW*B!)`vboy4lkCE=N?q%HKmoIuA9*dLC6*V<e
zFg>irKpSG94}EeiaG`-hJTh`Qxd~HLMpm}Hy&c4oXUAmW>zil`;9Jq^HydrHx{6q*
z*k*M=l7KFprBDEMf1wLb541=PIb^F!a798|2EGHuM)RPO2_YUUuTJQ21QM|s#JNz{
zh?IfXes^82Yb$x3cm0Vbi9^PF!NJAF#ou4yw-)k9ZipH-Ow-#lwRl!j^Tua2>~bV@
zB!{OAg&|*YMnEO1FoVm8?2D%yZ(KvIaqz&sS>iDT1*iND)Gtye9xd)xLa|(Yd<=U|
z%F4(nwr;0Wnx3B}ZyQDbr(<fB>pZ^QS<v6dClLTSSefn2>#*T8MYcEn&L5hZsN@gU
zVmoM+&YWqqDL~$EsGHTbq<d{`t*_7G#EBDU&w^KX@LXY4y6YxWQCw^%7QZmrlck%<
zYZPbB?V-KV-JRIsFgZGkhTSE+WBpx#CAO$bi3wzesYQIm-MdGQ*Yw%Bo)!om8K4Mh
z4C)@o$;I)GbGo|FR;LfBATB8Lp|LUG{(c5l-fsEQzNpZyiMFx%07b=&7BtQN#(cg%
zAWy>{XtY6Gv8Sh}%aeo1SW21U4<w=lGWG1mxqLpZZT<u}2aN)hfHlh*fy9hzT8$@H
zMq(L}H)>0NK)vB{xt92Nd>}AWF{7rZozaTz?O`aFg+T~WM1=9$@W;#I4<Kb_e`KL(
zFQS8>L?8x%W22^^GQktd(Ny3>!z3`5_BeuX%}`JoNO$46^CrJJJgjw-Y8g?Btl8?y
zio}&KQ?$h<BG5{Tx>&iTZon22LW;vpX5PzJfZY?>P<K14<AFqMbD$Koe&{BsgC)!Q
zvx@S`P``?=k8w&FLfdF~|9<+v{aVsDt;G=9s-?)~w2WZSc{E0QGX{o)hU#!+1E^+a
z*Ph^yVj_ia2@+)H|H;_M-!%GS9Bv{~R9b3Z)P;B%KDG>#8J}N2y(`QBy?!f;hz}+$
zI@kMf9%i6O0Q_M25kM(BU~+?atI_6fu1HY*ygJ@<S*^0Bbraw?VSq)r<U<cBc$ni)
z927ZDwv5bW8y9`B`8%qvOHMe9b>)ycyq;o{oakr>EFg;KOiZ5Z2`L%Li6r-&l`eAZ
zF+#Eh1@zCuT|ce=k(REv$-gdRdg;<Z`2&1=U^n5x*II2m#Ngr5f}MPsOjz^t7m7ui
z6qiN`Z7kzYXawY3TKD@TQ3ha@lfx2KGNJWeN#_gff-`4yNcX;dGmBP#wNvx9kNniU
z7hI&B!OBifxhniM#}m|ov5xIyxu#`p-QC?SEeF^b<#$R5J8$tBpen_S`th0}wwc`#
zpI|)x`t@sc6rMbigBZ`O8GjPBq*<wd7@C_WCnUgp1<Cv8pMT1Tk#r|@%6jA#6wdNT
zLup2CVdlcpQyS_tHVm~N<Pn#id?q-;@+<Tt5-Swo2MGx-10{Qjj4vxI9rFwk6bd9_
zVe#E4hZmDHq{+w}^kW6}gjzu^4GfBQY6!qnPj2#nVaOZR-qCRwqB&iF8e$K9?qzDK
zs$iCo3x6)I?6d7f=C-h~u(;R|w9VXH6yin0y4hV#!M_-R=2X-2o<4n=nRzNj+quM~
z{8`t>N8HTRZpTH4*6>51!DMIm@G!xNgWiCQ>H6xT)5$zb?nM^uRcHVTGjIN+T=*bM
z^NjL!!d)f_WET25=v}3;U)1#KIyx#uJFSeMT}CkO;~sZDxfhgb2RYMo_6M>`-rnBm
zJ|a>l?lujBDSY~LS2Yc8L7ck4(wg^8IGV6b7QHH>jxQLxxEyl~^?O~86cbFlOP7M{
z26?2M6^U$p1Ep#JI2L3=q-vwhH4+EVEmB7q(y6+cQl3tG-=lC)c<yBtNREOr?EN|9
zBkv^6g`ItjS=MWg#QWX%yAh~A_7B3l?(XgbowMI|DZ!70`5=>o;MJBD$nKx)K7dhl
zL70;z6omo}TO)l%SnUhn@gWOB;menh0q7k9OxfIClRwzxo0hqsNo&?KFo4WePI;Tg
z!;;)2NhZTm#r5%8G<<AgVWUHK3M#)%{$Y;rAO_ZfgO-ygZunLCU%W`2aEJT}C^ECW
z*7S&(@8HnmmJ!U~pc=)rW)>cqS36l4Xqw(SNVM3!I-qu^?_uMCqEE=fqC5c3p&`y#
z&9l;}rp<ha|680ZJ1YxB85(J6&!n9={P$3`$VnHYPKQFsQix(?>o<TL#G4R85EMg{
zw<m8=?SwQTWMqD&rba1A%K%1-EPF7LBKigf0Loe!@CBBBdB3`0NwKgX#x<M=Y5(%2
zuik*Q%?1`10*iw)P={AmRseaiDS!O1@#*X>V}Xf=ST=7|nF*A8^v5+n1!gLGdYRPp
z>Wjk+A^q^9mX|%zzPq~0cFN2tvEjR5jsjJ0Jp%cIQQT<wctQvv6%`p|wDiaSG%ig9
z(@Aiu+{Y3MZOF-K3WIT`@!{Eq<LJ^!TIQ8Lo|i7w4$f$k?rjMGXlrHvQr;;*Jm&i`
zbyQf`P#F62o#WmM<oFLsyzl9b^DB*BLkD^o{p+2<6j0XJuY{;NS)ZjBM%iy?w-<4s
z^Fg5A@)CeQVMrjBL@syk@6KvHD*%g=J}A0j2#$J)WsSur$D%Zn5oEVj!D;G(D|R+A
zLH~>c^ozt%7aa=!fHX5WL&5S*J`H~r^dIjU+T`Ey%zhzr8+Wxbkc{CDN+m_Bqrl6Y
zxTYSeevxvvAcXwAi-o(Z^Y4uV2E|RoC)mE<X@|^PU45f>s@LZr`~}yNiRo%=6FWOn
zLZjbYwu6MMnApqmavuXOU>5|bApjCW5CuP*mYsID>`v`Oa?P?$1Pzt^-^8Nbv)&C2
zVNO&G>vsu2Vk8oxL?38A$;&(TC{uAK_|5FQ^zhW5$29~K8o$l-0jyv)-0gz$v+T1W
zUkO75(ZZL@jBIqUe6rIMedPTSfsT6S#2;-(CdlzN{Wvn*l#Fm#m*vbYmDJhcCjWba
zP(efa{C*-?qje}eHQ5J&8yRe<QVvM7W5pVs{Gf7+-@K<{+E0)P+}zx6!u(I?A({X;
ztt=-3Z}IE<DHzGC5eE(&K-a>hYb8oq7IjSx0@GQ$yK`y_1`?@MDof~K^yyZc{3JQg
zUpczLmP>OZEfNV63ww9bQ{j_tE_o}meeW*0CKxj!UkN4YZC#yY+%TrY`1tttH1tNS
z2m*;2EzNcupO~4c=F9I5zB)))^ibp=TIz7@xIX#S!CjaW+?_q_c4Q=CSyAWbSa+co
zIU@r89mJzRu#!FOOr>T<3!cQp*qAr=D=Jqc4oWVZV@6u4voI$_UU*1ctf5rbl0;-#
zKYV~sFkx|QLgTw@Nkg2d|1TCHI;D#jFD}}y4HTQsE3$D!)maig4$tDkAmA4vRt%|*
zKl+BH)c^KBQCb1fEVoS<11$*dB__zWj0ZT~u`n<&IB{aT_TJwzz$4OwreP?N(}_3U
z-m0|%*H*d<B_*mZfPZ@<ExckW4Gdum!Z*DG2r6}xm-bR$Ad?hPdn04Vz4K(khap#_
z?u0p!O?i>HIMvH)R8A!`D{0FleUq7DQ{UsT^499uBlQ4_y1F_Y4n(=4)o)~AYAA9k
zKI@Bs=m~^h<UJj%3>Ai3j^cbS+gI<|Z}-AbxNzU?jxSw`+Sq-`O$<RbLqnGybxYXN
z-t`AU9C9r(XAr166jP6V-Y|qKP10hBg3gI{TUuILea`9ITeVBBx%;l5gFxTp+vw+m
zN(deaPe8}aOdiu#R<`T&XYjUOztyXp5%Y+)m1brhW@9u#lDn{QVWOxPoejSnizLOx
zp$4eM<{=PtHc<*eyN^k-MYc`6^g%8wbC+Q@6?FkZ1&mc7SBjy_#`tgjcfO5j2FAc|
z{+qsGDhP4VGcW`gZmCNTA3lUuf*JkN@HsXEPKF@aC0XKi0|OK@Seqm)DjK9OLcBRP
zLqT5&rNaDhFN1Xsj$K*F%S;at3mOtitvQ!ECHhK?OolE93|nr7DR<muKn2=ub+zK}
zqcdA#<LGE=vmGi2u7{V4%gpLj6|N7$I9>z#)a192k8432M#{t7ob|J0bw?7URm@Ze
z3Gd}!moOJM);v?RDI=djSZGA#j~zp1_(?{Fr1u6SO!$l4-CKyGyu3Uw4~bHUxV=;0
z?FiPu{)%fr%QdO;OKKY4+*qu_sPA`P`ka3HxA%gOI*#`EgSy9wm~KTET?Rum(g9O|
z>Dd^&5p+gkzShdLoN_F#VHYcFQDLEDaE%)-C!<ALQgUxZt%F1t?x*+Lw~fiNsZ<hV
zJUq;aIzInI)wCp;>rCCl9r?E4e28z)&AH)}60|Xe`Nc(qH_Lh^q0W3_mW`=@o|9u%
z=Dth3gNr}_eYX9Wh*USx4{8@WTD|py#Kc!!6YweNX!{3hBiQJYq+AA&-KnvdhVPo9
z{m#AsV;u+%F?)!H{LyT5$G9T#`aDAiD=U89C@4bEyXllZCMzU23_%(CF+7Y70qS9v
z3m$`GT&36H%`|=d_|i}~K#?pb$IK!G;l@Y&+_+f<H&^77W;;V+eOuc@2qVK)l}W0x
zP*4A?oH9L{m5Yc?TWjkcrX6{Pcm!)-FGfN0j8PXroG{f6u^Pk!4rnHs7#cd4^&kq+
zH$#z0ngmX$4kR5u+_9#4`SRtHCwIhZB*n+$H~^+I(mcv3@2p>9I3sld`kbwgH1KWJ
zi>9VL5Y@CvKt)?@zSB$FStben7f*C3&Ya$hfzij=`K}@{@whjq-F-Xp73l0}WdAkV
zKsJ5xVj7PqglcJWV{sewF9ijE9EyV;pVs_tcs9R781Y0{49}if<#&*o7Z(<g=m7R;
zwFl81cb8>G2&3%Pt1nZF$T>rtuD1r(MvdM$g>C|^l1>TU8;<rwt3R%)+RV&&h$;da
z1u*81MhC?x$;IcV`>9O90~i5Ka<jJ)?|=4wY7t%q1ZFrTV)4)Qv!HV+i6VN6BLp~l
zpiPoPTs@R3eSK69O9@*69+7S)Qp~Sj&E;;4=Hep2T41d2-ttRzGdTo;aG(lADIg%A
zE4Df)GNJLq2W}a+r;i_7U%IqI;8#FU7<!cwTY%!HZ{I}N!*C0*uODK?_U?tk*FFX&
z3+)nm9)UTkF5juQ5;>I3^Br3u_{&n<_chWX?m$k1KLm~A`|H<%9S+Es!kkvRJ6IRx
z;qJaLKR?ltKP*|b+_<-DsTN8iSp@nkh4R&cj1W2$5qw9eSZt?>>|xk2x$S_SIF`0E
z__gFWN*d_sZ{6(gcumw@%LrsDr-E0npa*S*e=yR$yo}OyaXt>x3Gv<Q*ROG6Mu5G(
zuI<tW$GwZ<T&z4YkZ2K3fpU&hW?P3Iz{pRqeZk=<F)=hpgql$PQM|{wn1Vr~e?R5l
z8mGeRY9k`sC;I}N82ai4FC9;D^ykmM+2!ih?N7G7h^{cp)ylxoL?A<jzt-v)dzb(R
z6UZ$n2tXqau+b?YkQc4~!tlAFa7b1*L!g_?dVccyIA|<-rq@jE-V4Gw8wC_lRJDE;
zIYNliEhFWwL+?R<a1djsX!)m(4rzILEHGkVI8>JWOi#!pWU;6<MVs`~Z3QR8@UqTM
zqx0uud#9iV{Lc|KkOua!-`XMI2@Vosx+7&1xnB~8)qIwJ4FTAnOlyvhkH=SHl-)al
z^9_)#K+1n|oHsKA+k$>X8&D1Fq_w99hZ5n+7-j!(mcllxw}xjVM!1a_4w@J=M?y%|
z=K567*Er~)M~+-8>!G9li-QTVjo&g8o-F_b4jobC;9NNtAwG=hLWH}peH?}*bR+;9
z9Cg|rKoeC5&@nqZYrZ~e00~Pu<rC*f;^)u07&Dk+FtwQJkw+wPAQ98y;BI3BhAg;s
z0(HluB=j8QZ*ZPSCJA#CE*ZEc&R*d)h~5*J1MQH%M-tDzKqk2<q45X$EK_i5t9_%*
zESC5MGBufcOarOV{F;XUCNSe1X0*E2LpkX13~SkN`%l4O52^_Z3&T6+wntbJv^@}#
zNBsBRJ-{y50Le}5I1)I!jPyB<Wgu3kio=vBR&+!-Q_z-#VHr`oEXY2~4d(Fp5RT$I
za{sIghnusr^VGKrq=p=eP)RseCXs*xCJ?ek;(&m+Z{H3}7fESY5AyEghB*3^0h>u2
z*gF4$M8dA|2(^Noz?w(BQw#zr`dOwTdv7fV5^vO4AW{K6pjrlL&lyVh?<{ei;kYx>
zo-dn*;YAUDA(95>fg?-5kIYc^&M^cU3QOSl9gMTxhC&b?RMY+levPw!e(PiAi>vFf
z#(d<>MdE-x0BgV||Na{%2mOcM$6^84!)`LPO|k+O{2TzDaFf~f<v5*^951V(DWE)w
z0}KbcoSnE=Uo{fumiZm<NU8m>U+|Q-^yAm5sr+K`Yj5{EA)*6!3x`O5M}BaUKqL-j
zfm27<uNUBbnRejI$pmDq1!GW+_@8kN**Q6QJ=+p^kx=Y2WUek=+#X^HmK?1Pt)Io`
zuyZ4v2A0t6N=Q3F)<tp1@j6*rS|Zwlvgxk+onS!9h(0JlT>!=!(wB<ZQs;>_^A-St
zP>uxH4+{w)EO9!c1)(0f!=Y3pEOFFHD+AHQEA2Uu|6zyW44R1~Y|$AC96iV*B_^;^
zYAmYBJ{xPx$j7#}p8tI$7WO+f3kMTpAjjUlL8kkNme_?kf6Sd1j6t3rD(v^O0aLJ4
zU`QU@N+e#;({o!}+B(JrpY-KRWg;6mpr+ty0d_1B@)2y!NKPP{T)lh4M8r0~Lz`p0
zdsu$hO$O;rxJqVb?o!<BVUJ(F{B<#^&Nuv;^wxpxoKQ<b;(tdun1HXvx2x&QwHlbO
zfApw4z!|YK7-0tB<`7FL`$Wd@RGcB+-Nr>Dx!t`LdEqdXPM>fbYl5C977yhX9;f0T
zO#IQso?STeq{5#<Vp0yi(FB}K;Zayxpa~rbVwK0Ud!&7gP6^rJCr^HicjRx`H;<5L
z1fh9RK*J>*OzlVI;Djk=L6TNz-2P&Pyr8w6;H>=p7T0eqv)-4B*97OCs@mL$tDHN?
zc7S%)f0mzUPq#s{a;wJT#&s3Jm>OC-{~*!8D(s=(N0u!v1yq3)dAP3DK}9zv;=n>e
zBkcjv<R+)ieZ+i=YsYDi(oODyTCG%VMDKM&Ipq<FNy{YA*vn3LhY(};o_I|-991i=
zxs|g?QwWGmyY(6O-Q5TBp+W!dg*NFEP6R|UnQfaw@ey|sMego?k(moCM%z4r`f8c;
z?%N-C0~D$c)qL8XiRN%u=jCOyphL9DbnG~sme*u7i60g4dF$r_c*KrwmtunL1hp6E
zy-6ZvgLAo!HnP4eZaBH<?Ja8-<(u%v(@>Z*s0P9mGyV3v$KM6e<sU%`rE&WUDVz<R
z4t1{V(1o&&{P7xWYiVfq=`)WWwT~feGB*$*>Zkg6g@(kS#CErNE3KdU{`Xl@+SU+J
z8g8i#e;UhUIOmvqkKvYsL<I4j2uW&rn)JVaI6(2<zBZ=+|Bngi`+t63K(gl=U&c2D
V`TJ#>wzxZ*Qzx}la+ECs{};y~UgZD)

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/schema-webradio-inkscape.png b/website/content/doc-2.2.5/images/schema-webradio-inkscape.png
new file mode 100644
index 0000000000000000000000000000000000000000..fe5a724425bff591b6a7c48e1ddb0fe04774406d
GIT binary patch
literal 38585
zcmYJa1yqz>+cr!|iFCI^hte=~3k+QXqJ)4T-JMEGNec)_N+aE&G)PN#_t0Jc=6>F9
z{j(M_>cn;JIM1VYn3{^*GfZ+!1O$X<3i2`<2ndK@!Sf+>RPg64Zpa((3&lxFK?@x`
zywOcV!QV0L<@KBp5U_V2e-Ir80usPKk~z!jI&0c}aCS3xG(&K6b9?#G*2>Am*xu}=
zouhdwT!b6}ffhkQMpDcD`(B!xH|2WT!{X4OwYpu6wO*`QJ+5^GOASk2($@~j9Ll4Z
zKV-i20c-GBMTS6x=WiX8vgx0bynOreNvt9w{N)d=H(1YkrImQ5>YkJE6~Qg5XXcZy
z?(f|{ysl*HeMZL4lQFsLG4OY6gKS{u>Tj*cqFfldCK0S)H-M~dQ`S_TrJC@P^p~Ve
z%l<??B^0~v2{W3Qkcy5@xO|z$&LZO2z%IfBk{@1-WNq0H^2z)$^bqARKlGG1V)y+L
zVH=Vd9YjySkNj}RA3<7z>5$yMEL7Jv?bVW{QDdlg`=t5PLu@1BVboigO#0k`_za=H
zhNYnW6MJghCpCx<NFr#r#yHBV2={0f&ShQ!-2sN7J%;lwWvDM-T1+xP%rD`7&#y%h
zy<sx&iv-c7^Hyn@1^5QblJO7hDMrYF28<5@$MY;+gC~H`R=|)j=4P&DH$W0kZ`pvN
zZN1IX=;acEzW+gJPucmYTPmg+Od0JS%Q?Jf`-z!izyoSJUQBeI2MH1lk_y^r8|qSA
z+xw+mg1HX__GE`!P_xI+i`NiGRY6V1jZvKUy5q5bZeJfNk`;d~X8%F*#$0BN4p!iX
zxafF7xx}!<wR8iCb+{3JCQ6g`G|<1Ktr~K?l>PwIM2B#j5gf9en%-hxTvNbZIDX7E
zm28o`eRf--pN@#?{jo-0U_Vj(iM891-)iHciLC)z3IfVqyLyWd>aYG61WQPU(;@;x
z=hYY2&_5+k#i_M}lW=~4Aw+|tv!h;t8!F12i)(gHBySvL$_r$j%-)kp+nK$4DueU&
zge)d~M7X5t)Teakrp5LW+l8ksuHx)<56CTUPHvLZuMMXKZ5JASJSgUy>fvX^7Y)C4
zHi_EoPhJ?+mOTj134P=xyJt%Y^*#I0nxx=a>jFQij@EQd(Lc}kdWW3jPu13%$+Xv+
z#dPN6b5OQuwP~=pbN{--=E2HPXl(yRa`6V*IdH>qaXk+|vzyyx^4@P<PAqZkuR#=-
z8^S<(yOYRvAwZ7Sg6vIjNpKhj?nP<m#=8>jP{=RhVX39c&$a9!;y#Pylmyo7b)TgV
z$Lrx>+8Uz!ik^awIuhra@c1t*77Avcy?iRlqTT8|{9K|RR@qL_O)GDZ^%3WGH%eS~
z*YMEogS|x2*&R;?T~1;p=2P#e8L!ejA1;RwWLvzo)eeYj7qp*TQ3w2WDRU!w>xFV0
zO)%Grs66QBvUm`BaX;@EE#ZpL>UsiqE4v7i2%cXxv-ORV@FyU<gIchX>RhGX*)ne5
z!EplIAIfSGGevKSCmPOFs5afItUfuoqi|!1Y-}jY&>m3#Y?h;Kbu7~%dCTEgMuVC~
z5b0C+6IYYM&o%ldTW(gH<0(pvWO&n0;(sT<lvvJu1bm#n``RJ-2E6vTQ;@lS+PCX(
zCP9?_zB*(ae#FYF{=F=|@MTkgg$TCyf<WH2LziQsm$$Brf$OZ;*7>`LbZ2aeP<i1u
zLb{mFY`MM%g<KJLdpmaV8ium1MNBfLR+3jb@fs9!&P5y#@2eV?Nh~k~zNGhHI#3K}
z#lOL5nr~hpDV9@Zon*^>|HO=KZj}x)nipTF278wi-+=DEDR%A$U4Bmc)Emh{2X?2$
zQY|%?>`tS;>or6Xuc7>8y%y<b9qUTip^xDW2VwkxI?RW%q_8i`kLO43U;fhvyCjVr
zu?uQT@h;yUlR|=?a0{Y;7+YmY%x~@vc~c}*oOX$Jq|A{?>bIL$PrXpz^dXRH!4e4L
z7bA(S*aA*OKB>bJ8t+`PTkYXeiaa!P?L5}f;q?gBtMNn5(G-}+0z~mNDo}zt;;FE7
z=)tQZ#B;O<)VFB#{(h7{o1WeY%=;&5h`1ZZwwgL~>kjDNlHQ$NvsF2}cl$={D_U&V
z*}v_CkK7m~M>19zB8bmM-{U+DmB+bOymzhAI>%e$c$o=jV}G@Hf_mDWOY;zUZ*+x9
z;Fq&^T7B@6S@<{AB1_vtCLd-UeeK-7o4_#A9GbTcxYe!I0pb7yyZ2guZ$+<ZR5K0V
z2+wS>N;I#9cX(+V*H4zf&lVdd(=m6Q+6E$amYT0=Tux^EGdK$s{bpVa75wtPI6d9O
zR_oFwnlPW=?e?*elE_H)J5RmCX1wwtUz?3jtoKVT{p9JTX-xIx?MiwpYJA-~LE*0+
zo#)M6`9fNx)#@Is#gL`N`4hX$+;JauV~@hV#(B3b&cZ(p{_5kV<#ulsXiq-0rYd;0
z-emvb_A$e}jMw*7m28~M{v(8`yPbaV>w&enafAkWVeWAHPkH0yX5Bi)!k!yva_<Q=
zrSFo*6W^EVP#+I3_g}UJQS2sBWzmlTrQCQ!hQq+R^w%#_;x&lcC@(zSByX5x*EnDW
zvTz@94DZwtj&YO}bO}Y0{sfJuWOvsruVL@}U;7k0p0qGQF!qPzLK^+ckeKQW%pZ0a
z$}p$UZ_RGS`{QK^4)t^Y`DHWh5{$&jb^D&j;m2guS$@9A-Z%4gS$`sykVywI{BU}A
zhpjC0qt$;Ap7`#aeRS$@++g&%lXaa>bCP#Lm)-Ee3E>h$?myKzhd`Vk57Ja-umZoc
zcMsU2zpsysbN^YMCVAn^w4mQy=reOPMTf3^q?cK9gMW7rT3yAT%*Om7Cu4h@APA{Y
zWI5xi;`z%5E1*F-Nzf3NQjDG@)0TCEcTeH?G)-fjdlI~{+w)=Y?Hyo~3ok{QTQ0h(
zZE3i7j@3_p*`vA=_xg}*WPaBS?!t7f*mW~=<|k>mzwz)i8$VS1SvCe_XM$$v>FzvS
z^mg9>G0LOz;T~<-N5$=7P;XKA^7BQM_u2V)XbZ|+!s6$|LtC>w;a?+#T?Q8|W8Qas
zjV?7jJ6~8Xv2I%y=fo6gZ5Q@!(-)r>kzcA_)HffwWX-!To?h@^9MndY`}rZZ^yp%&
z@t)@Fjc>nF?Wum^16M#|Q8Kjecft>Sthp+gC@ZR|a}^?V4XGDS0tZD~(L+pRX(9L)
zkzKKm_58!}TZ*6T@fyaj_K7&cCQ`HFg~)6Ordc7g^G(}ZVJ*0RL@{+5JI=56r7)JB
zI855t?MEZCHeElt_$c>a(b&o7+PJRW#$};DfVxC~iqof$Hp&1e$F22cN%@8kIWFdC
z#j?@0l~Iiy3f;Byh5qp=;~DYGXg?QZ`qWsHLoMH@%M?{h7_ZT3k+hJ;-O0$FtA%nW
z3_l!V2zi<(5`cn^ODo|ofTlVBlug1P0THQ50Ue$Gzh{)VNJtou|BHYY*#0|GKmvh7
zZQa9yBQLE@6Ed0^&pm>8jCm9hYW*6P_T~I5(*D(He5iAy&!9x3p=)?gdyAKL;{~}y
zS>k;v^0v5ye?e4RD78_aG>gj<p~Ls+`^$O$8R0!4^IHg?S9x!8LT^Jfb|%}rF#D+S
zW1Qw|(kuj)k|Eq{3kQ{3K{<<0N+k&to{K$)Eb74K!wqP+x<9YHI(~+0#7d`T{N&rH
z{ro%eaD!ihB>NgZ>_Rd@Gz!kTejM}KYWEJ#TVXHS1Yrd{Z*}$!kr~=<yj{fis1Hup
zpAnt<T~J?(Pr8ud;2Oc`Xul$8lEWJiD4OLD<F>{-IKp}kFbjkI>3n)wm=9jbE$us&
z#lc6y9bCBlHFo5e+?UMoJh~<qn70;RZngIBFKQYxVBi{kq5Bnp0;N1Os}kBiv7IT6
zZ+Ihfi-;aRT=Y$pa>!y>YPhJ?WJ^?5EPNpj<@C!ssHWUcsfKa7P*vIY9-z+b{5ayw
zTMuP7N8X4?l(Fda;IgP8$9@)P<4?9ksXibJG@?4=1hE$X+3JeUyr9L%l<sD(wWFZI
z5C~i#JCL^6&f*lZ&BU}?HMj=%)%V|hQNwFGjqyIpqABl5hIEx3YCHAd?7ky?y`thg
z+`%*)qseiU;4#{jG*VtpP1tM~M&q^nfL*mY5oi051Rvr-MYm^$fbj`IZh3mjmdl?_
z$D}H4*S5Y`)PmLAT#!`CvL_=$$*X|ycDHNwPo&K`mJkwmMC*l|hvb7H*-yXO$p=1z
z2Sg+#Z4~~;Pf?L8o3wZ(_s_?Fg!AI#(zU}(u|ssL%q%NELTC?p?mzS4)S!V6yu~*O
za37TY<aJ|Hj=KjW-H@VD{1|cNVLyKaP3+%7U%`S!LARGc*V27_g1h98i!1-Qicz4n
zC@A=kYZnn4JpfM>Jkdn0opV$)VJ750ubuDd=?OI3cJ|De4U>Opz29w(BGKP}5e610
zc#kyo;?<zrJtHBe56-tz!g>Y85UI~xmAVTH^Lq}4cHIthj9#U55Z%NeT0a;z!%*wl
zgg(=UbZL|qFJ3Tgp^tZNSzyRY6joQC)r<1a$)VssUJ|xPpj75TsrN<Whrh+CVWW~r
zj=17Jdq-Znjv=Cc{QXlr7xbwE_M24VqGmTeQR7>O0wMHo-n_947((z{oSM?*ciK>5
zWo6yk-Zmb~Q?9D2YKn-Ov1b|%!7dxaszR)-uBm}*7T5SoJdTJw0Md81|7!Ld$apNb
z_Yb-%tc#10VTe(TgnUBVY}&&Cm-2asbK`BH{j3BNPD56Od6nK*6<KNfjVf!n3||uy
z6U&nGuC6MF#2UB0I}K)LWg*Sh;NdBab#P)eG&Yimo(@abid=7HKfKqQVCzrf5O<v@
z))P7Vr|InK>RXtbyIwUhF)?}WTK2yS%FmwT#KH)|GMnX}G`v99=imRsOY}*K67dOU
z5ZxyYT5O?|X;O9RdWtTK@riuQzs;{Q-*V%tJG+@*Z4Yt$sA7+RelpXS$-=YG_eIX|
z!vZ6dhb({;KH@MnGosN!lA4+-eo`Lo6VcZP3l0w6+S{YlZVkf??_}oS*!)a$OS_rj
z=j+^`_@bNIZO%bAv9m9M?dms<@9^PYo}szFmlV0{&%yEr`)%}>O=EF>9rIIsJUmZV
zCc*tG*dJr3x58)<ZYl=vNQcC@Qx2+cPBK=puyV*$uxXKq))NBh@P=bh7I5pl7MMlp
zW5DQ<wJCxxOLhJIgv5vxm80bn@^I7oFw5-*pBs(#*)u_Kc5xY*p6*S2p-)OlNuQ=d
z2Z@i5SJT$+{Pg6hg{9^D-dG0kl5*pA)F`1H=9kT<8tGo}`it7Cs_)}7GuJ;wBVYXQ
zdUu$kUuD&-s+>+22Zbsynk+LRLG80hOL%6YU-siio9oqCkfTGRr0FRoI|@jJ|Mmt^
zunou@@MR;Y!vqgJCmZi`3kp8Y$dbI1;V&|AE!8dmw6U=<nvy~;5!XFaZAC^&`BxNd
z8z~u5YHG%0r3#-LS4&Gv-3n6-K0ZGBI0gJLl#|V&O`iiV8n;ECi-9d097Y)l+Q&_p
z^BiIpqbt*KmRMm!G5gviC%PFgbXEs0(%K@fimMLyNR)v{`z<0&N60!jU@Y5{c02T8
zPn@vkV$rTJiU%M-YiwE%PRCT4(p1JKCc29CDtkUu{u>{U8Tc?=ZAD@=S;~+ATbGw+
zd015RN(hpAetmtdTlwKxH>DF60|Ue9*;%>Mrb?9Pxh}lr2A<a($@hPAj2ly-%gz{O
zhxAXQCm$s<`YVUFe+Iqx-MRwBmCXqT3nBjX&8z&vLNofbSCnX)1oFMV-CyTwp*J7t
z5-QUg^9BSWd>Ba4&WtZCE-1*%&PL89BqAaLKVVM7%=AQV_9}D6wz<}pLv%LknacEQ
zqc%1^ye}s`a{q1*#WHalr~GWh;Q3e<J~HR_Wyj<n)8lp%ThAUbIK*k%Qx3RM`q=7W
zCo({z(nVYrrud^)jr6dWhG&KU9v*T^AJNy?n53X4n$Zv<Nyf=VjPOy&Zt+oeN`z??
z!eltHkY{Vi$jF|9p$R=3*D)N33DICZ*iwZRG&$xH&eqsuS60T!(@TB)$O0=U1dFxP
zi`@GEpRf@N`nAx;rReewW4)S#x!xH6*7Q~AO9%PVD8{6b>#z>aM%Vp~^`u$%^JyJY
zYL(H+R0w$_e$+SUiV?Xnd;b^Zb0^kZh(&L^Dn#%Y;ft`4P_Sl!7GsROn!dgwB<2VB
z_NXZA;E<5*-Q9k=5UD@R>}(>7O&&bE6D4%S;SONWd~3VVfAa>DD%<IQr5*ZDoj6QJ
zD*M{&mkpWRll4n2KCeojh#3^?*}TTaXgC~^z5l#~j*C;dvrU3r4y8N69g8l|W;RB<
z=rx(!yvwA)xX2CC<QVIYB6XOIzrByo-E3h|k!ob;`+oL*OuN~dNH9SgLm8^v$uctX
zKgR?c<=_h4<$i=Sl9b)Oco=Qr94+#ingnb*rE9%R86vqwMZ4UmS?yf^LrWpNl-(@R
zf$e#5n#O`t{1G#3O<|6wbE=fr&^LyL!Z~AP4UIS32hpog&n!MHj=zagESy;KSZ27h
z&*OUE&%Q2IQBY7I<K$F`Cj0QuKArCC&dyG7US8hNtLzbiD8UU<Vh)49bM;ObA?;Y$
z*cxx&Dygf-?CKhAPE@-e&WblV9USP&Q!mtq9xi>x866&OTTe0^d?qk=H~^;Cu(qb=
zoDf^+|LR3Px*X&=UWj!UVimdNP`dUi#bEQv!U8lct=a!ad_XtF6~QmY80)S-SgG;x
zM7v@Me|VL<&pJ|+kT6!`q(BSWNl8t$v$VFhuDe_bFDNYqMS+`}TZ%i`bhRt;yYr}m
z*6Y_RQ0zvxgTXklCi62z+OKvJ7ds@d=X7**U=If;u<2BIUmfrK%<#Q_wKV!i5)EL2
z$I`0?8?P&^>>&6UKZ@Uz|C@4BUM!`|hU#*Ura^_#WMpDO+0CuB=tclE60G(%&eQsq
ziRa={&yo8bd)^Q?&->^mMnbV=Wx4ttz8@=iiUr+&yO5_x>HybU_Fc@!v)wG|-78*l
zv&qtTpftoNF=7Nskp};M%F%@2|1kv&Y?RgRx1LY~3nh-K1na3^0brRfJltO(7u$aP
zNVYmb@gKOr{s@I?f6%4)6%x#zBq8$Yu;(+Sf_ukunisWhn9P@&nwPI$aeL5bhP^+X
zqr*R#tFTsT|6zR2j-^@T35m(K(VH+WdBQ>;E$`yu^4XYFaY%6U`<&-9j`W03PEJn$
zRVX0|$u721oU@Q<>5(^t?pmf}nZduC#_#*bu{?*{qi(jPl|KP!|G^t+3Tz@{&F(B%
z$5`l;pk1L<>>;}BX5_}ff~dUCBm$(50b6y3(`Phzn+~6cDQ&8zuDrszO?I}Nh4o7>
z{YysPInxFf4SoF^xIBFp@yoaJBGhi8J<hBzUgWm6()3p}osq9Lth1I_I%U`l;rGZG
z=-b%XoSvT_m%24ST{^%-qyE1k37sMW<y+1=IJhEoDl{U2Uq&m6v*}o=D=RxYV|n?s
zZZzm;-b@_td%YSC{HCQT{t;a)BMmLxH3E4kA*O8jmoI~Y@VZq5o9IL0TMrF6NK6kM
zt`Qbq$9paq43?jt|D&+*i#&aW-1vmMDbnGb)6mGje=;5(SD(NFkGn(0`H!@O@LJ2k
zl*c+80t4=2zGL>s@!ys<Q^!ozd{xSuZr1nGjf7DItIkYS?zb1&=`UOp^mev?>CCdk
z*VcXRO%L|XFT(uC%aCV`^B4^wiS;oxMVYM$lY!K8i{pLEOP0f5w*R)XW7*f&cb-2(
zt~y@ru=>h+b|Zpk5JC4H^zc9AX}Ub6Qt*)+v|K|&%rUHGXkAC9_YUiv)pKf9yy%~5
ztnr$9kuZ`g%fc{g8gOyv%pU$f|FB}R<T5HEsb9*|lSlG@K?fL*4is<&ngtJ`w5|%k
zAnQ5zeP^F=27{&lqqsOimz}>9(FfuMpe*|S{yw{53+0j>D4JOdqW|%>w&%}gYr>zk
zx8a4{-{WCPug3(*QA31=SK8V*x2vjEM?2HO*B|A7<@{cSpcAwXl`&Coui5X7mvB^I
z(cUS@6KVH&9tJ?JnVu<kvI8=sR0~C=9AU7rn!36qlyYH}_3Y2?+3qBd)dV{zrECFC
zx5zk;bWxf((X3M{I8g!>jptjQ9BnKeb~m0z0oIW_Io`RRa<yu@?sG7cf^-e5P#HRP
zf^UCAn-<b(GS!&1h)2AljPzcoWA>}k*4V`LnjZht=5*zVpL^y#`pUuK$Us}?eiv*?
z?qsZR;ulEJnO&a$6}5`G`|Djg$b0fk+$a+Qn!iS*eeam_!{`$#<QaKPE7Pfr7T-Bv
z$O@^$<mtKVxdZ_mB9|m9{18j6c@+g?(Z-K_HBb7^HT`sXak4#50wHU};-%l77*i}$
zGeThdGDdS{mtvUACugC7?}APU#Gc4Fud~nq-}ovkl=kvzNc&Qu`6;8u*WM}J#LsnJ
zldMEi1xGruUYkq%N$GY>Q~Gym@?7yf8)PGNG3Y%xHdedQ)umFIY6=bx4udsZ{MOC<
zIr@pRtO-axL0m_1vd<kZcM)VDc&}c)>XN5U7y9dmJ-oQ6DlLuN2C)O=@{!p{6GJpW
zPh`iFbbLO2rmpJfCGhE>h?iUaP7NJ(HF=KrAQWJ}SDB1fI)DD8%}Pt8kIeZgfzF1s
zy}$pYM^l&xKO{rq)`vW}T!(|*Z>HHxfak+s1l=v!t!IF7f^uB(i@it$KWu6Rn)jnU
zAyCTmb4#-#Nzf!3W10+vbNHvWY&xDOWf<*>(nQM^5)`h^-oLZ8yF2zoj40ksl$Tcq
zlv;cHufKmwg8M)ZlG4)F9+{t4W{e|C62TnTyPwkW<#^e;wycVbj0|d?Ny>);Grh>R
z^Zzl19w`=W;z+Q&M%2e%^gk!&yIa4XiOZ^BEvAVK-l8ETOY5Ktv7hR2Fs+E#isDcZ
zN?S;frw16di!<VTT6^Qe(h@BIs8zMKCVIp^K0ct5kW)}>Z*PNdZ#oa^r3(*}Z_ijc
zf@Z3P0@C2==}C<DzhY(vjnag_NR&3R=Tsa;k4)Y=;lksJ*!e<uB@>HtR83N$_gw7T
zK*CJaDm>gaiF!&iGGKr?V5&gNQqIFeP*hYjJ|STpYmqu2M}y_V;P>7Jm)#yyZqRYm
zb#&x>d_;FA%g{(oE)HjI7|6;NeYB0uD)rd=v-0wS)6>&E{}1p4E<;uH=*c_r&?GNs
z#LJ9~XiJ{@EXy`oJ$M)-yRFwv!q)YukEL2Q?OzW6(@H5~TB&1e%XP1yCQyd(FLkUQ
z?St7gx`5BeCnZH&$(I!r^iE6H*ewpObcXkua)TDVA=Tn#StxauFd41WQr25hg)GfW
z{zP8te@L)O9Sr`d?-o*JD(u_5R;(&6LE0_>LXGt_%$pOjO<j(ogZD3&jnN)8#P^bE
z@fTT_!(Ntx=c{maq;ib{Eh!mPFHcWafT%KfJa4+W06x&xCIS-;<^y0)PUX1ZU{vq`
z^EFsddb^Jq*25XmTv#fh$dW!Xzwd_re>DsXPyNXKtrTm=`Tnd^VX*^4<ZbbY*f6!6
z_ILvNpVG8_lbJe!lSQ{VC;yLQKQ#&2USZlf`{Uy2vzTRubs({KJGi>Ix#^I?kzfx{
znZPt*H*UXs?{v={7QhlMtgNy@CDp6^@W`{igoi8SYIyL|v_9qd)y)aN&rW*V``MHm
z1MyKMTT%<LnZ2-`JKV7m6>X+;+dJ}<{z<7xSX^_Cr?^a9lfAj}E@l-cW{#^&e6hZD
zu7=8Y?3!YhGt!IkNc{!vE|uJ?SN9E0n}f2wrubvL-K3*&z4T8>UalQ=(=f&L{xa()
ze#Cg7n6Iy|lLkxb=;)~IqnKdOQ(_-fUSsyio=}mKfBHW%y*i<9H-ERS>UT|Zzl$b*
zZK<Hpd#cO6;U=r?VMX1+<!DKMR8uoxNWhiOGzxVA%FIz^v>OBhwgD?4<{gV@?EMbC
znB_!<kgzaKx`5pRnxV%!(Q1Bn)O%CYjz&NDH+lN}qN41gqHro<*WvN;AdN4w;l$;x
z`)~48Gk`m)Gl;sv^wl03QQN=Tl3xaz(;-uPdpiQg|G{Bs%Sqb7?N5yzv?N2{tJ|2E
zm>&3iqvFl=b>ZrfyNgg-X$5=HacC{oQN4wF&igmok&YeD(+1T5uys);Vn$~{Cwopq
z0EOe#98CR|XH{l@EyGSsm!?oOkSg%t;x&8T{j5EdBACl4<%1tD`92#P+iq!T>B2QY
zzpl#1CZ20Ch!wr26-=oEVzs_^*SU&`?1-e<eSprAgp+XOWoLtV?FG26ErN^(ti|hV
zPcRZ6t*vufTQl56(yjD0G^D_o)~z9$jO#3TxVZ2E2DbHVEeVkV`B4;YdyX?wxxtug
zUd8=`I3HPqX9uV{`RrvD*4AnOA}BFRGsb1s)di-c6pA_*;?Qm5y&5HhEOQ1M<A)QK
zU*>oAgFVuIcxdlsXLoP{c+bshKS%2=_b^%q&Yu%KSOHcxeQa3wDo$!%eHEC6(NT?q
zesMY4WTjxRTGu1C^=oa-z~*Mo)opU;YHn_xsu`&IIQEU-=8b^`VXLt(<j>(IOD+&U
z%uP)LaeTI<=X`JW1*(B;R49e4{wR@A0vjtK(+!Conbkj~E3Ydqk+S)6r?Z<KV|*y3
z*Pa`6qd%NjS?X@>3>j##WgLWpX=0rWow_y3-KDPFbjg_w4cAo4%E}3mk&$Em%UZ1C
zaVkHBE2j5e=KkvkKp&^;efcI3K33M~MfJJV_H#jhclxI;cX!xB7hSAd{{9K524DL$
z|6djW*`z7|%a<<z>MaGJQPbjw+0Qw2JHYEVH_l;xN1Y^2U5<XxxT7e7G~p;|S=lE{
z>F$t3Gj&75p%=Ate>MhETdCw}f#~oJUkxVfpP%|3&Q+Cd)6E8e!kkdN{NMR`0&K8)
zqO-D?lbwSzO=FdWJ|_%pU>(jd@U6ipxIXX=A_bgBsl*;Z-_1AfZ$4blJy_44&+r5r
z)4wi#tLJyz%fwLt9xQBZMeH0L;+gsR7P-cxlT$VG4nX&)j*f`1hUIFMKpYntlHPJV
z`bU3r&?F~ypkzu=`AIWh^-;6G!mJ-Xq+L)S-2z{MF^-p?Uqe$<+RlyxbOiH-CXc^q
z!b!<I=G-<jyg<k}-?3R2rzva7%nT?keW^5-Q(hk9G$<GXZX$#5zgvaotHFp6{cy0t
zdu+<GGtl2$lg0sPx|8@)_?~Wjd|Zy>P17)EJ0qwlyo0tmb#>q5d0|lN4dM<nZZhs|
zth>8A>%|u2aw<=^3nBd)n`(pky6xyxep^q>l0x!0P!I`p-nnSY0=A4XVsV;d!7Ef-
zQE@!Ava<3Kthv<HqsuaWo0-$<-O|QE@&|?U%LpQggd{)_Hw5_jd>ZTP>$iY<V-A`Z
z2QP+&+gxWjiPMni42w0;3cZ(*X@2D71U57XrTd)gy?W)$oY<^Dy}C{o{CoRn#vmy8
zV5Cj1j@Lyl=A68D^%t)d|JRzB)nHVJZ<q5(?E^!t#lE(PU5`Zbn^jJ)hJ=K$jcq%t
zvnH_Cu(Kr&d<d_YwvMrx<pMzXeYvitnRe$Nd0uW&{IJ5pK1`x08LgM!(P&qU^!aOS
z6djoryg8%Rr;;-})XazA={mCX)R;jU!Nyo2Qki(|oZwlG(wI_mo*;gh%uM#kR=eM2
zJI!^|(cNXYc)Grp*6CGjY^)|L8yktMtLyzbVBlh#4ZEdI=O=c=X7LiN0eyl_8%?#v
z#e1vf-yKk&J$v@ZIMvO-M8)))x&vYd*gb&p-zx`&!qu2%Oibv8L@y}8B$+@?;7>FE
zg2kJc$B2rCwhf1GT&_l&11ZP*z-#fw>Bk>TP?K_grxh%sc_THS75t>T+75{AF4Qi9
z<eKFU3Gn{q&XVQAl?(G<{UJlS4vng9kPgf4N6?p%f@I0a2(GvzW}fCyXd`H-8$7Sv
zF~<-JyarBDT2WK4j~-htN)U4{%GY#wx|*Tk1HomDYxC)-Vl7fe(+#{avZkhnZFgs<
zMZ|8Qi34GAF2kHCrb@#S<xpd%deY!#K1()S#dD|NXX4*)T%YCXV`tGi4q~c}ej{xR
zruAEuHFup1i4TF|1qEvIqpAmV)74HALsP)gO{^t@4vVV6nCks93Lpte(q#`eCT%*O
zu|f#@uN88B#Km)9YD0b1Yl2dDEO8Uj`TiikIG<O?@Z60-IxMhk7CDf7^KTMfm<-Dc
zwvn4C^OIHiF!Vq|!}{YH9zb}Z=Iz1Hs35WDGk#z_{yJy^5eYzF5;Vqe>;vf}Fl|=D
z5Mn?N^e(HfznWDQJ<}Q~_?iC2Ob^I=O|QyYu31ku2HJU*Yiwq_G*v|()!Wd{_m5Y|
z{<iL`1#jQRz)jaGD3gzy-N0ZFRQX38r=YO#{oVE1oZrJ8!vE}vxF|V)ej_0@WN#fA
zA?&J3d#Lx30-Fl6=W>0LJYz7ERRjUVG!VLeN-*7U#W&;T8pTp(SG@XdHPN)Ou~8iB
zR*5A6DY*5b`CtG@lJ%fYZU1!_X`!fFm4I_V=w4#{97e%cp~n{nn^x6zZ|W$_Jl!LB
zHCmi{jJNq0M9>;YU|=iu^*QHU>9V74Q9YfVnaM9HF}pt9ww|ktDJ?xpssI9KIhZ(5
zV}LfARZ<c;Yu74@O<Jy7Z0ha~#qiDro<~3%>LWc-_^eS#e)(ef$t~NVoKb1$DYd*`
z#`V9SS)V_DM$TwH9xG3pXx8|Z(fzx9#e_JvH)r~nuaoT<1J0-R(`3HeO&jq!KEL~0
zrb6&2DlD`t0)iV*0<^f3y*(`~ws?}>I`#%5H@8|nEin40{sW8I#@5zX6$k>kfI0K1
z3h(nOjhR|lFq2et@G57GFz4px^78SG%*{oFE{Ka#Vk57epMqKpw2aZQvClTMf$hfN
zwnATJn^x-e_4kvJldsG!-n-V6l^yK283ufmXsWKRCi#@G_1I$QnRCg91CIy~xdh~w
z(6Hl05Uy`-7P*Ry6XO*0J!y^w(1qRhR(fRRzE)SnCq~Slo4Afy%jAd=ho`}zD&~fU
zhUTE}&wxt4c%DsjxAg?Cw<-OmvF0lw?yI3ORNNV`oSFfCcYk(yOLKo1QW&QymJB)r
zK4y^Pt|<7f>8g(el^+JASURJqg!7Awa|#PtYc~Mf;;hx_0ei`@%VikPQ&CZIduL~*
zX4W<?ARu78q@*OePFnG@o9sWHV;~T(A(z#=ngofhbPMgdEBk5K&Up_%<xzRDGc_G^
z^XdFd`N0ThWXnS9?A9l*E9v#=2Mu7t(0-{HJ?3)JXrF0O(|98@g%!=RI6vP0MN_r!
zeuu>E!FzwEx>e>NdYQpQoW==)#RH@Eq%r&o@R<uB^iBf<0~znYwXbAlLBPiD{ZL7d
zj{)j**~b)FIT|15a${0Z7dJ{?p}hzK)cgC-gxYhk!88g8{ccxjJhn1JTz`&jbAYOI
z|2_*5^*=5=`6TzBW7W*gqRd)e?~dDgU&07jHf|icoT@f6zn+ctFa>6=;Z~2C<7%Ms
zN1BzeZ!1|!^)jZxc#4b}KR5Ss6;|G-BfkFb>F7St9-aR5Hey6=Pw!N!ZStAUCyK5F
zu_o&_up(xzR>C=a!QL%w$;<ojQB_qHIBdUVAV)Aaw~LKj#Ux)_P)!a*jyeb&C__xS
z6$}k&AVO7lDSTE_4K8d?iP?=d{w9M323RK*6;<)OM%T8QeTsmCD&XBYB=|hGx2B-w
zVALz#Lk`IMgOYpb{v!6=liRpZ%C95t5J2Txoqpq;Q1#bLHQ9`PJ1#7QjV2qfAcr};
zIiL#u$mu4@Q`U6bcX?6vGP9;8F|te~_{FE%f&_G#EaRwmErCFGvG0l?`=FyUiOY#j
zFKgO5;k$=X%Gytd`$A}&3hM>!?BZf;b!+PbUu{EerLn7#(NbxNer-!7*z2{;`!?3|
z4G9*!Fa-q+fGMh~tIHi$yZq+r98Bnbp;N6EJ)Odso1U2w`o*#O^ihzjWuD`s5Jzh9
z^<O)xZQF0_gp3MJukt9b9t=Wvt03L3(3?G;E{mMwb3Pq{wS$7cqBa)!8NdG4*nqh>
zwn#4fVx#~4CaSVT22#EUP@%4Ha>sH=C{~d=UeB!Xe4MM&aV`NxkL`4YnGFCbhQ2qm
zi|G}fXO_e--pKH$=H};z1_U4)c&sN79^L^z^3LGJf!u$i?Bam+i>QY=7mkt=fD_(x
z-pr>3^TDq}w7`oIS3Pe7fR7Bgxjt?uO@gpYM#gA|zm#Zi64@3tlgmmpz7VJiJ-=?F
zp}zhV>TS33Gnvr+zTX$Am(!B&D2HH{Z5A+oA^?~KfYm5BCcJp1LQYOTRqw<EfD8`g
zczsfl8X<tf&L6=}z0R=O?MJI=D>6IEdoN8{mfRLhZ%X%{p-uLjU9MN_Ng;qT30cpU
zqJ9tK513Ki3&%P1b=iTcFjHbbEH8K+ysK~hEQnj@(Agvri`Ru8`m?JKA=#`yG2!ob
z!4uS__qE|vZ31uf^;^YRRx$pY6707=*R9A-0cBr$2yA`n4t<vFWKAtT)jVHnY!miB
zkulx<O??1>L!No%H2%R1O{A;eGF0e$*ebM77$-;yl%Njb#YHi?82N+div=&ESKp8W
zHCQ7UW2BG}GpJBV@nQ%i6cxj3({ma@H*l#Z-Hc>-6zLX()L_jN%@X^nZK@-Ihh9}E
z$I5sfHlJMaYVYwZdQB?a)}H>NvCr*B_e=}TkU%N<0}JojeXYL#Ea2JWQbLH=U}#eY
z5!DRY9BGy_>LtICxB;f~;hKLXB#48!F$#+@9Buc%=QFvU<-F@vyZVCth09OmKl43A
zFkXZ4P_@l!E1^RG;eaG24gS(S0WvBkIs38g!2ewvn(SJei##H>@c&*eK8W0c!j2zf
zo2$iSAFZ(?g*V-sAEHVfuTdFr6VQr4BaW-Hh!7%xgz<kD_JHsm)w}22auX@3J%(x1
zb@*_m!o9vs%PA^0UmM|niV9`0y$y8+QX+ytSWhK<CX%RaM^u3TRuJdE_(SLC;%zV%
zv@Krd5y&kac9gWGwH3AbzzR4*du(6@P|xTn_z^iv?gGXw{$+gV+*NQSKX~=yN~Zi^
z-|Xm%W-ZaUS&A^hmdgz}t`x1h!9Aqe8sBR5kVd5d!Ir8E*2lKRYEObf4mlQYvpijC
zBRqV%bOc^W=&9V(h<uFxs|?-x@$(qfVDn$@nMIH;8E4MUL$;X9ALt=vD#LKpCGI6E
z$ngpV?;Ju1A`;PSfAA|_qkAcM1=SYW0A-~u*<W;Fg<EI*jHYe6jRjJ%|BS-kza1$6
z6GV$xuyVD+G<Nj2v{&S^$JKOxwCl|=LZ&f#=)Np;n+V!lN>C$WqdZD2oU+ReJHFU;
zhB6aKvJyBcgua*&yPtM#A!ou>0u#xSZ;KGnzDNWS(Y6r=QYhIm3Kd_oAwV26HFhYC
zsO>XJ!m5AFJ3AkCP_@ZIxLIb)sI9$0StuopIhh+~^9ovxz<gI@vzex<wE-Rc)^N|=
z?NE`dw6SdGv#U>qc1{>VgG2|MSxt0UfhzJ)=7rlOw@?LqXoT%=H~c1L(G^>Ww>P_O
zU6X;gx1@H#vruDaIZse|T9-X>cC39iTlMhc*4*}Ayfz11he{dTz&U58PjuKnUiIVR
zE>_P@2@id!5P7(LiZ@#$Zoe8SaKA`#xK;KP)S7VrxM8mlcdyWIZS9~_6L_xe<NUY4
z3WB`+mD|8_eFieDV(0+qof+dza~seJIQP;72+OV&3fR__(ZC9ZzI#k;ZvcV%kMB0(
z=^DK8@Lgn*__>M49~_ILvwdo;G1KKNx~p{#cmp-m6eA}$*Nn?vnVq=tF#~}GXoxyc
z_JM8zYQ4+u#JoN5VVl??4^M8f>M-jNw$N;CZEWt=TNc<Jw{sqPyoPog*3!GSR+d}?
z!Wh1~7{`DXjF}RIHzQsdi^r(X+(vOR3+mU2h%7DKLj!(8{XE?pQ)&7Xp2N0Ze2|9O
zDHIWUm@V1puraUOs_c$Cog5v{4cx_RP&&vwDTg5Y>*j>c%)9}$&##@@7suk`$7ED`
zP|3zxnkWDeEcIQyS@@{}T}F}0#7$O0ovq=*`V2Ixqx6fWkf^9ASulpRk3PIW>)pPc
z4%2sgB;b<FxlF!m1s^3?Q(f(nv6Arwz=t+Mf2+nzF8j2{XuBmMTpL!6#FQmn5*=2!
zYfF3Pv_$jM(gGi^uRSj;wB2df)oC-D#(3i|E^R2Y%=hn>u&2z~g@u2z^$WGN2@}JL
zjy0GA&(Dotx*sTbuN_1|5-6WjMj53r*4P}xQEeDyf>9T<_hKg&ZUoXJkf1n$Y|@G?
z@8oo%Q(Cuz32sfE9v>*jK%bP))c{}trl<(ed}c*OEL&;ar~7+fZEbB?5$d0y!2?2R
zzh6D+n+NhXA>f9+w8H)?HcCX^h*YsY@+@b{Ra9$OKc3Wih?szs;rr9`Y8w2Q#g>@Q
zX-c8;Va6%Ct||BTgiagroPNGf>M_J?<%Db(ELvv8IP98k%l8AVUB9+05Ed*G`uHHn
z#}k{R7z3zw8tHC3sSdGgoB`Br5y7|Bdb;AO=ygdJp!3Vi%RQo?&-wWIi39CV5CH(4
zN1))c`x-d@C+9IbFd&0>kI2y|11bF7yLaHdLC43Ai5!N5$>!-~K;9a7v9&ls?a+qe
z2+|8fp)!#3r6r@|M15Pb)qSqcA1!Akb}xuyVw-iSp7xW^3v#Cpz{|axgr=>DyB&h<
z8n*LD7!EDbImOaZd=Z>86_#0-s0B=WNttuSkiDPivOxSi+FyC#(n31(KF0RuZS7Jp
z65_M>r|@PCZ!R&>BedgQ-^hg$b$-*++1(%u4ZZ$D(xT=F_9`Pz*U5EF(Tll*x1-yq
zaz9lw#2%UteC$*jm|0ks>1eLxZCfvaRFm#|{Sky>AX3bPeRQ~Z#(>D~%~Xd2kumY*
zyDv7gra*j2#v(Cre;zGz+;jD~_x1Jl4QIx5FTy2CTdsG=GS#-|mhCTB%XO{OZDtE|
za_F7GH0LRg-CFUd-j!%rMjDe^l{LZ}6lUx0j8=de{0{Rrv$(ie1gOR1Yz!CK&VHd$
zHaEWcEi_hx;nIxv#&k2eYJtu|CXZm~F5_lybFlGhBQ-<ZU6s;^RZ8Ywhh>}<qL=&c
zt<lfWh`TqSus?i?`s}i?jGH1O^CjYI0G*Vf-50eU#?<Prhm1bDFC!+t2FA^Qyb%e5
z5szeom4y1wCtXKH?D%0USna=n$}7mZjgl45J-ncCe>d2C=D7kLOqQeepdYb_PcrZf
z15$=eU}olXNX(;sDRQ+I2gb!_SKachT!0#L;3{-)u0F1%MGTA?OjQ*pmEY$5{p}TS
zae#7aZMQmaj&#+h)8eSXOMbWN&`m{>Chq53Ral5Q+%gK3=n*&^9_O|<RbEw6vR?>3
zxgHpV8I|n)bn!n+!N5s7vi((Kb{_wtsZ#1YI~#=_dBt;cf9PSx&1hci7ZUNJcc{-U
zGkztEDgFETp|sz%ko~<Fws@O9`b&@RNZ!=VGa@+fH7DUW)h@b$jE^5q2LeEO#-z|F
zWj{a6T$KKbr#a{e!e|fOlo1Tr%D7h@nz}=hET65rAe3CmZXJ~S$qd-#y6ma2+&+JW
zcQ`A-iAQrb*%nA#BPdx2<u*5=WIP`@MMRYNQyD0+dEDS{C&~;}Srb-*NDSI4ibakO
zqwd$BDp4|ES9$D}cSE;x;vB6EZ>@~Z1AQQ0txD@RJ^?+-@Es`QBimy?+4?Jh2?dS%
z913dD+1VK{@aI&-uGZv1Yy$|%{a~yd_DbJ1ws7+D5;nsdb|<E5d`zH}_ZdLkgFl-+
z^(j-M)E3U>=lw=%1m#nb>*nk`>ruP6EKLfjTOcc~lpFMFKijnz6%(<GR_DN($Bt+2
zcoF_8;(L*if;x*FsOnqGA=Cz^!J;?%ghe`KVr1^!yIb$)sQ^emFpd0)3oAfB%-G79
zVv?o5$lWc>?#j=J*WhyQm}lhmh-h5w)@ldDwvWAk)RI&#6eo{`jmUbomkuNMRzr*s
zM*Fp_FQu-fG)XB>o<0~u&f0p`cs7wAq}YB@r2=OJgfEXjAJ$Pj5OT2wU5@L<4txj^
z-G1-x{!In~ycQA|3(!O)LFynT<RMuU|7h-qC>UYLpD|VO0X_4ypwM6T%Tnon_gDP^
z=I6Xi&G<dqI`6c#-@d&K2a=0VIpE);+v@sheroqQ@$Ui00{EM!34~k@L0~H_Ev<jD
z%<v&j2IA1qH~IGDLSW9m-3RTMB;6T3H}B(nVZHlfUEv4c-S&T4A!kWpNDe5H>nOn^
zKy?}wm#3t3ph9TophR)tO%Ba&RD(}yxVfdM`knI*iWDKTS((Va$clkj&kE8CEBX7h
z=Yri;{4oW`2hio{gv3OoD=WlX!`#&bU^9ZG>ph!OFGG^|3X}L%Z#0vaH;jd#x#5=j
z2TC*7KQph7n%Hw8_hD%)kfUDe$<!b%R&4{Vx2DL!bl72;SVZfXvoEzIuNc0Tk9N8r
zxbrIZm|CNv5dgv-Baam~VA*Kq5*dky$z^U!7i_#V^_ay01m7&~>N~7}GyCa%)0&P+
zfj!jvL*?}H;GhcF`=FT#9s>&o@HDB+ku9yDQM9j>A(y@F!fz5g>7qsc{7vT3Yxd+b
zydF(@Y4!2r)loVz6+A)W&+;J&35S98YaN}<o^}&~gE_xvZ*Gs6atV3N2XitrGwXmt
zeF?O>>+#1CPp7c0TfX<Xy`koHM{Tec8i2!5!if_(y<GJI0&I?(MJ7siv$E-atBEMs
z+0mSk{O#oZqnmh^*MLqvsN3x6(hLUlv2>O{c}kq`Lo{{={OrFO;^Nm=Lw@%+U^!E_
ztVRj@^7Xch;OyIs(|aBqCxF9o{U`=numZ9+8h;xLodp)W6jO0EV*d8TP*TXJgz=Lw
zMqF`8=$axGK|$WJf|)yX06y<?de-UW5|7kAteI^l2wnMQC5OiIVdA|ozpSh*k`imc
zk6wtBSeQ(}VUx#+N>P43RGbo<gN1{GgB$BJsFxpx(g%Qx7$YBO&ELPYwDhgsLxgC;
zeJwM-uY|1r;r^z6D=Yl+FhsoA7c7tmIYq_((TR!IR!x!zF%qS%_t&Fp%%`frFbi`}
zmkC;laWi1%zB1M$-gYMMcE~R%Fz)<9RNhVPwf9ikd_F^Dcr!D(p!K;tl+fy~P&#@@
zLLeFLfAzkig&)fXmz{+zFQ=FkPlV<qOJI}3!QEuMP&*e$2Y%OWXku!QA~5hqF7$?W
zLo|T*gV}O_Rwnn@0fjm0*JA&v`X0wA#O2AZxxos|1Dr<Ky2XPQ2raP!>bg#E0>lw@
zdI&L;E5w11C1;{O>mciEbAxU?OKlvX5_Lt8`#xSi{=iRt6X#j(*3OQZ1@rnsx6$dU
zj~11U9zSMhL~`{vV^P(PFIg}dM&+P&SXw&DO0KS%*?O_Z$%apMU7h<qnfdqM;9eDN
zY+gjI4v&od2H-lhvnoyhF(OC+qxB_>4Vmnsiv>%0qC~&@3lW?9>4;nsfHdoxZFNu8
zE=VH<QU}tt_4Tcu;o$Iaa(*>oxyW?-d`i>(IpYps1kf|s-&Ezxv$)Ks!yiy3!sP#<
zlZ8T0FFa6%!matm&A6wVtolI^W7f@iE<4i3imF5<X!Cl8m&nJ5Wwd~|%w}3;qVIhQ
zYK;vA0AOF5di|2xF~Ku#pkeB(0wrpCGtJGQM?cw%7WXku0u<f#8LP5L(qM;4;8Hm*
z(BoV=E)~HFAb4biF*wAp)nG3qXQklyG0{{}Ylt9>qeqXA=TL>MJ1d6Ljc2WIC>*r}
zUAyn5?0y=NziTmmZE-g^C{|;$Yvc}<W;Qh<WehgP#Uu-qx_)bzs+-7I`ujI@IwA-}
zeIV-X4&On%Na>j2D}dnJr(l@pbqx*09~2F*@qro*-uVl}b!TR0A5}|`viw`14P5iN
zge%shrd>7W_$17J%-KMx=V0-10UP9TAtRL90b;<n&~_nDo2h284)(+szq?&Sr;`Bz
zr}YG#<LWY>N0mA)gxZtY{3}_s%x#YPw<IOTf}$eLsMX@zJ#+D!JRgTe*I63|NETMR
zgtf7e5oxY<6761-=`42Qdc<>7Wy+`<>4__YJM}-fG%;H=6~^dc?!gx9Fdq{tm_z|C
zj0I?dLZqk-wd`QnTNkFL+(#d7{2n+`20nBb_fH$T(~nL~^^mk)b}|n)SdJHt_L98_
zm1jD%S?W9LOVId<Xyxxm5W}H5;e(?dFH46<>EKv;l!8t#M|{177jh|Y8gD^~HoDDj
zWApCxobhceCl}TjLyR}%XwXJ~v9^vmPuqMZ)E6jvdwJ-%X`)`|A;7y!ec8CjEfWah
zQedG0rxdsk!^611bgf7KlMaG~S)|eQU38>nQL9jq`^!~c0f9>QqZN%M6M|>nAQm|S
z;&8ZMUS<EAm^l6e5)r`rpP8B20@f2i;>)1tao~s?B0M@&z)^p+qq=!iJei%JEB+kQ
z($Ucb`BWFmP3tbap+$6%ALDl04>1lOP=hGSCii)`Uv|TVBqL0I^$Uy=k#CBeB`mg?
z>+vT?1aY%hyiOcEx82z>r$ryp<xLGU?;E}mLivXBEw6qLXyq1v9lnb&eVq)~V(pw=
zIOmt4*8mSpEalgWkYl!7Ei>a5jU6Osgr-)Km<*MPJ8bPxc@JJ<?S<~b&HPmz_siyj
zD!1|cz9~(^&Q%3ZPgFcSEE8uNgF&lN*%nb9ul|S}YZy%NwBg0<bK>yis8yvtx%5Vh
z;SM=S-p9m__vN)5?;7HP1`0wDaKV7Ly0P}qJ+Y^cl667Z?T`la!P6BtTBPaZPZh`p
zst9dA9^!D{&P{p^qWj(@)zy5e<GjxUyw}+bKZ4P%2K`S<ON-NPL1a+;!5d@=L15bq
zsL0=a&ZnVK?FW7jUhu|)mbo9`go7Y($OOSu32uBd0apJEX;_CS$&#|uwhQG?c1r#i
zcw7kFWKZ#Ieo#=+UD}Xb%jsEA^okFamGuV)Yk(`ni^hpjilT-5Ew1Ex7FU=8(~{q&
zG3WijB(GEx0DpngUlH29+OZn9`GXKMh?zyuUBwB)z0?X0A!2%?*|29+WGbAaC7LA!
zwd2tV_|?UB=KoA6-Mo8<MBN=XtFalI6aZ+_mEpFWp374(Q7ayQ<%oC0B4)N#nVwwT
z)~LVNUlK6@7-8v!@r7@}S$|u;`U~%1<Kfxaa5KH18bh-GFAE@eBj@12b>!|HAvy!n
zT)fLAa~F+AJDX$-v2%ul)oEa0fW!*j{O<G(#ClIav_ut+`UuBY3P~N7Cg63x2Luff
z0%}syAAlrJSDI_Se%*y9NBR5q>cq(qSzy7PPUo$|6IHP*dR6f|UJ$>?uC7i1=0iLn
zq97zDc-%wxIM#Y~_QtmU)7Gz9a<7?IUr?e~1-$$a235x^@zh{l198}**LQ{j1dZsH
z3hh~qjTs<@Zau4+${df0hZ*VVP9G8+_6h<Bfx7zN<l?ea1e1~Raak{~n_V~)h`EDK
zq53EE{27degLtCR^h*fiv}%0!`|{y@6!0eU&Cii@)jEj-Z%)s<%Gp!ZdZy%7dRkxi
z88gQKPcG~2TBtnqlX3ozf@ce$Xd)1dq=ba#B9IXP`BZR1$7z=r0T>nFAWTOEyOO5r
z;;I53Na&97aw*3FdS#}E_3YU?URVb7cE4E!ZyC7N8~-#_*FlnX>G7aRyblBJ81Ev$
zQr}}kXnel`t7>e1KJ7#>ozIF`$H0RDq(16HQhCg=!IRs8#oK3K{udSoAH7_V#rSAv
zXAXSa#}h0bCm#kyFWwIEuocGdq~(y5FM=~1W-<1pL+$Mj`=p$&3rQ96vp0iWxXHrd
zwnKcwC#@6jD<9-6&8kB}KJGjTsxcvW@dX^J2taYfRR;kfkE;MDXZ}<(3k!>gz9pkJ
zZHHTm!{<v_c+)1<S?$lFR^w$M#$%5GcS#wFj_#YUC$vcI?Q|WhGwqgsTCaoXAy9h!
zM2g=!s#VMKq}|39^j~qs@L51=fk)Y?7sRmu%lb3;G$Ci)ZrYlkBz^vlV%?)V%A7R1
z^F7F90{0C-+Ex5+_nKIMus}>fufdrGC>}#WfXP1$&&;G~jz=ldP8$08^f-L41WEq7
zy^8*=tt}%Ek1qyCK^~*rd{z^O_ZO`hKoqcT*k(+3U%>!wbPrcIWji3V-5{3q*s1p(
zh89x0yS3-dSBL8Ri^=y>t92LLC`?QarT$VQN#f2(AnDNtem$-knEh%vlb7l6{VVTX
z)kk6}OofHOQGSdk6=C%LVJu51Ccl1n75#dl*Z68wK3ng=aq!}z`yDS`q_rNkG3Uvp
zQ*q;>)4`lq`prB?D<$9$EJ|Y_aMfN^*7AjbN##db8BSs0r%;WHdAG%pGT*ZzkLwpI
zI5Juw1jiop4Z)UT&T*E%czrcD*1DO^*pxo1rA5;ICAZ86+DU1vl*HAD;vU+Y<<py6
zED1@ZWJ&qhwHEKOfYskF+(Yf&ZLSBm&;6BuW%bXRp9b1V<EkeYvPJ|-u$KmK?NXVs
zPYU<YqC6*7l$wmh`XpYT(w8!%OkdH#$sOw&jAFlXn9tgFd>$3W^wkmaK2xpdnGfm1
z_w5GkG2Y7W-?%lCObz0sQKHQCz-bpqOejT0lA;S=3l-EJf#$LeZFp*mbZ>9(mexNc
z&BqZRebf7$x;oy;&E3-X?1lz%pova_b17mc$wPG{41p5h00?kqgTVw+MvI=4BK#;Q
zz_6Mq{tbZNFVkN9zbSlAeOqZL1Z+D%rBQ$L<_lmo{~t}?0Z#S%{{MFDeTX_r_6p$`
zWrd88T?yHak(80WvS)TtR!UJMv+Ov?kzG{C&dNvjO4k2A-{1A`>T-2`>cctj^E~%+
z->>zc)}(v4%>C|1Hd=A=+6MX!Tb-%X!Zn7u9$Y9qhi1@}kk3M<{G<`VKrOvNc{j<_
zaLsL54i3?N4vt5y7Y3eDKF^KS*R>6#&RE)1_~EeiN6Ga%C9a2Y$_Uv;#0ow6WI7jB
z(_Y;dxlX33=o*f7`r|?O>4%T11XT;D&GB+0!Xi^%uM#ar13%)wq@)v)Rk&PrxGWye
zE;5^4d33}0ya11%BFB)rjpb|H43oPewYR13N~*%JXP@U)Lf-|BWXcvB^t#{JB`dM-
z#`BfX>H=ST_vd?R<>S5nGC~m*8U8!y8#Z1hE5$>v0qq&+d~N%3<V<VbxfMB*b-0N2
z7N#!>s5nF{Y#5Zrz*<Lt4BY)ST!HfgiI?Hco6(>R!hs|L^j|6t4*WZ-lX+;>_p>vn
zo{B}Hxsy%OEm<?ThT3qAr!>X-g%_&$GQWM9<P3AZe=+=fYbWQm@$#TimpgAI6%`e`
z%r&^mn_RnXjo<F?uv8yQnbu`A$vw)=at2s+w>^iU@Qj+I@$jb!6h1UPi|@iq!Jsp0
zDvyPWX}HOlvAhozk>P7GD)R5zBxDil40nIWPtz*KY*(T`RFLFQ73YV0O1Zg?e!k3A
zT&$lW$u3*kp#RS&xnt%kXI)lRvl@?5UjI8L$;|(RJ#(G20KEiFAX#XMMX(&Ty3yk^
zPW{i8L1qf&0MB{+R}=IH`QWsG;fnFn7Fw+SHxD3O2}w!$fMkJWq4rn2h&wb7x0HQ&
z!d_}7gPVdB1QejMZiB)@tgWx9uBsS+zvq9zq<;oB<YoZ>+kCb#T9Q5~UfC-8-#?Ua
z1F>lQ+L}=QS27IFY!+J(lYv++7=FhFzv^Fjw0^RvJodK$VfeKzzgsp!7`AS`mM4Mi
z;;%AUbz{t_MTVEHZ42IKkOZ;fbCDm2UwrJ*L+lS^$_1XcHDCU!lnCxmjg9|g?}y!e
zB$OOEN{sdCo!aJMp=nuF-u%LAPM#fO<q(0rKzs8}+RJj9%egK^+WL&G#aDzP(<vWf
z8F<<cho$IT--eq--;#WC@%!+58D*Jk>jBifyg22sDfW{ujGC@9U=iJnxfI^8gzt)-
z8x~RdLT0d8*<rI4-4GTGv!568B3vjNT4GM|{L^`tI{^#bj@`;w9a3IfS7!$9ooN*Y
z)JVOz3w9yM0o0seU@V9B3=<v3tC?g2i&FOfEY%$s7w$+rkeUx+7@>g1%=E*ZbQe<4
zT`)9SiD!tKg-6kz3inI`*()g}g9=sH^t7!6A<1o|vOv6Fxz)Kv@{2!<Ao9h?mPAx7
zeeP38LR`1{O+%Q$sp#5rBt3NfwD`lm8j-THS~V!Mb0nKkq=>Kk{j^D7C8>QDTUt#S
zOpOo0cYWQ`3(Rgn?sDZ{N~kD9`H^JsZK@H5IZ3ui{<1JFCRD6q2^sj)7-f1J?h^a3
z29gqTG^x9C=ozPtdfA22zYipH;@Md=I%%04!m-r|Ja#9Nu|xfvtn;+0v36!RxwLF#
z^GUc~4Ms2B>6hHNX|_4|<ih=XtD8($G!wDB@=T5Ks5S{lKBwG#A&t=Our&SGg2O5~
zV<v^pJgHito=G=^qYQ;+ul|^c!!-)`a0}@T3K&}_K2ZhDqWgsZLd(*2fQ()?<&+*5
zW!Uhd&HyObTI?m`fXsnHL-eVDUD#LQih3=m$3VZC4D-qq5!D23R6<%BGfWS-#eo7S
zA1|`kmOw(LCY-JcTtWWVH{6j=E4+rUljBNsjg1}a25$ZPUXj&>BZ<gp>H8TI``nr0
z$`w0wIG1+Ud(LYVVSZyO{!ty<YioXrDX$vqs9=Y%I3+CO5-u@LJwZ4=SBx<6{KOep
z(>`ayYa%yViw6%Wkz@N&{dv?d-9r^C-h2kcCgChkzS_=KNoJz}0?Z5u)}uS54)0?7
zXw9sx^J*So34N4nfyi-kY}3;k(&n}naz^2Jx<_YX>0bW{qxUzwt`{7lCuPZ7&$TjJ
zqTo<ba4uXj8?8z@MbVgKVw;$h)Vi=)#|+>3GKgBkTWoF?j<5Hw&vzw|%VmDTHqq13
zg<`=9C;%D}u?~AOp6-qPg`Uirkev~y^?yrcyv%W27`pt@QU-u*S^$(J7u=fyh1vR0
z$l*{mgJhyw48!!=bQ?5+>ay(Meruoj7?`TXXL$WOY1z=j$-@<2&~ml@8L0}%d(CMB
zt1<m;F-;3~#nbuXf|ALuR7LjOx7(xw%+7qw&ZhN0r1pQ3kX^ya+n5Z@g^!Y&PlP}2
zqf+1UCp<ls(K~b6^uOYsQ-Yb;kEig;OkcD6P>$)whv%6N)37_2OpC?v1IxS}TjnVE
z$!TeewEp#_3o=}(Sf6vD)+B!=ne^IEZkL9kd4#%YyrdF;$5ND;_;k+b7CbC+EnD2-
zVnC6J)&%k_!rNv%n7`QE8AMs=9p}S~Jk}Lx02;7$S_0;8!8heF@Pe2NUzZ-^cKbFJ
zfGkg;Yb7?tSGi_BQsmxaPoMOA=`ZG;QRobAS)!22#brs-wBJSl%x7@rd0&GP0e#yV
z{2<&yU+!>Iu)@Hibkkat_!JDkEq%EPUneG#z{Y3?s$D}Ca#+wE0|h$c50_R~J5CrV
zh5?IZyZ)<v7-U-Dxkv(`Pf?-sielTD5CT`eq=qqfEHB4Jgo=ur+uXt7l7=d>?nhH7
z=bfJZ;lbU2gPk<8ge21d-ELZ4m2DxeeCl(ej;MqRO2mRj#V+AIUw(6s>BUnw4=#&`
zY9LK?Dx~fgaetf;S5DtrH<IC2%tKNk@-=!y9QD_UFr3#W`GfOm=aL+&q&1<27K6Kp
z@*~UW`medqCuG7^f__k3gjxNTjdXF#Oe$A*rqvZG1HK=c1(#w+k6ARPb2ibH%K3$)
zsb6o~+rO%UaSDJJGe9CUXu9{z&CD|S!?e;O!9O#k^~`zG{m5};HKn^qi?>SdnKj^i
zNcp$Lpp#(-Gs;IZ7G@bDI#;g({QyixGC0R(V6eRc>Su<t@{vF|hj}J(9!ydCZ5zKe
zH3lP%SnU)l$9KY?=ro6+Z2TdJt3m4a>Gy9T03z7$zi^jj|3vqVMd>WsDDD^Lw_Sbk
z4F9N>tM*w{v~+J5!Np(Fv__PZv1o`^J^C7(H3gaRwn{9NfoCk4k*PS#Gojh{OX`(y
z0l|bFH{|c_q~)^D6@M<V?Z4}nx%B9>w2D4uv@Nxs)72{p6$-WmokwV<!<7UE9|k)Z
z7~|2Z=?-jsR2<3Sri!8JX?nvKJgLKMf1Q-`dG4|Ki2eIg@7BLc0$E<alR8f-I`rtA
zWzXysh8JDxeCrw&6DWOIb)JazW|rSHV)+}S1P77(@WzUdq`Dw8wQK<mdySP-^E$!L
z=D$0lf@iM^v7ky4S`dM&T&wTO$}U<3Eb@PVP5>4*L<JCQBb;ZD9WeLo07O!FV%I+2
z;0rS?Ye&*qHDBM0z-@$qg#ZMQFDfdS0I#_c7^raYKzYJ%hJI^n3%|Nsa|HWIZt20Y
z>YANKHI==+EWH`WBl!~D2KM^Cdp;Rl+Iuoz{1sK~{d(FWXc>%+Rrod*c}x+4m5N!$
zWp$^L@cSERy;BJl;`riwM@l?d?|+RpuzkJ#ez+@1B#bt!`CpGP^422aLTKFJ5A`4Q
zrlJgbI;1vh`@w6J2WGRWd)yKu6;d@-ANk2Qrp{~M{3^llP)io+lUwCrXD@N5Sn2Up
zxKje-xtFgm4)%1a7Fng}%NH+5;BW!ArrGTDpC{)Mb4t&C8kyA3`}N?j6H{!y(8UYV
z(qulX6N%vaA+}jC0LQ7LK!=B)JU*Pn?fe-jt*ruJ3rxurIiA1klZe9(JXrVzDqdNS
zUu1Cb-!N`J<JLGGf7QXk!AWo{h`koA5zo^$CC{Vgti>Er=rKBFe^1K$7e+bc4$rz@
z=$mDp+e}rVn#Q*Gt+-OO@fcdvZLWOY!I9?1Ms{$d`7d^R4YW!v+5WwVT%2Lo)oaC=
zlTFDo<(l;cA!&S3_GTAIg!ss6%PBu~e#SBLV0B3s--A`kEOi=t>BJ5RfvJ=4)vwzE
zK}zCJ_|93c-zprJMO?EShrWFIBK(?j#@G}rXiqN%UeM2x4f9h3Ed&Dy2XP>|H#Gjf
zJ#e2Q#A$MUGihhe{?oLD6t2gclVDHQDmQ6iX_*Lbl!*w9Byn6KE+HJOA6c*8==%D4
z_~xOMoIz-}rab{7js5+t32wSI3W^^z|1gTXx95V<55hlq&{SaFuz~6)>$k=Q>||cg
zV4^ZFmFt<`3DQ^cPxEz3<{RA16`iDz&r3!pp2ji8mPb6+wGwhskV`|JIV5c3E6*O}
z#1=j_==EpoR}W5)8|;m0FZsr&95(mDr?gO@jsmYNL3ltj#l#bEub%Q(j;7qjbD6r_
zxj(QH=;{Y;+I)%YgBSxeS3;6HR-XB6jll&0US@=fB3wx1yr!FVUJUkR=E{e}h|I5a
zmP4c9!vcLUG)%&mRqVg#6Q_AAziDz<4bX7gZU6TjKryI0k!aMkyI=UfJBsIKD}!a1
za+>w88?z!Qx&mPqWR+0A><CYl(Nrpf(!?&uyqXU1kG2k_9W3%$vX3YT9|mnZjLz0C
zU>U#`B!Djd%eQZ{m|I-h%%Beh6l_Ug3l(}p*!#z|TBmT&6%!V=9I`7{;QMW`1>Vek
z#+1vQTdDLd$3C7!1m*qn9}{6%1DS{1D_<%Gr1msE3Tf)a1fIPa5XH&-)wwFdIZHO^
z@0#=S%;sLX*W$o+x7!ieo75sI<#hO)$XhntTZ5%nt8|}8Zjk&vgM_qUmO|(Hg2kC~
zZ=RkdilKOkn8xa}e}~tHVBG7h@>-X4DHnXG8cSf#yA`CeBcE+YmUz$YeEDv7kFy|Q
zCu*B%fg>j8@ZB-h&65!woPn)e+(}0}HO;}epT6hLi1{NDZPROgU><2;V3&PfV)gMf
zB=Cf@fcN(6@Ng^)mSB;zb$3T6V1b;jE&T|)a7Af``qRRuo>?%t>9dCk6`j<dBoZXe
zGQ8U)6f@8IY*}Zz+JXp6L}}{<Bj}dsK?4I^Pb(nTFdoHJS6=|d`U@DPV33EwGPHjo
zB420)8__Z~8m^){xTRf5#uGODhNR3Sny*5NCn|1Ja8mi5gP&O_mxyE}`akkh7SDl=
zdOPUh@sSR{Usy4zKuym!NK>Msj>uBIRr>pii^t2$>-p=~lrXG4Rq!oc>XUW(@vYS`
z=We6E{PMYcj+>`rd65;_+_RIm<p+Zu7S&Fqwd5*{xIcNZzu&VvF~@z%4YZ!zT|C@p
z93xjvQPDNs8_Pt0ibOM?vOuA^F7IStI7ybnRx@8s7hXPQv3%nSpGr7h&VZB;gF_*5
zAtWj2SDt+#U2?~+94qOhyjA><I&Iq|cGwmD)>=Qfywg;W+Gb#S0k05@P_1z%1YyB?
zOyNmDKF<#vrqKEG8lorF92^R=WwDP`ZWu=mE#=+_Cf9we3WS^_^(T5;-${h<wEw>|
zb*{CUXZsGgB}t1Q`-HqtE)osXE%A59jM=%e+~?<=o`e6wDOaW1b^NqVf;RIbZrRI&
za?vqo$KOQVwR#%w)FJyzc9B3PL6Iz|(2;0)D-8tTYKXqMx<I}g{{D+gPA!-~CVUW5
z)_M(hm=Ifdqs7C^iv`w!Y4u$;B4z;f*#=rJL}HHa<6vi$hI$|yZWo`Xq@=F??sagA
zFM`1hwH8a9rd*>nZSMD+jir4Z2h7iH^iBDkvXPEm(l_LW^g07Y!?n(B3vcffXMFE1
zj<R+Coy8y7=b9B9|MCPBTBa4w(EK+-)EO$q#xRXLPc{W7pOw3B4+?csBpQh%@gn)1
zxAH;vCoNA4X3&-?mO+K{?Ac&_qsO%1c?A#SpF)|6nwZihuu!T2oRro{)U8#3EE!rQ
z07yB(6~_bZDm-9xoVpDrqgWAYCYq|&>XzVja|bcc_g8(CN|I$RUJR)!D2QqxyHB*2
zJy_JSj@RU2a+AR1Ocg%`rxZW4Q+;hMrp4w9y;WShovW9(K%>>FnJ<BpgM)!Q;_@Rd
zmT-K=`BOY6hosbh+{KOA2bfsa43M}FzE8{29w7U;6geZe6g##1c17Cewb$;x_h^Tr
zwfqlHik_<#8>rBR&q+3U!t9JEwbPy#3j?FXlz3&bav04Mkb=EQKE+0W4BG!5=;$B(
z$fv+}kR1H-DoDKE;-g}Sb#xcV>tCQ}jmfwmBU4d1aP8Hg^Y3~F0_N&f{bj!PW${2`
z;}^vo?qbBI#jM74ToVLU--~V(n^1X3pH5T?{JS>21=&+)V$yvCC%;IUgIhub+DTqY
z26mxwK;)RImu@<yX=!T4=$r(vp{)B9a=~?s%5n$`?p~0aUCwa$_U)U!mbqg085iLJ
zN*lR6_#`d-rlbBYyM;9HFvlHmBD)P_s_I(>;=zl}qobq8cD-3L&({5oCCvpqa!SY}
zT5_5?00eNdL~-Zal?~yTQ&A{IC2CfsN#{CBl!|o-OQ#=med)`>YI%`Xe_^Y$b=8}D
zjevNax)VN&FtwBDDty-j(=#-y<-V&{aGvn%WYjM4q{anZvbsc#KMcrbSVw;~xfl3(
zFrlJX-Ag~15B=4^ac%8#1G!C6*8o(<r`e59us1nHY4Yo<DdPN4SsBr`Pp87oedzN=
zWl~OfEo=uEnOMiDa3SLoU%rn-J@H-sc2%eAnLHSo?wk}gH8e9e_AVG&I;^@O%vuNY
zHYG>M!Mbaozps3*5?*d{Vq|3RA7oJVeOu}YWqtFO<Vz&F$V>k4*ZNFH_QiWYXHTYe
zu^UiQP`DrME#Uf}U4mX~xW<h$<9t=x9E?FjdJmRvh?3oZ)K-+S7o_w!BO@QMVx>Gr
z&b`l??#G9_AqC)@qBOf|!SnBdx%ud8XjCO2Fd`u#L6<A3lZt;R0591jtKGm(M@N_A
zjbc)L`ts$=$|+Rp3#uzuUcTO%eJZgwdW<DZtp|V@Dtvl6^$|0fzA9gf4HLXi3Hj64
zF*v6`6lS4OJx}!0_$<7>YG6*ER`u|xF!y}{Lowd8;+)_Sp6xb)cd+mx{Q-UGG1;0q
zVK{y7=$i7WmXe@5uH)_v{)m>KygUaZSwsjc4Qpo(*}Sw2H<}JFtp|wVZ|7c~6N6-r
z_&=wSX&6s$`oDN1{QiA(>53}=p<CNq>qkvTPI==yF$<jVY>kkLx$Y+-M0?U7kfWX#
z18=gpuy8RQ8R`sFyJL2|3D7b>fx@n613QeI-r&(82(0Aqjq)>PR-e|1aKL>5>1Xxc
z;n5O+p#3*XOjBhzM)z%wj}A?nA6x=Akg^TLk`QYMF`MQkJa6FpTS2;&vwxAl71PXt
z!04Ky#RuVMux()xAf_V%2WDg&-vPP*3?H_u9~cYr#>#CYKtl?;j-RZwo<;BOr(P8p
zJay{S%$FBxd?nH~%!oz6VgXe1mFDB4>i*yr&lu|m{zLJbLplBS+LiqDE{1}q&rF>?
zQS-9vzM_JSxGyEM(;-=F=gxD?Cdwn34w3LW+wZzhN+P>H`^ex~MnGX`Q3N&`W<_7C
zv{%>X38xKCW^QBjPpPXXRE&}woW`F>sBq*7==Kc%*rp<vg>X$MZp=5Si>{y7GYBck
zZ_KxoK5g8nq<q5|pb|M$7?)~6`&vNb7n!p~UZ;!fnR9bVwF(BO3gcFi#Hwn_tQFj+
zrdH*DDom(ciBAQ@j*bKBgly;}f+3eUm=g~%d;9L4B?}c<>CXP)5RkAIW8c1cfgN|X
zgD8_)Is?Wm&Ag`snLBLf&&H`InHU=%+QJqv>3eqRj8)mtyP0XO^sC%xD&mPG``|!!
zB4|^O9f$?Uh>9#-GHnWygUR;s9E%KxAh@A1FvHqr3DC8L+G40EB35?l2I|}zz(L`5
zJeYU1)dt8Hgez1M!EZPlK!_lp8(rx9MSA(w05t*|OVx-4z~a+LExMHvF|WQWw?u|Q
zqHV{j4;lN%Yv9Yr{)J8LM@7E`csq-<ob<bUqU9b)+@HT*^f<*~am4FZ!|vU&WKXut
z*+ZYu!}h()$S9)NirLp{N~~I-fzX>InY_QB1eN%-?<y@6+GVNA=v`+D7s;XhF0GfY
zC8QcVVJe-W^!`|@NVHpnPB+b71U;M~km-D@=yC1TlmI1Dsx8KO@XLwlmY19JJ(d+V
z69?^SpXdmDYH1||jFf|!r0i>Mo&ZN^i;wBMmsYt#-H6Uvt3R82N}M!NKl-y|mO4NX
z8@sWd9CGk=uuh-nsuW?MoG*n1aRbuS06abK|Lra0l?5H|PbNb;Qp@v+pFiXEvM<yL
zzXgkCZDxLVcQ-Mk0KhE4w@v?U@G&A!0lbBCmMhZz(JV;C8kRi&aZf-@oiccIT)H7U
z=k@V!$nh?1d_K#QCr@0!<EH`VjF6bv74SGo>#51-K1+$2Slxa3<}*#<M3ob8gIAZ4
z@`;t<(HVM*wei&lyE4e?@z!hQv)~<k24EX&RNHjCy`)*eQUL2h<K4ZkIbT>gVr4?&
zPBx(#Ke)8%w(03lFg|q<<_6E9ItB0A8!MKmc)VQ4moHOmka4_MZi}%c43~>`s}&bB
zM5(@b2K#veCfIrLUKbL7HL+iE*Cl!KS#W>kP4!78$=6JryzrhZm7>b;?Y>uTF8#M;
zkFQ^)W4nbyMv5JsjG`6F8qz}Jnzl(05=VdUMBnC~jY4TUfT@nU%|S%JtF#Mrd9BBJ
z5Mp*PA-+lnYi&w{(!OL7EzOa}X@9*^`|f5H(latJ94X-bOaPk`ao)1tD_mHIDh!xl
zav~c{4Ag)FR`GCakeI|{$yiK(<^mB{Pdc*_>2&dl{WT!N;P`{!BD$g*GytGP^e?o5
z`Io{}4xjc&z7jxmeuk-RP>k1UroDPKvGD5uYXSCe7$*+>_)&cUevt@?ojYd)WfZuz
zE@(({+4s<@Dns7zAai6rc<yD**CesaZBUjC?Tb_frA}TT`!)3<hT|$qOHxFTJ|ewx
zjFSqG!S3#iUe~PN_+_5m`ckztzQ^ggqBHfIZTE#LQGm^L)39h0TFGg<e^|et?t@^1
zJpI?B$(+hfA7Ody1D47QAz0)M9dve$TMN1(@em6{pVuD)U(1GQ+a$)E<g130PJGPn
zP)d{_lv1o|5{93|{qFWx_$wDm%zmu8VQd*Z7byNjVbp2DIZ>OA_GB;V0{h`d(i76u
z5V7!kaRr<A?@-EDLL}QeKGwprkWZU)doSpPIuCZ-BBXSSq?_<^XJ@AggfErB(4Crm
z8yezep|SPyl3tSY3b!r$xC6e4YI=Y>pgDqKLp&0>(0D@Pne{G_vRSW_9%YjPX~4KO
zq&q?)C3T-192233`@1the^Z76kA42%Io=l-TsuHaHVNN-e0^8<I}ILG`oJf*2@jq#
z;mXTXXD<b?BvkNdr$yfLdv!yYKfBQ1&)t1(0YHO&0}Z2-_Kl5h3Mi5>b{&oKu7>-_
zxj|`7Z%czB4jEHpOY%^3GCvm?r3&Wli<LL_<G3&^H4u%^IvlAW30N;5@0kxnyBPZI
zM7O>?<>uO^rU%Pl-tes}bXHsRlD~_&vJ3GigZdy+04?4q3H!68%cY@3Ek>6DJ`#H^
z&^UluT!jnfY4Y!-?aP=matp5K*`1CRw_iTN`ml;JvjKZGH-}$9Vt+?;XNb$xD+E4v
zKYpwl+=p?PD-aT<`8Aw<@5JEua#suY>06U|NAEXr2nS_KBgDPxh&Qga%7BHxrZ-PH
z1afok85CTz&g-kYxBpa)hr_fFbrrguWMawk1D8H*hPx^N(_PWjtQy#G@B7~XMr>8i
zp6#VcfJ7unb@jOZj9u<NnVOo~iD%PrNM3Au_5M8ze1yqL|8BQRBv_Nka{BE32XSY|
z6aq%Ji4D))<#YAnJW`O5mGv7*H?i7tAq?NuPP_Tw*NHqlz|jRTQgcTd!c51f4RaoU
z^JMe4nf1HNzkd(c2kx$<g6gwOj|V;?+nb#?lgAr<u6tWv<Vl^L-0|5xGBYwVEGl}}
zk~UIB0_;SZ*6RTYy0e8X+>vuX&xvGECU-1F^{-Nrq8S*u*jGB%3?uVozpno(d$6~3
z5_t)tko>wj|8=m#pM*4|bm*pwZ6s<xt?q_IVy|QsZXf(Q)qGp0;94Nq(UX-S%7#<%
zVa;L=-jDhdca)d>^8DE}KI&*&Kqec+8q)ac20nYCz`|aJtLEEa$K8#MeUP#HsF8Gf
zb8p48VI?TU+V^ilvDPz&fcn6SJKHo=wyg`<Plw)@HZgD{J54VDSFPy+P-(T(&Ck-k
zuy=L@uN8g!2<WoYs8_$++Y7ntTIA1fXI=OP*{XYcn+qX3z)01)gVyzbB;X@~(>j~3
zSpracUfgm{h1SaO#tpJT>93=sv}PF<L3{TB^x=EdDe8n?h&YF#<2m_o8lc#zXxpIL
zf&zZ0qt+tyX9F1ahXxm=fl17VS75dJ?N=~}fQ-z|AA<9~4oYKI;pK||$fepO@N&La
z&u7S8@yqM)X!_eOE_VEHsQE|$@hpyR16=NHeW?g6DJ{K46WQR|jg9ByWq&3z^acDC
znU1UWHs^~XNY$8ebl&tpr&kWV_xoriRE$!)Xh9iqTRMKH`U0AXN3G3k>$g$Wvg!U#
z1SLa#QG<el!ptNzlz9<ziBdE+TVQq89|KinB1iIqWO9dR*yO6U0u+mG8NG%jq5$}T
zpWk0MFbb67q`Vj>jNSRr8b;5T<YBp$E~Pk(^g8~Brjy7xXG5`H1sjeuRFDnVroQzp
zA@|SO&{5ZhcO3Zm`g*fiI(5O4n&MeKWo%)`OjyTEZu!`k62{1119lQwPjjEYeM$Mm
zs+z5A<>z&N?SU|N*~Vb7|L?(}<IvF*yif5t-dO(nE1O4@C1nq^2c?Oy#}WX%f4_v0
zQYwKMpa)Ww62Jx^K}gYm4e?`%V4wowHYd@31DRh_>wcgCiG`G>K?XliHozgiLdk67
ztd9yq0Q&{tlbEOpALrqB`&klQRjwTpW26i89>Orm0Kn>D=K-`G{CR43pF2_o(nA$F
zIzW#G;gaL060p&Lx|dkgF~fmDL_@Q(vH*Son;o}h@b-5%Fo5qY{4Z--94AVmkZLNn
zI19ZGPAlzIVggn#?UmY2V(%H(hUMy!n#l+Ib6JJPXQHRSOZPfqqWdN2#23ck4<=ME
z=%RT03r_q*HBVlAsC{i}t%Y~i$XK9TlF!VJj?TjUses_1#PcPJ_7hk_-IuiW*)P9;
z-;Vjj=L}-(Q(9?{(;Vc^Yo`fxR|<6Bzm?$tKi3ux(6L<Ki8@NW5?;7i3X(kx{vIAN
z!cM-o74Wei8e`@9e|-w8qP2U^xY<#u4s7+M4eFB5RM_pWto7OCS=lE9v*7#La6{;?
zI#L0xHCQjpX8*y!3u{di<-hDBdev_k<TyJ2`crwm;*(JLos}-?3RCu~1?l|PFGE^2
z)q<pxWR`xEzYb~E3;a7BQ-i-M_B7O?`Exg^s=7Q*l-eaBLo!K6GnwPiSxv1iTQ!z(
zcYFK%W4^c%wby-e%0k_h7FJeG*M_`z+q8^WfKh%4=zpOzfT}DpD2bD%Ba@TK_eQIy
zL2P+ROZ|9wU|{3nqis)Am;_-=B^TJc^dH~8{ka1~!+Fzk{JY(03_EEU0*nc?Viq3C
z9Lc<yy2L#W?P$#8swU{e;qO4WTmdSeoh9qzTM(JC-Ua}w!5&!r);vt7_bG5a$a4k7
zjg4;cq0f~;3JV7YfYXaldJXFBb++Y_BoA$xj+dB;2)`BP<0j*!NHHcG-`FVsb0#5{
zD;C3x3Zv$+%TP)xL6N9)IWZ#`Jf4iS2)RSz$oj(O>68{8vD3|md_wDy57|Uvems%c
zJ&g=Al`501wGoLm9eC}xz+QMnj`!YcI<+7iE3}}q{HC1!dwOxP1YKL=KZgW|be3M}
zH_4iTfq_go-4}}ATDbC05{8e-zqDc+B4hjRoSUj5Pag8@_(|Kh%dn+c!g867i`&r3
ziaK^Nc}Ro*^6kzs0fPG^GB2L<@Q0cv6BSw2K(J7JeAa(={*pEkK#OStfGJ(u={D)v
znyx!EC#cmCiH7?6qv7x0KZvl<5Kju>HVI}x0fHfT3CP!mzn|hxOfD@hUWSew=me~+
zY^;q0m01ReDWd?}(}KxO3v$)Sadgn^K$!L?5L{%JZ+ti`0axVXpD%js<LPid2qV%D
zbAcOF@XcKC@!SECA0Y7MP`VKnKtRpS&&bQmj~V(K8#B>Fp{d9u0(b5LGiP$m`QAMZ
zfN_9Ow!uVi!6>_7?po(?9efi{K$E)~u}%89{6EhnsEvwwo<}AL6`BB?Y}rjbNTUma
zllTpJ`ObXu7+*5OLT6yc+|x?#PUbszit%!qJkN5brkUs{Aoca>gToIWFJcJ~$hk6$
zeqA^Iz#i(TS#nZ>T!Qe5=z@^rUtVX9ec77EcTNYDNfQS0mJF1TLqg(goca-<`e7A~
zX3I_iJ-*DYO?&erN_lS1diUs)IF%W27VBbW8HOenF?~sWkJzL1gc&7}hbP5V1NS{<
zE4zMN{1M@q6kRB<{?dr5g_~@|*@#T~eB!R9=ZD|Riw(6eU(OgKMy4EQ{#ENgDYhfW
z$3;<L>HpLrIJwAF^ariZTp!6(sBYpzLqnVsb)E}p*{=1}z|MjD=1plSgmz-#vEt>9
zEx<~q2C<<woGw&&B-9dG%<C66&Z+2ctfAIm)G!b;uNHm2RKKq(r*33s76%;=fQDPU
z<_=-rmM|Kj;iG>i^5LT~RAp$ZBEfKVQ5&bN9e2>id1QFl<D|411~q;9=MCZQ{6c3+
zP*UV}%s5Zw3>6jstAVyP(6(L~Uu2UtPiaze%XQ0Vr|Z&qu#|U}C>be<yRF^oN*rf;
zyfALFV0E2C+2@ZBB2J=(C8Sv&Z9H)Sqfw(bNZL%;qM075^BnJGc<qd-qzJ|EoVi{V
zmSDgk&lU!!KeH*nKKaIDvPZE;y?xo+bhtluJn~Bp&nH!bey4R$w#isNGAXgZVrxEJ
zGB>tN|LEH4ST`iseev$F#G<^~MMF!=sQ>;ej_cr^I{2_q)VycBN3Xu+`#RYBI++>2
z+gWB0ZPbM@E^~R0p~QrQAcxh7kI8^?3K0oA$Zs+H2{Hxbzzr7W8Kmz`Vce#J!04cU
zDI0kxkM=doqTK2GLI12@t7Ttwy8_xyJRSimfBY5~1f{!fh`&~Sfiv~pa)UkeA6Ozr
z3?>4W-c^Anwe|vru1S;XYsS@rXOIOy=F@$?rsqw?@Y3dk`{PkA!G|9sJ{RC}slB|t
zY^T%6C3Me{gt)i<gW*C_W8LCkO~`)DB+;EDa{l}~*nDqy_JUaA)UEWPU*3oLUx}A_
zq>e%%B+Y;ddoIkrxcn|<iYWM%sO=@s#Fj3#mopz0Y!-A??*C=H5O?ql>%+$MQ3R!T
ziDSDBC>M_N?{K1FDN@lW_xEXR6`dotT}if23G-48q*wY*?yUc5r(;{l62jXHs~LYM
z)f+rz4d?E65PfeYq&DP!;7Y=xrpu{5$&}+nKhRRz{F!V%ZU?wP+;y_)a0$%G8&KdG
z2c_3xK!)tSi6J;A0+jyEqhs6bGDGI<CHMY*eW|GoxQ*n8nwpCu=VP3+TwCRmJ0c+6
zl1O4j+G3)0*!y<$H}`@tY-}V8LC4S>Kr;5kIK^9Z%1g~}B)5szQYe*T1@AH@r+aUE
z%Ux0|3B&!%<mc1w+xu|(j9w^~A_PxqoT+td-H#atmDHJv*#MA=g4`+zPQ6Q`6B9?D
z+ZdG(C|H?Sa~X2Tg6PTz<Yn2Ik)?}1vA<y8gI7@tfnC$v0Ulp9P61-|{LLGx_<WT#
zJ}`FxUt4?mRi-^pq&upaJ=a@l{S@3shc9Ept@83L-%w~AeBt~rMCs`F2`g^(BHY8C
zyQoKv*|SM|E6I;+Nfk0%K1o_S4hv>Bi2D9H%_Mchc>MZ}8`1@7T~6V2%pR}k#4D-E
zK=*JW^ypx-KV%j9#nB(oWPgA-7J1X1Ot)uU5)b6vsUq(m6hQoG2RwZxB>?e>uZ*2R
zZBY7&ti72}@T}By?4iDWJ+C(vw;?3MYp0cil5z{&mHoM%dIOGhh0YU=4`!kqYu!}(
z_=6J&nrLAfTX}s}GS$1%@m=x%<t%yYb(GZKN?<UU4R3n(z#?Fee{0!o;&}dWck)=y
zG|Hb{JUMfd`_jeB<u^KiK?2=83^9Vig$x`yK2H;QA|-4;;`>1GqjIz5MKWIa+m<I`
zm@-c2xJAf~S8-<;H%YO!Ts59tbK=jWqN~CgIpGprROby3XZ6RZwbP+4PQ?ZcVQUGF
zKXWC4Y#8nC>N;8>x)XmwIFKUTpYR0CS<oAfvn*%!HhmV&t$2y^*>Iv~VE6@o&H>)k
z&moNftTcC+Ub0at?Y&J_T`cTdVp&5__@=CQIT*Cb(1UOlDqB5y9ElgK3vZf`IDL9)
zJ-|;nJnXK_$<*+=&3Q><<DqC(?sF#}%I$WjKeK$=?>+nvcR1A&Va<lY)W&<RWX9c)
zk5jj+Eh{Ud{jvJ!SzJqQtTbUb5veBqOA=}@zt2wIC}pEe%MfNC;LLP)apv7Wyx|`P
zIeu2NE4;`S7|RZQ01VZPL^A?ZVhqLOi@CKmqge*D!<G%vn<hpqpDXELOehwHeu+<8
z71TdID`Q1)M`Sh#IgTff4)=X+N+MsHcYSsB-*&_>j<(^n@7<%{Sq{djN~D#1emX93
zM)2orw61(yXyt#6>BIZ~CUTbMd+wod-iD2IhiaD)rpR*3=(zIRd#IASsi6N>SDUB6
z-S7aF5u+JYeEA8vJvR{qX=Iqfh*l_1il2<w=5Q{5)jqArIZ4jc4g?}H+=AI($dsNq
zxwaF1>E!M5M#<&!h#IACO-BvYK8%j7C}WdID!cN71H+Jz<NYV1X7_vXc)VU3U#`jZ
z>o_RM&^K_x8-y7G=%DP4OD7+~WenWRalgR{oZvaZn%t2GG&NkzvP_S&;Py{o>PT34
zV3#l+wCJ$PR9}jlDcpV(;3wUidudVLWn*@N^NF>`$g3r~aeNy8L%|(-x>jkAcH<}h
zR+Ck`r;$m2g~Aa3*Z8AbXQH<q<|~fpPcVzdS(2ulIyLbqES3Uxa=Yn7NeEm{#=5rC
zF~ZJCFyZ4fwc?W}SOl;lcX(32fJWv}3Q7JxG-T2-v+e?kaweZE$3A1;+9ssaa-$Nk
z^mqxTD7l48i(db<;7zX**D$uQ`2Gz^2LIdTpGs?H;kt}~(E|-y#hYjCWnQyj!(=6&
z7|aX%RnE-HkMVI_qEoRP7X{nl2-tCF!n{Lho(kN3S>?E(*u5(yVD{Q?=`OSSH`_;_
zX`#%|zLWPQA-A`yL_|m)Y7LY(mF8@uN+Jaf4GI(E<A<x|Rvengghs2feCMq6;tLHP
z_Bt|2#do^u$~UO{_Rj2vEQLiCI?GdY2)?hPCt#j9?EMD65Y33+W+dC`+5Y%jsj&=L
z!UUtp6+Tt<W~DQSLQ~`PKJpO-?_3@cWaMx^!^~ZoakJCaHEqbH6YgHA3^c{BQI4m5
zPXFy7u`p2Y&s#oXSzBp!X3`=dXIa}J#r+XL7)ffwW33cM56?}FM_e!T6n`Fynwa3q
z@A%Vb*6ft<F(!6GaWq(XYCH@T#$t$<LwEutc-?*ghblLxPtM{VE%c_GMrev1h5Iv#
zlp^Jsv5ukw1)-?W|NH0Uqp34Y$R>$}wt8pPSOKcfmWAq7D5?)DL100e!{^xi+sv7A
z%<&B;qGp5O+a<LmMK@F53{H#bXn1nUP^HO`D+NU(OKIz5_mKflgG|bGkDr@j*Jz=A
z3*W^E{gn#$=T5?0@4v2*l|ip^$m=iwlcpexMpGuXNObq+2sKG0LPi}*rS20)ouaV%
zIJ-O}(fD=G7~!XNZJd6b5HaOcN8pii0OYs+a%(AQUN-vQPmH;&9_%wwa`r-8(DB_}
zi08a^ZDSocFgI&})$)oR8O%n$lfBdKGQEO(`#H<g%U^xw4tvt!6C>VS$y1}Oht=<v
zmlxlm*4hs&#(SParYH^GiKK*ds{gid=xgNQ4Fsx`eY}Sa<wxwGsf^KIP$cIKAR%w0
z#bXp0Z=O#*R#Q)YwtSSs&;(BXk82aVmfO#|x@dm?Gqp16a!e}O>+v}6l8`MScSZIQ
zNB^@O|6nbC8O5zB#`@;<L^tW2z4SRw2(5EKjxMLYYJjk0_Qu&X9iaIWfOhSZ0}nfq
z_<<nRv*Y9A4I~FFcxy;A7uOYdB%!zIjO2m(Tn?MQ$;t<h-|tjt?2aTs33(ocy`Zb!
zpR=r_$C~hBY;{v@a8UL^5OTa0b<dDhx5S{ovg)=|sX*mWc|syqTlMa)Y^1^X2a1PJ
zZrzd^lxEtBvB6vsGI(;~9{4u<N!&?Gt`@vRZXuxY?|*0A{9tZ-$T}IohnkWriX1Vb
z-D`V6!{xT5VoiVTKuBDA2=rIo4&;WkgQFSHEMg|F#UZhNlR>o6qGp&1tVBx`Pe3Ym
z#|SxY!!%^YS}BbNXVJtOz7nE|)n!-a&~T`WhKn1dDxDNA(AbVDl<-Zd+LxZ%smQrg
zl;MS~?j2V8VLkOZRl?`bn@@iPIIn2hy>Tl60nSv;e&5et<jdIDfi_{-_oC|<20Rk#
zE-oS<$g7IM3QW4U(TkMT|0fK$3vKQ0;%saXNUjE$_lq?B3qxW+Hpm`Zi6ZBA@dr#<
zh0}l6XW$LiLQ=)rNdJSKO1Qv?vHJac#RtVr|Jx)J8eI7RKjo3E@!|e3^JMvO|E-}>
zzX9)LAUf&A3qC~-3hlH?Dl#rK7EO|7fBwl_5A$f{TS%0c#88`U{&+vsjb^*rwy@bk
zm4yyxN3D+qZT4;)AM_vhn9^fLw||~95or-i^k`=_`9_Hf+gFA}+J8gu%qa(@Js`Rm
z2a%L65HRiW-PnZtbYlM7x3rXu91xG+TR#tG0+5;g0wAItJVO<B?KB_~Sy^!f#?KD)
zb+v~(qw9b`9l1b25b=5k{aaTWRJfq%h><c~vJ<opipEx_#>)5k<mppf=Hcp=)Z(S1
z7vR=LMcX=lU&$0ov=`^hzM}ujhK_Cj)<U|24PTber4Nx)DGqF^RKOd=APGI6wtt2_
z*T*WqwxB@JxIa}84{`+hz8M(24UJjDRA62_-wL_$p#Sgy(6Dixa0abftFAEpjE3l+
zn1aV&3tntE)j@a-Lj~~$AN<U^^kRJz4PLw8n<_h$$wu1C>XWE7PNW)3C<g7ZK25m6
zO?xyooo1R%f(^zoi2&@V?xP4#+vB;Z9Gfgu;W>O=`4F|cYuyUXWeL6eL$sHtEL74k
zY1E{JElkNBwofzgfd7Jo&*>9GE9N?O9?OcLd+w^nZW2jvy}>W=?tlQOtds=X9?ZAw
z3O;oEyQ`FlRvH;W)cIbJXU3W6FklXC{QTf%CU)R0BKWl7!8}#nTlinmZD3K~(m;-B
zMd%OAF48Tu5^sv5h>Pt^qZ0#R-ayJ6mIvb^y;7#eV*e<%$~8fn@WV+gqM?khQ-Y2`
zBi+c#h$0S4)dG!ooh_z)uj!`w#@a|PH~KX>37Oo&2bjEIMHf1&QiVbI0r>MZH9bK2
zLj9@*<M|{pFN5zP3K(QEy+Olk*HHL0L*zzIaX&fg-1AW1iz^ggD5gvju&X00J$`7T
z&uo8U$?{*G#^Bfn$m(8Ar-bu+$bM2W`-FXVS8}&vXC_wN?zY>in)PG~fBRF^CCgwC
zzFScJJyg<H_vg15ou6*U_}gE2qV8qM2tn5PrES$gX*xzmz+p)L=OH(_m#*{ga}K8g
zPXd-*DF~yP#2)6HRSQdjWGWAEkhw?O4K}32mxhhik{~FdrhJhHU6=;{=sO(-r?`!c
z=@DUSRe1;1;&R?@OLGeSJKdP7FxgQB3SSiNWEdS?f{i_2w4Y+St(1)fJ%brUbGVXX
zFk}mB|ANW5CYiG-ab&-w8B6fWb#LAX0isuPh017raF7%ntxkRH@KV)`jXzf=+z?Km
z`*}B2tS+QO@r!60+wm!cC<O$7-QvOC++U#D-`4}EQAQFJSgC*Ne>M3@M64IWiF~1&
zYN;B_71c@uU!z|wmq>4{^L^x6^rw_};g$2AI;U{Vu^K8_g)gf-k^LReRqrCq)bt73
zDST{|B`O&XPYXl2!f@~IY4HzEg||UPr%H8W%~0dg-y~TZ`u_c$#m9hc<@4s%e>#B(
z9rFbZhB*8u88|;6;fwel$RfZQ8QId(lEWPHvbw9F>2xzaLJYqKbI9Lsua(HnGMWd*
z#w?W0UehuY8xMphUW!mkzQ*%EH6g82gF$FP>$OY8Tsne`gHs4b_7p;BD#?AtH!`3h
z=KLw1dU5%zDj&1=ZaN=7?;Cf~&tGOicSB?!TX?whhD4~jHw40lqdi$q#`)RkaKTj4
zoZr}ZFafnd2ZF#^0p^Cw?7#`3pHq%%Kbsw8i#dT3G2joAP0K*@baUi8pC-B;AZmr=
ziKUO(?-8fGLxxbs`Tqhh6BjKCLDZ$GramG{AUhZvSz$z|xZ{JZ%FumNnlp*xH^1cZ
zTc(IuCTR0!@cnvkf32+oH;&;*8X1WGb@fcztKrQIG9GOj-NCe=Bu*F2AZZeAvPPvc
zUG=@kDj-y(#lxu4TnzErt8hk(217V^^w5%qlapXTU|{Oi0+0_SfU}i4$Mbg9d~sQ!
za9F~{H_4MLzrVhOdmz+2J*8MQfI69<@2!&u-8PCw2v5%B-O7{Nj7u2zsov*}q}mIz
zattI7`=ovibKNMh*Zh^L*a+2S%;|VYj-hKqi)ovF!d_TL$4Q-+z3kpP=C4P^Vz&3{
z;6d}<EJvk#Tr`AKEe(zK7`QFx5;3+Ll9nQGOW!&15_G9*!Vc}bBP-Rw2<EDw>c)Hx
z<}+oQmWL}yt;$ZV!rgi#Q+*a^#nHr%J%yY{o^I-psP=VH$_}2+iD5BLkBwyQ(UcCu
zltk103T@D(5^;Rh5J;t_=Al5iTv0$DBU`el%TqDWDj|@f_0(0snujD=(|BWUrw8-M
zhACEu=Y`>$TObc75|#3~SA^5=cdAi^-Ik{5lVfSGQ~`EN{pHu3S6JgB-cy}Gw}Z2L
zy0Tjg8sC1{{DKyq#E#*4C^c8UiH)($fdRo(f4kj0(k`!GQ0{|#ZKh7W%E>s>fCnyS
zilr}J3!*G93TmBV@PN;H<dt3UIPE99`t0{l%sseLUS03d(q*a~w_t{dj)q%CKQ%6%
zMv#*f+Ul2YusA@pFUU=+JJ{+5I^cpA-9fJcFtmn($AbToY}^UBM~X<ynPt2#Y3j15
zaTyW=_R$vZQY10$S35~Vc1?wZe3p#q60MH+x(;FZzpAg4-0E78r)STn*29;yzWGC%
zbOAn;FfBfcZY?FF`p-Aa9GJBWrBPR66L0a)QIoZh-}p`%n!d2eoNHksi9})N*Y^)i
z%1kRz@%g$bN&sJsaj9yeJQAiEm|)gT?jR*f9f{*E$PNGwzfXwBDS<0Va3E|2kr*{H
z_U!E@Ig6nRiQHxNWYWKsreFWtocwQ-mOK6uM=}sj>Cz+umEUgUNM&nHiCxqS)3RrY
zi&Q#?)lJt@LA`t#Eu%GROmm5YmF)5SBJ<ge6x;T|$2w^@8g75(Arg{{ZQL}LLsf9S
z;Gl4oocm{x5y3^1_=U~fYu++PvQWl}?qxhC&;S~YgY{hE)I#$V&OLPKYD-tP%+fo>
z8b0kguz%BrnOacdGSeu#4Nc7ShV<wd1@Ur~jYax}g<V^pPB(w-XhXAc=xDiUa|x>m
zbq?}NHfSUEWkcqw>d>6I7N_-GQHSF$#}gBc^+5;XeRJp~pU7Q{6YU0aI;yz%^$kmh
zK2A7VARB$W-Wyr_S~4kUaPbAa9$A<ntV!2g5CbW~20&ivn;AvLC}!09Q|h>Nx=vhz
zqHK+Y*NjIm2ifb=LitSTU+Y?!q}yBxbxd!I;}rvJ<z~4_QvT<4USKyHh*4tzYFSzj
zB&mqmK-=FxZ7bS$nN#_wA$RX_@mpPH$a-!Co6*g8x5$wtDFtgPK2dlqh4Fzl4r{?_
zpdMh#eScH^nPIVzFo>W#WX%7S-w@HqKQBG=#hZaAoUc=k^gqe@`xJC2(S;oj#<tJy
zKV|Z1TVA}OA&bjDuqxz_6N+c%A^NUOP;7ZwR%v`s3#s)6|0o5FJ?5L~<dq8jV&r`;
z9%XD?#fPD+`)2#Uq&&Fzk_2Dbv;2R>UxGhHMtGdW27{mJ>EcirToAp<LLM%gZ*(>^
zJzjl~Y`~ec^A$rImxO>GkEIaXfJSL(OXsT-E`enxgwL@uhL0>OKz-}}h|+QDz9q`Y
zm^EjU`U0ApOp$|8cEMFt3#tHQxHRZFeyWqY=fF2#$}+PZU~tagUO%SI7OoFMso*?4
zt8||IuOC4b((y==jL|*E;0=cV_8%%ncygq%vZ<o4L=W2Z@GuO{qET$5$3+%ig0z^P
zd;9Lyy8#ZLW(r-v?*tZ-Lg#;*UU6pMpYdtaAnwAP`sHDtW;{&f;gSr<z=TBuhO<%{
zkwGgvjo+Ik&FVKD+Kc>b<$8-Qfv%_v5%u2Bew__lh`dq9=51*fNeOE0ywjd8+;JKE
zoJRz$YU5`bQQRf>Dr&LrxBk6A@@Q;Ej;T9|v5{?7p%ZWedl+Tv(DLInTTBE}dG)Jf
z+GWv`5tFNc=1%2+!4j;#pw6qgWmgC-h$gC&FSS##?EZ(;R3`U6;=%o#*pM4S{B7(N
z#De~LCf29y<6jW1ZfrX+AQE+KDXg70ZJpQrUa=3fF8be`n>d<X)cxZU%|&7c#wzAO
zXazQHDLp=`A<z93C&=-=B?=RyBDwl6D=P;+ghBHvK`?}vv-)lQE9^7;sYP!}a~z3E
zLeQtPrr1)R!+fQM+Upz^`wxRNAp!JCgmTRT=_mc`(bUIXyCzbJ`W1QmM$FJ#m5j6R
zMv4-rUb{&5fB4whp_q+?n)^_VmtK_(5E!C-C_8pRQE_bW%NH9c@gGV{`#zZ2pKb?L
z-DTpfq99GNN#MrN{bbs>cGBOT;0b@%apH4P*36!<l@$X5i{}4M0jbN3p`0l9S1Apt
zf~dNMXMqQ4eA;QEVJAAG6F>OPp9}8VKOsr0jSZFaNuWOC*w1Xi%#FU8Ym!sZcRJ|s
z0Vil__T1;@d`=*;Odj0o*0Sub?3_c>DY3Q~Q05U}X99B%1RBtGmX>EBO#Rn-tqw<y
zr|%>{u5<UiD+zVRZXntt4P9z7{@+n<bE};G_c3Zp9J`|(LV~-So2#>wz}0=93gL5P
zixIDT#gQ#uRCQB+`;yA*oR!7JcK8{!oko_H+s8G&r4=6Oi)W9Uo%+Tu;gVO``el=%
zW@tT7qoJp?22${qURcbB@HE4}$lLh2Bj?NM7v2<~JTH=N*@Q3V*I+SLITiE$oa%q|
z+E-DjTr%r~zV-^7;4`-5nF=Suv+la)L-#)R{)Dqyzse;C_8;l@t=Ba<DK#D|F4Vm!
zEOl((3>_GY>vmgmm$&@4{h1uApn3<n@zgHg`4%5!ygd}$|Ahsjj0l%!>fYjEW{6>8
zh{4LpIDGFHj@6w0Y3K5)cKcr4Q^eH6@^2$KmwB!D2{c87hu%}$kNwQ5N33{dRPChV
z7A;19$Cz6?t$*%*k^Fc6bK+{()Hhpnezd1k#SJZm4J}2Lo;en=wlKA*-x7|B<R$wa
zcG{i&#jL#XY<rsD8{~$D5zpr4CjSq$irAi>p66i3fq>L2N_ib%nnyFlfat;YdsElk
zeg1GmF|Nngx}EOxpVVsM<csIQlSQ`JScnT1s39C&kz=T-d&n-cD(dmT?41?!>(`}H
z^<NKERmGidZf0JTmXT~Fk#a1u(4y(+>HNV$en-mS`A%!-lU&V*QJ(@TS}$en)Qxk9
ziaDYa2|4lkIi|h)tS?TA?*$ztj4p%ynMmbs>;=VzvgDUqh@E25X!-kB79<uIK<N!M
zWZHefD3>nsS2n>x+2UlO=|Ngl=VqTtkl0FKhE8o(eRs5b9I}d9+q<(;<2I>u2#b4v
zd-S;SIInu5(ikpTn?G;#{PANav!%z(hG(NLR15Ka&HSh?Btx!sF=>(T{4%X=rOvX)
zxdQnQkpyN;yqEC1;G;e4ovM+eU>h47S7YU2=Bw+>58El;zJ2=$a!kX(I?SCdGrwfV
z1Qw6m_wKbrwjUTu#H<=)LB9py4=(@;O-&pyzh)J_6XJ5M*^iHWSzc=)hNy@=A$=Mu
zfk{}Uxw_~yv}EN5lY1FRHH#RNf_&_g3!RPA_~ckMJU&<cNp%>36l3$DZEvOKRm%8$
z!{iP<X+2V*sj@BeAB1Z%mTg|=bO{i#o7tXVmVeezhIP|(lS#u!%$;5E=iLim9joU2
zpY>;rI%oIpaKg2&i+QC(3a#aeq9l+zm@mY^cIHe&$o|gq&BZi35^X+aV*UjrWAbSe
zElFPn22dJC@HHH6SAv8b22W2<w8mFvGz7F6Sc+&kv;LT~yJl=muB!FoD1)`Bhqz!$
zoB?+0)kd1h5Y<>x6|@R(=q==f@1*BY*;z4;7w##a)9AF*RAj>q-z=K1=4$nDxAccE
zEV~b%UE4eSa^w8ts|5q=eh0JQbWjG^@;dShDMWgVu6}T<TQ<IYt{@W47W#pYIW9u%
z$<opKx(8gHWg2zjp~ffInwJp!^7S@Lg(=<j>(_6)y29K}>FDJ2LWm~3h3kGDgfCQ_
zzUIO16c@9X{ov(^Ty!`fg~rCj3}kkBuiu#y6B8H7F2_m{SJfmf6}JyU-tmD<#k0;r
zQH9iddz*-ciDgHKc0Yd%;Q%j&rL5SS%&7)t@>8kU87M7WFJ3E>mQ4bqDsLkQANnAl
z=`ROz%G)wIHs6msSD!Noa+8xA4>r21hW55;enIP#);Vi0fl>7R?^{tdjAt)quUm$}
z|4Oul0q+9AutbHZEIXm6hj_a?NGzySse+WOwOzI9Cfg3~z1zOJ4^vA;Z7p%pfl9so
zqO|mu2$KANZ{gI~{4bIzvgh&nPt#cEbc}BXo|Iy9Rdb<zqo3MqpVB|~;?8NWw?UfD
z(##!9ejho${rDbQGwQMai$z+mZSC{tt<-*{kVCl5;2t>b_cK6rB@bG~&V|i;zOw8F
zos~h_=tyT{<CkfCdJpscBr<i6rs0Ah3q9{&cC_j!E(jA<lai9UM@vf!l1TF72!5Wu
zAdaj;II2LSV;dC2j>F-IGag9mL4@xC;SwU15>3u|aKd-bwSN1?GUj@bBWUe11k@Z_
zg8pAhR|P{y$cjPRc`vIub9#)fefi9(=<4QjXlF_9R<j8K9@1ruFAIO(HrMw)TU>fM
zmDQb{@=X7k4})^yHzX5p^M$M1acss#o{ZC7Fi6Z{x?%jC{IaYFRjY|aW$!6)V^70P
zbVCI2z`LyneBAbF`1o~o*A2$&0G>ykx(`4U=%itE&<jZo$NP6C`wtTMTi&Z6TCiNp
zCs#veAvLE7RDkB;w$B*x<*LL;BCt1b<@L|NFbi_ur@6Truq5Hi6li&m&+Gh{tQKcy
z;C<44+1MC*&cRAj5*yxj0j3DpMaDgiv>{)w{T=P_uyEL&*Yl0ZZd1M=s8~HeFR`$>
zM-^)no{L7+bkJkP0TCL$djXBIuaY~R8^5^d75}LaXMMc5^eE<raV}*!m6~kV5Us=k
z7c)ZSDp!D@&a1O1-G@@<2C3mNw}s?nW{yB6d;e9Fy$3!>Sbl*p++!h&rc!K%Tjhzx
zEd45p&~_A@X5s&@q-*hKa{uF_bx_)tTkGYza&igrE0?kiS#nKoNfNo7@^Ua7vBcat
z=_r{?J9HZQoyc8QMl#dfmm|M83`0i9WmHElzt1}R3!dlM^L)Rb@B2DsB9g;KF_n#Z
zk+M+V9<q$jdh_NiC|^7mN!{hb-1i*qagGoV&IJ_UJ{cKOB2ZQo5CECI`w(JB)TDp#
za}cs+&o?0wZ<o>C^WzZCV@q_MXL<Q4=#2ec%%&P=G0!y#oPTL&wZAIPiXXFm2cF}C
z9$^J?u6PTPr{cY@UL7|*eR?YtGUZ~ngT|?t$uupMl+wC7p(<X5s|&F7kGIW#B~HIl
z3}u5z<%os`e<eB$QW2r$To#qK3*c%_mMTO0i}%xeph^Z{7bdH8dOB#6;VlQAunCBH
zgj4&!D_Y#ffW{Ph@gG{M(}RO<MBAU%vs2YS{8C}-s2#N8NggzIi7a~(6up?YqeDD&
zp9dhamjM@=ns?$&ev1IqmPh)4Hc$<)Dv(E($e0Jf)coT4^L0k6PxT~-_3F*+s9c^X
zoeEZ7D5D1sMg)<9RKZS^A`Kl`w#dnFOG_=HK9&tWAs@zw-R2=!TyS6q-)KoxTkto7
z(V-?#lsDZ#ZXWB}Xe7tR1TUM$tKeRv89Z^f3#9N_*Mbk?NO9^ANno`7MRko}BY6_7
zhE}uIqK?N13XQTjLK=MGMbY@}mFM_J&f2n;tNMvZC4^FeeIO{BTO1@~;=tep>I+zx
zQfdz=00wzIG&GGD0<F-LHs9$6_`5qhZNTQ&DiDI`J+k0fz}%J;99&@Ss@T&47%zv#
z5(mKDz{n`I?k8@aSoD6M7}5K%uZ=WXH1g>M6~e;*D&wtPk-ckQtW}RHuvc(QtD7G3
zx~9UT84o9C5$2%Mj10Z-KP!Sfr#c4QS9d|~O<4Q3^~yu%v$aijkyks$3d@>C_(=FL
z!}u)9z?>K1#EEx#j{haiS1?#1jKdE)bJAb4*+}4l!2nuOyF}SvsdV=&Km2929|vWB
z{=6TV{I~6i`r+W^Z(AaICb~$1D}=-H*N^2@VUz5PDlk<7D`4DK%^8zH@@2kHO3!>H
zaamEkq4uo8LJBWrrw)IdbOSYinN__q`YSi`)bGHuRE<JbHisWJ)JF1hb{iZ%r@rcD
z_9%V|M9o-_Ug4c*7}K6}#}T8j4UYh~C5wmydC%{rQ41g=sG$0H2=Oo*fs(hZta>=O
z<3l)bFDYl8FvR_^?cuq8kWUGDGWE94@6fO3mfdVyjPe8Dwx|zAozfzM#Gxiyx;S02
z-@ib}Qp{R&y(obqtoMvF`wCCCEJR-mQK08rXIK|spP~W3q?fmMFyUdqm(rYTLUd!;
z=N`@J&DD~Ku~yu%nc4VP;{?6#RT{hnJ2#;|Ns}U-dFsN!#;y!1hSj>9@U^E@oN|D|
zY-ot`b8#8qDx<8=Xv)>@(VPiC35Q4+>mcD`0(=b|81x|I@9o$aig@8(Zy=!Zy8W85
zUD~drzc6`lZ{Rb=VzKGFhO{JE!`*iuT>5_fEa7Ic>C%SXtw`+#`j2n1!N~rq=A#VM
zZYB4IAeoGq`ua-FFrU<&2LWm~W@i`FvegYG6T_ra!{j^%g39I5uRqFWw>kIOS$tcA
z{O?n=-dAAzufHtU-jbi6f4w9}FX*8Wl`D{F_6{9@EV`m#qrJ9T{+CjLv?Din2!vp{
z#40MD(Z^ajIP8lqN>jIi?*g3t`XYB(Zoof=h!%My?$)qHqLgG(t49*XvI91bFHp2Q
zoSNonA!p~JtvT3_4Q6kSZW<B}%Xz2Wap{*oT$?VM8x@3eC;zN%)S)rUnaYpDItGEm
zj9Z=V<obTq{ZGzcqlV}|rEQ=3A8}GBFF_SgGx0`7pKl?y^w}w_SuHxi@E1YufIneo
z*2iElrht;mFDMWN8Nr+aE6iB@&XxrNMeB_!uAEPHZbVGTP|#wVo|xo!)Xe+eFE;|e
z_Vx_p{X6$tTV{m+85&{-{QB`+lG3OO8Xt0?QtwcnoRO2fBqiML{<(GzUd0$D_C>}Q
z^L{z=q)VT!q&aFqKF4`-d@#*~5cj_Gfd)bRUTMz9qlERpALq>Ua4+TVPAvV{9EF{9
zHhCiEG$RnWWUJpM1I;p)o2vk6b<hp)f+yNs;5d(ncEBW~0WaP{s9RtvwdZOOqQg?n
z%tXwmer8<#h+Zc|H7MGmJ%#uL?nTnDU$+O}!^NfAiqcgzrHqe`c&J{gK`$;Zj4<&c
zKwS96T9|p6pC&I@@sB&Vc4;2K^x*?Dy4h^@QIOR?+1}n>-i5|f;7Tx-VH;~VVgU+}
zLZl(gG07=|(wYB0Atzh%D;4}>9UZ-)^ueE_o<{u9FG!-~^v(T|Q#pP57<Kox?TCYX
z&6d#)CynmDUV*TYuIY9)c7>>$3H2OOfrZa>a*<X^I5qd=+?XH>^LJ2!?W!q9jt&l9
zxEb2K?tT-B#a-Qq>M}2p6IFYCUzDd1eGRaghSpG2XN>b#EUlNJP_?cMZ7XCpMHH7v
zB^YpZFVjlxW^L!`wMX&_)ueEHaMKGKk78?en%0?#n90QZ{<G|Gv6@Xa{j!a~CFYXZ
zo{3P<52%YZ!4wo!_CwxpX`-9+iH+A+o_EZ*N%dGwn)Rr)T+MM_uQh(@?dL1b@`34?
mU@st(@~cn-)~kYt?{`!)bB>QBI4&JUz|V&0XjN(HllXrX$-;X8

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/stream.png b/website/content/doc-2.2.5/images/stream.png
new file mode 100644
index 0000000000000000000000000000000000000000..ea96b46c1639998322b054a9808589ba4b2d297d
GIT binary patch
literal 10336
zcmW++2RNHu6t+iELaRnq#ok4YQk2GwO_iE8YwtZ`wu!A~DQee>#@>_^rAF-<i5fL)
z6Jq2~|0hrGm)z(1&b{~CbIyD3c@IoaM~&td%Pj%|0vZi<kO2V!;R*hC3<Vj!b%_3j
z!#@ap4Ahhf;G_4q@PEi`z-k}@+`rGK&hj*T52dHNsSp13oqu0KWm|52d?&fDhPDd%
z94R9W4*^KHxQu|{A%O-+$tZCCZ(dNg#fuMnkc>*Mj1SZ)G0(C&xPGtzkGYP82mz6*
z_6DHNxZs5cEj2Yw7*tbdm|5-YPGg2Y(Om%O1FwCi7zfw0_nHPDHjJF}vB~@Lx@>W>
zE-&A+j8+6g#te0}FRSavP%gCrVSQM}Yy%tWFLHXQ=YK~?MF`$vCvu1qh(@=+o{5lm
zZ4WzZjT!z1j~7#?&NUJCMFxM8-^cYuXkK?R^G(VRUO%ONGvOjIrITxERu*~6wA|h!
zd+ni)>S=#b%UUWW*NyYE=F+ReJRz8aOAQ^N>ZhCQ?3ivP5Wk8*^aL+q%nLpcB)mkM
z)GA2bnk&QYm)+>q+U`WW?Kq<)ypcO7!)g{|J#%@oS*L4xDs^k7#h#RHwy;=7C$VKn
z-)N1uN@9&!Y?VZLZWE$vBmIQFPy`wg&wTCq#_~goxO=82i06Rr5lai%If86-H8Qrx
zpi%y|j8Rm$<Uzvx6Q$@A^=0y&yDTMwk>#g1>pl8Czv$1kdqm}6*RIPCmua16)5$^z
ztOzo9x|%g2Sf}re&7$8DVF;&tO1B};BNigi#L2`3MmV!y6;}8~<dyr6jk~-g7A3Ba
z_`ZD{ABp}<TObr4niq4E9Q4<isGM*zqFs2i|0F@hDL9EZQk2N-aZf(sj}&g-T+k({
zH9IVT+p~y=Xu#!@{M|WL85Lr?B%a20!ay+bno<w%W3kJ4p`E+fAm#&mYmzSzl$R)x
zhf9j6;Q}v_^zgj%ftwJ2zq3ILTOdI;@qJ1yQU&1fx#ej*t7NMjVYUeE$deo{o#`<%
z*+$&k`9S4s_W*4^E7BX1Y9h;7(7}__Rn7?c$c1V29%=pyxhJ|mNoDtAgCNrVbIPIu
zGeiMf^AE^&c?B<pmUrsXrHD6((325?(CUwJ5tEd&d|0a_+3PMX;w{xq2mS-Ouv&u3
zh_p38c17eVf$2G}k}&<Ln4((dC7OteVz!1~xN?2n^!63=c?6GZy<KB6ulY)di$SYV
zky%C8W36j<vESiij!%9k71W{^PMR-Ij~^|+2_m}9vA7d5%<zKnDvAQP=F>L1mAjq1
z=ksrdnwd@nE-5eM4UCOq!%@U0#8-O8)AXj23>32)kv*4O+pMyUOEVe?KG7Gd*H4Mh
zGsC+L-4ZfYrk)|SeHwOLN_dzXgZ}1D6mg6V)ud%NRpFj$w)8*<LXEGFolLg|DhjAm
zC2_v@+?xG=ZW#YL%~+Luavj;B11aRZS3G`hP`WSSX2gWIL`h@1!xNTe!1C+mAevx7
zu9YWWEkH=ddxv{W(sjE7+vk*dG0eS*ZHb=m_BaIjqzPzw7cWA-yXaNmmW0Q8{^qEs
zU;5KzD>Spry<}+erVOJxh~t5*QoanVuil+)d*c{=1Ca#?Y%ePISFk7ZDr?oBV1jbE
z!i}!C`GTlYUfj3=t9>Z}jN<*fzy}>6nHnsQ3o=#e*?&htz{VFEpv924LK{KBOI<x+
zP}EO7nk38tYOO&Q=yGmts<Xg7RXd(Ktza0X7_0s`80v}0WH_8A=HB+uIFa7zd}vb<
zKMm)n@iyHNt)$&m<&y6bQc^U(wr4-Bi3Pp?V+2GTaW^9F2Bu)z7R{#jIJR|JPcMhD
zIOEgH=g@QPFlf_(<KQ;Hc^(`V+&W)1iS*C2Y`!z_Gx3-GP$*?^x>%h_<>{rJ?E7Cs
zl3)Ic2s*`97ZkFXH*c6OGo0f75bcY-Ahxa{J8txCktyGlpBcVo#l6#Qz<3o%a}GZB
z$qi@ML@r3Xq)3%2xqn!Zl2zuj59)oYiu&jP^RmsiUlQ_SgWn+X;8{Yqf08s<)H3(C
z_euA0Z!c_`oMnUIA3ymFp6<Vv-S{gz<|SJmjMlXMVQpK<L)L$Ccb(psm7w%%R}Z3#
zI+}K19GrX{NqZrltzf6PELT^iedxpGnJOAhx^zd;zRRPG9s9BVCwM3PSFVkcbU%}A
z0_hUI5o7elH~qW!!vObKBUe4-HMkL4ZxTdfw>VW9hFR2B^UgIR0S`Fi@)>QM978H7
zvC~Mb!+zP6#C>q}y5B_nmLLz{TZ((n&NpzRDRN@QER;WPCIzLudx3yYk%ZmXr$16C
zGD!a=c{aNnQt?l&cjHRdAxhJ`OorFG*sogvx?;@lZF)%TB>Ju{zbQN<<+u0`cdpFn
zOe6bISkFtSe2xX3{cJ1Y`A5;{t>?FaXBy~{tRk+Kn7LnvkCz4Nd`i#A;JgC29mFgL
z95ZNYA6AkW`}Zy9)@Z25c`xe~eK8J@c{dlq7atZ8AMgyCy!i)l>0pl8>QN+u=o$s=
z0<b`ScTNPuB;ztqkx+$Le>TdV7_o8nF=6!;GzYhl$~LsXdY+Dy90q$*Ay}<69q0X$
z92p9cci0Kw+(WjG2+DI8=5&7N$YcO3g}oU4`8)See>>m2f^(ervXyUmvvb{-;gjh<
zLVi8D+a_wnwUhcgzjm4S4F@2jS-mF!hRC!?@~g#65{U?>o?5Q5dvC6ma_Aa`drFaA
zbX5{D-c~l{9kcxRqbf28EOlIG>MMG@w6SPO<O3!_hF+_hv$urD67a9iVP~u`;TWn|
zwryBqWf$QU>_mYvQ8sx8I+9|*daH)Bqe9S6<S!}eQZk6)j8kgInV(c?42ER|Y4ifN
zsr#ecg*M9qNUi~tLs~X3+k+@yn^j$g#v$wU%$pPERQ9QDI6r6c-LHZZ-G12QcH^U5
zJ+lL0pY`&iq%j5V1So99)cJ>@4E=7`a-$%UsXm_h3c3P^KCwtlm~%JBZ#Mq4j2o%_
zr6&>t{ubr+ejb%`v2zeBkAhcK@c|MD+WLUgx=*ZBZCh+g5G~_%0n@F&$fl;)m|$kl
zk0d)6)L=i#-<6i!se)5~a_NV>=zElH8ci~B-+QQhJ16aQu9_LdaNP%c7PwoDA%#e9
zjg{*xdYE&__Qza?f-vsXf=91r!oZPZU2$`8tonrImNp3fbqi@cCzlsE&wg20JN?7`
z_CZO3JXIUwQ?4b0@8%r+1rKaJlc?4u<%@+NRlUIBgIqff^sSDMU!JjYr4$g&yqVA&
zEE)~+92g|hh2aW&F75Tp>&|`5u=$)y=oGqbZCQ6gz^c1$Ln}?TpjWL<=-GM?IcyP;
zg`ZJI^~o#K6K>AUzd6&3WKU6v%$bOP%l{Rmq!y(wGJIATL)vBvJh{8<G+{aAY%T7|
zc%Y?hBF*5wn@mv4Gyfxq;g55jUfy`hdfgkfH@)Ne2lQ(~>%|naA-0iH(w{r29_!EL
z2jV2#@}-F}yb706+V2&f#|Rj6D}<1y4tRR-Q_8lrk`Ij>s4C|5=~?s`n1whgNi+J^
z7f0p$K*l&SEj!hJS3;_|U46KxXz<2RDTU!N-;SL(ukevg@)W!$@VF^b-9fH^g4R`=
zVx7?jhMJGjEBZccMn9~X=g4sgF`L~W0cya7y>`v8T3Lj;dNQir8nPJeAoW|^6e7eo
zf}Z4Zrm2VycDW@>P+hO#^~sInXCGmn_Jb(WFl+HB6TyW9aL%i7@}^H4pf>=vkWx_%
ziWza!hD&h5Ez=V}koje(X+x~}^a%Y@8f6x?h-l25l?@guf!9IdVGs>M<i<D8R{JgB
z;`V`+?=F6J-Ky1S(aE5)YTP}j-|nQkV@2%?Id<bqi=Z+yislgGUMnT6k56Vz8}s$I
z*WQA8n;VdEZ@L3g;DZf=w&=7c)bOa6RS{@9uO((!c=rdBGpXk@&Xtv$tT|83g}|M3
zf+whQdYDb@XTm+M_s2TA_h*T&bY^ZcmIB}2Bf`C-z?6;pupYdC?e8W?nMHUES1NL@
z$}Xv`ahr2LFB*4b@2r<@RwNBeMhaDkzTp;U!C7uhe5eRC{17?nUS|v+cri{USU|3z
zM0@v)kMI?xG*-E{)bcaBnLz|QK+$~GK&>C5w|X%k5p${nWX7hI2u=!<hTjfN9}E{o
zGA_T1**I!&54|CmBy7z;`6KB;+|5N#f*E<^Bj!n)I-)3Xc+m_vT?il_{aZAa;Y43w
za)&gmOauh^S)>ypbbxMaVdQ1dxbI+1>u#U36!7B43kY|W8ULVsM{-Liqajkcrg|Ud
z+k$Q{`k?-)ibs6y`<F_HdW^p452k?q)bize=Gm(t)05^jk>oZb<D(52ozjd1&c}v%
zDYm3<lon9<PEexyj|1>+SHxU`tMba6eGcEp=P{3uK8R?)vT}~<Dp2@Qd_7l@JKZ`Y
zY1Y<YxRLV=X*P<y?58z)1wCH`Ef>JrMlTY`ZrHC`S;RZR(PR^5l056lgsZTLQd{!n
z4NG3Y6(1m63x@07`jwq4#t7%^%`U)OwLMI#yKpDWN!iGZd$S5AURN>kMU=3cXK~AP
zZ08ni`#W-?StveO7ub|{G&ckI?)p5kTQjsw%I0EzEHI#@`J?AIT&9Kk)E;di3xDAi
zN9?S~8L2k?sRJ<I+k)4n+OocL%&tXWYl|xQgTpR*(~j~n-C<v?!;d!YErVL6b1s_C
zc}rgk(qg6Pcu&Dl8s#oc*)ntD&<~#FW1~z|SpctX-Lz5d&%`${&kgpxH}$0F@Pr;8
zhN5{L<fQbQ_wVaA7bs_O1u&V52I?K0NRa34v6lP=sP>@F1c|k}@)UatAX4E{?8tqw
zSx~y6R&GmgWKi|{-w8DBQT(<L<_%e}YdP*E-FHsuH$BqC@y5VHhxTxV{DA%OsZa0r
zfy=jmf+*^zN@`=+#tu13fsJqNd3)a+!KvlYY^*kO+Ke;vYlw=!)`dRsW3YXHOKSw5
zuG~vwPmY;E1I0XFq8$g={@1#2LGk?S%QfM1^|y=)f`{D|tf-vnoQD>=7^zSthJx0%
zdsSeS@nM+k*Kz`Mv1cc$t6{tV=s$K56`r5EAyC0F16EKL`YwaCMMpG@-=p7ouBcm0
zD=)g=`eyvomv;}wIYYmb-It7^I%5MOj}SW7#gTJQb_IPsvT6+096?btu_a6Mw8J)?
zQNHwBQj`aefyH5OB3D`LDx{nzo{DpHjcu8B3axhDb5{1!csomIQ#wrxJLn;oK;mAq
zu)A}Gv|<FYSL|ty9N%PsdtGejob4?_4Yed;&}wuQR6yq27cp@BXjOuV+y%{2jQN!f
zl|JF7u}yCK)`Ls3lGv_Sn2Sqf+&izJOwBZ*M2{^cxwO5%%x;?R{KOx@A1;m!Y%Hxh
z(4ZD519oUAy#(y>cN~U=v<De7?(Ip#lzu}*mO!fW73%nKdBE5W0boo7Bn;qW*A2!U
zF={`}1iV<RGf{2n^5D)ylqp;W_$F=m7cZf~FX5vH2BA5hn=lOi9L#W0(oQXjPiEYI
zXboD_m8__OTj5IZ%sm6yIEpEkKPD<%s!Q*fp^U-pSfwiLpN-AWYv~I=RthKrcE!oY
zj>^6&=kfT}(rMTz7TePPHBO{rC+kv=Sx*u|j7fj=eag%%)|!3v;*LLLL!j?Eha&Gm
zx|nJB`#~d|a_^A`Z(Q>gXf{y!?Kw`gH$zcyH9uUpU^UKtbFr$fN3r1WW`}G0rE}EF
z%-^Nwq^Vic85_1TsXfgFJnsdAhrIXP90(!cJGWZO)sasjXG<4l)RTTrKUh0*J!7jQ
zoeP^c<jIA7UH_y&w4#NQaGyMXsT$@yUN>Dz>_LC88~XXIWfgKO6n3M%wxmBq`SQpu
zC@p<z?Mxa(vC<a9Ta-wltDwXso&5dHv07WdG!LjV(PaN71bFjQr0)oq(^W@*(N!`g
z&ig!c!QK_lo%yJ&!?Sjf*i#s>CN}*?9C&;!l=nOdA@1q8eM#p3dU&eq&IvQfe~k@9
zW&@GP807g_rjstZ$q56+vHBWfc-VBsOLfgqJy~PwVHv-tX^8XwxGQYbfX?l`D8rhJ
zi+*hKwTakGd>{ip4=V%lO=BP$G2Du&Ue`JHk@;Fi2H?gE&aiHQRr3O#?P_%PYyDcX
z@Ml~{_TTE7=_vik=}fm{dnpq^i{1IYi;4qaq(Q^vQGe!ei4yKv@ct>BsYb)-1N;)S
z6-fF;&11&9Kov=D$-#Jpk#=-a4U$X^lhLUkzXv`4@e@>iRlI#=_}Dh2WAK5&tT$Tn
zY@$!nG_&tFOG(u<yAD^K>DW|>yX<v0u(+FfuyHZ@=W%*B4&x4@cO^!k`>O7syc?Ll
z*RESW56lxWWVgyVoM$opTEJoc+l65U^VGEG6sgJ``#HnWR^)e`RaUmOXqMj0_MEcO
zmTBHIqXw|st@`f#V`*{hz60fYEQsvp4|3zzvlzA}yN`~eRbN#9<`o@o+@A1Tq4Ij5
zFTKpBtpLyH*CD#;`sm5oRYL3Cj%qO`e}EkQ`&R0$N&TD_Qg!>XHCmUa&S-<4lI7iY
z;Sz9GKaK3bMUt2WuH@RaD9Csc`PB>bq9=JLe7{!7u8{0~1t`H?Bo!IN#Rhf|+AI~_
zY@NuFb{Th{ka-km(w4z+j?+eJ=+4CKC36dHsy`F7uR!UZse)YmuD*d>JICWn{(>mB
zH7S2!sa=BN^1lYbq@;&ep62p(zv4r_DE~eXgbl5te-I@J+AP#^EA!W@;_)YvPyBr6
zB{Xqcv7m_4P;s5#wANoyqXkp&dP6FPg)<D!^E5sqhlwD86_};fsc;UIomqohZ_FTH
zY&z^}BlF@o{ycs+sB=GmqcWSr#Z4WhT|2AohId;liAPLILW&*g(O9AD@W*T-7zF*{
z?`_UWuZ)&RqykG?mvTB=XPT$z#z1^GC~(uE3bH0@FZ?10wtMmo8)_P2)WD$8vjaV_
zwO^UrfcnkPrii4O>$c<z`dPf=9zA_cd2;toQh75WgoFM<q3C;H;h2F6*O7&mY^tcV
z{&|-Ws*3M^ru%e|f-3U3zE|qG@81HBPWCWH(Vbvvje`AYt`G*#0lH;~^O+viRW`+%
z^tLvxfx$yYV`gNjE#<GucwxYPku7zaWd5)>gz>!1VHLAoSg<eV+4H3UYp;^uD5V6c
z9jw27Q~j<D=E*5Ckb6RXCutTLp1|W~XjieZ(zxCs7huyu^5&rt%w^(Sit1cX8hhdZ
z1cxY^HpeD;JXAJt^WBxUgi6M!oj*odAgd%Ad%9hSGAj{iVBRlHe;~SmtE)NH;=V&W
z661XOVd@f>i`AGRQ+%hvip#SAQ+tfm?=DOkw|C_P7Z>kwR{dEAZvPl#aGyTwFkPtA
zK}BoFw4e6H44=LPy^mp*q24<2Y}&$nByF;+{|n(+ghQfNH;7^IGy7~UHPRkqX31m9
zdzbMbb$C!j=#45+chePR*4!nC;t?Mk8~ftw<MQ2+LFDvK?aqfb7(Af$2SO+F=$*Q#
zz6%%qg+of-U_klkDOnu@$!x`v3)IAKDEE*JXyjvKa}<!lqb}ST6dlr+;Tty}_8BUB
zWIWP=t~Ff@ZiPq<iq~$f9XW}vyqgd^$tzBRz8=xXxz0W}t5FI;+%)BwWF9|Cbxn(F
zrC}t~qz>cJrz`D9<CazQ=y+9)F5rG2#Lm6gUCOncXS;df%Jnpjw+b?A*U<Q$LOx9I
zZzDITGY>kcsL@8hNpE^n4iMSQj8Q>@jGRJsGJQDWgT)XeyTWx07x2<P;w+mC>ZxL=
zc^x*UE8VI0{I<owwFmKyXy?cHpR9~nE^I)-v2uM&0YMf6rP#~iTbKEuCF)S`jI#Xq
zd~O-!e=ru*3N?&}gx`r-^n5T)8o&(E1MQsUB@Te;r!EP-HxGN`YI;cR_I1aft+5#m
zy%GlH@~DW?gEI{8p5{PpEJEl|<98q_>L}2B9!?g3=@#odvZ}&#K~F?{T4B8&)2J=j
z*i<zP&0-_@bxy?BpT6CsytDh<Wh5dlqcHt!euWk4?BFoKpVb)DA`~N5XKe2Aa6~Ca
zFu0i>cfXJO;n;A|rJAV~`vYst4n5G)5-M(EiqeHi&Mv*KL!KfN4t+=v`B!c3ObKd(
z<FX>fBU>N}p{nhLz@kUv8xlyxd&f77TcECwOa-4PQ9lxFF<drldCe>EhsxvJrc&oD
zz_T|(oA_IPobI^KM;&B+xo`c_B($WdTI(>Hd#XI;_Kq=~*b!u!q+Lji@PYtfSdhlC
zO<vharNMinJtf)pVefCzxjxKq2A=!QX=O4<qPD$VjAIiJUt0c4yT0r4+WhoZQekeF
z!^3--%+L~>%?qO~l;!8c60z0u)0oR3sZ>WjzOoK&^cXNx`QEFxMb(x<$2atkl063k
zzRB9W7}Ai1>pcyV0O+*nS!OG{tnQq4gP{jz#$MSfpxZM-rVGNb<LWf>WffWPJ4rM3
z^<ShtLOqb<vka7Pim%O?ZMA+*h*bG7>EGuW<~9eXA3V^u8@e}i$79CMCQ<0Xs1tMb
zzN(xz$px6n&`iHGYFMzPp)F%@y82TLL#GjtCZQ0*fKXocEYeXD0D0E(P_U0pevQp(
zIT7gO*lfL}kapd{WUHlbs5T`BVF$2}73Fxc7pMe7&PR~q2xjC^)EzL?Vh^6>SV+eT
zi)mtz7;Q{7Db&-kTPjE5^n-Z2wERUzf-S13)c4zFHIa*$lylnDScp3Rt>9<}ix8|S
zKJyfAE1>_-{#Cyh6|`ml9n^b}-}~<T1A_&AfH@CgN5*d6_k7M7CrH}KTizF--OGKb
zU2FO}PO`T&Uvtf6itDuy0?Q9(u;P+>*Ba+5b?sebcd`XC593G;8Lv{Q4CZ``(&6IK
z;&Mjj=6@6Oot%|<Yx!!;W;2<NR9C007#YBkY6+iZQxYO{`9XJjA$tb0iLO!>ThBNm
z3e7aRZBj6v7zCPF0F<mwRY{Ur!Z9KZf8<{tU#aGK6t*1*=S-P{k&{`5EsPpfJOcHS
zh1piiPZv&6iL%}H$X7Q4b<%_U0!khnnM6OPv=0fa|D_uyF;O=Wp!Gl?3D!ZGE0^1D
zV>oViw9H%-P?a+e0}97FOAB#nc8-oCfiFrn+<HrwbhsKDxvO!-F!|>wt%lZo6JiCm
z6*KiKmlI3Jo%)iqhZVdt^;XIQd%m$e{P8ezqP5bw0=`#9;!(F#g}g`*Ux#HCt?+42
zCFwAc&13-cMr)12&cBfc*+QbLPZF8;C%F(gf>jdsK_aB1g|-9rXE869KHFyL%YZwT
zHUjVwy82meYhrT}@8Wj+W^h)$6kEWfRMtm|ePD!=8|0(sSC9SvF#gF41y#`(4|au>
zJjO{E;kl0gdmq+v+{f5i*po`%+0SLAv5MPWnjkq~HN2L$ZcdlmLbFMgA;O2U*@vTW
zlyb+nx8~Y;<-Qc)!^J)NkSGsu2S%#s(TKsVm#!`;YOC}?;&qwX!da&f1pLK}|7ZIn
zBcZYS`H*zfyvk=)-cH3W5^{WYw-YP~=)U1TP*lIC=ERw4QS<O@Z&Y)|xx_a4l#1WH
zq%@YVy#s0j%$m<^$y86t)oMXgaW_aZ*t=Hw!DCOV^C)l%6rriUK(se7b)WH;$M>B5
z!gGLr#@?$s!IVEM$7-0F#J!QQ@LXukzGbn@8K^ndJwf>7>zl%jm|%s}1z)n%nx*V)
zf)4&jI9Et?QLt&(OK<}tFDQ%yP>!}R_6sQ*2|`NEP|+LvQ2~a#jc2gAr1P$vM?|-|
z1yJ&8zeA&5h--E~!yg|oH&jsbsPrAha+obNFuYPmNB<U<r}g!#)5t{9C6jS&97S+a
zY+IJ$iBF-4dmhOK{&Z=|>h6|FfqG__@1bpS(mG;X2^Bg|S82a>PK_{f2lpC4REW$=
zkA;z7Um;zy^z6?<@44l{s!oPQBP^7cPjaqYM<4m(O-opiTWQR#EBr3PHu3*l-IkS7
zEiZk>SjNxBq6n1_3zmTb`fAsW)Zn|lc~33f6!YnZwLu2IM(A;FFsZ7DFc^)2rN&9O
z@I)@yuCyEpxtluJ%wwyJNLROEEz(doQ{I`O8*X$=(fM4(Ia93r(@Q?*{!7#_n+qF2
z)b!b*TZJ<|b04KJN789w)26!WGnC_+dH0ESROUL+J!=~Mki%W~e!Esta|0_wtN_fK
zW=jj}Y{R_3)!S*gc`dzpUr>G46AiD`z+UkScIxjJfU8|}ppbYTdC^oIy~Wo8!L7E_
z0DB@u($Ky!)8t2y>W@F}fnQ^x@{#&ImK_1Lj)tLHKzekUBa@jrL49Bxv@{^#N6@?7
zZC`a?wJkvv=G3d1iA0}3(A#ZG=7G-A)j9=8BYc`GvD4JZiRh`A*AFR+v0q2dCrn`o
z(epb+=izw;^$%W)Y9lK{`L)=^;!F_l<63i8Ue}Ra3tPn%l}63&ertb!+q;9kZOf&D
zJ=p2z()IWVfh|-tQmp@kBBN#REq)_xwZ8k@Pfc{w>el-WwoVX}@AU%}P4{)(!Gm3b
zSm}398{1^@qARCPQP`HtuD5i5w#CLZ2#_fcTUYNl8BY`|BYBdq4z1#{+3G)e;@`?@
z`vWd^Unb)773r6Po0(0pt<WaVH+mXIJn5nh8re6tiWB*j$Codu)~#68{Q@(2AyjnF
z|46+5<f%Q9F|_}L`}UZ<Vpj8JRkix)z&VGc%BcD>Ll<>fvePj)KJ~o3VI#wi4?ikH
z8la2W*Z6rd;YTPP_Ch8-SGzR8voeTJSv=2Se(=7?<FF@qdd6fNoW>d12aCxnJ`f=N
z$J(5{w`2SQGij3|k@=B@{Kw{Wp6pF~FY`XTd*EiBE*dY^&-7)uX(}-Dv+^|AQyA5c
ze_~@Ty&DK=p2dfIkZy;X{x3KYk2-`=7JL2KU$ug0S)^M1-<~aBG%i<q{I9(a=G6DK
z#?qU-5`@6`>VT<#wE!b-xw1v%ysX{CjOS9!RBdAYB~MuAsDJE4Hto$|@+(7d95%4Z
zf8LlV#uFX9tiSvl__UcgEaXSha)}I{z;a~rlsphCYU&GIj_+v=8d&pC3l{idR*v&S
z!5gU0x!6KPd=>uSbDMjJxjAM0emy9<KSw2FI)jyg1$FihUgMd1Mr%$_W<AOdt*NN&
zTaSr7=!Z3EQ<m9DI*JNtdEPHnMyT3QtqE95K2ow;h-ii~T|srCJpSjr+LUO%+@534
zR=VS*yb}5V;K)wdA>yS-Vp7q~2A{n$ax*73B9^efPM#DqjBJkV9;EVw@(^9VQAQ~0
zQ`S*uM>VTU$w8N%_A@a6u`-@Ko+JnFZ^DTXeZTcgfA(?BV2I-F?yPsAL|>z*LkrX$
zTnra7kn|0G_At>GtS_)=y2h}Qd5A@3$N${hFT#0PC%too;-r487sD4z8=Mbin7hTf
zdk=ZUY=k5>tevEdnn}B5ME8Xp73IrdQvFjencs0})<7i)t6)_ppjJ^@4u9?l>qGT$
z%RgR4MSCtS%|)lR`S}X9ia9)r3t|IE;O+r$htum(JymV#_jo^tOY$6myoEN;(j6Xf
z#0Z8p3LWk<xE}|b{$@|JM}0agAiW_AB+4c+ua#mX7@%X`D-Lt{k)-zrJkI-(FqEdH
zihQ0$K;P<DbXsB<48(3r#)>A~E0@WtSrVzb(LwXrQgyaulZR$O)7Blfo>MlP3CrzU
zvTC#(HhmspvzPLW_ed7&PnSw6#0bA5YW}JJXoYCm(6_Vp;x%?C$5)$oF`Bde9DN_C
z>WDW{#<ne`GJ<l#G2(r?Z$iey&g>PqX*!s6xq3nY*#jbx_x3n0!106PRm@O();+@Z
z9Z7J6pj{(c*KRbQ$W<?71Vlfkj%NI4{qFuBXJN{B2k3{*n&{jyqTdY^Q%nZhK0pgP
zt7mIc4#v2}Un{Cr+vh1GzjBDXRzYcay?5-;4>M;!74Xti`q@HdXD%-@|9RWeu8apm
zEDxOb{n|XNqyf=m2g8~G<@_6CLhtCetXKp8$g6ha$Pexys>_sn!ykL5&(Bj=6U}T(
zs_kSmNT!}Yd4z68W^<*T?5;r)5ADUiy~XdLF6#mH?`=zUWVg?-X(h$WAXWe?+K}-S
z0Md^ih@f==Hf2D+@0T|9)2$11i&S+g5A4=R={y`V9?c4{=0jY$ee{5dX_OIf_+l4C
zp$FOcIH5E|*6Vh2|3KikGoEfg@9TMNx=clhIVUOd{06jU{GDVauyZW}JK@tNYN{Cd
z1p>tTVcXI_>on>yL}+&69`!CMpqjsBa|s9kIdVF+$4mS=k_!?yPwNthKr<lr%PD42
zZzv%&2LuQ%H@4qE56<_$n&_sh837`fuNn_=exaR~XujVblQ=ZbtvBi4IS=BhA+}@^
z_B|IMXw|E<<@ShGn6l_}4`-fbJ?y~Kg5WA)&@Jd$+8P41Qh^_iP%EtbLpT*+V-#U*
z^+ampy1PnQyb531(G_odv|xtXf|zmd_ES5|b1$~S4kdzh?$N!jbfZ6jTVkqtHbf^<
z(`6U4rv4A}5R)9tafisw%-u#`u8gjVeZQ{svTo1Jc6_kJ$76h>C1#x!;<XgNB)63I
zO7{J4y!|mz1yeq{-I8finYl{3OxqFgJwdE&pKsr$+Vu>yU@}fF{T#|I-kLX)b9^%c
zs@51o69;7^)r?~}Kn`xKh@_71SyS1T8`edCo-05~Hkuwul?{;epRi3vU;x9fL?%xa
zBlx&~DOXEd<zX6Ch;Ec@I5RjSqaPEtEM`q+E4=2@hl$~a`%@6H3WH9?#l1%LF|FEG
zr$`Yei=R1|PT~DiJf4*&@MSH2+VIphMKf&j4R;_WU2>q6@rF>%<Vk1_ZSi9`{McR+
zpVb=ClwI`g{)zdv6u8uf&9{pABVwgv8=PQEQ9Gx(thM|SyFg?kkKNW8m}StYX6KT6
zB1;;WGN<9?ijr{oKYU`L{>zlW-DyqN4uh(0$*p~hAmj{TfaW5kYTwL@Z}NXlqX%mb
zj3>XL+lnOj=l%vkB+9G~v?l&R5FW1a`om*WXCM=;xss6X@F5Fe;5g~c{~*Y%%yz(w
z>O5T`>v%fy&(AtHKc`#I5`@t07^`h67!l0^z^}cZstD<_D%p)CJrsA}fu7d7glgbn
z%w+sBzcV5%!ZD(?2NOvg3F}$y$-33CXR{2jCez<s@mtnhmg_3{f1I$fV4E6e1^}xE
zX(i=saNIq+>F%1@CgNnQH_IevI^h8Q^s*Gu00Ro~p+~$o%>lpij`$iZQFiTqZrfp7
zz==F$wlS#dWB&<LYu(Ua-?f^C?EpN8_cIw1H82Qjddo2@D6Lg?ylqyO{8wSYPdOC%
z9TW~mAaXsD|39)|Ou(+y-bR4@1tZ`--pKGMYIk636VPB&I^R6_Pl^3ePGkW1Itr8S
zhecgD{wvdnvRu<5PU5KiW}(TocK?}I|Nj3Nu1z=;`5GHk()Duf`k&T*@!x;GZ<e`3
zwOo$v8qE5J?-KsM%wtY@|G5acj!^G03t`9l0$yb42!x0+>b9QtM;lLk`5%FXiVg^_
HY#sF<ua7{c

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/tabs/tab_API.png b/website/content/doc-2.2.5/images/tabs/tab_API.png
new file mode 100644
index 0000000000000000000000000000000000000000..6c39787675ef3018de65d1e71f4ad6ad58d66eed
GIT binary patch
literal 1014
zcmV<S0}1?zP)<h;3K|Lk000e1NJLTq002_}001Ni1^@s6^_2#B00001b5ch_0Itp)
z=>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iOG|
z3kf3-1mQRU00VYOL_t(&-tCxAXcJo$#=n^+uT5*JQKLnvB|}6~5QIV9SPOMR7cRs=
zcZF_VZg~Eo-6eD_GT9XbW$w<ZAdRGJ&1`B`N=96n-GxvBg0<DiOX11mx=3@;q!C($
znZ)~BT@ELZe0=wun@_PoH~{zpevJP!iSUI84o1U}bf*5khL3O8@$SJI{;hrzb;SbV
zN6wAn%F`qcojER*+5`W6-p0$nm%*OB0RX52;UKQQn3qECgTD?2aOG(dBbTBLG0)CV
zVIUlo%Ip)RPsRB=*BWA;jE_r2evy$&QTPIWsDmTJUHwBSrO0G5uDi4U@DS8)cZF@+
zpp<&zy8F6a%$1cD&wLlvOAfPbTbvnV0071q9LEv$=DCUEIBhl8_)_`E-DGoflk2+9
z0dN3Z(=-l%o2JP*=iD?+u4x(%g+ii-5F$Qr7zQ^CgS*X>QyK2MGgGM)7-J|D3gDcB
z5YpDe7=vk=;GDy<EKo|3&1O9}a$FZPm&<_=0>dx>0O@oZx~~7wqwBg5nGgb9*TqPX
zV)iJmi#anh14^lIS~i>Ab;&fJKa^59jw75b#rzJ-vY=@i;_)~XMd^5bDWy;p1*udD
zhG8I`PJ2#F*Wa0;Pza?`Nw~3fUN-5}Qz#Uqn5}dYaj!jc0rg6P)J)n{zaQbrNeo3I
z=nu=J{bziw)lgqw$A`5weErmtv=5GsB9csE;J6Hk_rm|%+o&urW9!XM((Vfeae97U
z3b_yZ0s%ylNgRmoB<;thrr-<8q<!CWQdM!{+D_6wJT8;=U*$kF3f1q2>L2dzq&;7x
zxR=kk?#{lU9!T0>mu;*TsVA;`*C*{JkxBcm4trg;#ksoCNZP9#4CRU=>dkYLa>Z$@
z{jq;1YxOPMT#5@pP9D`z-C($#FflishVA5#e@XGBzJ*$S3jmOqAXuEW008$^8}su1
zLP0w7?&B1y9~ka06i~7_5|`VP_UZ=1t%Qk^#j!YRAz!3;_*^FKZP-o@*Cz-r#2WeJ
z+;keTu^$7C*qDyQ1QD)`jp=w*mPvb0<GPrJK7-XF70c)0^X#rmCcpFi$rmZg6$ck%
z-b>nDUqFkq7H%%ZabqbC0OGp0vRb6L`#2?f=B8!R-p24?2#*#^!i}x-vPq{NFKlto
ki241J`5irS0rd#q016{pg<%=UUjP6A07*qoM6N<$g8cE*!T<mO

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/tabs/tab_about.png b/website/content/doc-2.2.5/images/tabs/tab_about.png
new file mode 100644
index 0000000000000000000000000000000000000000..4ebbdf1ec98590ca328632448751c7b9c41b0d9d
GIT binary patch
literal 1363
zcmV-Z1+4msP)<h;3K|Lk000e1NJLTq002_}001Ni1^@s6^_2#B00001b5ch_0Itp)
z=>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iOG`
z7a$Xdcw<-q00h%XL_t(&-tAaTXd`79ewsGB{a>dxZZX@2julNo5I(J!ErsrcE_f&#
zh$kf;?1*-k_BK<!>Y6!O=vv9#T69^Aq<E||2sI#V>9+_Ark4!FZa`?8SyODmMLrM7
ze6}WS+0rDNkmodC=6&<cJoCKoJM%O}Au|AIX>()vqcM0!261V~g9eVr{vSE){<?+V
zzFxy$naBM1rYL0g{OkR=c5e#Ly>hw1)KlQ^KM(Np2g|U&e*ge*wR*bn_K!0SBF}&e
zm)dac-W2+-4&}*wZDt&;o~{NnXGBx83vYflnJ3d57_REY=(>(TAW+kU_FWx9OPd?6
z_P*|_UWjemFio@O)p@a}1Fm{5LCdnBX&NlcstBQVPo}D>6(JKqWyo|&nNrG+ZQCx2
zb7GDorc@rK^hnO(wL_w_Z`rYz-eu*)#>NH{1c3oy0GKF>3;;6>gE7WfBobi&7$Jnm
zghC;npUq~OBuV@n0H!DkKQBoVlO(C+`f#4JU%Bw@fXd3Q%s?OjQ52C%rI5{LAxTon
zI9Zm#7(+A~MJyJBrfC2GRaHSLg<%+Aj3E+<K+`nnx_;{3ilP7j48u5f-<m0Nrz{mk
zfhdX)1Obsqq$rLM0$G+hse}+d;dNbyEX$k>MNvQqK`a(~=6ZBp51_gtQ<5YIg1}!-
zY}<yaszq^>QeL*Yu7gs_l_<+HbY164)ie#1QiMVw0Dvfppp?S0ELfHWN-0E9tPY!%
z9zf1eIB5VK9w?^`pj0Zwhnh3sQmGVUj4{J7Dl&YW0o1gY-esKwJ!OArrfEVH#S>Ly
znkEE603oELdTrYVAq0XTl+1Oip&GdBn?uFOtase?%{2zlxqebQPP@zPhG%RH9fO0o
z=xI3ZC*eshhyATBY_F~1$>aYy?d|>j7@V3y>*a<){51II-~j36W!Mi2PJ2sN7hay3
zX%Kk^G`F>3aB2#jLj|Y(h4FE;bTypzGxtfC3olL<oc8YF>N@T5gpQBrYujn>92$bl
z?S{+UU0tVrZ{Nmx(yV!PHh0vy)1KL}u(YZnvtw0+(E28G+rmOzMP|E>oc3Iyl#^-7
zk8}IQ&bJeDoXSe&CDZgs&f)c=f+CZ@(~|q0H(JWQK{8D-Js;pV<LwoZ*|D%VYhc9x
z-*@zTx8L9-NF;=a{2hM~s{YQAz8aoTa4VSiMHg1`F4W?zQM5K`-t%0DtMCtyBm32)
zGN<PQ@Oni2@OcV9eVN5u$K243Q5hRihELv&!lW@Qt>&HfJ8>18X^O>J0~=9>TfqpH
zRyD*Er#tQMPbi$&auZp0GM%yvPbl#Ais)_^a5Gr!wEKMo!O^_a9vqe7_YvGLC^4SU
zabr~GWP~Ra_<e+{?pZ>^=%^JkNBk1H+Xeo5lH0d&C$5(4t4`U*6FQP<%G*J3RK`j|
z=RI?2RYNjOA(6b(ex+B$W||_iV<EF+VKYr}rMEgxd)WujSF;AD=L4Ah^d(MkDXb)P
z-2Uc69uqF~yPLrX9_?61zLLTd3U3SH>k95CP5%GhUJ>EzN_Ae|fB9mUUFa#lIlP`U
z;q{2{o}ilbq=~L}0e&ATsouSP8?X8Zy4!`4xhFlWa^vCLT;<5DcRZYHIPK?(e*vjF
V4^Z-k=_ddH002ovPDHLkV1mU!e(L}L

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/tabs/tab_developers.png b/website/content/doc-2.2.5/images/tabs/tab_developers.png
new file mode 100644
index 0000000000000000000000000000000000000000..0b23f8d93d6b662d944faab87020e6eec61db132
GIT binary patch
literal 1975
zcmV;o2T1sdP)<h;3K|Lk000e1NJLTq002_}001Ni1^@s6^_2#B00001b5ch_0Itp)
z=>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iOG`
z7a0qhkan~H00%coL_t(&-tAaHh#S`#{&u~ac;!gxxKd-P+G2+-wG4s6+iosV49<u(
z^bjl<pSGxn?ugnoc26TK*RDEy@`96=(QO?Cf>LCB>sEuo6%?{)LLt!Eiw0y@P}ub-
zm5B@q;q@TBml<ib83}C~gT9l{|Gziyeee7JH}lWvP$&S*EzIM>Z!aRUvWQogBA8-0
zI{#_o=|7*~Uw?jtFPfk8|7Ub4^oKt`i?=^o#}9t?+LWmg@a2D><L|$@2m3Fd0sv-D
zMuPa|-)>Hc90M=Cx`4MoTF03;m%3!We)AGeMuJmj#>C8tS^VM;?{vwGCNGRNNj95B
zHk&<`1)8RbWHJfUG+zip&%C*WxrKSm1<r)V-tcju)oQ^o476IU7e<{gpFV}zsZl3K
z=#<O}Vs=z(8-_77ZrirUp3JVcZI6^Q42EGGT3*<E{d4;n&z{}C2GcZst;vIDji=NP
z6h)x`C;%#oA{9lEN|JPF901jIol;5%@+3*3q9{^IDb;n|Ge%JqN-3q4N`(TTl}d%@
z34-8xeyvvHa{{1*5FQr<!4t35YM$|g5b8J%AIoBFU8<_`+)}CJi=PkAWvMSRHBF-c
zsHSOrvw|RSk{BtBKt`<NI6PLVRA{YM<9YRZ-9sSDE0szfGTnKO<IsA&P6;7=<8Cq?
z$DxknP(lb51cApzQRHz(tg5PfEIS-_0BnuAu5;2SMy4c5ln~<iPgPY;CL>RhB%bS5
zmMDr;mSw6a%77{fA$%M=FgKa(Al;iPl}euZ`xWGlv%_ExktE3@1h+^SWLc&Fs4UAK
zg?}5FbCW8*f*?RuRnO}UAp`)Rswy&>3;;mWG|xCiQ6P#U|4j%Py;k{vEX$B2iLZ@4
z^DvZ3B@_w;6bc0_FE68BuOFE|Qq3II=9;EaK@e!YUgvWNf<Og9;0o)vIh*siZO+EK
zZSGd4<2Y2)G+L|G1{^REn~!q=^;<{Nw1NNnFCbZ#Cw2k3ZGYGW#18r>o4eOEQ8JmD
zjyfe4cPr8zJFJ*Hj>9jfqi|FnBZTD)yEH15iZ7M11Mpif$0GClio?|PUE{-ZSvvg!
zn&c-X>$K0#&m(g2B2FzX;^oM+(|#1bYPZpO@&x;j9^tFc`#SA`vuClmzK)ZxO&i3c
z;Opnl(YSXHtxtQM_PJmXKfQT#O5_+gv9N%}^>w_m)a$hW=+Y(31*e_%vFqgQEPnh>
zuhSm7FkYwqZaIs)<>TqJTMZM}wvw<KFGi>Rm8B)j&d+0RJ~UpZ-Fkd{8-3PkVb?P7
zY_;{msPn|BX{UXngigu)e|6fehKXHkc&EL2U}M)Z(C&2Y+3wl3d0>x}GYq?yacCW7
z^Yzc|XFPj${~D}@>1$1H_-?`Fiy4%w1pq)a+-*liBjTZP0LZQBNF@|(6f=lMMEvPi
z1pu&7%%Hh%<H1H9<!S->Vup`NB^2b=^nquWs|CDQ&T^8XVG){ALOj-O@m<?WA|4~0
zs8B$_`?o4QZZ%9?-%9fF@fgATw<-t)1YFxnA`}qN?z9jMi+He6$K7%k+dG@xmZ4ID
zMC8dSb9-kK<!S*pQW|PH#k*@dp1DrHTrHqnEg-k1qoz}&5(@Ig4BDL*(w9~2S_W6e
zu4N#7Sw-`}M!uLqDxsjJQ{>ikl&b|8=EnnS&lfY0h>VAK96Z>lBXmkYws3V|oe%Fg
zczDM_G$P{qR+9gpEnG!3BI4m42Os2WXzttC{_7@>2Ll2=$km`JCBEO>nvUF>j+MAH
zS(|@i8HmRS(yQI(?@C<4m4w3Mdp$)M=EvPvn%+&n*D#SvD2Rqdl&b~YuNDvui%2CD
ze9|iy*5mGL5F@eQTI~Pdr8I;B0-|9N=~b0mlOesTA`}o13J6HAs-E)EJh0LJqJ?bX
zD(>FT4!n(|-ck^c5w2v3$jBEn-SPYO<Zb?K2n7WEdi9%5d%M%Z`QGBvmsM`(8!2z6
z{YpZ?PkLn|mFRA2lnwZWL}a|tQyH`LFlb7NAO5fM%XqL+KQezLWxf%YU^Pr$M|Ld(
z_g(eze2k#oY2n`oHdf*itj8wu#SAY6sf5B+!xYUnw%0JZmGZ^Rzy-nT6|0%e0~^~r
zn}~)*j|I1PHqq|1(C)Oby|al>K)^~|LNqKQ8Wyp;XW)E{AQ};|y|Xz`PTV5c-q}R_
z+&512d$_)onO;@V+_(8xPc$qd7!W)c$6ljLpj(0N(@bAhxq{gxl3UX~7nek2NJRG7
zm*u@z&U!9DR^QyX^!wBN8SaZrQ%bnLmE`ewj3D)vGSp#K!{lFg5|Mq^&6$7v@hN@j
z^l4wo%>x_FeS7HSEFO)B1GZ=$*a-I2*{_7XhKXQ6;5BQQVus}{XJ&9CrQu5NP|wH6
zz;l?RSk3qI8pw$EgU@c?9*xZJD;Sw+SIz#e@!9R$(=VV&;(se_zO<8D^T+@I002ov
JPDHLkV1lc|x`zM&

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/tabs/tab_docs.png b/website/content/doc-2.2.5/images/tabs/tab_docs.png
new file mode 100644
index 0000000000000000000000000000000000000000..8372b42eae2d5ccb6ca3e00c9d8142fffc1b9ecc
GIT binary patch
literal 1159
zcmV;21bF+2P)<h;3K|Lk000e1NJLTq002_}001Ni1^@s6^_2#B00001b5ch_0Itp)
z=>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iOG`
z7Z?)f;O{j600aj~L_t(&-tCw{XxnBOhF>do8z*tPWc3;r(qQAUB`_F>rI&hvR3?WV
zN)7U<kjpHyb|t-8&Us|=EwIvI-I`{lsKYyV)+ICSVC*s|%sc&HQo|sQ)!NK~mGSS8
zNUK~c(BMco(F?x(k1WftzE9t;*OP-l0l@3`VgBny1Q$ZM5DCJSwK{*bu=o28{`g@V
zf7f3c>z*70`u=A#xb`@S_ddSlI`t0v=hZ%b{c02Br)K~FW;htYm%psKMjk`wF8Fcn
zaS~HkBL`-Fy1InnV8C_enDPuU`25@J2WC#k<{iJFSS$uvmIv0*sjCrq{XQ@wQ{#?b
zjH;^8G;N@(^Zeu}7`IXTXQ*ptAH_J?+LcPhk`qFXY=4~-LQHE%o%6)iuI*7f)oeB?
z%d!*z1wc8DqX4KRNe0)~^iMjSHhrJxc@r;}%T!U6p2ypzA1{m4_R379QXqt&P$+;>
z3XbDUTogrADiwoEl7wtFYfO7l6rrlBiEEk$S(YIP0u)7oAP8rpGJ91H%d$pgT5*o!
zEIFl=N|HnYP?lw>q9|vhGEYkBbQ*<10pV~MiA2JYeXH$e@;nb&mZ7RD03e&qnudlT
z2t7H^^OjsyRmidoLI`rX8~`}8Zym$|)XmG~veD)MXgD0E&1Tc~Hutn^dvxsbr0q9R
zuSS+-ExD#?U|ALu6B9kRMuZR(*Vnp-njLyHn}K6yo;E$2&A4wseSM|WlXk}ELvV2s
zqoEMa2i>IoD7|jA(An9+?)ElbzwAodM`mUaN+vOU$qk6#MgQ*aqqeyT?b%_{?hOR+
z(dw#e<S{hl_al@{Vk~l)w12R)1aH7i+K>I5WEgyS{V-`CpLafKzqJuVzBsr^`&c9b
z#^(d$8+SfwFI82vJK8{3=g_E|wD;9e*UUi<I^JyUYRx(ouQv!vRTV9Z_Sbp6K}>5$
zo%5vSwfhHK9SyfPV#c3dnB(5!qMSgfsv2u6%W2$+O9o%xN<pnWG5Eu^GU^QiQBJ&d
z{Hd<Y^{o`@y9D>|7EsPnT<J3NUS7nXwTi*-#3ej<nl+~Vy}XE0RW<Q;M?=0SBOVnX
z2@2w02xp_s)yfmxhzdqUt}Lf9H~W8blrPFXxn7CA_`)2AD{~z3MHvsCW*uwwQ!{{8
zmeaU@w}9!3VTf|Vk$tP}W^yc#pNq2bOzf_tcvR@gIhMENrK*a2QO1h~!P?D(q}_>q
ztL+15?Pd<QH)6Q85$idCzKKhC(I5ubt1ccDEcwH=GTI#t-{(cFZ>2DOF^n5g`=6Vh
z-@e<U=O*nBhxKZF^Lg3L+Z_#`%(56CndrGSs_zmL*VnplkR5uS$v9``Y18wJo3!^;
Z{{i<b8RWajIa2@t002ovPDHLkV1fvXBys=%

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/images/tabs/tab_snippets.png b/website/content/doc-2.2.5/images/tabs/tab_snippets.png
new file mode 100644
index 0000000000000000000000000000000000000000..913a072e545195413c7e83b7a561e10cd3a26687
GIT binary patch
literal 1611
zcmV-R2DJH!P)<h;3K|Lk000e1NJLTq002_}001Ni1^@s6^_2#B00001b5ch_0Itp)
z=>Px#24YJ`L;(K){{a7>y{D4^000SaNLh0L01FcU01FcV0GgZ_00007bV*G`2iOG|
z3koEqO($3Y00qlQL_t(&-tAaVXcSi*{#+9^t64kNt<qqYEGf+hg~ChYMG<tQhaRMX
z-BYAJm<er_*wc>NYfWcQ3TZ7fw-^Q4lnuQ#ok7q*p<$jB3SBQdu-b(};*8zk3YGGD
zNanel?BBRawz}VCXXp3Z_uhQ-`?uc?4Kf3Oj;>A|{p=)yLw(raA4D6KQTQv5$G<(o
zAK%}_)7%q&e}@K{z4`tToW4DZH{LzeW~u@F^Y=5{JAVWA5BC88zCFQieDw2po5&4d
z*ZwY?zCDV=$NN{vd~f^|_5{1z%xn-lcKYza*JoGA>^XC^&B#mQ@bP|hbale#KOESW
z1L(RAMNwXv=-ho^FMQi|0Mj&~>-wheW7{?oi3Duh-gH8@jm%^+3CD4^giJ+IHl0iW
z%_WmkT5@R9G-2B|D5Wq>bDb}xls~X{ZJH*(E+(X!y?D*F`*`P}l)`mg0D$Yd>-?I6
z<?LhD48&qF27m!z$z+l-#uxx52m-$!4u@GLlVOZ8CP@;LB#AM`n5wEQ91fTG%CgMY
zu4Q)|hY>=!O%McTSr*^NyKfi<%VaWq9YP3e7H;(_tZ8HdV49{eP1Bg;IQ*U@Nz8E^
zW?2>kz*JQ&OQ!dG#u(Eyt;DyMU6y4|phv7nlwla0$l@1cSr)(7EHayx=8;GQV`F1H
zwLM6Z1VIo$2&wveLI`A81^~#i3_?grDps?5pNgU&8jZqr-HN4v5CYeA5sgMG`fL;(
z&1@*Tu0z*#3=R$=lgVspLnDMB7K`zkC<sDXKS`2cSr#A7Y}<yWX|2<MT-QY+ktlhf
zM!P4al#fcfu7gqvNs{WaOOgaiDbE1YG%L=qrfFhkW(KONf)LW&F5j%08Hq%Ap^ro&
zyk>fJZSD7RHM6*hc(!`%<r<Jz57*XA!!URQD)wus2E-U+mSyoS+6X+dDy>n=UcA3y
z7`y>ig5x-K`87&rN3-kJX0K7rUhn>bAe5AlmK@q&dj-i;+I^j!2%bENy?uSy9c(M@
z)$lx@N8!;UEZ)6~=TFus?fxT2&^J1YJ%`!?aU=Nm*)wEs+<<$3RcY_&?#4Ug<82~0
zfSp}k=o=lyzW!CE{jF1{(9zvi+BaM$eLlQ>c2#K)9BnJ@FN=Ns{qS{m!q*wt9;H1s
zuVXT$yfV?bbMH1P?F(rWv-6v;wC9#=OwA>bTe3Hu(2ngQQ<aljvQKW&#$-x?*h|oJ
zF#P{f+S6HD5&;Wo6S*ZD=`6)U+Fa+G&Qcyd-t|J-<k!W~Rn1<!=GuM!Ts=?vAw|Bh
zqO|7=?mEAglHev&3Z~`~JnAG8!ROb`AmA7HL-ZUB<NB8ddJcv$IlEFXuU|4?(ix=g
z=~ynf+;{kdjQGfkG*-)=FSz*P+8IuAz%SstO9sRcfk|ih`NUp=o?sZ~t_&hya3O{W
zrsG!YMds980`U<I@evI};*0;i10jMtR~<~pE##JL{&3}L+l65jmc|et(U6+g`OB$g
z|2Cx{w`gNJZsE>V2R*?sCT@)Z06zUN#$VcyD8ZyN==KYkj$63+vD%txE|CZ(ZjP;_
z_Tr0FKPE~D_yvfe>LP>~A{ag)^QaR;1iu!gVl}(>IXSC9(WA&ebt{$vv6o=E;6l-(
zNIz^*rCpViNX_e*o!4=0Vh}%G*;=K2AVhc+<_j(Y{_;xukSJmLD+{T6E2CL%(dOl%
zB_cCla4|KPfY?j$$?5|YM`yjwE44Z*rRH^{vlPdQ%0)H%F;T*UEJe3pz(9y#A#L)S
zTy7*Y=?pFos}MtkH>j40%z$4&I!pNwE|Ew{-K-b0^ExJOj`0ZcUQ8|fg<%!xhZN@~
z2Kjlajb2kfB`}#%YWg)iYyR@hW47zSfu@Z{UVUq{c}=DiSQ;z4MlE~s{>udy10hl|
z&Am)|kfk;K8o}?EFE@8+Z<NH1tWnKg@BRV5u%XP^(xLrz$A23Dqe8$?o4)`6002ov
JPDHLkV1nXb_Fn)1

literal 0
HcmV?d00001

diff --git a/website/content/doc-2.2.5/in_production.md b/website/content/doc-2.2.5/in_production.md
new file mode 100644
index 00000000..68adca54
--- /dev/null
+++ b/website/content/doc-2.2.5/in_production.md
@@ -0,0 +1,25 @@
+# Using in production
+
+The full installation of liquidsoap will typically install
+`/etc/liquidsoap`, `/etc/init.d/liquidsoap` and `/var/log/liquidsoap`.
+All these are meant for a particular usage of liquidsoap
+when running a stable radio.
+
+Your production `.liq` files should go in `/etc/liquidsoap`.
+You'll then start/stop them using the init script, _e.g._
+`/etc/init.d/liquidsoap start`.
+Your scripts don't need to have the `#!` line,
+and liquidsoap will automatically be ran on daemon mode (`-d` option) for them.
+
+You should not override the `log.file.path` setting because a
+logrotate configuration is also installed so that log files
+in the standard directory are truncated and compressed if they grow too big.
+
+It is not very convenient to detect errors when using the init script.
+We advise users to check their scripts after modification (use
+
+````
+liquidsoap --check /etc/liquidsoap/script.liq```
+)
+before effectively restarting the daemon.
+````
diff --git a/website/content/doc-2.2.5/index.md b/website/content/doc-2.2.5/index.md
new file mode 100644
index 00000000..380293a6
--- /dev/null
+++ b/website/content/doc-2.2.5/index.md
@@ -0,0 +1,61 @@
+# Liquidsoap
+
+Liquidsoap is a powerful tool for building complex audio and video stream generators,
+typically targeting internet radios and webtvs. It consists of a simple script language,
+which has a first-class notion of source (basically a _stream_) and
+provides elementary source constructors and source compositions
+from which you can build the stream generator you want.
+This design makes liquidsoap flexible and easily extensible.
+
+We believe that liquidsoap is easy to use. For basic purposes, the scripts
+consist of the definition of a tree of sources.
+You will quickly [learn](quick_start.html)
+how natural it is to use liquidsoap in such cases. The good thing is that
+when you'll want to make your stream more complex,
+you'll be able to stay in the same framework and keep a maintainable
+configuration.
+Of course, using some complex features might require a deeper
+understanding of the concepts of [source](sources.html) and
+[request](requests.html) and of our [scripting language](language.html).
+
+We'll discuss below what liquidsoap is and what it isn't.
+If you're already familiar with it and want to get started,
+just jump to the [documentation index](documentation.html).
+It will provide guidance,starting with the [quickstart tour](quick_start.html).
+
+Liquidsoap is an open-source software
+from the [Savonet](http://liquidsoap.info) project.
+
+## Features
+
+Here are a few things you can easily achieve using Liquidsoap:
+
+- Playing from files, playlists, directories or script playlists (plays the file chosen by an external program).
+- [Video streams](video.html) generation.
+- Decoding/encoding using any media format supported by FFmpeg.
+- Transcoding of media stream, relay of encoded media stream without re-encoding, sharing encoding to avoid encoding multiple times.
+- Transparent remote file access; easy addition of file resolution protocols.
+- Scheduling of many sources, depending on time, priorities, quotas, etc.
+- Mixing sources on top others.
+- Queuing of user requests; editable queues.
+- Sound processing: compression, normalization, echo, soundtouch, etc.
+- Speech and sound synthesis.
+- [Metadata](metadata.html) rewriting and insertion.
+- Arbitrary transitions: cross-fade, jingle insertion, custom, etc. The behaviour of the transition can be programmed to depend on metadata and average volume.
+- [Input of other streams](http_input.html): useful for switching to a live show. Liquidsoap can relay an HTTP stream but also host it.
+- [Blank detection](blank.html).
+- Definable event handlers on new tracks, new metadata and excessive blank.
+- Multiple outputs in the same instance: you can have several quality settings, use several media or even broadcast several contents from the same instance.
+- Output to HLS/Icecast/Shoutcast (MP3/Ogg) or a local file (WAV/MP3/Ogg/AAC).
+- Input/output via Jack, ALSA, OSS and PortAudio. Output via `libao`.
+- [Interactive control](advanced.html) of many operators via Telnet or UNIX domain socket, and indirectly using scripts, graphical/web/IRC interfaces.
+
+If you need something else, it's highly possible that you can have it -- at least by programming new sources/operators. Send us a request, we'll be happy to discuss these questions.
+
+## Non-Features
+
+Liquidsoap is a flexible tool for processing audio and video streams, that's all. We've used it for several internet radio projects, and we know its flexibility is useful. However, internet radio usually requires more than just an audio stream, as such components cannot easily be built from basic primitives as we do in liquidsoap for streams. We don't have any magic solution for these, although we sometimes have some nice tools which could be adapted to various uses.
+
+Liquidsoap itself doesn't have a nice GUI or any graphical programming environment. You'll have to write the script by hand, and the only possible interaction with a running liquidsoap is the telnet server.
+
+Liquidsoap doesn't do any database or website stuff. It won't index your audio files, it won't allow your users to score songs on the web, etc. However, liquidsoap makes the interfacing with other tools easy, since it can call an external application (reading from the database) to get audio tracks, another one (updating last-played information) to notify that some file has been successfully played. An example of this is [Beets](beets.html), RadioPi also has a more complex system of its own along these lines.
diff --git a/website/content/doc-2.2.5/install.md b/website/content/doc-2.2.5/install.md
new file mode 100644
index 00000000..2619e214
--- /dev/null
+++ b/website/content/doc-2.2.5/install.md
@@ -0,0 +1,113 @@
+# Installing Liquidsoap
+
+You can install liquidsoap using binary builds, with OPAM or from source.
+
+Binary builds are provided with our releases, either in the form of debian/ubuntu and alpine
+packages or as docker images (also for debian or alpine). Your favorite distribution may also have
+binary packages.
+
+The binary package and docker images we provide are compiled in two flavors:
+
+- The main `liquidsoap` packages are compiled with all available features and functions. This is a good starting point for general-purpose development
+- Binary packages and docker images labelled `-minimal` are compiled without the extra libraries and with a limited set of essential optional features
+
+Minimal builds are useful if you are concerned about size or memory usage. They also reduce the chances of running into issues that could be introduced
+by optional dependencies that you do not use. If your script works with them, they are recommended over the fully featured builds for production.
+
+Each binary build that we provide have a corresponding `*.config` file. This is a text file that lists all the features included in a specific
+build. You can consult it to know what features are available. You can also get the same information by calling `liquidsoap --build-config`, for instance
+when using a docker image.
+
+Binary packages and docker images are useful in that they provide a readily available liquidsoap installation. If you
+need more finer-grained build or if your distribution/OS does not have a binary build, you can
+install via OPAM, which is a very convenient package manager that can compile liquidsoap from sources
+and knows how to handle external dependencies for most OS/distributions.
+
+Lastly, compiling from source should be reserved to developers.
+
+- [Debian/Ubuntu](#debianubuntu)
+- [Alpine](#alpine)
+- [Docker](#docker)
+- [Windows](#windows)
+- [Using OPAM](#install-using-opam)
+- [From source](#installing-from-source)
+
+## Debian/Ubuntu
+
+We generate debian and ubuntu packages automatically as part of our [release process](https://github.com/savonet/liquidsoap/releases). Otherwise, you
+can check out the official [debian](https://packages.debian.org/liquidsoap) and [ubuntu](https://packages.ubuntu.com/liquidsoap) packages.
+
+## Alpine
+
+Alpine packages are also provided as part of our [release process](https://github.com/savonet/liquidsoap/releases).
+
+## Docker
+
+We provide production-ready docker images via [Docker hub](https://hub.docker.com/r/savonet/liquidsoap).
+Docker images are tagged with a release tag (e.g. `v2.1.4`) and with the sha of their git commit (e.g. `a24bf49`). Please note
+that images tagged with a release tag may change while images tagged with a commit sha will not.
+
+## Windows
+
+You can download a liquidsoap for windows from our [release page](https://github.com/savonet/liquidsoap/releases).
+
+## Install using OPAM
+
+The recommended method to install liquidsoap from source is by using the [OCaml Package
+Manager](http://opam.ocaml.org/). OPAM is available in all major distributions
+and on windows. We actively support the liquidsoap packages there and its
+dependencies. You can read [here](https://opam.ocaml.org/doc/Usage.html) about
+how to use OPAM. In order to use it:
+
+- [you should have at least OPAM version 2.1](https://opam.ocaml.org/doc/Install.html),
+- not all version of the OCaml compiler are supported. You can run `opam info liquidsoap` to find out.
+
+You can create a switch for a specific OCaml version as follows:
+
+```
+opam switch create <ocaml version>
+```
+
+A typical installation with most expected features is done by executing:
+
+```
+opam install ffmpeg liquidsoap
+```
+
+This will install `liquidsoap` along with the optional `ffmpeg` package, which provides most
+of the expected functionalities (encoding, decoding, metadata support etc) out of the box.
+
+The `opam` installer also handles external dependencies that is, dependencies from your operating system
+that are required for your install. Typically, this would be the `ffmpeg` shared libraries here, as well
+as `libcurl`, which is required for `liquidsoap` to install.
+
+In most cases, `opam` will simply ask for your permission to install these dependencies on your behalf. In
+some cases, however, you will have install them yourself.
+
+Most of liquidsoap's dependencies are only optional. For
+instance, if you want to enable opus encoding and decoding after you've already
+installed liquidsoap, you should execute the following:
+
+```
+opam install opus
+```
+
+This will install `opus` and its dependencies and recompile `liquidsoap` to take advantage of it.
+
+`opam info liquidsoap` should give you the list of all optional dependencies
+that you may enable in liquidsoap.
+
+**Note**
+
+`opam` handles external dependencies via your system's packaging. In order to build
+some of the associated OCaml modules, macos users using `homebrew` might need to add
+the following to their environment/shell configuration:
+
+```shell
+export CPATH=/opt/homebrew/include
+export LIBRARY_PATH=/opt/homebrew/lib
+```
+
+## Installing from source
+
+See the [build instructions](build.html)
diff --git a/website/content/doc-2.2.5/json.md b/website/content/doc-2.2.5/json.md
new file mode 100644
index 00000000..6e43ef16
--- /dev/null
+++ b/website/content/doc-2.2.5/json.md
@@ -0,0 +1,333 @@
+## Importing JSON values
+
+_Note:_ If you are reading this page for the first time, you might want to skip directly to the
+explicit type annotation below as this is the recommended way of parsing JSON data. The content
+before that is here to explain the inner workings of JSON parsing in `liquidsoap`.
+
+Liquidsoap supports importing JSON values through a special `let` syntax. Using this syntax
+makes it relatively natural to parse JSON data in your script while keeping type-safety at runtime.
+Here's an example:
+
+```liquidsoap
+let json.parse v = '{"foo": "abc"}'
+
+print("We parsed a JSON object and got value " ^ v.foo ^ " for attribute foo!")
+```
+
+This prints:
+
+```
+We parsed a JSON object and got value abc for attribute foo!
+```
+
+What happened here is that liquidsoap kept track of the fact that `v` was called with
+`v.foo` and that the result of that was a string. Then, at runtime, it checks the parsed
+JSON value against this type and raises an issue if that did not match. For instance,
+the following script:
+
+```liquidsoap
+let json.parse v = '{"foo": 123}'
+
+print("We parsed a JSON object and got value " ^ v.foo ^ " for attribute foo!")
+```
+
+raises the following exception:
+
+```
+Error 14: Uncaught runtime error:
+type: json,
+message: "Parsing error: json value cannot be parsed as type {foo: string, _}"
+```
+
+Of course, this all seems pretty trivial presented like that but, let's switch to reading a file instead:
+
+```liquidsoap
+let json.parse v = file.contents("/path/to/file.json")
+
+print("We parsed a JSON object and got value " ^ v.foo ^ " for attribute foo!")
+```
+
+Now, this is getting somewhere! Let's push it further and parse a whole `package.json` from
+a typical `npm` package:
+
+```liquidsoap
+# Content of package.json is:
+# {
+#  "name": "my_package",
+#  "version": "1.0.0",
+#  "scripts": {
+#    "test": "echo \"Error: no test specified\" && exit 1"
+#  },
+#  ...
+let json.parse package = file.contents("/path/to/package.json")
+
+name = package.name
+version = package.version
+test = package.scripts.test
+
+print("This is package " ^  name ^ ", version " ^ version ^ " with test script: " ^ test)
+```
+
+And we get:
+
+```
+This is package my_package, version 1.0.0 with test script: echo "Error: no test specified" && exit 1
+```
+
+This can even be combined with _patterns_:
+
+```liquidsoap
+let json.parse {
+  name,
+  version,
+  scripts = {
+    test
+  }
+} = file.contents("/path/to/package.json")
+
+print("This is package " ^  name ^ ", version " ^ version ^ " with test script: " ^ test)
+```
+
+Now, this is looking nice!
+
+## Explicit type annotation
+
+Explicit type annotation are the recommended way to parse JSON data.
+
+Let's try a slight variation of the previous script now:
+
+```liquidsoap
+let json.parse {
+  name,
+  version,
+  scripts = {
+    test
+  }
+} = file.contents("/path/to/package.json")
+
+print("This is package #{name}, version #{version} with test script: #{test}")
+```
+
+This returns:
+
+```
+This is package null, version null with test script: null
+```
+
+What? 🤔
+
+This is because, in this script, we only use `name`, `version`, etc.. through the interpolation syntax `#{...}`. However, interpolated
+variables can be anything so this does not leave enough information to the typing system to know what type those variables should be and,
+in this case, we default to `null`.
+
+In order to avoid bad surprises like this, it is usually recommended to add **type annotations** to your json parsing call
+to explicitly state what kind of data you are expecting. Let's add one here:
+
+```liquidsoap
+let json.parse ({
+  name,
+  version,
+  scripts = {
+    test
+  }
+} : {
+  name: string,
+  version: string,
+  scripts: {
+    test: string
+  }
+}) = file.contents("/path/to/package.json")
+
+print("This is package #{name}, version #{version} with test script: #{test}")
+```
+
+And we get:
+
+```
+This is package my_package, version 1.0.0 with test script: echo "Error: no test specified" && exit 1
+```
+
+Back to normal!
+
+### Type syntax
+
+The syntax for type annotation is as follows:
+
+#### Ground types
+
+`string`, `int`, `float` are parsed as, resp., a string, an integer or a floating point number. Note that if your json value contains an integer such as `123`, parsing it as a floating point number will succeed. Also, if an integer is too big to be represented as an `int` internally, it will be parsed as a floating point number.
+
+#### Nullable types
+
+All type annotation can be postfixed with a trailing `?` to denote a _nullable_ value. If a type is nullable, the json parser will return `null` when it cannot parse
+the value as the principal type. This is particularly useful when you are not sure of all the types that you are parsing.
+
+For instance, some `npm` packages do not have a `scripts` entry or a `test` entry, so you would parse them as:
+
+```liquidsoap
+let json.parse ({
+  name,
+  version,
+  scripts,
+} : {
+  name: string,
+  version: string,
+  scripts: {
+    test: string?
+  }?
+}) = file.contents("/path/to/package.json")
+```
+
+And, later, inspect the returned value to see if it is in fact present. You can do it in several ways:
+
+```liquidsoap
+# Check if the value is defined:
+test =
+  if null.defined(scripts) then
+    null.get(scripts.test)
+  else
+    null ()
+  end
+
+# Use the ?? syntax:
+test = (scripts ?? { test = null() }).test
+```
+
+#### Tuple types
+
+The type `(int * float * string)` tells liquidsoap to parse a JSON array whose _first values_ are of type: `int`, `float` and `string`. If any further values
+are present in the array, they will be ignored.
+
+For arrays as well as any other structured types, the special notation `_` can be used to denote any type. For instance, `(_ * _ * float)` denotes an JSON
+array whose first 2 elements can be of any type and its third element is a floating point number.
+
+#### Lists
+
+The type `[int]` tells liquidsoap to parse a JSON array where _all its values_ are integers as a list of integers. If you are not sure if all elements in the
+array are integers, you can always use nullable integers: `[int?]`
+
+#### Objects
+
+The type `{foo: int}` tells liquidsoap to parse a JSON object as a record with an attribute labelled `foo` whose value is an integer. All other
+attributes are ignored.
+
+Arbitrary object keys can be parsed using the following syntax: `{"foo bar key" as foo_bar_key: int}`, which tells liquidsoap to parse a JSON object
+as a record with an attribute labelled `foo_bar_key` which maps to the attribute `"foo bar key"` from the JSON object.
+
+#### Associative lists as objects
+
+It can sometimes be useful to parse a JSON object as an associative list, for instance if you do not know in advance all the possible keys of
+an object. In this case, you can use the special type: `[(string * int)] as json.object`. This tells liquidsoap to parse the JSON object as a list
+of pairs `(string * int)` where `string` represents the attribute label and `int` represent the attribute value.
+
+If you are not sure if all the object values are integers you can always use nullable integers: `[(string * int?)] as json.object`
+
+### Parsing errors
+
+When parsing fails, a `error.json` is raised which can be caught at runtime:
+
+```liquidsoap
+try
+   let json.parse ({
+      status,
+      data = {
+        track
+      }
+    } : {
+      status: string,
+      data: {
+        track: string
+      }
+    }) = res
+
+    # Do something on success here..
+catch err: [error.json] do
+  # Do something on parse errors here..
+end
+```
+
+#### Example
+
+Here's a full example. Feel free to refer to `tests/language/json.liq` in the source code for more of them.
+
+```liquidsoap
+  data = '{
+    "foo": 34.24,
+    "gni gno": true,
+    "nested": {
+       "tuple": [123, 3.14, false],
+       "list":  [44.0, 55, 66.12],
+       "nullable_list": [12.33, 23, "aabb"],
+       "object_as_list": {
+         "foo": 123,
+         "gni": 456.0,
+         "gno": 3.14
+       },
+       "arbitrary object key ✨": true
+     },
+     "extra": "ignored"
+  }'
+
+  let json.parse ( x : {
+    foo: float,
+    "gni gno" as gni_gno: bool,
+    nested: {
+      tuple: (_ * float),
+      list: [float],
+      nullable_list: [int?],
+      object_as_list: [(string * float)] as json.object,
+      "arbitrary object key ✨" as arbitrary_object_key: bool,
+      not_present: bool?
+    }
+  }) = data
+  - x : {
+    foo = 34.24,
+    gni_gno = true,
+    nested = {
+      tuple = (null, 3.14),
+      list = [44., 55., 66.12],
+      nullable_list = [null, 23, null],
+      object_as_list = [("foo", 123.), ("gni", 456.0), ("gno", 3.14)],
+      arbitrary_object_key = true,
+      not_present = null
+    }
+  }
+```
+
+### JSON5 extension
+
+Liquidsoap supports the [JSON5](https://json5.org/) extension. Parsing of `json5` values is enabled with the following argument:
+
+```liquidsoap
+let json.parse[json5=true] x = ...
+```
+
+If a `json5` variable is in scope, you can also simply use `let json.parse[json5] x = ...`
+
+## Exporting JSON values
+
+Exporting JSON values can be done using the `json.stringify` function:
+
+```liquidsoap
+r = {artist = "Bla", title = "Blo"}
+print(json.stringify(r))
+```
+
+Please note that not all values are exportable as JSON, for instance function. In such cases the function will raise an `error.json` exception.
+
+## Generic JSON objects
+
+Generic `JSON` objects can be manipulated through the `json()` operator. This operator
+returns an opaque json variable with methods to `add` and `remove` attributes:
+
+```liquidsoap
+j = json()
+j.add("foo", 1)
+j.add("bla", "bar")
+j.add("baz", 3.14)
+j.add("key_with_methods", "value".{method = 123})
+j.add("record", { a = 1, b = "ert"})
+j.remove("foo")
+s = json.stringify(j)
+- s: '{ "record": { "b": "ert", "a": 1 }, "key_with_methods": "value", "bla": "bar", "baz": 3.14 }'
+```
diff --git a/website/content/doc-2.2.5/ladspa.md b/website/content/doc-2.2.5/ladspa.md
new file mode 100644
index 00000000..c8eff8bf
--- /dev/null
+++ b/website/content/doc-2.2.5/ladspa.md
@@ -0,0 +1,42 @@
+# LADSPA plugins in Liquidsoap
+
+[LADSPA](http://www.ladspa.org/) is a standard that allows software audio processors and effects to be plugged into a
+wide range of audio synthesis and recording packages.
+
+If enabled, Liquidsoap supports LADSPA plugins. In this case,
+installed plugins are detected at run-time and are all available in Liquidsoap under a name
+of the form: `ladspa.plugin`, for instance `ladspa.karaoke`, `ladspa.flanger` etc..
+
+The full list of those operators can be found using `liquidsoap --list-plugins`.
+Also, as usual, `liquidsoap -h ladspa.plugin` returns a detailed description of each LADSPA's operators.
+For instance:
+
+```
+./liquidsoap -h ladspa.flanger
+*** One entry in scripting values:
+Flanger by Steve Harris <steve@plugin.org.uk>.
+Category: Source / Sound Processing
+Type: (?id:string,?delay_base:'a,?feedback:'b,
+ ?lfo_frequency:'c,?max_slowdown:'d,
+ source(audio='#e,video='#f,midi='#g))->
+source(audio='#e,video='#f,midi='#g)
+where 'a, 'b, 'c, 'd is either float or ()->float
+Flag: hidden
+Parameters:
+* id : string (default "")
+    Force the value of the source ID.
+* delay_base : anything that is either float or ()->float (default 6.32499980927)
+    Delay base (ms) (0.1 <= delay_base <= 25).
+* feedback : anything that is either float or ()->float (default 0.)
+    Feedback (-1 <= feedback <= 1).
+* lfo_frequency : anything that is either float or ()->float (default 0.334370166063)
+    LFO frequency (Hz) (0.05 <= lfo_frequency <= 100).
+* max_slowdown : anything that is either float or ()->float (default 2.5)
+    Max slowdown (ms) (0 <= max_slowdown <= 10).
+* (unlabeled) : source(audio='#e,video='#f,midi='#g) (default None)
+```
+
+For advanced users, it is worth nothing that most of the parameters associated with LADSPA operators
+can take a function, for instance in the above: ` max_slowdown : anything that is either float or ()->float`
+.
+This means that those parameters may be dynamically changed while running a liquidsoap script.
diff --git a/website/content/doc-2.2.5/language.md b/website/content/doc-2.2.5/language.md
new file mode 100644
index 00000000..9cdb6945
--- /dev/null
+++ b/website/content/doc-2.2.5/language.md
@@ -0,0 +1,1377 @@
+# Liquidsoap's scripting language
+
+_The following is adapted from the [Liquidsoap book](book.html). The reader is avised to check out the whole
+chapter in the book for more details about the liquidsoap language_
+
+## General features
+
+Liquidsoap is a novel language which was designed from scratch to handle media stream. It takes some inspiration
+from functional languages such as [OCaml](https://ocaml.org/) but features a syntax that is more intuitive to the
+general purpose programmer, similar to Ruby or Javascript.
+
+### Typing
+
+One of the main features of the language is that it is _typed_. This means that
+every expression belongs to some type which indicates what it is. For instance,
+`"hello"` is a _string_ whereas `23` is an _integer_, and, when presenting a
+construction of the language, we will always indicate the associated
+type. Liquidsoap implements a _typechecking_ algorithm which ensures that
+whenever a string is expected a string will actually be given, and similarly for
+other types. This is done without running the program, so that it does not
+depend on some dynamic tests, but is rather enforced by theoretical
+considerations. Another distinguishing feature of this algorithm is that it also
+performs _type inference_: you never actually have to write a type, those are
+guessed automatically by Liquidsoap. This makes the language very safe, while
+remaining very easy to use.
+
+### Functional programming
+
+The language is _functional_, which means that you can very easily define
+functions, and that functions can be passed as arguments of other
+functions. This might look like a crazy thing at first, but it is actually quite
+common in some language communities (such as OCaml). It also might look quite
+useless: why should we need such functions when describing webradios? You will
+soon discover that it happens to be quite convenient in many places: for
+handlers (we can specify the function which describes what to do when some event
+occurs such as when a DJ connects to the radio), for transitions (we pass a
+function which describes the shape we want for the transition) and so on.
+
+### Streams
+
+The unique feature of Liquidsoap is that it allows the manipulation of _sources_
+which are functions which will generate streams. These streams typically consist
+of stereo audio data, but we do restrict to this: they can contain audio with
+arbitrary number of channels, they can also contain an arbitrary number of video
+channels, and also MIDI channels (there is limited support for sound synthesis).
+
+### Standard library
+
+Although the core of Liquidsoap is written in OCaml, many of the functions of
+Liquidsoap are written in the Liquidsoap language itself. Those are defined in
+the `stdlib.liq` script, which is loaded by default and includes all the
+libraries. You should not be frightened to have a look at the standard library,
+it is often useful to better grasp the language, learn design patterns and
+tricks, and add functionalities. Its location on your system is indicated in the
+variable `configure.libdir` and can be obtained by typing
+
+## Basic values
+
+### Integers and floats
+
+The _integers_, such as `3` or `42`, are of type
+`int`. Depending on the current architecture of the
+computer on which we are executing the script (32 or 64 bits, the latter being
+the most common nowadays) they are stored on 31 or 63 bits. The minimal
+(resp. maximal) representable integer can be obtained as the constant
+`min_int`
+(resp. `max_int`); typically, on a 64 bits
+architecture, they range from -4611686018427387904 to 4611686018427387903.
+
+The _floating point numbers_, such as `2.45`, are of type
+`float`, and are in double precision, meaning that
+they are always stored on 64 bits. We always write a decimal point in them,
+so that `3` and `3.` are not the same thing: the former is an integer and the
+latter is a float. This is a source of errors for beginners, but is necessary for
+typing to work well.
+
+### Strings
+
+Strings are written between double or single quotes,
+e.g. `"hello!"` or `'hello!'`, and are of type `string`.
+
+In order to write the character "`"`" in a string, one cannot simply type "`"`"
+since this is already used to indicate the boundaries of a string: this
+character should be _escaped_, which
+means that the character "`\`" should be typed first so that
+
+```liquidsoap
+print("My name is \"Sam\"!")
+```
+
+will actually display "`My name is "Sam"!`". Other commonly used escaped
+characters are "`\\`" for backslash and "`\n`" for new line. Alternatively, one
+can use the single quote notation, so that previous example can also be written
+as
+
+```liquidsoap
+print('My name is "Sam"!')
+```
+
+This is most often used when testing JSON data which can contain many quotes or for
+command line arguments when calling external scripts. The character "`\`" can also
+be used at the end of the string to break long strings in scripts without
+actually inserting newlines in the strings. For instance, the script
+
+```liquidsoap
+print("His name is \
+       Romain.")
+```
+
+will actually print
+
+```
+His name is Romain.
+```
+
+Note that there is no line change between "is" and "Romain", and the indentation
+before "Romain" is not shown either.
+
+The concatenation of two strings is achieved by the infix operator "`^`", as in
+
+```liquidsoap
+user = "dj"
+print("Current user is " ^ user)
+```
+
+Instead of using concatenation, it is often rather convenient to use _string
+interpolation_: in a string, `#{e}` is replaced by the string representation of
+the result of the evaluation of the expression `e`:
+
+```liquidsoap
+user = "admin"
+print("The user #{user} has just logged.")
+```
+
+will print `The user admin has just logged.` or
+
+```liquidsoap
+print("The number #{random.float()} is random.")
+```
+
+will print `The number 0.663455738438 is random.` (at least it did last time I
+tried).
+
+#### Escaping strings
+
+Liquidsoap strings follow the most common lexical conventions from `C` and `javascript` and `JSON`, in particular,
+`string.unescape` recognizes the same escape sequences as `C` (except for `UTF-16` characters) and javascript.
+
+The following sequences are recognized:
+
+| Escape sequence | Hex value in ASCII | Character represented                                                                 |
+| --------------- | ------------------ | ------------------------------------------------------------------------------------- |
+| `\a`            | `\x07`             | Alert (Beep, Bell)                                                                    |
+| `\b`            | `\x08`             | Backspace                                                                             |
+| `\e`            | `\x1B`             | Escape character                                                                      |
+| `\f`            | `\x0C`             | Formfeed, Page Break                                                                  |
+| `\n`            | `\x0A`             | Newline (Line Feed)                                                                   |
+| `\r`            | `\x0D`             | Carriage Return                                                                       |
+| `\t`            | `\x09`             | Horizontal Tab                                                                        |
+| `\v`            | `\x0B`             | Vertical Tab                                                                          |
+| `\\`            | `\x5C`             | Backslash                                                                             |
+| `\/`            | `\x2f`             | Forward slash                                                                         |
+| `\'`            | `\x27`             | Apostrophe or single quotation mark                                                   |
+| `\"`            | `\x22`             | Double quotation mark                                                                 |
+| `\?`            | `\x3F`             | Question mark (used to avoid Digraphs and trigraphs)                                  |
+| `\nnn`          | any                | The byte whose numerical value is given by _nnn_ interpreted as an _octal_ number     |
+| `\xhh`          | any                | The byte whose numerical value is given by _hh_ interpreted as a _hexadecimal_ number |
+| `\uhhhh`        | none               | UTF8-8 code point given by _hhhh_ interpreted as an _hexadecimal_ number              |
+
+This convention has been decided to follow the most common practices. In particular, `\nnn` is an _octal_ escape sequence in most languages
+including C, Ruby, Javascript, Python and more. This differs from OCaml where `\nnn` is considered a _digital_ escape sequence.
+
+These lexical conventions are used in the default `string.escape` and `string.unescape`.
+
+Here's an example of an escaped string:
+
+```
+# "\" \t \045 \x2f \u4f32";;
+- : string = "\" \t % / 2"
+```
+
+The function `string.quote` returns [JSON-compatible](https://www.json.org/json-en.html) strings.
+
+### Regular expressions
+
+_This feature was introduced in liquidsoap version 2.1.0_
+
+Regular expressions can be created using the `regexp` operator or the syntactic sugar: `r/.../<flags>`. For instance:
+
+```liquidsoap
+# Using the regexp operator:
+r = regexp(flags=["g","i"], "foo([\\w])+bar")
+
+# Using the r/../ syntactic sugar:
+r = r/foo([\w])bar/gi
+```
+
+Using the `r/../` syntactic sugar makes it possible to write regular expressions without having to escape `\` characters,
+which makes them more easily readable.
+
+Regular expression flags are:
+
+- `i`: perform case-insensitive match
+- `g`: substitute all matched sub-strings, not just the first one
+- `s`: match all characters, including `\n` when using the `.` pattern
+- `m`: `^` and `$` match before/after newlines, not just at the beginning/end of a string
+
+Regular expressions have the following methods:
+
+- `replace(fn, s)`: replace matched substrings of `s` using function `fn`. If the `g` flag is not passed, only the first match is replaced otherwise, all matches are replaced
+- `split(s)`: split the given string on all substrings matching the regular expression.
+- `test(s)`: returns `true` if the given string matches the regular expression.
+- `exec(s)`: execute the regular expression and return a of list matches of the form: `[(<match index>, <match>), ..]`. Named matches are also supported and returned as property `groups` of type `[string * string]`:
+
+```liquidsoap
+r/(foo)(?<gno>gni)?/g.exec("foogni")
+- : [int * string].{groups : [string * string]} =
+[
+    (2, "gni"),
+    (1, "foo"),
+    (0, "foogni")
+].{
+    groups = [
+      ("gno", "gni")
+    ]
+}
+```
+
+### Booleans
+
+The _booleans_ are either `true` or
+`false` and are of type `bool`. They can be combined
+using the usual boolean operations
+
+- `and`: conjunction,
+- `or`: disjunction,
+- `not`: negation.
+
+Booleans typically originate from comparison operators, which take two values
+and return booleans:
+
+- `==`: compares for equality,
+- `!=`: compares for inequality,
+- `<=`: compares for inequality,
+
+and so on (`<`, `>=`, `>`). For instance, the following is a boolean expression:
+
+```liquidsoap
+(n < 3) and not (s == "hello")
+```
+
+_Conditional branchings_ execute code depending on whether a condition is true
+or not. For instance, the code
+
+```liquidsoap
+if (1 <= x and x <= 12) or (not 10h-15h) then
+  print("The condition is satisfied")
+else
+  print("The condition ain't satisfied")
+end
+```
+
+will print that the condition is satisfied when either `x` is between 1 and 12
+or the current time is not between 10h and 15h. A conditional branching might
+return a value, which is the last computed value in the chosen branch. For
+instance,
+
+```liquidsoap
+y = if x < 3 then "A" else "B" end
+```
+
+will assign `"A"` or `"B"` to `y` depending on whether `x` is below 3 or
+not. The two branches of a conditional should always have the same return type:
+
+```liquidsoap
+x = if 1 == 2 then "A" else 5 end
+```
+
+will result in
+
+```
+At line 1, char 19-21:
+Error 5: this value has type string
+but it should be a subtype of int
+```
+
+meaning that `"A"` is a string but is expected to be an integer because the
+second branch returns an integer, and the two should be of same nature. The
+`else` branch is optional, in which case the `then` branch should be of type
+`unit`:
+
+```liquidsoap
+if x == "admin" then print("Welcome admin") end
+```
+
+In the case where you want to perform a conditional branching in the
+`else` branch, the `elsif`{.liquidsoap} keyword should be used, as
+in the following example, which assigns 0, 1, 2 or 3 to `s` depending on whether
+`x` is `"a"`, `"b"`, `"c"` or something else:
+
+```liquidsoap
+s = if x == "a" then 0
+    elsif x == "b" then 1
+    elsif x == "c" then 2
+    else 3 end
+```
+
+This is equivalent (but shorter to write) to the following sequence of
+imbricated conditional branchings:
+
+```liquidsoap
+s = if x == "a" then 0
+    else
+      if x == "b" then 1
+      else
+        if x == "c" then 2
+        else 3 end
+      end
+    end
+```
+
+Finally, we should mention that the notation `c?a:b` is also available as a
+shorthand for `if c then a else b end`, so that the expression
+
+```liquidsoap
+y = if x < 3 then "A" else "B" end
+```
+
+can be shortened to
+
+```liquidsoap
+y = (x<3)?"A":"B"
+```
+
+(and people will think that you are a cool guy).
+
+#### Time predicates
+
+Time predicates are special boolean values such as `{0h-7h}`. These values are
+`true` or `false` depending on the current time. Some examples of time
+predicates are
+
+---
+
+`{11h15-13h}` between 11h15 and 13h
+`{12h}` between 12h00 and 12h59
+`{12h00}` at 12h00
+`{00m}` on the first minute of every hour
+`{00m-09m}` on the first 10 minutes of every hour
+`{2w}` on Tuesday
+`{6w-7w}` on weekends
+
+---
+
+Above, `w` stands for weekday: 1 is Monday, 2 is Tuesday, and so on. Sunday is
+both 0 and 7.
+
+Time predicate can also be parsed at runtime, for instance if you want to create
+them dynamically. The syntax is:
+
+```liquidsoap
+# f = time.predicate("00m-30m");;
+f : () -> bool = <fun>
+```
+
+Be aware that, if parsing fails, it will raise `error.string`:
+
+```liquidsoap
+# f = time.predicate("foo")
+Error 14: Uncaught runtime error:
+type: string, message: "Failed to parse foo as time predicate"
+```
+
+### Unit
+
+Some functions, such as `print`, do not return a meaningful value: we are
+interested in what they are doing (e.g. printing on the standard output) and not
+in their result. However, since typing requires that everything returns
+something of some type, there is a particular type for the return of such
+functions: `unit`. Just as there are only two values in the booleans (`true` and
+`false`), there is only one value in the unit type, which is written `()`. This
+value can be thought of as the result of the expression saying "I'm done".
+
+### Lists
+
+Some more elaborate values can be constructed by combining the previous ones. A
+first kind is _lists_ which are finite sequences of values, being all of the
+same type. They are constructed by square bracketing the sequence whose elements
+are separated by commas. For instance, the list
+
+```liquidsoap
+[1, 4, 5]
+```
+
+is a list of three integers (1, 4 and 5), and its type is `[int]`, and the type
+of `["A", "B"]` would obviously be `[string]`. Note that a list can
+be empty: `[]`.
+
+You can extract list elements through _splats_ such as
+
+```liquidsoap
+l = [1, 5, 7, 8, 9]
+let [x, _, z, ...t] = l
+```
+
+In this example, the value of `x` is `1`, the value of `z` is `7` and the value of `t`
+is [`8, 9]`.
+
+You can also combine lists in a similar way
+
+```liquidsoap
+x = [1, ...[2, 3, 4], 5, ...[6, 7]]
+```
+
+In this example, the value of `x` is `[1, 2, 3, 4, 5, 6 ,7]`
+
+### Tuples
+
+Another construction present in Liquidsoap is _tuples_ of values, which are
+finite sequences of values which, contrarily to lists, might have different
+types. For instance,
+
+```
+(3, 4.2, "hello")
+```
+
+is a triple (a tuple with three elements) of type
+
+```
+int * float * string
+```
+
+which indicate that the first element is an integer, the second a float and the
+third a string.
+
+Similarly to lists, there is a special syntax in order to access
+tuple elements. For instance, if `t` is the above tuple `(3, 4.2, "hello")`, we can write
+
+```liquidsoap
+let (n, x, s) = t
+```
+
+which will assign the first element to the variable `n`, the second element to
+the variable `x` and the third element to the variable `s`.
+
+## Programming primitives
+
+### Variables
+
+We have already seen many examples of uses of _variables_: we use
+
+```liquidsoap
+x = e
+```
+
+in order to assign the result of evaluating an expression `e` to a
+variable `x`, which can later on be referred to as `x`. Variables can be masked:
+we can define two variables with the same name, and at any point in the program the
+last defined value for the variable is used:
+
+```liquidsoap
+n = 3
+print(n)
+n = n + 2
+print(n)
+```
+
+will print `3` and `5`. Contrarily to most languages, the value for a variable
+cannot be changed (unless we explicitly require this by using references, see
+below), so the above program does not modify the value of `n`, it is simply that
+a new `n` is defined.
+
+There is an alternative syntax for declaring variables which is
+
+```liquidsoap
+def x =
+  e
+end
+```
+
+It has the advantage that the expression `e` can spread over multiple lines and
+thus consist of multiple expressions, in which case the value of the last one
+will be assigned to `x`. This is particularly useful to use local variables when defining a value.
+
+### References
+
+As indicated above, by default, the value of a variable cannot be
+changed. However, one can use a _reference_ in order to be able to do this.
+Those can be seen as memory cells, containing values of a given fixed type,
+which can be modified during the execution of the program. They are created with
+the `ref` keyword, with the initial value of the cell as argument. For instance,
+
+```liquidsoap
+r = ref(5)
+```
+
+declares that `r` is a reference which contains `5` as initial value. Since `5`
+is an integer (of type `int`), the type of the reference `r` will be
+
+```
+ref(int)
+```
+
+meaning that its a memory cell containing integers. On such a reference, two
+operations are available.
+
+- One can obtain the value of the reference by applying the reference to `()`,
+  so that `r()` denotes the value contained in the reference `r`, for instance
+
+  ```liquidsoap
+  x = r() + 4
+  ```
+
+  declares the variable `x` as being 9 (which is 5+4).
+
+- One can change the value of the reference by using the `:=` keyword, e.g.
+
+  ```liquidsoap
+  r := 2
+  ```
+
+  will assign the value 2 to `r`. Internally, this is done by calling the `set`
+  method of the reference, so that the above is equivalent to writing
+
+  ```liquidsoap
+  r.set(2)
+  ```
+
+  which used to be the syntax for some reference manipulations.
+
+### Loops
+
+The usual looping constructions are available in Liquidsoap. The `for` loop
+repeatedly executes a portion of code with an integer variable varying between
+two bounds, being increased by one each time. For instance, the following code
+will print the integers `1`, `2`, `3`, `4` and `5`, which are the values
+successively taken by the variable `i`:
+
+```liquidsoap
+for i = 1 to 5 do
+  print(i)
+end
+```
+
+In practice, such loops could be used to add a bunch of numbered files
+(e.g. `music1.mp3`, `music2.mp3`, `music3.mp3`, etc.) in a request queue for
+instance.
+
+The `while` loop repeatedly executes a portion of code, as long a condition is
+satisfied. For instance, the following code doubles the contents of the
+reference `n` as long as its value is below `10`:
+
+```liquidsoap
+n = ref(1)
+while n() < 10 do
+  n := n() * 2
+end
+print(n())
+```
+
+The variable `n` will thus successively take the values `1`, `2`, `4`, `8` and
+`16`, at which point the looping condition `n() < 10` is not satisfied anymore
+and the loop is exited. The printed value is thus `16`.
+
+## Functions
+
+Liquidsoap is built around the notion of function: most operations are performed
+by those. For some reason, we sometimes call _operators_ the functions acting on
+sources. Liquidsoap includes a standard library which consists of functions
+defined in the Liquidsoap language, including fairly complex operators such as
+`playlist` which plays a playlist or `crossfade` which takes care of fading
+between songs.
+
+### Basics
+
+A function is a construction which takes a bunch of arguments and produces a
+result. For instance, we can define a function `f` taking two float arguments,
+prints the first and returns the result of adding twice the first to the second:
+
+```liquidsoap
+def f(x, y)
+  print(x)
+  2*x+y
+end
+```
+
+This function can also be written on one line if we use semicolons (`;`) to
+separate the instructions instead of changing line:
+
+```liquidsoap
+def f(x, y) = print(x); 2*x+y end
+```
+
+The type of this function is
+
+```
+(int, int) -> int
+```
+
+The arrow `->` means that it is a function, on the left are the types of the
+arguments (here, two arguments of type `int`) and on the right is the type of
+the returned value of the function (here, `int`). In order to use this function,
+we have to apply it to arguments, as in
+
+```
+f(3, 4)
+```
+
+This will trigger the evaluation of the function, where the argument `x`
+(resp. `y`) is replaced by `3` (resp. `4`), i.e., it will print `3` and return
+the evaluation of `2*3+4`, which is `10`.
+
+### Anonymous functions
+
+For concision in scripts, it is possible define a function without giving it a
+name, using the syntax
+
+```liquidsoap
+fun (x) -> ...
+```
+
+This is called an _anonymous function_, and it is typically used in order to
+specify short handlers in arguments.
+
+#### Anonymous function with no arguments
+
+You will see that it is quite common to use anonymous functions with no
+arguments. For this reason, we have introduced a special convenient syntax for
+those and allow writing
+
+```liquidsoap
+{...}
+```
+
+instead of
+
+```liquidsoap
+fun () -> ...
+```
+
+### Labeled arguments
+
+A function can have an arbitrary number of arguments, and when there are many of them it
+becomes difficult to keep track of their order and their order matter! For
+instance, the following function computes the sample rate given a number of
+samples in a given period of time:
+
+```liquidsoap
+def samplerate(samples, duration) = samples / duration end
+```
+
+which is of type
+
+```
+(float, float) -> float
+```
+
+For instance, if you have 110250 samples over 2.5 seconds the samplerate will be
+`samplerate(110250., 2.5)` which is 44100. However, if you mix the
+order of the arguments and type `samplerate(2.5, 110250.)`, you
+will get quite a different result and this will not be detected by
+the typing system because both arguments have the same type. Fortunately, we can
+give _labels_ to arguments in order to prevent this, which forces explicitly
+naming the arguments. This is indicated by prefixing the arguments with a tilde
+"`~`":
+
+```liquidsoap
+def samplerate(~samples, ~duration) = samples / duration end
+```
+
+The labels will be indicated as follows in the type:
+
+```
+(samples : float, duration : float) -> float
+```
+
+Namely, in the above type, we read that the argument labeled `samples` is a
+float and similarly for the one labeled `duration`. For those arguments, we have
+to give the name of the argument when calling the function:
+
+```liquidsoap
+samplerate(samples=110250., duration=2.5)
+```
+
+The nice byproduct is that the order of the arguments does not matter anymore, the
+following will give the same result:
+
+```liquidsoap
+samplerate(duration=2.5, samples=110250.)
+```
+
+Of course, a function can have both labeled and non-labeled arguments.
+
+### Optional arguments
+
+Another useful feature is that we can give _default values_ to arguments, which
+thus become _optional_: if, when calling the function, a value is not specified
+for such arguments, the default value will be used. For instance, if for some
+reason we tend to generally measure samples over a period of 2.5 seconds, we can
+make this become the value for the `duration` parameter:
+
+```liquidsoap
+def samplerate(~samples, ~duration=2.5) =
+  samples / duration
+end
+```
+
+In this way, if we do not specify a value for the duration, its value will
+implicitly be assumed to be 2.5, so that the expression:
+
+```liquidsoap
+samplerate(samples=110250.)
+```
+
+will still evaluate to 44100. Of course, if we want to use another value for the
+duration, we can still specify it, in which case the default value will be
+ignored:
+
+```liquidsoap
+samplerate(samples=132300., duration=3.)
+```
+
+The presence of an optional argument is indicated in the type by prefixing the
+corresponding label with "`?`", so that the type of the above function is
+
+```
+(samples : float, ?duration : float) -> float
+```
+
+### Getters
+
+We often want to be able to dynamically modify some parameters in a script. For
+instance, consider the operator `amplify`, which takes a float and an audio
+source and returns the audio amplified by the given volume factor: we can expect
+its type to be
+
+```
+(float, source('a)) -> source('a)
+```
+
+so that we can use it to have a radio consisting of a microphone input amplified
+by a factor 1.2 by
+
+```liquidsoap
+mic   = input.alsa()
+radio = amplify(1.2, mic)
+```
+
+In the above example, the volume 1.2 was supposedly chosen because the sound
+delivered by the microphone is not loud enough, but this loudness can vary from
+time to time, depending on the speaker for instance, and we would like to be
+able to dynamically update it. The problem with the current operator is that the
+volume is of type `float` and a float cannot change over time: it has a fixed
+value.
+
+In order for the volume to have the possibility to vary over time, instead of
+having a `float` argument for `amplify`, we have decided to have instead an
+argument of type
+
+```
+() -> float
+```
+
+This is a function which takes no argument and returns a float (remember that a
+function can take an arbitrary number of arguments, which includes zero arguments). It is
+very close to a float excepting that each time it is called the returned value
+can change: we now have the possibility of having something like a float which
+varies over time. We like to call such a function a _float getter_, since it can
+be seen as some kind of object on which the only operation we can perform is get
+the value. For instance, we can define a float getter by
+
+```liquidsoap
+n = ref(0.)
+def f ()
+  n := n() + 1.
+  n()
+end
+```
+
+Each time we call `f`, by writing `f()` in our script, the resulting float
+will be increased by one compared to the previous one: if we try it in an
+interactive session, we obtain
+
+```
+# f();;
+- : float = 1.0
+# f();;
+- : float = 2.0
+# f();;
+- : float = 3.0
+```
+
+Since defining such arguments often involves expressions of the form
+
+```liquidsoap
+fun () -> e
+```
+
+which is somewhat heavy, we have introduced the alternative syntax
+
+```liquidsoap
+{e}
+```
+
+for it.
+
+Finally, in order to simplify things a bit, you will see that the type of
+amplify is actually
+
+```
+({float}, source('a)) -> source('a)
+```
+
+where the type `{float}` means that both `float` and `() -> float` are accepted,
+so that you can still write constant floats where float getters are
+expected. What we actually call a _getter_ is generally an element of such a
+type, which is either a constant or a function with no argument.
+
+In order to work with such types, the standard library often uses the following
+functions:
+
+- `getter`, of type `({'a}) -> {'a}`, creates a getter,
+- `getter.get`, of type `({'a}) -> 'a`, retrieves the current value of a getter,
+- `getter.function`, of type `({'a}) -> () -> 'a`, creates a function from a
+  getter.
+
+### Recursive functions
+
+Liquidsoap supports functions which are _recursive_, i.e., that can call
+themselves. For instance, in mathematics, the factorial function on natural
+numbers is defined as fact(n)=1×2×3×...×n, but it can also be defined
+recursively as the function such that fact(0)=1 and fact(n)=n×fact(n-1) when
+n>0: you can easily check by hand that the two functions agree on small values
+of n (and prove that they agree on all values of n). This last formulation has
+the advantage of immediately translating to the following implementation of
+factorial:
+
+```liquidsoap
+def rec fact(n) =
+  if n == 0 then 1
+  else n * fact(n-1) end
+end
+```
+
+for which you can check that `fact(5)` gives 120, the expected result. As
+another example, the `list.length` function, which computes the length of a
+list, can be programmed in the following way in Liquidsoap:
+
+```liquidsoap
+def rec length(l)
+  if l == [] then 0
+  else 1 + length(list.tl(l)) end
+end
+```
+
+We do not detail much further this trait since it is unlikely to be used for
+radios, but you can see a few occurrences of it in the standard library.
+
+## Records and modules
+
+### Records
+
+Suppose that we want to store and manipulate structured data. For instance, a
+list of songs together with their duration and tempo. One way to store each song
+is as a tuple of type `string * float * float`, but there is a risk of confusion
+between the duration and the length which are both floats, and the situation
+would of course be worse if there were more fields. In order to overcome this,
+one can use a _record_ which is basically the same as a tuple, excepting that
+fields are named. In our case, we can store a song as
+
+```liquidsoap
+song = { filename = "song.mp3", duration = 257., bpm = 132. }
+```
+
+which is a record with three fields respectively named `filename`, `duration`
+and `bpm`. The type of such a record is
+
+```
+{filename : string, duration : float, bpm : float}
+```
+
+which indicates the fields and their respective type. In order to access a field
+of a record, we can use the syntax `record.field`. For instance, we can print
+the duration with
+
+```liquidsoap
+print("The duration of the song is #{song.duration} seconds")
+```
+
+Records can be re-used using _spreads_:
+
+```liquidsoap
+song = { filename = "song.mp3", duration = 257., bpm = 132. }
+
+# This is a fresh value with all the fields from `song` and
+# a new `id` field:
+song_with_id = { id = 1234, ...song }
+```
+
+Alternatively, you can also extend a record using the explicit `v.{...}` syntax:
+
+```liquidsoap
+song = { filename = "song.mp3", duration = 257., bpm = 132. }
+
+# This is a fresh value with all the fields from `song` and
+# a new `id` field:
+song_with_id = song.{id = 1234}
+```
+
+### Modules
+
+Records are heavily used in Liquidsoap in order to structure the functions of
+the standard library. We tend to call _module_ a record with only functions, but
+this is really the same as a record. For instance, all the functions related to
+lists are in the `list` module and functions such as `list.hd` are fields of
+this record. For this reason, the `def` construction allows adding
+fields in record. For instance, the definition
+
+```liquidsoap
+def list.last(l)
+  list.nth(l, list.length(l)-1)
+end
+```
+
+adds, in the module `list`, a new field named `last`, which is a function which
+computes the last element of a list. Another shorter syntax to perform
+definitions consists in using the `let` keyword which allows assigning a value
+to a field, so that the previous example can be rewritten as
+
+```liquidasoap
+let list.last = fun(l) -> list.nth(l, list.length(l)-1)
+```
+
+If you often use the functions of a specific module, the `open` keyword allows
+using its fields without having to prefix them by the module name. For instance,
+in the following example
+
+```liquidsoap
+l = [1,2,3]
+open list
+x = nth(l, length(l)-1)
+```
+
+the `open list` directive allows directly using the functions in this module: we
+can simply write `nth` and `length` instead of `list.nth` and `list.length`.
+
+### Values with fields
+
+A unique feature of the Liquidsoap language is that it allows adding fields to
+any value. We also call them _methods_ by analogy with object-oriented
+programming. For instance, we can write
+
+```liquidsoap
+song = "test.mp3".{duration = 123., bpm = 120.}
+```
+
+which defines a string (`"test.mp3"`) with two methods (`duration` and
+`bpm`). This value has type
+
+```
+string.{duration : float, bpm : float}
+```
+
+and behaves like a string, e.g. we can concatenate it with other strings:
+
+```liquidsoap
+print("the song is " ^ song)
+```
+
+but we can also invoke its methods like a record or a module:
+
+```liquidsoap
+print("the duration is #{song.duration}")
+```
+
+The construction `def replaces` allows changing the main value
+while keeping the methods unchanged, so that
+
+```liquidsoap
+def replaces song = "newfile.mp3" end
+print(song)
+```
+
+will print
+
+```
+"newfile.mp3".{duration = 123., bpm = 120.}
+```
+
+(note that the string is modified but not the fields `duration` and `bpm`).
+
+### Optional fields
+
+During the execution of your script, it can be useful to allow functions
+to receive records that may or may not have a specific field. This can
+be used, for instance, to model optional arguments.
+
+This can be achieved in two ways:
+
+1. Using the `x.foo ?? default` syntax
+
+Here's an example:
+
+```liquidsoap
+# This functions adds 1 to x unless options has a
+# add field in which case it adds this value
+def f(x, options) =
+  x + (options.add ?? 1)
+end
+```
+
+The type of this function is:
+
+```liquidsoap
+f : (int, 'a.{add? : int}) -> int = <fun>
+```
+
+which denotes that the `options` argument can be any value that may or may not have
+a `add` field. However, if this field is present, it must be of type `int`.
+
+2. Using the `x?.foo` syntax
+
+Given a variable `x`, `x?.foo` returns the field value `foo`, if present, or `null`
+otherwise.
+
+The `?.` syntax can be chained and works with functions, which make it a very convenient
+way to drill deep inside nested records:
+
+```liquidsoap
+x?.fn(123, "aabb")?.field
+```
+
+## Patterns
+
+As explained earlier, you can use several constructions to extract data from structured values such
+as `let [x, y] = l` and etc. These constructions are called _patterns_.
+
+Patterns allows to quickly access values nested deeply inside structured data in a way that remains pretty intuitive when
+reading the code.
+
+Patterns are constructed using _variable placeholders_, which are either a variable name such as: `x`, `foo`, etc. or
+the special symbol `_` for any ignored value.
+
+### Tuple patterns
+
+Tuple patterns are pretty straight forward and consist of any sequence of variable captures:
+
+```liquidsoap
+let (x, y, _, z) = (123, "aabbcc", true, 3.14)
+# x = 1, y = "aabbcc", z = 3.14
+```
+
+### List patterns
+
+List patterns are composed of variable placeholders, etc. and spreads of the form:
+`...<variable placeholder>` such as: `...z`. The spread `..._`
+can be simply written `...`. See below for an example.
+
+You can use any combination of:
+
+- Forward variable names: these capture the first elements of the list.
+- One spread: this captures any remaining element as a list.
+- Backward variable names: these capture the last elements of a the list.
+
+Here are some examples:
+
+```liquidsoap
+# Forward capture:
+let [x, y, z] = [1, 2, 3]
+# x = 1, y = 2, z = 3
+
+# Forward capture with spread:
+let [x, y, ...z] = [1, 2, 3, 4]
+# x = 1, y = 2, z = [3, 4]
+
+# Forward capture with ignored values:
+let [_, x, ...z] = [1, 2, 3, 4]
+# x = 2, z = [3, 4]
+
+# Full capture:
+let [x, y, ...z, t, u, v] = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+# x = 1, y = 2, z = [3, 4, 5, 6, 7], t = 7, u = 8, v = 9
+
+# Backward capture only.
+let [..., t, u, v] = [1, 2, 3, 4, 5]
+# t = 3, u = 4, v = 5
+```
+
+### Record and module patterns
+
+Record and module patterns consist of either variable names (not variable capture!), which capture method values
+or variable names with an associated pattern.
+
+Record patterns are of the form: `{<captured methods>}` while module patterns are of the form: `<variable capture>.{<captured methods>}`
+
+Here are some examples:
+
+```liquidsoap
+# Record capture
+let {foo, bar} = {foo = 123, bar = "baz", gni = true}
+# foo = 123, bar = "baz"
+
+# Record capture with spread
+let {foo, bar, ...x} = {foo = 123, bar = "baz", gni = true}
+# foo = 123, bar = "baz", x = {gni = true}
+
+# Module capture
+let v.{foo, bar} = "aabbcc".{foo = 123, bar = "baz", gni = true}
+# v = "aabbcc", foo = 123, bar = "baz"
+
+# Module capture with ignored value
+let _.{foo, bar} = "aabbcc".{foo = 123, bar = "baz", gni = true}
+# foo = 123, bar = "baz"
+
+# Record capture with sub-patterns. Same works for module!
+let {foo = [x, y, z], gni} = {foo = [1, 2, 3], gni = "baz"}
+# foo = [1, 2, 3], x = 1, y = 2, z = 3, gni = "baz"
+```
+
+## Combining patterns
+
+As seen with record and modules, patterns can be combined at will, for instance, these
+are all valid patterns:
+
+```liquidsoap
+let [{foo}, {gni}, ..., {baz}] = l
+
+let (_.{ bla = [..., z] }, t, _, u) = x
+```
+
+## Advanced values
+
+In this section, we detail some more advanced values than the ones presented in. You are not expected to be understanding
+those in details for basic uses of Liquidsoap.
+
+### Errors
+
+In the case where a function does not have a sensible result to return, it can raise an
+_error_. Typically, if we try to take the head of the empty list without
+specifying a default value (with the optional parameter `default`), an error will be raised.
+By default, this error will stop the script, which is usually not a desirable
+behavior. For instance, if you try to run a script containing
+
+```liquidsoap
+list.hd([])
+```
+
+the program will exit printing
+
+```
+Error 14: Uncaught runtime error:
+type: not_found, message: "no default value for list.hd"
+```
+
+This means that the error named "`not_found`" was raised, with a message
+explaining that the function did not have a reasonable default value of the head
+to provide.
+
+In order to avoid this, one can _catch_ exceptions with the syntax
+
+```liquidsoap
+try
+  code
+catch err do
+  handler
+end
+```
+
+This will execute the instructions `code`: if an error is raised at some point
+during this, the code `handler` is executed, with `err` being the error. For
+instance, instead of writing
+
+```liquidsaop
+l = []
+x = list.hd(default=0, l)
+```
+
+we could equivalently write
+
+```liquidsoap
+l = []
+x =
+  try
+    list.hd(l)
+  catch err do
+    0
+  end
+```
+
+The name and message associated to an error can respectively be retrieved using
+the error `kind` and `message` attributes, e.g. we can write
+
+```liquidsoap
+try
+  ...
+catch err do
+  print("the error #{err.kind} was raised")
+  print("the error message is #{err.message}")
+end
+```
+
+Typically, when reading from or writing to a file, errors will be raised when a
+problem occurs (such as reading from a non-existent file or writing a file in a
+non-existent directory) and one should always check for those and log the
+corresponding message:
+
+```liquidsoap
+data = "bla"
+try
+  file.write(data=data, "/non/existent/path")
+catch err do
+  log.important("Could not write to file: #{error.message(err)}")
+end
+```
+
+Specific errors can be caught with the syntax
+
+```liquidsoap
+try
+  ...
+catch err : l do
+  ...
+end
+```
+
+where `l` is a list of error names that we want to handle here.
+
+Errors can be raised from Liquidsoap with the function `error.raise`, which
+takes as arguments the error to raise and the error message. For instance:
+
+```liquidsoap
+error.raise(error.not_found, "we could not find your result")
+```
+
+Finally, we should mention that all the errors should be declared in advance
+with the function `error.register`, which takes as argument the name of the new
+error to register:
+
+```liquidsoap
+myerr = error.register("my_error")
+error.raise(myerr, "testing my own error")
+```
+
+### Nullable values
+
+It is sometimes useful to have a default value for a type. In Liquidsoap, there
+is a special value for this, which is called `null`. Given a type `t`, we write
+`t?` for the type of values which can be either of type `t` or be `null`: such a
+value is said to be _nullable_. For instance, we could redefine the `list.hd`
+function in order to return null (instead of raising an error) when the list is
+empty:
+
+```liquidsoap
+def list.hd(l)
+  if l == [] then null() else list.hd(l) end
+end
+```
+
+whose type would be
+
+```
+(['a]) -> 'a?
+```
+
+since it takes as argument a list whose elements are of type `'a` and returns a
+list whose elements are `'a` or `null`. As it can be observed above, the null
+value is created with `null()`.
+
+In order to use a nullable value, one typically uses the construction `x ?? d`
+which is the value `x` excepting when it is null, in which case it is the
+default value `d`. For instance, with the above head function:
+
+```liquidsoap
+x = list.hd(l)
+print("the head is " ^ (x ?? "not defined"))
+```
+
+Some other useful functions include
+
+- `null.defined`: test whether a value is null or not,
+- `null.get`: obtain the value of a nullable value supposed to be distinct from `null`,
+- `null.case`: execute a function or another, depending on whether a value is
+  null or not.
+
+### Runtime evaluation of scripting values
+
+Similarly to how JSON is [parsed](json.html), you can evaluate string into values at runtime
+using the `eval` decorator. As with JSON, too, the recommended way to use it is by adding an
+explicit type annotation:
+
+```liquidsoap
+let eval (x: {foo: int, bla: string}) = "{foo = 123, bla = \"gni\"}"
+print("x.foo = #{x.foo}, x.bla = #{x.bla}")
+```
+
+### Including other files
+
+It is often useful to split your script over multiple files, either because it
+has become quite large, or because you want to be able to reuse common functions
+between different scripts. You can include a file `file.liq` in a script by
+writing
+
+```liquidsoap
+%include "file.liq"
+```
+
+which will be evaluated as if you had pasted the contents of the file in place
+of the command.
+
+For instance, this is useful in order to store passwords out of the main file, in
+order to avoid risking leaking those when handing the script to some other
+people. Typically, one would have a file `passwords.liq` defining the passwords
+in variables, e.g.
+
+```liquidsoap
+radio_pass = "secretpassword"
+```
+
+and would then use it by including it:
+
+```liquidsoap
+%include "passwords.liq"
+
+radio = ...
+output.icecast(%mp3, host="localhost", port=8000,
+               password=radio_pass, mount="my-radio.mp3", radio)
+```
+
+so that passwords are not shown in the main script.
+
+### Code comments
+
+Comments can be added to your code in two ways:
+
+_Multi-line comments_ are comments that can span multiple lines. They are delimitated
+by the sequence of characters `#<` at the beginning and `>#` at the end. Anything
+in between those two sequences is considered code comment.
+
+Here are some examples:
+
+Simple multiline comments:
+
+```liquidsoap
+#< This is a comment >#
+```
+
+Multiline comments can be nested:
+
+```liquidsoap
+#<
+This is a top-level comment
+
+  # This is also a comment
+
+  #<
+    This is a nested code comment
+  >#
+>#
+```
+
+Fancy looking multiline comment
+
+```liquidsoap
+#<------- BEGIN CODE COMMENT ----#
+Comments can also look like this
+#--------- END CODE COMMENT ----->#
+```
+
+_Single-line comments_ are comments that are limited to the current line. Such comments
+are started with the character `#` without a following `<`. Anything after the initial
+`#` character and until the end of the line is considered code comment:
+
+```liquidsoap
+def f(x) = # This is a single line comment.
+  123
+end
+```
diff --git a/website/content/doc-2.2.5/memory.md b/website/content/doc-2.2.5/memory.md
new file mode 100644
index 00000000..a888419d
--- /dev/null
+++ b/website/content/doc-2.2.5/memory.md
@@ -0,0 +1,135 @@
+## Controlling memory usage
+
+When using liquidsoap in production, it can be important to understand how to control the memory footprint of the application.
+This is not an easy topic as there are several layers of memory management inside the application and also some
+trade-off considerations between memory footprint and CPU usage.
+
+As of writing (version `2.2.0`), some of the trade-off that we are making with the OCaml garbage collector do not seem
+satisfactory in some memory-intensive conditions. Hopefully, this will improve in future major release (`2.3.x` and later).
+
+But first, let's look at what's going on.
+
+### The OCaml memory model
+
+The OCaml compiler provides a garbage collector. This module is able to track memory blocks used by the OCaml program and free
+them when they are not used without the programmer's intervention.
+
+This is done by scanning the memory currently allocated by the OCaml program to identify the memory blocks that are not in
+use anymore. While this is transparent to the user (you!), this also means that there will be extra CPU cycles dedicated to
+this operation.
+
+How often these cycle occur help controlling the growth of unused memory but with the understanding that _to minimize unused memory,
+more CPU cycles have to be dedicated to tracking it_.
+
+You can find more information about the OCaml garbage collection on [this page](https://ocaml.org/docs/garbage-collection).
+
+Inside liquidsoap scripts, the operations that the OCaml compiler provides to control the garbage collector are available within the
+`runtime.gc` module. The documentation for these operations can be found in the [OCaml Gc module documentation](https://v2.ocaml.org/api/Gc.html).
+
+Typically, to change the garbage collector parameters, one can do:
+
+```liquidsoap
+# This code was contributed by AzuraCast:
+# Possible settings:
+# - less memory: space_overhead = 20
+# - less cpu: space_overhead = 140
+# - balanced: space_overhead = 80
+
+# Optimize for memory usage over CPU
+# This results in a slightly increased
+# CPU usage and reduced memory usage.
+runtime.gc.set(runtime.gc.get().{
+  space_overhead = 20,
+  allocation_policy = 2
+})
+```
+
+These parameters and functions make it possible to experiment and see if you can find better parameters for your application.
+
+### C memory allocations
+
+Not all the memory in the application is allocated by the OCaml garbage collector. External libraries such as `ffmpeg`, `libmp3lame`
+and etc. need to allocate their own memory. This is usually referred to as _C memory allocations_ though it does not have
+to be allocated by a program written in `C`.. Another, more technically appropriate is _heap memory_ though, dynamically memory allocated
+by the OCaml garbage collector also lives in the program's heap.. 😅
+
+This type of memory is also cleaned up by the OCaml garbage collector. To do so, a _custom block_ is passed to the OCaml program with
+a reference to a C memory pointer and how to clean it up. When the OCaml program detects that this custom block is no longer
+in use, it triggers the required operations to clean its corresponding C memory.
+
+However, things get complicated when considering how to fine-tune the garbage collector to account for memory allocated on
+the C side..
+
+Remember that, as we discussed in the previous section, the garbage collector has to consume CPU cycles to free up memory. And, in the case of memory allocated on the
+C side, a single OCaml value (usually a small amount of memory) can actually refer to a much larger amount of C memory. This
+is typically the case when the corresponding C memory represents decoded video frames, which is usually a fairly large amount of memory.
+
+In general, the trade-off is: if the garbage collector does not run often enough, a lot of these rather larger C memory blocks are lingering
+longer, which leads to potentially huge amount of memory needlessly consumed by the application.
+
+Conversely, if the garbage collector runs too often, memory usage is controlled but CPU usage is increased.
+
+As of now, the strategy implemented by the OCaml compiler consists in tracking the ratio of OCaml held memory vs. its corresponding C memory and running the garbage collector
+more often when this ratio increases. However, this is not optimal in cases where the application purposefully holds large amount
+of C memory such as when doing video processing.
+
+In the future, we would like to explore tightening up our control of this mechanism. It should be possible trick the garbage collector
+by not declaring the full anmount of allocated C memory to make it possible to run the memory cleaning operations on purpose and at specific times,
+typically after a streaming cycle has ended.
+
+Most of the tools for that are already exported in the scripting language so, we will make sure to report our progress on the [blog](https://liquidsoap.info/blog)
+for anyone to test it.
+
+### Audio data format
+
+Another source of memory usage is the audio data format. By default, we store audio data using OCaml's native floating point numbers in order to be able to run the application,
+including audio processing (crossfade, filters, fades etc) at the best possible speed and CPU usage. However, OCaml's native float are stored using 64 bits (8 bytes), which is a large
+amount of memory per number.
+
+If you are concerned with reducing your audio memory footprint, for instance if your applications has a lot of audio sources with buffers, you can
+do a couple of things:
+
+1. Use the [ffmpeg raw content](ffmpeg.html).
+
+This means storing all the audio content as ffmpeg audio frames. This is an opaque format that works very well if your script can use ffmpeg end-to-end, for instance processing
+audio using [ffmpeg filters](ffmpeg_filters.html)..
+
+2. Use one of the `pcm_f32` or `pcm_s16` audio format.
+
+These formats are less opaque. Their data is stored in a C memory array and can be accessed by the OCaml program. Some, but not all, of our operators
+do support them transparently. When using `pcm_s16`, audio samples are stored as 16 bit signed integers (2 bytes, the audio CD format). When using `pcm_f32`, audio samples are stored as
+32 bit float (4 bytes). 16 bit signed integers is probably enough for most applications and consumes 4 times less memory than OCaml's native floating point numbers.
+
+The `pcm_*` formats can be required by the encoders by adding `pcm_s16` or `pcm_f32` to their list of parameters. This will, in turn, inform all operators
+and decoders to operate with this format, if they support it:
+
+```liquidsoap
+# Mp3 encoder, pcm_s16
+encoder = %mp3(pcm_s16, channels=2)
+
+# Ogg/opus encoder, pcm_f32
+encoder = %ogg(%vorbis(pcm_f32))
+
+# FFmpeg AAC encoder, pcm_s16
+encoder = %ffmpeg(format="mp4",%audio(pcm_s16, codec="aac"))
+```
+
+For both `pcm_*` and ffmpeg raw formats, you can use also conversion functions (`ffmpeg.raw.decode.*`, `ffmpeg.raw.encode.*`, `audio.decode.pcm_*`, `audio.encode.pcm_*`) to convert
+content back and forth.
+
+In general, working with the `pcm_*` formats is easier. If you know what you are doing, though, working with raw FFmpeg frames can also have some advantages. In both cases,
+there might be an increase in CPU usage if your script needs to process audio (for instance via a `crossfade`) when converting these formats back and forth.
+
+Finally, if you need to store large amount of audio data, for instance to create a one hour delay, you should consider using the `track.audio.defer` operator which was designed for
+this purpose.
+
+### `jemalloc`
+
+Lastly, the user-land memory allocator [jemalloc](https://github.com/jemalloc/jemalloc) can be used to control all memory allocations (C and OCaml). This allocator is particularly
+good at preventing memory fragmentation, which is an important topic for an application like liquidsoap running short streaming cycle involving small amount of memory (FFmpeg frames etc).
+
+The allocator is enabled by installing the `jemalloc` opam package and is included in all our production builds (except windows). It also comes with a lot of customization options
+that are exported via the [runtime.jemalloc.\*](https://www.liquidsoap.info/doc-dev/reference.html#runtime.jemalloc.epoch) functions.
+
+If you want to explore more, we recommend [reading about it](https://engineering.fb.com/2011/01/03/core-data/scalable-memory-allocation-using-jemalloc/) and
+then exploring the [manual page](http://jemalloc.net/jemalloc.3.html) which contains details about all the available settings.
diff --git a/website/content/doc-2.2.5/metadata.md b/website/content/doc-2.2.5/metadata.md
new file mode 100644
index 00000000..5d65f8f7
--- /dev/null
+++ b/website/content/doc-2.2.5/metadata.md
@@ -0,0 +1,118 @@
+# Customize metadata using Liquidsoap
+
+Liquidsoap has several mechanism for manipulating the metadata attached to your
+stream. In this page we quickly detail and compare the different operators, see
+the [language reference](reference.html) for full details about them.
+
+**Warning**. The protocol used by Shoutcast and Icecast before version 2 does
+not support many fields. It mainly support one: `song`. So, if you
+need to customize the metadata displayed by these servers, you should
+customize only the `song` metadata.
+
+## The annotate protocol
+
+The metadata are read from files, so the most simple way is to properly tag the
+files. However, if it not possible to modify the files for some reason, the
+`annotate` protocol can be used in playlists to insert and modify some
+metadata. For instance, in the playlist
+
+```
+annotate:title="Title 1",artist="Artist 1":music1.mp3
+annotate:title="Title 2",artist="Artist 2":music2.mp3
+```
+
+the title metadata for file music1.mp3 will be overridden and changed to ``Title
+1'' (and similarly for the artist).
+
+## Map metadata
+
+The `metadata.map` operator applies a specified function to transform
+each metadata chunk of a stream. It can be used to add or decorate metadata, but
+is also useful in more complex cases.
+
+A simple example using it:
+
+```liquidsoap
+# A function applied to each metadata chunk
+def append_title(m) =
+  # Grab the current title
+  title = m["title"]
+
+  # Return a new title metadata
+  [("title","#{title} - www.station.com")]
+end
+
+# Apply metadata.map to s using append_title
+s = metadata.map(append_title, s)
+```
+
+The effect of `metadata.map` by default is to update the metadata with the
+returned values. Hence in the function `append_title` defined in the code above
+returns a new metadata for the label `title` and the other metadata remain
+untouched. You can change this by using the `update` option, and you can also
+remove any metadata (even empty one) using the `strip` option.
+
+See the documentation on `metadata.map` for more details.
+
+## Insert metadata
+
+### Using the telnet server
+
+This operator is used for inserting metadata using a server command. If you have
+an `server.insert_metadata` node named `ID` in your configuration, as in
+
+```
+server.insert_metadata(id="ID", source)
+```
+
+you can connect to the server (either telnet or socket) and execute commands
+like
+
+```
+ID.insert key1="val1",key2="val2",...
+```
+
+### In Liquidsoap
+
+Sometimes it is desirable to change the metadata dynamically when an event
+occurs. In this case, the function `insert_metadata` (not to be confused with
+`server.insert_metadata` above) can be used: when applied to a source it returns
+a source with an added `insert_metadata` method.
+
+For instance, suppose that you want to insert metadata on the stream using the
+OSC protocol. When a pair of strings `title'' `The new title'' is received on
+`/metadata`, we want to change the title of the stream accordingly. This can be
+achieved as follows.
+
+```liquidsoap
+# Our main music source
+s = playlist("...")
+s = mksafe(s)
+
+# Create a source with a `insert_metadata` method
+s = insert_metadata(s)
+
+# Handler for OSC events (gets pairs of strings)
+def on_meta(m) =
+  # Extract the label
+  label = fst(m)
+  # Extract the value
+  value = snd(m)
+  # A debug message
+  print("Insert metadata #{label} = #{value}")
+  # Insert the metadata
+  s.insert_metadata([(label,value)])
+end
+
+# Call the above handler when we have a pair of strings on /metadata
+osc.on_string_pair("/metadata",on_meta)
+
+# Output on icecast
+output.icecast(%mp3,mount="test.mp3",s)
+```
+
+We can then change the title of the stream by sending OSC messages, for instance
+
+```
+oscsend localhost 7777 "/metadata" ss "title" "The new title"
+```
diff --git a/website/content/doc-2.2.5/migrating.md b/website/content/doc-2.2.5/migrating.md
new file mode 100644
index 00000000..19ac9f7e
--- /dev/null
+++ b/website/content/doc-2.2.5/migrating.md
@@ -0,0 +1,487 @@
+# Migrating to a new Liquidsoap version
+
+In this page, we list the most common catches when migrating to a new version of
+Liquidsoap.
+
+### Generalities
+
+If you are installing via `opam`, it can be useful to create a [new switch](https://opam.ocaml.org/doc/Usage.html) to install
+the new version of `liquidsoap`. This will allow to test the new version while keeping
+the old version around in case you to revert to it.
+
+More generally, we recommend to always keep a version of your script around and also
+to make sure that you test your new script with a staging environment that is
+close to production. Streaming issues can build up over time. We do our best to
+release the most stable possible code but problems can arise from many reasons
+so, always best to first to a trial run before putting things to production!
+
+## From 2.1.x to 2.2.x
+
+### References
+
+The `!x` notation for getting the value of a reference is now deprecated. You
+should write `x()` instead. And `x := v` is now an alias for `x.set(v)` (both
+can be used interchangeably).
+
+### Icecast and Shoutcast outputs
+
+`output.icecast` and `output.shoutcast` are some of our oldest operators and were in dire need of some
+cleanup so we did it!
+
+We applied the following changes:
+
+- You should now use `output.icecast` only for sending to icecast servers and `output.shoutcast` only for sending to shoutcast servers. All shared options have been moved to their respective specialized operator.
+- Old `icy_metadata` argument was renamed to `send_icy_metadata` and changed to a nullable `bool`. `null` means guess.
+- New `icy_metadata` argument now returns a list of metadata to send with ICY updates.
+- Added a `icy_song` argument to generate default `"song"` metadata for ICY updates. Defaults to `<artist> - <title>` when available, otherwise `artist` or `title` if available, otherwise `null`, meaning don't add the metadata.
+- Cleaned up and removed parameters that were irrelevant to each operator, i.e. `icy_id` in `output.icecast` and etc.
+- Made `mount` mandatory and `name` nullable. Use `mount` as `name` when `name` is `null`.
+
+### HLS events
+
+Starting with version `2.2.1`, on HLS outputs, `on_file_change` events are now `"created"`, `"updated"` and `"deleted"`. This breaking
+was required to reflect the fact that file changes are now atomic. See [this issue](https://github.com/savonet/liquidsoap/issues/3284)
+for more details.
+
+### `cue_cut`
+
+Starting with version `2.2.4`, the `cue_cut` operator has been removed. Requests cue-in and cue-out processing has been integrated
+directly into requests resolution. In most cases, you simply can remove the operator from your script. In some cases, you might
+need to disable `cue_in_metadata` and `cue_out_metadat` either when creating new requests or when creating `playlist` sources.
+
+### Harbor HTTP server and SSL support
+
+The API for registering HTTP server endpoint and using SSL was completely rewritten. It should be more flexible and
+provide node/express like API for registering endpoints and middleware. You can checkout [the harbor HTTP documentation](harbor_http.html)
+for more details. The [Https support](harbor_http.html#https-support) section also explains the new SSL/TLS API.
+
+### Timeout
+
+We used to have timeout values labelled `timeout` or `timeout_ms`, some of these would be integer and
+in milliseconds, other floating point and in seconds etc. This was pretty confusing so, now all `timeout`
+settings and arguments have been unified to be named `timeout` and hold a floating point value representing
+a number of seconds.
+
+In most cases, your script will not execute until you have updated your custom `timeout`
+values but you should also review all of them to make sure that they follow the new
+convention.
+
+### Metadata overrides
+
+Some metadata overrides have been made to reset on track boundaries. Previously, those were permanent even though they
+were documented as only applying to the current track. If you need to keep the previous behavior, you can used the
+`persist_overrides` parameters (`persis_override` for `cross`/`crossfade`).
+
+The list of concerned metadata is:
+
+- `"liq_fade_out"`
+- `"liq_fade_skip"`
+- `"liq_fade_in"`
+- `"liq_cross_duration"`
+- `"liq_fade_type"`
+
+### JSON rendering
+
+The confusing `let json.stringify` syntax has been removed as it did not provide any feature not already covered by either
+the `json.stringify()` function or the generic `json()` object mapper. Please use either of those now.
+
+### Default character encoding in `output.{harbor,icecast,shoutcast}`
+
+Default encoding for `output.harbor`, `output.icecast` and `output.shoutcast` metadata has been changed to `UTF-8` in all cases.
+
+Legacy systems used to expect `ISO-8859-1` (also known as `latin1`) for metadata inserted into `mp3` streams via the `icy`
+mechanism.
+
+It seems that, nowadays, most software expect `UTF-8` out of the box, including for legacy systems that previously
+assumed other encodings. Therefore, by changing this default value, we try to match exectations of the largest
+number of users of our software.
+
+If you are using one of these outputs, make sure to test this assumptions with your listners' clients. If needed, the
+characters encoding can be set to a different value using the operator's parameters.
+
+### Decoder names
+
+Decoder names have been converted to lowercase. If you were relying on specific settings for decoders priority/ordering, you
+will need to convert them to lowercase, for instance:
+
+```
+settings.decoder.decoders.set(["FFMPEG"])
+```
+
+becomes:
+
+```
+settings.decoder.decoders.set(["ffmpeg"])
+```
+
+Actually, because of the above change in references, this even becomes:
+
+```
+settings.decoder.decoders := ["ffmpeg"]
+```
+
+### `strftime`
+
+Add file-based operators do not support `strftime` type conversions out of the box anymore. Instead, you should use explicit conversions using `time.string`. This means that this script:
+
+```liquidsoap
+output.file("/path/to/file%H%M%S.wav", ...)
+```
+
+becomes:
+
+```liquidsoap
+output.file({time.string("/path/to/file%H%M%S.wav")}, ...)
+```
+
+### Other breaking changes
+
+- `reopen_on_error` and `reopen_on_metadata` in `output.file` an related outputs are now callbacks.
+- `request.duration` now returns a `nullable` float, `null` being value returned when the request duration could not be computed.
+- `getenv` (resp. `setenv`) has been renamed to `environment.get` (resp. `environment.set`).
+
+## From 2.0.x to 2.1.x
+
+### Regular expressions
+
+First-class [regular expression](language.html#regular-expressions) are introduced and are used to replace the following operators:
+
+- `string.match(pattern=<regexp>, <string>` is replaced by: `r/<regexp>/.test(<string>)`
+- `string.extract(pattern=<regexp>, <string>)` is replaced by: `r/<regexp>/.exec(<string>)`
+- `string.replace(pattern=<regexp>, <string>)` is replaced by: `r/<regexp>/g.replace(<string>)`
+- `string.split(separator=<regexp>, <string>)` is replaced by: `r/<regexp>/.split(<string>)`
+
+### Partial application
+
+In order to improve performance, avoid some programming errors and simplify the
+code, the support for partial application of functions was removed (from our
+experience it was not used much anyway). This means that you should now provide
+all required arguments for functions. The behavior corresponding to partial
+application can of course still be achieved by explicitly abstracting (with
+`fun(x) -> ...`) over some arguments.
+
+For instance, suppose that we defined the addition function with two arguments
+with
+
+```liquidsoap
+def add(x,y) =
+  x + y
+end
+```
+
+and defined the successor function by partially applying it to the first
+argument
+
+```liquidsoap
+suc = add(1)
+```
+
+We now need to explicitly provide the second argument, and the `suc` function
+should now be defined as
+
+```liquidsoap
+suc = fun(x) -> add(1, x)
+```
+
+or
+
+```liquidsoap
+def suc(x) =
+  add(1, x)
+end
+```
+
+### JSON parsing
+
+JSON parsing was greatly improved and is now much more user-friendly.
+You can check out our detailed presentation [here](json.html).
+
+### Runtime evaluation
+
+Runtime evaluation of strings has been re-implemented as a type-safe
+eval `let` decoration. You can now do:
+
+```liquidsoap
+let eval x = "[1,2,3]"
+```
+
+And, just like with JSON parsing, the recommended use is with a
+_type annotation_:
+
+```liquidsoap
+let eval (x: [int]) = "[1,2,3]"
+```
+
+### Deprecations and breaking changes
+
+- The argument `streams_info` of `output.file.hls` is now a record.
+- Deprecated argument `timeout` of `http.*` operators.
+- `source.on_metadata` and `source.on_track` now return a source as this was the case in previous versions, and associated handlers are triggered only when the returned source is pulled
+- `output.youtube.live` renamed `output.youtube.live.rtmp`, remove `bitrate` and `quality` arguments and added a single encoder argument to allow stream copy and more.
+- `list.mem_assoc` is replaced by `list.assoc.mem`
+- `timeout` argument in `http.*` operators is replaced by `timeout_ms`.
+- `request.ready` is replaced by `request.resolved`
+
+## From 1.4.x to 2.0.0
+
+### `audio_to_stereo`
+
+`audio_to_stereo` should not be required in most situations anymore. `liquidsoap` can handle channels conversions transparently now!
+
+### `auth` function in `input.harbor`
+
+The type of the `auth` function in `input.harbor` has changed. Where before, you would do:
+
+```liquidsoap
+def auth(user, password) =
+  ...
+end
+```
+
+You would now do:
+
+```liquidsoap
+def auth(params)
+  user     = params.user
+  password = params.password
+  ...
+end
+```
+
+### Type errors with lists of sources
+
+Now that sources have their own methods, the actual list of methods attached to each source can vary from one to the next. For instance,
+`playlist` has a `reload` method but `input.http` does not. This currently confuses the type checker and leads to errors that look like this:
+
+```liquidsoap
+At script.liq, line xxx, char yyy-zzz:
+Error 5: this value has type
+  _ * source(audio=?A, video=?B, midi=?C)
+  .{
+    time : () -> float,
+    shutdown : () -> unit,
+    fallible : bool,
+    skip : () -> unit,
+    seek : (float) -> float,
+    is_active : () -> bool,
+    is_up : () -> bool,
+    log :
+    {level : (() -> int?).{set : ((int) -> unit)}
+    },
+    self_sync : () -> bool,
+    duration : () -> float,
+    elapsed : () -> float,
+    remaining : () -> float,
+    on_track : ((([string * string]) -> unit)) -> unit,
+    on_leave : ((() -> unit)) -> unit,
+    on_shutdown : ((() -> unit)) -> unit,
+    on_metadata : ((([string * string]) -> unit)) -> unit,
+    is_ready : () -> bool,
+    id : () -> string,
+    selected : (() -> source(audio=?D, video=?E, midi=?F)?)
+  }
+but it should be a subtype of the type of the value at radio.liq, line 122, char 2-21
+  _ * _.{reload : _}
+```
+
+In such cases, we recommend to give a little nudge to the typechecker by using the `(s:source)` type annotation where a list of source is causing the issue. For instance:
+
+```liquidsoap
+s = fallback([
+  (s1:source),
+  (s2:source),
+  (s3:source)
+])
+```
+
+This tells the type checker not to worry about the source methods and just focus on what matters, that they are actually sources.. 🙂
+
+### Http input and operators
+
+In order to provide as much compatibility as possible with the different HTTP procotols and implementation, we have decided
+to delegate HTTP support to external libraries which have large scale support and implementation. This means that,
+if you have installed `liquidsoap` using `opam`:
+
+- You need to install the `ocurl` package to enable all HTTP request operators, `http.get`, `http.post`, `http.put`, `http.delete` and `http.head`
+- You need to install the `ffmpeg` package (version `1.0.0` or above) to enable `input.http`
+- You do not need to install the `ssl` package anymore to enable their `https` counter-part. These operators have been deprecated.
+
+### Crossfade
+
+The parameters for `cross` transitions was changed to take advantage of the new module system. Instead of passing multiple arguments
+related to the ending and starting track, those are regrouped into a single record. So, if you had a transition like this:
+
+```liquidsoap
+def transition(
+  ending_dB_level, starting_dB_level,
+  ending_metadata, starting_metadata,
+  ending_source,   starting_source) =
+...
+end
+```
+
+You would now do:
+
+```liquidsoap
+def transition(ending, starting) =
+  # Now you can use:
+  #  - ending.db_level, ending.metadata, ending.source
+  #  - starting.db_level, starting.metadata, starting.source
+...
+end
+```
+
+### Settings
+
+Settings are now exported as records. Where you would before write:
+
+```liquidsoap
+set("decoder.decoders", ["MAD", "FFMPEG"])
+```
+
+You can now write:
+
+```liquidsoap
+settings.decoder.decoders.set(["MAD", "FFMPEG"])
+```
+
+Likewise, to get a setting's value you can now do:
+
+```liquidsoap
+current_decoders = settings.decoder.decoders()
+```
+
+This provides many good features, in particular type-safety.
+
+For convenience, we have added shorter versions of the most used settings. These are all shortcuts to their respective `settings` values:
+
+```liquidsoap
+log.level.set(4)
+log.file.set(true)
+log.stdout.set(true)
+init.daemon.set(true)
+audio.samplerate.set(48000)
+audio.channels.set(2)
+video.frame.width.set(720)
+video.frame.height.set(1280)
+```
+
+The `register` operator could not be adapted to this new API and had to be removed, however, backward-compatible
+`set` and `get` operators are provided. Make sure to replace them as they should be removed in a future version.
+
+### Metadata insertion
+
+The function `insert_metadata` does not return a pair anymore, but a source with
+a method named `insert_metadata`. This means that you should change the code
+
+```liquidsoap
+fs = insert_metadata(s)
+# The function to insert metadata
+f = fst(ms)
+# The source with inserted metadata
+s = snd(ms)
+...
+# Using the function
+f([("artist", "Bob")])
+...
+# Using the source
+output.pulseaudio(s)
+```
+
+to
+
+```liquidsoap
+s = insert_metadata(s)
+...
+# Using the function
+s.insert_metadata([("artist", "Bob")])
+...
+# Using the source
+output.pulseaudio(s)
+```
+
+### Request-based queueing
+
+Queueing for request-based sources has been simplified. The `default_duration` and `length` have been removed in favor of
+a simpler implementation. You can now pass a `prefetch` parameter which tells the source how many requests should be queued
+in advance.
+
+Should you need more advanced queueing strategy, `request.dynamic.list` and `request.dynamic` now export functions to retrieve
+and set their own queue of requests.
+
+### JSON import/export
+
+`json_of` has been renamed `json.stringify` and `of_json` has been renamed `json.parse`.
+
+JSON export has been enhanced with a new generic json object export. Associative lists of type `(string, 'a)` are now
+exported as lists. See our [JSON documentation page](json.html) for more details.
+
+Convenience functions have been added to convert metadata to and from JSON object format: `metadata.json.stringify` and
+`metadata.json.parse`.
+
+### Returned types from output operators
+
+Starting with liquidsoap `2.0.0`, output operators return the empty value `()` while they previously returned a source.
+
+This helps enforce the fact that outputs should be end-points of your scripting graphs. However, in some cases, this can cause
+issues while migrating old scripts, in particular if the returned value of an output was used in the script.
+
+The way to fix this is to apply your operator to the source directly underneath the output. For instance, the following clock assignment:
+
+```liquidsoap
+s = ...
+
+clock.assign_new([output.icecast(..., s)])
+```
+
+Should now be written:
+
+```liquidsoap
+s = ...
+
+clock.assign_new([s], ...)
+
+output.icecast(..., s)
+```
+
+### Deprecated operators
+
+Some operators have been deprecated. For most of them, we provide a backward-compatible support
+but it is good practice to update your script. You should see logs in your script when running
+deprecated operatords. Here's a list of the most important ones:
+
+- `playlist.safe` is replaced by: `playlist(mksafe(..))`
+- `playlist.once` is replaced by: `playlist`, setting `reload_mode` argument to `"never"` and `loop` to `false`
+- `rewrite_metadata` should be rewritten using `metadata.map`
+- `fade.inital` and `fade.final` are not needed anymore
+- `get_process_output` is replaced by: `process.read`
+- `get_process_lines` is replaced by: `process.read.lines`
+- `test_process` is replaced by: `process.test`
+- `system` is replaced by: `process.run`
+- `add_timeout` is replaced by: `thread.run.recurrent`
+- `on_blank` is replaced by: `blank.detect`
+- `skip_blank` is replaced by: `blank.skip`
+- `eat_blank` is replaced by: `blank.eat`
+- `strip_blank` is replaced by: `blank.strip`
+- `which` is replaced by: `file.which`
+- `register_flow`: flow is no longer maintained
+- `empty` is replaced by: `source.fail`
+- `file.unlink` is replaced by: `file.remove`
+- `string.utf8.escape` is replaced by: `string.escape`
+- `metadata.map` is replaced by: `metadata.map`
+
+### Windows build
+
+The windows binary is statically built and, for this reason, we cannot enable both the `%ffmpeg` encoder and any encoder that
+uses the same underlying libraries, for instance `libmp3lame` for `mp3` encoding. The technical reason is that both libraries
+import the same C symbols, which makes compilation fail.
+
+The `%ffmpeg` encoder provides all the functionalities of the internal encoders that conflict with it along with many more format
+we do not support otherwise. For this reason, it was decided to enable the `%ffmpeg` encoder and disable all other encoders.
+
+This means that, if you were previously using a different encoder than `%ffmpeg`, you will need to adapt your script to
+use it. For instance, for mp3 encoding with variable bitrate:
+
+```liquidsoap
+%ffmpeg(format="mp3", %audio(codec="libmp3lame", q=7))
+```
diff --git a/website/content/doc-2.2.5/multitrack.md b/website/content/doc-2.2.5/multitrack.md
new file mode 100644
index 00000000..166b4556
--- /dev/null
+++ b/website/content/doc-2.2.5/multitrack.md
@@ -0,0 +1,357 @@
+# Multitrack support
+
+Starting with version `2.2.0`, liquidsoap now supports track operations, making it possible to manipulate data at the
+track level, including demuxing, remuxing, encoding, decoding, applying filters and more!
+
+**Only the FFmpeg decoder and encoder supports multitrack**. This means that you need to have `liquidsoap` compiled
+with the FFmpeg support to be able to decode or encode sources with multiple audio/video tracks.
+
+Support for track muxing and demuxing and track-level operators, however, does not require the FFmpeg support but, without it, all decoders and outputs are limited to at most one `audio` and one `video` track.
+
+## Multitrack sources
+
+Liquidsoap sources can have multiple tracks, such as an english language audio track and a french language audio track.
+The number of tracks in a source is determined by how you use it.
+
+For instance, if you have a file `movie.mkv` with two audio tracks and one video track,
+you can create a source `s` with it using the `single` operator (or `playlist`, `request.dynamic` etc):
+
+```liquidsoap
+s = single("/path/to/movie.mkv")
+```
+
+By default, `liquidsoap` decodes _only_ the track that you tell it to pick. So,
+if you output this source as an output with only one audio track, it will happily do so:
+
+```liquidsoap
+s = single("/path/to/movie.mkv")
+
+# Copy first audio track and video:
+output.file(
+  %ffmpeg(
+    %audio.copy,
+    %video.copy
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+Resulting in the following logs:
+
+```
+[output_file:3] Content type is {audio=ffmpeg.copy,video=ffmpeg.copy}.
+[decoder.ffmpeg:3] Requested content-type for "/path/to/movie.mkv": {audio=ffmpeg.copy,video=ffmpeg.copy}
+[decoder.ffmpeg:3] FFmpeg recognizes "/path/to/movie.mkv" as video: {codec: h264, 1920x1038, yuv420p}, audio: {codec: aac, 48000Hz, 6 channel(s)}, audio_2: {codec: aac, 48000Hz, 6 channel(s)}
+[decoder.ffmpeg:3] Decoded content-type for "/path/to/movie.mkv": {audio=ffmpeg.copy(codec="aac",channel_layout="5.1",sample_format=fltp,sample_rate=48000),video=ffmpeg.copy(codec="h264",width=1920,height=1038,aspect_ratio=1/1,pixel_format=yuv420p)}
+```
+
+This shows that the `output.file` source was initialized with expected content-type `{audio=ffmpeg.copy,video=ffmpeg.copy}`, i.e. one audio and one video
+track, both copied from the original file. This comes from the `%ffmpeg` encoder definition in our script.
+
+Then, the `single` file was decoded with the same requested content-type and FFmpeg reported all the details about the file's content, including a second audio track named `audio_2`.
+
+Eventually, we picked up only first `audio` and first `video` track and reported a more detailed content-type now that we know the actual content of each track.
+
+Now, let's say that we want to also keep the second audio track but convert it to stereo and re-encode it into `aac`. We can then do:
+
+```liquidsoap
+s = single("/path/to/movie.mkv")
+
+# Copy first audio track and video track
+# and re-encode second audio track:
+output.file(
+  %ffmpeg(
+    %audio.copy,
+    %audio_2(
+      channels=2,
+      codec="aac"
+    ),
+    %video.copy
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+And now we see the following logs:
+
+```
+[output_file:3] Content type is {audio=ffmpeg.copy,audio_2=pcm(stereo),video=ffmpeg.copy}.
+[decoder.ffmpeg:3] Requested content-type for "/path/to/movie.mkv": {audio=ffmpeg.copy,audio_2=pcm(stereo),video=ffmpeg.copy}
+[decoder.ffmpeg:3] FFmpeg recognizes "/path/to/movie.mkv" as video: {codec: h264, 1920x1038, yuv420p}, audio: {codec: aac, 48000Hz, 6 channel(s)}, audio_2: {codec: aac, 48000Hz, 6 channel(s)}
+[decoder.ffmpeg:3] Decoded content-type for "/path/to/movie.mkv": {audio=ffmpeg.copy(codec="aac",channel_layout="5.1",sample_format=fltp,sample_rate=48000),audio_2=pcm(5.1),video=ffmpeg.copy(codec="h264",width=1920,height=1038,aspect_ratio=1/1,pixel_format=yuv420p)}
+```
+
+Now, we are actually using both audio tracks from `movie.mkv` and one of them is being converted to stereo audio!
+
+One thing to keep in mind, however, is that **expected content-type drives the input decoder**. Typically, if, instead of a `single`, you use a `playlist`:
+
+```liquidsoap
+s = playlist("/path/to/playlist")
+
+# Copy first audio track and video track
+# and re-encode second audio track:
+output.file(
+  fallible=true,
+  %ffmpeg(
+    %audio.copy,
+    %audio_2(
+      channels=2,
+      codec="aac"
+    ),
+    %video.copy
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+Then all the files in the playlist who do not have at least two `audio` tracks and one `video` track will be rejected by the decoder!
+
+Lastly, it is important to keep in mind that **decoders always assume a specific nomenclature for tracks**. The convention when decoding is to name the first audio track `audio`, then `audio_2`, `audio_3` and etc. Likewise for video: `video`, `video_2`, `video_3`.
+
+Typically, the following will not work:
+
+```liquidsoap
+s = playlist("/path/to/playlist")
+
+# Copy first audio track and video track
+# and re-encode second audio track:
+output.file(
+  fallible=true,
+  %ffmpeg(
+    %audio_fr.copy,
+    %audio_en(
+      channels=2,
+      codec="aac"
+    ),
+    %video.copy
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+This is because the decoder has no way of knowing which of the audio track present in the files in `s` should be matched to `audio_en` and `audio_fr.copy`.
+
+One might think that the order in which they are declared in the encoder could be used but this would also be tricky as the decoder could report tracks in different order when decoding different files from the playlist.
+
+Also, and perhaps more importantly, tracks can be demuxed and remuxed at will, which also makes us loose the notion of track order. Actually, let's talk about demuxing and remuxing next!
+
+## Tracks demuxing and muxing
+
+For any given source, you can extract its tracks using the `source.tracks` operator:
+
+```liquidsoap
+s = playlist(...)
+
+let {audio, video, metadata, track_marks} = source.tracks(s)
+```
+
+In the above, `audio` and `video` represent, resp., the `audio` and `video` track from the source `s`.
+
+The `metadata` and `track_marks` tracks are special track type that are available in any source and hold, as the name suggests, the source's metadata and track marks. We will see later how this can be used to e.g. drop all tracks from a source (something that used to be done with the
+`drop_tracks` operator), or select metadata only from a specific source or track.
+
+Internally, **a track is a source restricted to a single content-type**. This means that:
+
+- When pulling data for a given track, the underlying source is used, potentially also pulling data for its other tracks
+- Tracks are subject to the same limitations as sources w.r.t. clocks
+- Tracks, like sources, always have a `metadata` and `track_marks` tracks. The `track.metadata` and `track.track_marks` operators can be used to retrieve them.
+
+Tracks can be muxed using the `source` operator. The operator takes a record of tracks and creates a source with them. Tracks can have any name and type except `metadata` and `track_marks` that are reserved for their corresponding track types.
+
+### Add a video track
+
+Here's how to add a video track to a source
+
+```liquidsoap
+# A playlist of audio files
+s = playlist(...)
+
+# A static image
+image = single("/path/to/image.png")
+
+# Get the playlist's audio track, metadata and track marks
+let {audio = playlist_audio, metadata, track_marks} = source.track(s)
+
+# Get the video track from our static image
+let {video = image_video} = source.tracks(image)
+
+# Mux the audio tracks with the image
+s = source({
+  audio=playlist_audio,
+  video=image_video,
+  metadata=metadata,
+  track_marks=track_marks
+})
+```
+
+The above example was purposely written in a longer form to make it more explicit. However, if you wish to just add/replace a track, you
+can also overload the existing tracks from the first source as follows:
+
+```liquidsoap
+# A playlist of audio files
+s = playlist(...)
+
+# A static image
+image = single("/path/to/image.png")
+
+# Mux the audio tracks with the image
+s = source(source.tracks(s).{video=source.tracks(image).video})
+```
+
+### Add a default video track
+
+You can also check if a source has a certain track and do something accordingly:
+
+```liquidsoap
+s = playlist(...)
+
+# A default video source:
+image = single("/path/to/image.png")
+
+# Pick `s` video track if it has one, otherwise use the default one:
+video = source.tracks(s).video ?? source.tracks(image).video
+
+# Return a source that always has video:
+s = source(source.tracks(s).{video=video})
+```
+
+Please note, however, that **tracks available in the playlist sources are determined based on the first decoded file**. If the first file in the playlist is audio-only then the playlist content-type is assumed to be audio-only for the whole playlist and the default video is added to _all decoded files_.
+
+To decide on a case-by-case basis, you might need some more advanced coding!
+
+### Merge all tracks
+
+As mentioned before, you can also remove the track marks from a source as follows:
+
+```liquidsoap
+s = playlist(...)
+
+# Extract all tracks except track_marks:
+let {track_marks=_, ...tracks} = source.tracks(s)
+
+s = source(tracks)
+```
+
+## Track-level operators
+
+Some, but not all, operators have been updated to operate at the track level. They are documented under the `Track` section in [the API documentation](reference.html). More operators might be converted in the future (feel free to file a feature request for those!).
+
+For instance, to convert an audio track to mono PCM audio, one can do:
+
+```liquidsoap
+mono_track = track.audio.mean(audio_track)
+```
+
+Likewise, inline encoders are now available at the track level, for instance:
+
+```liquidsoap
+encoded_audio_track = track.ffmpeg.encode.audio(%ffmpeg(%audio(codec="aac")), audio_track)
+```
+
+However, remember that tracks have the same limitations w.r.t. clocks that sources have. Here, in particular, `encoded_audio_track` is in a new
+clock (due to the fact that ffmpeg inline encoding is not synchronous). Therefore, the following will fail:
+
+```liquidsoap
+s = playlist(...)
+
+let {audio, metadata, track_marks} = source.tracks(s)
+
+encoded = source({
+  audio       = track.ffmpeg.encode.audio(%ffmpeg(%audio(codec="aac")), audio),
+  metadata    = metadata,
+  track_marks = track_marks
+})
+```
+
+This is because `metadata` and `track_marks` are tracks from the underlying `s` source, which belongs to a different clock. In this case, you should
+use the track marks and metadata from the encoded track:
+
+```liquidsoap
+s = playlist(...)
+
+let {audio, metadata, track_marks} = source.tracks(s)
+
+encoded_audio = track.ffmpeg.encode.audio(%ffmpeg(%audio(codec="aac")), audio)
+
+encoded = source({
+  audio       = encoded_audio,
+  metadata    = track.metadata(encoded_audio),
+  track_marks = track_marks(encoded_audio)
+})
+```
+
+## Conventions
+
+Now that we have seen how we can create any collection of tracks with any possible name, in order to make things work, we need to assume a couple of conventions.
+
+**For decoders**, the convention, as explained above, is, when decoding files, to name the first audio track `audio`, then `audio_2`, `audio_3` and etc. Likewise for video: `video`, `video_2`, `video_3`.
+
+This is the convention that you should use when demuxing tracks from request-based source:
+
+```liquidsoap
+s = playlist(...)
+
+let {audio, audio_2, video, video_2, video_3} = source.tracks(s)
+```
+
+**For encoders**, to drive content-type at runtime, since tracks can be remuxed with any arbitrary name, we need to a way to decide what type of content a track contains, being `audio`, `video` or, potentially `midi` and, planned for later, `subtitles`. This is achieved using the following convention, by order of priority:
+
+1. A `copy` track is any track named `%<track_name>.copy`. We do not need to know the track's content in this case.
+2. If a track has `audio_content` or `video_content` as parameter (for instance `%foo(audio_content, ...)`) then it is considered, resp., `audio` or `video`.
+3. If the track name has `audio` or `video` in it (for instance `%dolby_audio_fr`) then it is considered, resp., `audio` or `video`
+4. If the track codec is hardcoded (for instance (`%foo(codec="aac", ...)`) then the codec is used to detect the content.
+
+For instance, imagine that you want to encode a source with a `fr` and `en` audio track and a `director_cut` video track, you can do the following:
+
+```liquidsoap
+output.file(
+  %ffmpeg(
+    %en(codec="aac"),
+    %fr(codec="aac"),
+    %director_cut(codec="libx264")
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+This works because each of the codec used in these tracks can be mapped to a specific content-type.
+
+Now, imagine that you actually want to use a variable for the codec of the `en` and `director_cut` track. In this case, you can do:
+
+```liquidsoap
+output.file(
+  %ffmpeg(
+    %en(audio_content, codec=audio_codec)
+    %fr(codec="aac"),
+    %director_cut(video_content, codec=video_codec)
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+This informs `liquidsoap` what type of content these tracks contain.
+
+However, you might also opt for a more explicit track naming scheme. Something like:
+
+```liquidsoap
+output.file(
+  %ffmpeg(
+    %audio_en(codec=audio_codec),
+    %audio_fr(codec="aac"),
+    %director_cut_video(codec=video_codec)
+  ),
+  "/path/to/copy.mkv",
+  s
+)
+```
+
+In this case, `liquidsoap` assumes that the track with `audio` in their name are indeed audio track and the same goes for video tracks.
+
+Lastly, these naming conventions have no bearing for the `FFmpeg` encoder. At the FFmpeg encoder level, tracks are identified by an integer and stored
+in the order they are declared in the `%ffmpeg` encoder. This means that, once encoded and saved to a file, track names internal to liquidsoap are not saved by the FFmpeg encoder and, instead, when decoding the file, you will get `audio`, `audio_2`, `video` and etc.
diff --git a/website/content/doc-2.2.5/on2.md b/website/content/doc-2.2.5/on2.md
new file mode 100644
index 00000000..de4b1d8a
--- /dev/null
+++ b/website/content/doc-2.2.5/on2.md
@@ -0,0 +1,28 @@
+Savonet was at the [ON2: Test Signals](http://testsignals.org/) conference in
+Berlin, on October 22-23 2010. We presented Liquidsoap, but also held the first
+Liquidsoap workshop.
+
+<iframe src="https://player.vimeo.com/video/16528307" width="640" height="352" frameborder="0" allow="autoplay; fullscreen" allowfullscreen></iframe>
+<p><a href="https://vimeo.com/16528307">Liquidsoap presentation at ON2</a> from <a href="https://vimeo.com/smimram">Samuel Mimram</a> on <a href="https://vimeo.com">Vimeo</a>.</p>
+
+# Liquidsoap Workshop
+
+Below is a list of topics that we covered, proposing problems,
+guiding you through solving them and discussing various solutions.
+
+**1. Getting started**:
+Get to know liquidsoap, playing with audio streams to get used
+to the main concepts in liquidsoap.
+Learn to run liquidsoap is various modes, from one-liners to daemon.
+[More...](on2_part1.html)
+
+**2. Typical netradio examples**:
+We will go through typical needs for netradios, covering transitions,
+complex playlists, live show handling, blank detection, metadata handling,
+etc.
+[More...](on2_part2.html)
+
+**3. Beyond audio**:
+For those who are interested, we can go through more advanced examples
+exploring the possibilities of video and midi support in liquidsoap.
+[More...](on2_part3.html)
diff --git a/website/content/doc-2.2.5/on2_part1.md b/website/content/doc-2.2.5/on2_part1.md
new file mode 100644
index 00000000..20ed121b
--- /dev/null
+++ b/website/content/doc-2.2.5/on2_part1.md
@@ -0,0 +1,301 @@
+This part starts from scratch. All you need is a working install
+of liquidsoap.
+If you don't have one already, we can help you;
+but if you haven't, check the [corresponding page](download.html).
+
+# Run liquidsoap on one-liners
+
+A good way to test your install and get started
+is to execute very small liquidsoap programs.
+Such ``one-liners'' are also often useful to accomplish simple tasks.
+
+## Play a synthesized sound
+
+Simply execute the following command,
+and you should hear a 440Hz sound on your soundcard:
+
+```
+liquidsoap 'out(sine())'
+```
+
+Did it work? If so, try to modify it:
+
+- Change the pitch. Hint: get the doc of `sine` using `liquidsoap -h sine` or [online](reference.html).
+- Use a different wave shape, or perhaps some white noise. Hint: look-up the [API](reference.html) in the `Source / Input` section.
+
+## Play a remote stream, discover fallibility
+
+Try to execute the liquidsoap expression:
+
+```liquidsoap
+out(input.http("http://ice.rosebud-media.de:8000/88vier"))
+```
+
+You should now be listening to [Pi-Radio](http://piradio.de),
+unless you have no network connection, in which case the
+`input.http(...)` source _fails_.
+
+The output operator `out` is okay with failure: it simply plays silence
+when the source fails, waiting for it to be ready again.
+But some operators are stricter.
+If you try
+
+```liquidsoap
+output.ao(input.http("http://ice.rosebud-media.de:8000/88vier"))
+```
+
+the AO output (which uses libao to access your soundcard)
+warns you that there might be a failure.
+To ignore this problem, pass `fallible=true` to the output.
+
+This might seem annoying
+but it can make sense if you have listeners and you want to make
+sure that your stream is always up and running for them.
+
+## Play a list of files
+
+The `playlist` operator can be used to build a source that plays
+a list of files. The resulting source will be fallible.
+You can either pass a directory name, or a text file containing the
+list of files.
+There are lots of possibilities here, but for now just look
+at the `mode` parameter; we'll learn more later.
+
+## An interactive example
+
+Suppose we want to be able to request a particular file for playout
+instead of the automatically chosen files of the playlist.
+This is achieved by wrapping the playlist in a fallback choice
+with a request queue:
+
+```liquidsoap
+out(fallback([request.queue(id="q"),playlist("music")]))
+```
+
+If you run this example, you'll hear your playlist, because the queue
+is empty. The queue can be fed through _server commands_. Enable the
+telnet server interface by passing `-t` on liquidsoap's command line,
+and connect to it using `telnet localhost 1234`.
+
+- Type `help`, find the command for pushing a request (by its file name) in the queue, and try it.
+- Find the command for skipping the current track. If you skip a playlist track after having pushed a request in the queue, you should hear that request -- unless the request failed to be prepared.
+- Find the command for listing the next requests in queue. They are given by their request id (RID); the commands `request.metadata` and `request.trace` give you info from the RID.
+- Also notice commands for listing the next files to be played by the playlist (depends on the playlist more), and reloading the playlist.
+- Try setting `track_sensitive=false` for the fallback, see what it does (better, guess what it does from the doc).
+
+## Encode a file
+
+You have learned how to build a few sources, synthesizing sound from scratch,
+from a remote stream or from a list of files. Now, instead of playing the
+stream directly to your soundcard, we'll encode it and save it to a local
+file:
+
+```liquidsoap
+output.file(%vorbis,"test.ogg",source)
+```
+
+Here `source` is whatever you want, for example `sine()`.
+
+You can tweak the options of the encoding format, or change the encoding
+format; the available options are listed [here](encoding_formats.html).
+You can change the number of channels (for example, using `%vorbis(mono)`)
+but this may create problems with a playlist or remote stream,
+because conversions are not implicit in liquidsoap;
+we'll see later how to deal with them.
+
+## Icecast output
+
+You can now easily change the file example to send you stream to an
+icecast server: simply use `output.icecast` instead of `output.file`,
+passing a `mount` parameter instead of a file name,
+and perhaps overriding the defaults for `host` (`"127.0.0.1"`)
+and `password` (`"hackme"`).
+You just created your first Internet radio using liquidsoap!
+
+If you have control over the icecast server (or over the network link to that
+server) you can simulate a loss of connection. Notice that liquidsoap only
+attempts once to reconnect, then fails and shuts down. For another behavior
+that tolerates more persistent failures, set `restart=true`.
+
+# Using liquidsoap in production
+
+One-liners are good for one-shot uses, but not the most convenient
+for more complex liquidsoap programs, and for saving/editing the program.
+
+## Running a script file
+
+Write the interactive example expression in a file, say `test.liq`.
+
+- You can run it using `liquidsoap -t - < test.liq`, you get the same behavior as before.
+- If you run it using `liquidsoap -t test.liq` the logs will be written in `test.log` in the default logging directory. This can fail as you may not have access to that directory. Change the directory using the setting (see [how to get help](help.html) about that) `log.file.path`. Then use the settings `log.stdout` and `log.file` for logging to the terminal and not to a file.
+- Finally, find the setting for getting rid of the `-t` option on the command line.
+- You can also use `#!/usr/bin/liquidsoap` (adapt the path) as the first line of your script to directly run `./test.liq` instead of `liquidsoap test.liq` (you need to `chmod +x test.liq`).
+
+You can also load several scripts and expression on the command line. The last
+script or expression is taken as the main one, and determines the logging behavior of liquidsoap.
+
+## Daemon mode
+
+Finally, the `-d` command-line option (or `init.daemon` setting) triggers
+the _daemon mode_ where liquidsoap detaches from the terminal to run in the
+background.
+
+## Checking a media file
+
+To check how liquidsoap sees a file, you can run `liquidsoap -r <FILE>`.
+Liquidsoap will attempt to decode the file and its metadata,
+and compute its duration.
+This is (almost) the same process as used during streaming,
+so it can be used for checking how something works (or doesn't work).
+
+# Get comfortable with the language
+
+Although it's easy to forget it when using simple liquidsoap expressions,
+liquidsoap is a rich programming language.
+Below is a list of simple exercises to get more comfortable with it.
+Those exercises do not deal with sources and even less with radio,
+and might seem pretty dull. But it's useful to go through them and
+try to understand what's going on: it will allow you to avoid the
+most common mistakes later,
+when trying to write more complex liquidsoap scripts.
+
+You can write the following examples in a script and execute it, or
+type them directly in your terminal, followed by ctrl-D, on the
+standard input of `liquidsoap -`.
+You can also pass `-c` so that liquidsoap does not warn you that
+it has no source to stream.
+
+## Using variables
+
+Run the following script:
+
+```liquidsoap
+x = 42
+print(x)
+```
+
+As follows:
+
+```
+% liquidsoap --no-stdlib -i /path/to/script.liq
+x     : int
+42
+No output defined, nothing to do.
+```
+
+Try to obtain the following types (some help can be found [there](language.html)):
+
+- `float`
+- `bool`
+- `string`
+- `[string]` (list of strings)
+- `(bool*string)` (a pair made of a boolean and a string)
+
+You can redefine a variable:
+
+```liquidsoap
+x = 42
+y = "42"
+x = (y,y)
+z = (x,y)
+print(z)
+```
+
+## Defining a function
+
+Try this:
+
+```liquidsoap
+def double(s)
+  s ^ s
+end
+print(double("foo"))
+```
+
+Change `^` for `+`. Liquidsoap will complain that it cannot add strings;
+additions are only for numbers (integers and floats). Adapt the last line
+to fix that problem.
+
+## Conditionals
+
+A simple example:
+
+```liquidsoap
+if "foo"=="bar" then
+  print("This is madness.")
+else
+  print("Phew.")
+end
+```
+
+It can also be written as follows:
+
+```liquidsoap
+print(
+  if "foo"=="bar" then
+    "This is madness."
+  else
+    "Phew."
+  end)
+```
+
+Now, define the variable `message` to be the correct message depending
+on the test, and finish by `print(message)`.
+To do this, keep in mind the following:
+A variable definition is local to the current scope.
+Redefining a new variable does not erase or override previous definitions
+but only masks them in the current scope.
+In other words, _definitions_ should not be confused with
+_assignments_ (which are performed by `x=...` in non-functional languages).
+You'll learn later how to use assignments when you really need them.
+
+## Sequencing, returning
+
+Here is a function that prints the date and returns 42:
+
+```liquidsoap
+def f()
+  print(get_process_output("date"))
+  42
+end
+# Let's use it:
+print(f())
+print(1+f())
+```
+
+Note that there is no return statement in liquidsoap (in fact there is
+no "statement" at all). Every expression evaluates to a value. A sequence
+evaluates to the value of its last expression (`42` in the body of the function
+`f`, and `print(1+f())` in the full program).
+The value ``returned'' by a function is simply the result of evaluating its
+body.
+
+## Labels and optional parameters
+
+In liquidsoap, functions arguments can be labeled or not.
+For example, in `f(x,y,foo=z)` we pass `x` and `y` as the first two
+unlabeled arguments, and `z` for the argument labeled `foo`.
+Moreover, labeled arguments can be optional:
+you saw this with most examples in this page, where each operator
+had lots of parameters that you didn't set (for example,
+`track_sensitive` in `fallback`).
+
+When reading the doc of a function, you see the type of the function,
+followed by a description of its arguments. Often you can ignore the
+type, but when you write an incorrect script, you might need to read
+types to understand error messages. A function type is written
+`(A1,..,AN)->T` where `T` is the type of values returned by the function
+and each `Ai` specifies one parameters:
+
+- unlabeled parameters are simply given by their type (for example, string concatenation has type `(string,string)->string`);
+- mandatory labeled parameters are written `label:T` where `T` is the type of the parameter;
+- optional labeled parameters are written `?label:T`.
+
+You will rarely have to define a function with labeled parameters,
+but if you're curious you can learn it [there](language.html).
+
+## What you cannot do
+
+Liquidsoap does not have `while` and `for` loops, nor recursion.
+This is mostly because they are not really needed (yet...), notably
+since functions like `list.map` and `list.iter` are often a good replacement.
diff --git a/website/content/doc-2.2.5/on2_part2.md b/website/content/doc-2.2.5/on2_part2.md
new file mode 100644
index 00000000..13f5d86c
--- /dev/null
+++ b/website/content/doc-2.2.5/on2_part2.md
@@ -0,0 +1,849 @@
+# Building an advanced stream: file-based sources
+
+The purpose of this part is to document and illustrate the creation of an
+advanced stream using static files.
+
+In order to be self-contained, we will use here only pure liquidsoap scripting
+functionalities. However, all the parts that use pre-defined functions can be
+implemented using external scripts, which is the most common practice, and has
+proved to be very convenient in order to integrate your liquidsoap stream into
+the framework that you use to manage your radio.
+
+## Preliminaries
+
+In order to make things more clear and modular, we will
+separate the code in two parts:
+
+- `radio.liq` is the script that contains the definition of the main stream
+- `library.liq` is the script that contains the functions used to build the stream
+
+The scripts here should be tested using the following
+command line:
+
+```
+liquidsoap /path/to/radio.liq
+```
+
+Thus, we do not define here daemonized script. In order to make
+things work smoothly, you should put the following lines at the beginning
+of `radio.liq`:
+
+```liquidsoap
+log.file.set(false)
+log.stdout.set(true)
+log.level.set(3)
+```
+
+Finally, we add the following line at the beginning of `radio.liq`,
+in order to load our pre-defined functions:
+
+```liquidsoap
+%include "/path/to/library.liq"
+```
+
+We will use the telnet server to interact with the radio.
+Thus, we enable the telnet server by adding the following line in `radio.liq`:
+
+```liquidsoap
+settings.server.telnet.set(true)
+```
+
+## An initial model
+
+In this part, we describe the initial stream that we want.
+We start with a simple stream that contains songs from
+a static playlist, with some jingles, with 3 songs for one jingle,
+and output the result to an icecast server. This
+is described by the following graph:
+
+![Initial stream model](/assets/img/on2_part2_schema1.svg)
+
+This very simple stream is defined by the following content
+in `radio.liq`:
+
+```liquidsoap
+# The file source
+songs = playlist("/path/to/some/files/")
+
+# The jingle source
+jingles = playlist("/path/to/some/jingles")
+
+# We combine the sources and play
+# one single every 3 songs:
+s = rotate(weights=[1,3], [jingles, songs])
+
+# We output the stream to an icecast
+# server, in ogg/vorbis format.
+output.icecast(%vorbis,id="icecast",
+               fallible=true,mount="my_radio.ogg",
+               host="my_server", password="hack_me_not",
+               s)
+```
+
+For now, `library.liq` does not contain any code so we only do:
+
+```
+touch /path/to/library.liq
+```
+
+- Write this script to a file, change the default directories and parameters.
+- Run it.
+- Listen to your initial stream.
+- Connect to the telnet server (`telnet localhost 1234`)
+- Try the telnet comment: `icecast.skip`
+- Check that a jingle is played every 3 songs.
+- Sometimes, when skipping, the source does not prepare a new file quickly enough, which breaks the rotation. If this is the case, add the parameter `conservative=true` to each playlist and try again.
+
+Now, we extend this initial stream with some advanced features:
+
+### Notify when a song is played
+
+Once the stream is started, we may want to be able to keep track of the songs that are played,
+for instance to display this information on a website.
+One nice way to do this is to call a function every time that a new track is passed to the
+output, which will inform the user of which tracks are played and when. This can be done
+using the `on_metadata` operator.
+
+First, we define a function that is called every time a new metadata is seen in the stream.
+This is a function of type `(metadata)->unit`, i.e. a function that receives the metadata
+as argument and returns nothing.
+The `metadata` type is actually `[(string*string)]`,
+i.e. a list of elements of the form `("label","value")`.
+
+Thus, we add the following in `library.liq`:
+
+```liquidsoap
+# This function is called when
+# a new metadata block is passed in
+# the stream.
+def apply_metadata(m) =
+  title = m["title"]
+  artist = m["artist"]
+  print("Now playing: #{title} by #{artist}")
+end
+```
+
+**Note**: the string `"foo #{bla}"` can also be written `"foo " ^ bla` and is the
+string ``foo bar'', if `bla`is the string`"bar"`.
+
+Now, we apply the `on_metadata` operator with this function just
+before passing the final source to the output, so we write in `radio.liq`,
+before the output line:
+
+```liquidsoap
+s = on_metadata(apply_metadata,s)
+```
+
+- Update your scripts.
+- Run the new radio.
+- Observe the lines printed on new metadata.
+- You may prefer to use the `log` function rather than `print`.
+
+Solutions:
+
+- [radio.liq](radio.liq-notify)
+- [library.liq](library.liq-notify)
+
+### Custom scheduling
+
+Another issue with the above stream is the fact that jingles have a strict
+frequency of one jingle every 3 songs. In a lot of cases, you may want
+more flexibility and have full-features scheduling of your songs. The
+best approach in this case is to _externalize_ this operation by creating
+a scheduler with the language/framework of your choice and integrating it
+with liquidsoap using `request.dynamic.list`.
+
+`request.dynamic.list` takes a function of type `()->[request('a)]`,
+i.e. a function with no arguments that returns an array of new requests to queue
+and create a source with it. Every time that liquidsoap needs to
+prepare a new file, it will execute the function and use its result.
+
+Requests in liquidsoap are created with the function `request.create`,
+which takes an URIs of the form:
+
+```
+protocol:arguments
+```
+
+where `protocol:` is optional is `arguments` is the URI of a local file.
+For instance, `ftp://server.net/path/to/file.mp3` is a requests using
+the _ftp_ protocol, which is resolved using `wget` (if present in the
+system).
+
+We are going to use `request.dynamic.list` to merge both the `songs` and
+`jingles` sources into one source and let our external scheduler
+decides when to play a jingle or a song. However, we will need
+later to know if we are currently playing a song or a jingle.
+
+For these reasons, we will be using the `annotate:` protocol.
+This protocol can be used to pass additional metadata along
+with the metadata of the file. Here, we will pass a metadata
+labeled `"type"`, with value `"song"` if the track is a song
+or `"jingle"` otherwise.
+
+In the context of this simple presentation, we will write
+a dummy script. Thus, we create a file `"/tmp/request"`
+that contains a line of the form:
+
+```
+annotate:type="song":/path/to/song.mp3
+```
+
+And, we add in `library.liq`:
+
+```liquidsoap
+# Our custom request function
+def get_request() =
+  # Get the URI
+  uri = list.hd(default="",get_process_lines("cat /tmp/request"))
+  # Create a request
+  [request.create(uri)]
+end
+```
+
+Now, we replace the lines defining `songs`, `files` and the line
+using the `rotate` operator in `radio.liq` with the following code:
+
+```liquidsoap
+s = request.dynamic.list(id="s",get_request)
+```
+
+- Update your scripts.
+- Run the new radio.
+- Edit `"/tmp/request"` and change its content to:
+
+```liquidsoap
+annotate:type="jingle":/path/to/jingle.mp3
+```
+
+- Use the command `s.skip` through the telnet server and verify that the new song is being played. This may need more than one skip..
+- Use the commands `request.on_air` and `request.metadata` through the telnet server to verify the presence of the `type` metadata
+- Extra: think about how to use the previous notification code to interact with this function.
+
+Solutions:
+
+- [radio.liq](radio.liq-request.dynamic.list)
+- [library.liq](library.liq-request.dynamic.list)
+
+### Custom metadata
+
+We have just seen how it is possible to use the `annotate:` protocol to
+pass custom metadata to any request. Additionally, it is also possible to rewrite
+your stream's metadata on the fly, using the `on_metadata` operator.
+
+This operator takes a function of the type `metadata->metadata`, i.e. a function
+that takes the current metadata and returns some metadata. Thus, when `metadata.map`
+sees a new metadata in the stream, it calls this function and, by default, updates
+the metadata with the values returned by the function.
+
+Here, we use this operator to customize the title metadata with the name of our radio.
+First, we create a file `"/tmp/metadata"` containing:
+
+```
+My Awesome Liquidsoap Radio!
+```
+
+Then, in `library.liq`, we add the following function:
+
+```liquidsoap
+# This function updates the title metadata with
+# the content of "/tmp/metadata"
+def update_title(m) =
+  # The title metadata
+  title = m["title"]
+  # Our addition
+  content = list.hd(get_process_lines("cat /tmp/metadata"))
+
+  # If title is empty
+  if title == "" then
+    [("title",content)]
+  # Otherwise
+  else
+    [("title","#{title} on #{content}")]
+  end
+end
+```
+
+Finally, we apply `metadata.map` to the source, just after the `request.dynamic.list`
+definition in `radio.liq`:
+
+```liquidsoap
+s = metadata.map(update_title,s)
+```
+
+Solutions:
+
+- [radio.liq](radio.liq-map_meta)
+- [library.liq](library.liq-map_meta)
+
+### Infallible sources
+
+It is reasonable, for a radio, to expect that a stream is
+always available for broadcasting. However, problems may happen (and always
+do at some point). Thus, we need to offer an alternative for the case
+where nothing is available.
+
+Instead of using `mksafe`, which streams blank
+audio when this happens, we use a custom sound file. For instance, this
+sound file may contain a sentence like ``Hello, this is radio FOO! We are currently
+having some technical difficulties but we'll be back soon so stay tuned!''.
+
+We do that here using the `say:` protocol, which creates a speech synthesis
+of the given sentence. Otherwise, you may record a (more serious) file and
+pass it to the single operator...
+
+First, we add the following in `library.liq`
+
+```liquidsoap
+# This function turns a fallible
+# source into an infallible source
+# by playing a static single when
+# the original song is not available
+def my_safe(s) =
+  # We assume that festival is installed and
+  # functional in liquidsoap
+  security = single("say:Hello, this is radio FOO! \
+                     We are currently having some \
+                     technical difficulties but we'll \
+                     be back soon so stay tuned!")
+
+  # We return a fallback where the original
+  # source has priority over the security
+  # single. We set track_sensitive to false
+  # to return immediately to the original source
+  # when it becomes available again.
+  fallback(track_sensitive=false,[s,security])
+end
+```
+
+Then, we add the following line in `radio.liq`, just before
+the output line:
+
+```liquidsoap
+s = my_safe(s)
+```
+
+And we also remove the `fallible=true` from the parameters of `output.icecast`.
+
+- Update your scripts.
+- Run and test the new radio.
+- To hear the security jingle, you can empty `"/tmp/request"` and use the skip command in telnet or wait for the end of the current song.
+- If you put a new valid request in `"/tmp/request"` then the stream comes back to the normal source.
+
+Solutions:
+
+- [radio.liq](radio.liq-safe)
+- [library.liq](library.liq-safe)
+
+### Multiple outputs
+
+We may as well output the stream to several targets,
+for instance to different icecast mount points with different
+formats. Therefore, we define a custom output function
+that defines all these outputs.
+
+We add the following in `library.liq`:
+
+```liquidsoap
+# A function that contains all the output
+# we want to create with the final stream
+def outputs(s) =
+  # First, we partially apply output.icecast
+  # with common parameters. The resulting function
+  # is stored in a new definition of output.icecast,
+  # but this could be my_icecast or anything.
+  output.icecast = output.icecast(host="my_server",
+                                  password="hack_me_not")
+
+  # An output in ogg/vorbis to the "my_radio.ogg"
+  # mountpoint:
+  output.icecast(%vorbis, mount="my_radio.ogg",s)
+
+  # An output in mp3 at 128kbits to the "my_radio"
+  # mountpoint:
+  output.icecast(%mp3(bitrate=128), mount="my_radio",s)
+
+  # An output in ogg/flac to the "my_radio-flac.ogg"
+  # mountpoint:
+  output.icecast(%ogg(%flac), mount="my_radio-flac.ogg",s)
+
+  # An output in AAC+ at 32 kbits to the "my_radio.aac"
+  # mountpoint
+  output.icecast(%fdkaac(bitrate=32), mount="my_radio.aac",s)
+end
+```
+
+And we replace the output line in `radio.liq` by:
+
+```liquidsoap
+outputs(s)
+```
+
+- Write your own output function.
+- Run and test your new radio.
+
+**Note** liquidsoap may fail with the following error:
+
+```
+Connection failed: 403, too many sources connected (HTTP/1.0)!
+```
+
+In this case, you should check the maximum number of sources that your
+icecast server accepts.
+
+Solutions:
+
+- [radio.liq](radio.liq-outputs)
+- [library.liq](library.liq-outputs)
+
+## More advanced functions!
+
+Now that we have a controllable initial radio, we extend our initial
+scripts to add advanced features. The following graph illustrates what
+we are going to add:
+
+![Advanced stream model](/assets/img/on2_part2_schema2.svg)
+
+\*\* The `Replay gain` node normalizes all the songs using the [Replay Gain](https://en.wikipedia.org/wiki/ReplayGain) technology.
+
+- The `Smart crossfade` node adds crossfading between songs but not jingles.
+- The `Smooth_add` node adds the possibility to insert a jingle in the middle of a song, fading out and then back in the initial stream while the jingle is being played.
+
+### Replaygain
+
+The replaygain support is achieved in liquidsoap in two steps:
+
+- apply the `amplify` operator to change a source's volume
+- pass a `"replay_gain"` metadata indicating to the `amplify` operator which value to use.
+
+The `"replay_gain"` metadata can be passed manually or computed by liquidsoap.
+Liquidsoap comes with a script that can extract the replaygain information
+from ogg/vorbis, mp3 and FLAC files. This is a very convenient script but it generate
+a high CPU usage which can be bad for real-time streaming.
+In some situations, you may compute beforehand this value and pass it manually
+using the `annotate` protocol.
+
+If you cannot compute the value beforehand, liquidsoap comes with two ways
+to extract the replaygain information
+
+- The `replay_gain:` protocol. All requests of the form `replay_gain:URI` are resolved by passing `URI` to the script provided by liquidsoap. This method allows to select which files should be used with replay gain. However, it will only work if `URI` is a local file.
+- The replay gain metadata resolver, enabled by adding a line of the form `enable_replaygain_metadata ()` in your script. In this cases, all requests and not only local files can be processed and you cannot select which one should be used with replaygain.
+
+The most simple solution, in our case, is to change the requests
+passed to `request.dynamic.list` to something of the form:
+
+```
+annotate:type="song":replay_gain:URI
+```
+
+However, in order to illustrate a bit more the functionalities of liquidsoap we present
+another solution.
+The method we propose here consists in using `metadata.map`, which we have already seen
+to update the metadata with a `"replay_gain"` metadata when we see the `"type"` metadata
+with the value `"song"`. Thus, we add the following function in `library.liq`:
+
+```liquidsoap
+# This function takes a metadata,
+# check if it is of type "file"
+# and add the replay_gain metadata in
+# this case
+def add_replaygain(m) =
+  # Get the type
+  type = m["type"]
+  # The replaygain script is located there
+  script = "#{configure.bindir}/extract-replaygain"
+  # The file name is contained in this value
+  filename = m["filename"]
+
+  # If type = "song", proceed:
+  if type == "song" then
+    info = list.hd(get_process_lines("#{script} #{filename}"))
+    [("replay_gain",info)]
+  # Otherwise add nothing
+  else
+    []
+  end
+end
+```
+
+And, we add the following line in `radio.liq` after the `request.dynamic.list` line:
+
+```liquidsoap
+s = metadata.map(add_replaygain,s)
+```
+
+Finally, we add the `amplify` operator. We set the default amplification
+to `1.`, i.e. no amplification, and tell the operator to update this value with
+the content of the `"replay_gain"` metadata. Thus, only the tracks which have this
+metadata will be modified.
+
+We add the following in `radio.liq`, after the line we just inserted:
+
+```liquidsoap
+s = amplify(override="replay_gain",1.,s)
+```
+
+**Note** we can also apply `amplify` only to `songs`, _before_ the `switch` operator
+
+- Update your scripts.
+- Run and test the new radio.
+- Change the content of `"/tmp/request"` with something of type `"file"` and skip the current song.
+- Use the telnet server to make sure that the new `"replay_gain"` metadata has been added.
+- Also, in the logs, you should be able to see that the `replay_gain` information was used to override the amplification factor.
+- Can you find a content for `"/tmp/request"` that will enable replay gain on a file which is not of type `"song"`?
+
+**Note** in this case, the `replay_gain` metadata is not added during the request resolution.
+Thus, it is not visible in the `request.metadata`. However, you should be able to find another
+command that displays it!
+
+Solutions:
+
+- [radio.liq](radio.liq-replay)
+- [library.liq](library.liq-replay)
+
+### Smart crossfade
+
+The `smart_crossfade` is a crossfade operator that decides the crossfading to apply depending
+on the volume and metadata of the old and new track.
+
+It is defined using a generic `smart_cross`
+operator, that takes a function of type `(float, float, metadata, metadata, source, source) -> source`,
+i.e. a function that take the volume level (in decibels) of, respectively, the old and new
+tracks, the metadata of, resp. the old and new tracks and, finally, the old and new tracks,
+and returns the new source with the required transition.
+
+We give here a simple custom implementation of our crossfade. What we do is:
+
+- Crossfade tracks if none of the old and new track are jingle;
+- Sequentialize the tracks otherwise.
+
+We identify the type of each track by reading the `"type"` metadata we
+have added when creating the `request.dynamic.list` source.
+
+A typical `smart_crossfade` operator is defined in `utils.liq`
+but you may do much more things with a little bit of imagination.
+
+Here, we add the following in `library.liq`:
+
+```liquidsoap
+# Our custom crossfade that
+# only crossfade between tracks
+def my_crossfade(s) =
+  # Our transition function
+  def f(_,_, old_m, new_m, old, new) =
+    # If none of old and new have "type" metadata
+    # with value "jingles", we crossfade the source:
+    if old_m["type"] != "jingle" and new_m["type"] != "jingle" then
+      add([fade.initial(new), fade.final(old)])
+    else
+      sequence([old,new])
+    end
+ end
+ # Now, we apply smart_cross with this function:
+ smart_cross(f,s)
+end
+```
+
+Finally, we add the following line in `radio.liq`, just after the
+`amplify` operator:
+
+```liquidsoap
+s = my_crossfade(s)
+```
+
+- Update your scripts.
+- Run and test the new radio.
+- Modify the custom crossfading to fade out the old song if it is not a jingle, and fade in the new song if it is not a jingle.
+
+Solutions:
+
+- [radio.liq](radio.liq-smart)
+- [library.liq](library.liq-smart)
+
+### Smooth_add
+
+Finally, we add another nice feature: a jingle that is played on top of the
+current stream. We use the `smooth_add` operator, which is also defined in
+`utils.liq`. This operator takes a normal source and a special jingle source.
+Every time that a new track is available in the special source, it fades out
+the volume of the normal source, plays the track from the special source
+on top of the current track of the normal source, and then fades back in
+the volume of the normal source when the track is finished.
+
+Typically, you use for the special source a `request.queue` where you push a new
+jingle every time you want to use this feature.
+
+We modify `radio.liq` and add the following line just before `my_safe`:
+
+```liquidsoap
+# A special source
+special = request.queue(id="special")
+# Smooth_add the special source
+s = smooth_add(normal=s,special=special)
+```
+
+- Update your script.
+- Run and test the new radio.
+- Use the telnet server to push the request `say:My new radio rocks!` in the special source.
+- Listen!
+
+Solutions:
+
+- [radio.liq](radio.liq-smooth)
+- [library.liq](library.liq-smooth)
+
+## What about DJs?
+
+We present now another important part of an advanced stream: the addition of a live stream
+in order to allow DJs to broadcast their shows.
+
+We are going to add the following features:
+
+- A live input that is played immediately when it is available
+- Use different harbor ports, to replace mount points for shoutcast source clients
+- A transition jingle that is played when switching between live and files
+- Skip the file currently being played when switching to a live source so that the file-based source starts with a fresh song when the live stops
+- Define different authentications for the DJs and make sure that a DJ can only broadcast when its show is scheduled
+
+### Live inputs
+
+The live inputs in liquidsoap are of two types:
+
+- Network-based, mostly `input.http` and `input.harbor`.
+- Hardware-based, with operators like `input.alsa`, `input.jack`, etc.
+
+We focus here on the first type, and more precisely on `input.harbor`. When using
+this operator in your script, the running instance will be able to receive data
+coming from icecast and shoutcast source clients. Then, your DJs can broadcast
+a live stream using their favorite software. Liquidsoap supports most of the
+usual data formats, when enabled as encoder:
+
+- MP3
+- Any supported ogg stream
+- Aac and Aac+
+
+You may also communicate data between two liquidsoap instance, one using `output.icecast`
+to send data and the other one `input.harbor` to receive it. In this case, you want also
+use the WAVE or FLAC format to send lossless data.
+
+We add a live source in `radio.liq`, anywhere before the outputs:
+
+```liquidsoap
+live = input.harbor("live")
+```
+
+**Note** `"live"` is the name of the mountpoint that will be
+associated to this source. The default parameters for the port,
+user and password are contained in the following settings:
+
+```liquidsoap
+settings.harbor.password.set("hackme")
+settings.harbor.port.set(8005)
+settings.harbor.username.set("source")
+```
+
+We want the live source to be played as soon as it becomes available. Thus, we
+use a `fallback` to combine it with the file-based source, and add the following code
+after `my_safe` in `radio.liq`:
+
+```liquidsoap
+s = fallback(track_sensitive=false, [live,s])
+```
+
+**Note** the `track_sensitive=false` parameter tells liquidsoap to
+switch immediately to `live` when it becomes available instead of waiting
+for the end of the track currently played by `s`.
+
+- Update your script
+- Run the new radio
+- Try to connect to the harbor mountpoint. You may use a separate liquidsoap script and `output.icecast`
+- Why is the output still infallible ?
+
+Solutions:
+
+- [radio.liq](radio.liq-harbor)
+- [library.liq](library.liq-harbor)
+
+### Enabling shoutcast clients
+
+By default, shoutcast source clients are not supported. You can enable them by
+adding the following settings:
+
+```liquidsoap
+settings.harbor.icy.set(true)
+```
+
+**Note** `ICY` is the technical name of the original shoutcast source
+protocol.
+
+Additionally, the shoutcast source protocol does not support the notion
+of mountpoint: all the sources try to connect to the same `"/"` mountpoint.
+However, you can emulate this in liquidsoap by using different harbor sources
+on different port.
+
+For instance, if we replace the definition of `live` in `radio.liq` with the
+following:
+
+```liquidsoap
+live1 = input.harbor(port=9000,"/")
+live2 = input.harbor(port=7000,"/")
+```
+
+And the `fallback` line with:
+
+```liquidsoap
+s = fallback(track_sensitive=false, [live1,live2,s])
+```
+
+Then your a DJ should be able to send data using the port `9000`
+and another one using the port `7000`, and the one connecting on port
+`9000` may be played in priority if the two are connected at the same time.
+
+- Update your script
+- Run the new radio
+- Connect one source client to port `7000`
+- Connect another source client to port `9000`
+- Verify that the client on port `9000` is broadcasting
+
+Solutions:
+
+- [radio.liq](radio.liq-shoutcast)
+- [library.liq](library.liq-shoutcast)
+
+### A nice transition!
+
+Now that our radio support live shows, we deal with another issue: when switching
+to the live show, the current song is cut at the point where it is and the audio
+content switches over to the live data without any transition, which is not very nice
+for the listeners. Further, when switching back to the file-based source at the
+end of the live, the source resumes in the middle of the song that was last played..
+
+In this part, we define a transition for switching from file to live, which fades
+the current song out and superposes a jingle before starting the live show.
+We use the `transition` parameter of the fallback operators.
+
+This parameter contains functions of the type: `source * source -> source`,
+i.e. functions that take two sources as arguments, the old and new source,
+and returned a source that is the result of the desired transition. Finally,
+when defined as:
+
+```liquidsoap
+fallback(transition=[f,g], [s1, s2])
+```
+
+`f` is called when switching to `s1` (and `g` when switching to `s2`).
+
+We also use `source.skip`, which skips the file currently being played, in
+order to play a fresh file when switching back to the file-based source.
+
+First, we add the following code in `library.liq`:
+
+```liquidsoap
+# Define a transition that fades out the
+# old source, adds a single, and then
+# plays the new source
+def to_live(jingle,old,new) =
+  # Fade out old source
+  old = fade.final(old)
+  # Superpose the jingle
+  s = add([jingle,old])
+  # Compose this in sequence with
+  # the new source
+  sequence([s,new])
+end
+
+# A transition when switching back to files:
+def to_file(old,new) =
+  # We skip the file
+  # currently in new
+  # in order to being with
+  # a fresh file
+  source.skip(new)
+  sequence([old,new])
+end
+```
+
+**Note** `source.skip` may cause troubles if
+the file source does not prepare a new track quickly enough.
+In this case, you may add `conservative=true` to the
+parameters of the `request.dynamic.list` source.
+
+Then, we add the following code in `radio.liq`, where
+we defined the `fallback` between the two live sources and
+the file-based source:
+
+```liquidsoap
+# The transition to live1
+jingle1 = single("say:And now, we present the awesome show number one!!")
+to_live1 = to_live(jingle1)
+
+# Transition to live2
+jingle2 = single("say:Welcome guys, this is show two on My Awesome Radio!")
+to_live2 = to_live(jingle2)
+
+# Combine lives and files:
+s = fallback(track_sensitive=false,
+             transitions=[to_live1, to_live2, to_file],
+             [live1, live2, s])
+```
+
+- Update your script
+- Run the new radio
+- Connect to each harbor and listen to the result
+
+Solutions:
+
+- [radio.liq](radio.liq-transitions)
+- [library.liq](library.liq-transitions)
+
+### Custom logins
+
+Another powerful feature of `input.harbor` is the possibility to define a
+custom authentication. For instance, imagine that DJ Alice may connect to
+the `live1` source only between 20h and 21h, which is the time of her shows,
+with the password `"rabbit"`, while DJ Bob may connect to the `live2` source
+between 18h and 20h with password `"foo"`.
+
+This can be implemented using the `auth` parameter of `input.harbor`. This
+parameter is a function of type: `string * string -> bool`, i.e. a function
+that takes a pair `(user,password)` and returns `true` if the connection should
+be granted.
+
+You may use this, for instance, with an external script and integrate harbor
+and DJ authentication into the framework of your choice. Here we illustrate
+this functionality with a custom functions. Thus, we add the following
+in `library.liq`:
+
+```liquidsoap
+# Our custom authentication
+# Note: the ICY protocol
+# does not have any username and for
+# icecast, it is "source" most of the time
+# thus, we discard it
+def harbor_auth(port,_,password) =
+  # Alice connects on port 9000 between 20h and 21h
+  # with password "rabbit"
+  (port == 9000 and 20h-21h and password == "rabbit")
+    or
+  # Bob connection on port 7000 between 18h and 20h
+  # with password "foo"
+  (port == 7000 and 18h-20h and password == "foo")
+end
+```
+
+And we use it by replacing the `live1` and `live2` definitions by:
+
+```liquidsoap
+# Authentication for live 1:
+auth1 = harbor_auth(9000)
+live1 = input.harbor(port=9000,auth=auth1,"/")
+
+# Authentication for live 2:
+auth2 = harbor_auth(7000)
+live2 = input.harbor(port=7000,auth=auth2,"/")
+```
+
+- Write your custom login function
+- Run and test your new radio
+
+No solution here :-)
diff --git a/website/content/doc-2.2.5/on2_part3.md b/website/content/doc-2.2.5/on2_part3.md
new file mode 100644
index 00000000..9106cb97
--- /dev/null
+++ b/website/content/doc-2.2.5/on2_part3.md
@@ -0,0 +1,321 @@
+This part is pretty open. We describe below a few advanced features of
+liquidsoap, including video and midi. We provide some examples
+or simply propose things to do, to give you an idea of what's in
+the near future of liquidsoap and hopefully draw you into
+contributing to shaping that future,
+if only through discussions.
+
+# Visualization
+
+A liquidsoap script is like any other program: you can in principle
+predict what it does, but there's always a point where you miss something.
+In such cases, you need to debug it: control all the relevant parameters
+until you spot what's wrong.
+
+In liquidsoap, the most important parameter is probably the availability
+of a source. You'll end up creating devices dealing with various sources
+going on and off. To test them you can create sources whose availability
+is controlled by you, and you should also be able to monitor their
+availability.
+
+As an exercise, you can try to write a simple logging function that
+periodically displays `source.is_ready(s)` for some source `s`.
+The `mix` operator can be useful too: it is a mixing table for
+liquidsoap, allowing you to monitor and cancel the availability
+of its inputs; the best way to use it is through liGuidsoap.
+
+## Audio volume
+
+You can visualize the audio volume on screen using `visu.volume`:
+
+```liquidsoap
+d = 1.
+t = "lin"
+s = fade.in(duration=d,type=t,
+      fade.out(duration=d,type=t,sine(duration=3.*d)))
+output.ao(visu.volume(s))
+```
+
+# Video streams
+
+Video may be used very simply in liquidsoap: common operators
+such as `single` and `playlist` will attempt to decode their files
+as video if their content type is appropriate, which is dictated by
+the output operator.
+For example you can do `output.sdl(single("video.ogg"))`
+to display the video part of an audio+video stream;
+to hear the audio part, insert your favorite audio output operator
+together with `drop_audio` and `drop_video` at the right places
+(most outputs do not silently drop irrelevant data).
+
+## Slideshow
+
+The following script displays a slideshow of images,
+while playing a playlist of audio files.
+Pass it the images playlist/directory as the first argument on the command
+line (after `--`) and (optionally) the audio playlist/directory as the
+second argument.
+
+```liquidsoap
+def images
+  video.fade.in(duration=1.,video.fade.out(duration=1.,
+    video.add_text(metadata="filename","<no filename>",
+                   size=12,
+                   playlist(prefix="annotate:duration=3:",argv(1)))))
+end
+
+def sound
+  playlist(argv(2))
+end
+
+output.ao(fallible=true,sound)
+clock(id="video", output.sdl(fallible=true,images))
+
+# You can also combine the two in a Theora file.
+# Play the result in VLC rather than mplayer (or even liquidsoap)
+# as it is a sequentialized ogg stream.
+# output.file(%ogg(%vorbis,%theora),"slideshow.ogg",
+#   mksafe(source.mux.video(video=images,sound)))
+```
+
+If you experience transparency problems... it's a known bug
+(see notably [#393](http://savonet.rastageeks.org/ticket/393)).
+You may also experience segfaults... it does not seem to happen
+with a selected list avoiding too large sizes or too exotic formats.
+
+## Audio volume
+
+You can render the audio volume visualization as a video stream,
+that you can then process as any other video stream:
+
+```liquidsoap
+d = 1.
+t = "lin"
+s = fade.in(duration=d,type=t,
+      fade.out(duration=d,type=t,sine(duration=3.*d)))
+output.sdl(drop_audio(video.volume(s)))
+```
+
+## Static image over audio track
+
+TODO: the youtube encoder
+
+## Transitions
+
+Playing a video file `video.ogv` is simply achieved by
+
+```liquidsoap
+s = single("video.ogv")
+output.sdl(s)
+```
+
+There are many useful (or not) effects in Liquidsoap which can be used to modify
+the video. These should be inserted between the first and the second line of
+the script above. For example, the image can be converted to sepia by adding
+
+```liquidsoap
+s = video.sepia(s)
+```
+
+Common operations include adding a logo (stored in a PPM image file
+`image.ppm`):
+
+```liquidsoap
+s = video.add_image(width=30, height=30, x=10, y=10, file="image.ppm", s)
+```
+
+and displaying a scrolling text:
+
+```liquidsoap
+s = video.add_text("Hello people!", s)
+```
+
+Try modifying the scrolling text example so that you can modify the contents of
+the text over the telnet interface.
+
+Very similarly to audio transitions (fade in, fade out, etc.) there are some
+video transitions implemented. For example fading in the video is simply done using
+
+```liquidsoap
+s = video.fade.in(s)
+```
+
+The kind of transition that should be used is controlled by the `transition`
+parameter of `video.fade.in`. Try `disc` for example, as well as the others
+that you can find in the documentation.
+
+Of course, the `add` operator of liquidsoap also works on video streams. So, in
+order to add a rotating image on a video you could use
+
+```liquidsoap
+s = add([s,
+         video.rotate(
+           video.add_image(
+             width=50, height=50, x=150, y=150,
+             file="image.ppm",
+             blank()))])
+```
+
+## Overloaded demo
+
+```liquidsoap
+file = single("bus.ogg")
+
+istring = interactive.string
+
+v = add([file,
+         # video.text("Hello world..."),
+         # video.text("Mip mip!",color=0xff0000,y=-1,speed=300),
+         video.text(istring("a",""),color=0xff0000,font=mono,size=30,y=-01),
+         video.text(istring("b",""),color=0xff0000,font=mono,size=30,y=-31),
+         video.text(istring("c",""),color=0xff0000,font=mono,size=30,y=-61),
+])
+
+output.alsa(drop_video(file))
+
+# output.file.theora("out.ogv",
+output.sdl(add([video.fade.in(video.fade.in(transition="disc",v)),
+                # video.rotate(video.scale(coef=0.3,offset_x=20,offset_y=20,v)),
+               video.image("chameau.pnm",width=50,height=50,
+                           x=-10,y=10,alpha=0xffffff),
+]))
+
+text = fun (v,s) -> ignore(server.execute('var.set #{v} = "#{s}"'))
+
+def pingouin()
+  text("c","(o_ ")
+  text("b","//\\ ")
+  text("a","v_/_")
+end
+
+def pan()
+  text("c","(X_ ")
+end
+
+server.register("pingouin", fun (_) -> begin pingouin() "Oui seigneur..." end)
+server.register("pan", fun (_) -> begin pan() "Zog zog!" end)
+
+server.register("anim", fun (s) -> begin
+  s = if s=="t" then
+    pan()
+    "f"
+  else
+    pingouin()
+    "t"
+  end
+  add_timeout(1.,{ ignore(server.execute("anim #{s}")) (-1.) })
+  "Done."
+end)
+```
+
+# Manipulating MIDI data
+
+## Playing with the keyboard
+
+MIDI is a format for describing streams of notes, scores, etc. Liquidsoap has
+a basic support for such streams.
+
+In order to generate a MIDI stream, the `input.keyboard.sdl` operator can be
+used. It will convert typing onto the keyboard of your operator into notes. In
+order to be able to hear the notes of a stream, you have to _synthesize_ them,
+which means to convert them to wave sound. Various operators can be used for
+this, each corresponding to a different instrument. For example, a synthesizer
+with sawtooth waves is provided by the operator `synth.saw`. A mini-keyboard
+synthesizer can thus be programmed using the following script
+
+```liquidsoap
+s = input.keyboard.sdl()
+s = synth.saw(s)
+out(s)
+```
+
+You can also test `synth.sine` or `synth.square` for other kinds of simple
+sounds.
+
+In order to check the MIDI data contained in streams, the `midimeter` operator
+is very convenient: it prints on the standard output the notes currently being
+played.
+
+## Playing MIDI files
+
+Liquidsoap comes with built-in support for MIDI files: when such a file is
+played it is detected as such and decoded as a MIDI stream. Usually, MIDI files
+contain multiple channels of notes (typically one for each instrument). In order
+to use the sawtooth synthesizer on all channels, the `synth.all.saw` operator
+should be used (with the `synth.saw` operator, only the first channel will be
+synthesized).
+
+So, a MIDI file named `file.mid` can be played using the following script
+
+```liquidsoap
+s = single("file.mid")
+s = midi.remove([9],s)
+s = source.mux.audio(audio=blank(),s)
+s = synth.all.saw(s)
+s = drop_midi(s)
+out(s)
+```
+
+The second line removes all the notes from the channel 9 which is usually used
+for drums (and would thus sound bad with our basic synthesizer). The third line
+adds an audio channel to the stream `s`, in which the sound will be synthesized.
+
+## Playing chords
+
+The implementation of MIDI-related operators in Liquidsoap is still in early
+stage and their implementation gives us the possibility to simply test new
+ideas... we would be glad hear yours too!
+
+For example, we thought it would be nice to be able to play chords in
+Liquidsoap. This is actually pretty simple using metadata. First, describe your
+sequence of chords in a file named `chords.txt` with the following contents:
+
+```
+1 "chord" "C"
+2 "chord" "Am"
+3 "chord" "F"
+4 "chord" "G"
+```
+
+This file just contains a list of metadata: on each line, the first number
+indicate when (in seconds) the metadata should occur, the string in second
+indicates the name of the metadata (`chord` here) and the string in third
+position indicates the value of the metadata (the chord to be played here). This
+file format for metadata is supported natively by Liquidsoap. Now, the metadata
+containing the chord names can be converted to MIDI notes by using the `chord`
+operator. The sequence of chords above can thus be heard using the following
+script:
+
+```liquidsoap
+s = single("chord.txt")
+s = midi.chord(s)
+s = source.mux.audio(audio=blank(),s)
+s = synth.saw(s)
+s = drop_midi(s)
+out(s)
+```
+
+# Open problems
+
+If you feel like hacking seriously, here are some tasks
+from the Savonet community.
+
+## Listener-sensitive radio
+
+Write a script that checks whether an icecast mount point is being listened
+to, and use it to switch a radio to some dummy source when nobody is
+listening, and switch back to normal when listeners come back.
+This can be useful to avoid using the hard drive when unnecessary
+-- it is noisy, calorific, and simply not so long-lived.
+
+## Liquidsoap script generator
+
+Write a script (even better, a web page)
+that generates a simple liquidsoap script with a few options:
+input from playlist, live relay, output to icecast and/or soundcard.
+
+## Re-usable tools for radios
+
+The open-source radio community needs re-usable tools that can be interfaced
+with existing streamers: indexer, database generator, scheduler,
+crossfading editor, etc.
diff --git a/website/content/doc-2.2.5/phases.md b/website/content/doc-2.2.5/phases.md
new file mode 100644
index 00000000..6599cf84
--- /dev/null
+++ b/website/content/doc-2.2.5/phases.md
@@ -0,0 +1,23 @@
+# Liquidsoap execution phases
+
+There are various stages of running liquidsoap:
+
+- **Parsing**: read scripts and scripting expressions, can fail with syntax errors.
+- **Static analysis**: infer the type of all expressions, leaves some type unknown and may fail with type errors.
+- **Instantiation**: when script is executed, sources get created. Remaining unknown [stream types](stream_contents.html) are forced according to `frame.*.channels` settings, [clocks](clock.html) are assigned (but unknown clocks may remain) and some sources are checked to be [infallible](source.htmls). Each of these steps may raise an error.
+- **Collection**: Unknown clocks become the default clock so that all sources are assigned to one clock. Active sources newly attached to clocks are initialized for streaming, shutdown sources are detached from their clocks, and clocks are started or destroyed as needed. Streaming has started.
+
+Usually, liquidsoap is ran by passing one or several scripts and expressions to execute. Those expressions set up some sources, and outputs typically don't change anymore. If those initially provided active sources fail to be initialized (invalid parameter, fail to connect, etc.) liquidsoap will terminate with an error.
+
+It is however possible to **dynamically** create active sources,
+through registered server commands, event handlers, etc.
+They will be initialized and run as statically created ones.
+In **interactive** mode (passing the `--interactive` option)
+it is also possible to input expressions in a liquidsoap prompt,
+and their execution can trigger the creation of new outputs.
+
+Outputs can be deactivated using `source.shutdown()`:
+they will stop streaming and will be destroyed.
+
+The full liquidsoap instance
+can be shutdown using the `shutdown()` command.
diff --git a/website/content/doc-2.2.5/playlist_parsers.md b/website/content/doc-2.2.5/playlist_parsers.md
new file mode 100644
index 00000000..65f3cbe4
--- /dev/null
+++ b/website/content/doc-2.2.5/playlist_parsers.md
@@ -0,0 +1,50 @@
+# Playlist parsers
+
+Liquidsoap supports various playlists formats. Those formats can be used
+for `playlist` sources, `input.http` streams and manually using `request.create`.
+
+## Supported formats
+
+Most supported playlists format are _strict_, which means that the decoder can be sure
+that is has found a correct playlist for that format. Some other format, such as `m3u`,
+however, may cause _false positive_ detections.
+
+All formats are identified by their _mime-type_ or _content-type_. Supported formats are the following:
+
+- Text formats:
+
+  - `audio/x-scpls`: [PLS format](http://en.wikipedia.org/wiki/PLS_%28file_format%29), **strict**
+  - `application/x-cue`: [CUE format](http://en.wikipedia.org/wiki/.cue), **strict**. This format's usage is described below.
+  - `audio/x-mpegurl`, `audio/mpegurl`: [M3U](http://en.wikipedia.org/wiki/M3u), **non strict**
+
+- Xml formats:
+  - `video/x-ms-asf`, `audio/x-ms-asx`: [ASX](http://en.wikipedia.org/wiki/Advanced_Stream_Redirector), **strict**
+  - `application/smil`, `application/smil+xml`, [SMIL](http://en.wikipedia.org/wiki/Synchronized_Multimedia_Integration_Language), **strict**
+  - `application/xspf+xml`, [XSPF](http://en.wikipedia.org/wiki/Xspf), **strict**
+  - `application/rss+xml`, [Podcast](http://en.wikipedia.org/wiki/Podcast), **strict**
+
+## Usage
+
+Playlist files are parsed automatically when used in a `playlist` or `input.http` operator. Each of
+these two operators has specific options to specify how to pick up a track from the playlist, _e.g._
+pick a random track, the first one etc.
+
+Additionally, you can also manually parse and process a playlist using `request.create` and `request.resolve`
+and some programming magic. You can check the code source for `playlist.reloadable` in our standard library
+for a detailed example.
+
+## Special case: CUE format
+
+The CUE format originates from CD burning programs. They describe the set of tracks of a whole CD and
+are accompanied by a single file containing audio data for the whole CD.
+
+By default, the CUE playlist parser will add metadata from cue-in and cue-out points for each track described in the playlist, which
+are automatically handled with source-base operators such as `playlist`.
+
+The metadata added for cue-in and cue-out positions can be customized using the following
+configuration keys:
+
+```liquidsoap
+settings.playlists.cue_in_metadata := "liq_cue_in"
+settings.playlists.cue_out_metadata := "liq_cue_out"
+```
diff --git a/website/content/doc-2.2.5/presentations.md b/website/content/doc-2.2.5/presentations.md
new file mode 100644
index 00000000..dda96c0c
--- /dev/null
+++ b/website/content/doc-2.2.5/presentations.md
@@ -0,0 +1,30 @@
+# Presentations about Liquidsoap
+
+## Liquidshop
+
+In January 2021, we organized [the _Liquidshop_, a workshop around
+Liquidsoap](http://www.liquidsoap.info/liquidshop/), where you can find lots of
+presentations around Liquidsoap.
+
+In particular, Romain presented the main features of the upcoming Liquidsoap
+2.0:
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/VT6TEjJzWoY" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+and Gilou did a tutorial about setting up a webradio with Liquidsoap
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/B8l8uqBS6-c" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+## FOSDEM 2020
+
+We presented liquidsoap during the FOSDEM 2020 conference. You can watch the video here:
+
+<iframe src="https://player.vimeo.com/video/388951779" width="640" height="360" frameborder="0" allow="autoplay; fullscreen" allowfullscreen></iframe>
+<p><a href="https://vimeo.com/388951779">Functional audio and video stream generation with Liquidsoap</a> from <a href="https://vimeo.com/user27259977">Romain Beauxis</a> on <a href="https://vimeo.com">Vimeo</a>.</p>
+
+The slides for the presentation are available <a href="/fosdem2020/index.html" target="_blank">here</a>
+
+## ON2
+
+We were part of the ON2 conference, during which we presented liquidsoap and held a complete workshop
+about how to install and use it. You can see the details about this event <a href="on2.html">here</a>.
diff --git a/website/content/doc-2.2.5/profiling.md b/website/content/doc-2.2.5/profiling.md
new file mode 100644
index 00000000..08071b3e
--- /dev/null
+++ b/website/content/doc-2.2.5/profiling.md
@@ -0,0 +1,33 @@
+# Profiling scripts
+
+Sometimes, some functions of your script are taking up time and you would like
+to optimize those. We are not speaking here about the encoding of streams, which
+usually takes the vast majority of the spent computing power, but of functions
+written directly in Liquidsoap. In order to understand those better, Liquidsoap
+has a _profiler_ which records all the function calls. It can be enabled with
+
+```liquidsoap
+profiler.enable()
+```
+
+(or by passing the `--profile` commandline flag of Liquidsoap) and the
+statistics can be obtained with
+
+```liquidsoap
+print(profiler.stats.string())
+```
+
+It will output something like
+
+```
+function              self              total             calls
+
++                     0.359139919281    0.359139919281    302000
+list.add              0.324638843536    442.74707818      202000
+if                    0.242718935013    442.951756954     102002
+list.cons             0.230906486511    442.277146816     101000
+```
+
+where each lines consists of a function, the time spent in the functions, the
+time spent in the function and the functions it has called and the number of
+calls to the function.
diff --git a/website/content/doc-2.2.5/prometheus.md b/website/content/doc-2.2.5/prometheus.md
new file mode 100644
index 00000000..792fb98d
--- /dev/null
+++ b/website/content/doc-2.2.5/prometheus.md
@@ -0,0 +1,146 @@
+# Prometheus reporting
+
+When compiled with optional support for [mirage/prometheus](https://github.com/mirage/prometheus),
+`liquidsoap` can export [prometheus](https://prometheus.io/) metrics.
+
+The basic settings to enable exports are:
+
+```liquidsoap
+# Prometheus settings
+settings.prometheus.server := true
+settings.prometheus.server.port := 9090
+```
+
+Common metrics, namely `gauge`, `counter` and `summary` are provided via the script language, as well
+as a specialized operator to track source's latencies. A fully-featured implementation can be found at
+[mbugeia/srt2hls](https://github.com/mbugeia/srt2hls)
+
+## Basic operators
+
+The 3 basic operators are:
+
+- `prometheus.counter`
+- `prometheus.gauge`
+- `prometheus.summary`
+
+They share a similar type and API, which is as follows:
+
+```liquidsoap
+(help : string,
+ ?namespace : string,
+ ?subsystem : string,
+ labels : [string],
+ string) ->
+   (label_values : [string]) ->
+     (float) -> unit
+```
+
+This type can be a little confusing. Here's how it works:
+
+1. First, one has to create a metric factory of a given type. For instance:
+
+```liquidsoap
+is_playing_metric = prometheus.gauge(labels=["source"],"liquidsoap_is_playing")
+```
+
+2. Then, the metric factory can be used to instantiate speific metrics by passing the label's values:
+
+```liquidsoap
+playlist = playlist(id="playlist", ...)
+set_playlist_is_playing = is_playing_metric(label_values=["radio"])
+```
+
+The returned function is a setter for this metric, i.e.
+
+- For `gauge` metrics, it sets the gauge value
+- For `counter` metrics, it increases the counter value
+- For `summary` metrics, it registers an observation
+
+Finally, the programmer can now use that callback to set the metric as desired. For instance here:
+
+```liquidsoap
+def check_if_ready(set_is_ready, source) =
+  def callback() =
+    if source.is_ready(source) then
+      set_is_ready(1.)
+    else
+      set_is_ready(0.)
+    end
+    0.1
+  end
+  callback
+end
+thread.run.recurrent(delay=0.,check_if_ready(set_playlist_is_playing, playlist))
+```
+
+## `prometheus.latency`
+
+The `prometheus.latency` operator provides prometheus metrics describing the internal latency of a given
+source. It is fairly easy to use:
+
+```liquidsoap
+s = (...)
+prometheus.latency(s)
+```
+
+The metrics are computed over a sliding window that can be defined as a parameter of the operator. Exported metrics are:
+
+```
+# Input metrics:
+liquidsoap_input_latency{...} <value>
+liquidsoap_input_max_latency{...} <value>
+liquidsoap_input_peak_latency{...} <value>
+
+# Output metrics:
+liquidsoap_outputput_latency{...} <value>
+liquidsoap_output_max_latency{...} <value>
+liquidsoap_output_peak_latency{...} <value>
+
+# Overall metrics:
+liquidsoap_overall_latency{...} <value>
+liquidsoap_overall_max_latency{...} <value>
+liquidsoap_overall_peak_latency{...} <value>
+```
+
+The 3 different groups of values are:
+
+- **input**: metrics related to the time it takes to generate audio data
+- **output**: metrics related to the time it takes to output (encode and send) audio data
+- **overall**: the sum of all previous two groups
+
+Each group of metrics is divided into 3 subsets:
+
+- Mean latency value over the sliding window
+- Max latency value over the sliding window
+- Peak latency since start
+
+Latencies are reported over a frame's duration, which is typically around `0.04` seconds. Thus, in a situation
+where liquidsoap does not observe latency catch-ups, the overall mean latency `liquidsoap_overall_latency` should
+always be near that value.
+
+These metrics can be used to report and track the source of latencies and catch-ups while streaming.
+Typically, if a source starts taking too much time to generate its audio data, this should be reflects in the
+`input` latencies. Likewise for encoding and network output.
+
+Keep in mind, however, that enabling these metrics can have a CPU cost. It is rather small with a couple of sources
+but can increase with the number of sources being tracked. The user of these metrics is advised to keep track of
+CPU usage while ramping up on using them.
+
+## OCaml specific metrics
+
+The prometheus binding used by `liquidsoap` also exports default OCaml-related metrics. They are as follows:
+
+```
+ocaml_gc_allocated_bytes <value>
+ocaml_gc_compactions <value>
+ocaml_gc_heap_words <value>
+ocaml_gc_major_collections <value>
+ocaml_gc_major_words <value>
+ocaml_gc_minor_collections <value>
+ocaml_gc_top_heap_words <value>
+process_cpu_seconds_total <value>
+```
+
+These metrics can be useful when debugging issues with `liquidsoap`, in particular to track is an observed increase in
+memory usage is related to OCaml memory allocation or not. More than often, if the increase is not related to OCaml,
+it can be safely assumed that the issue might come from an external library used by `liquisoap`.
diff --git a/website/content/doc-2.2.5/protocols-presentation.md b/website/content/doc-2.2.5/protocols-presentation.md
new file mode 100644
index 00000000..c7f9bb4d
--- /dev/null
+++ b/website/content/doc-2.2.5/protocols-presentation.md
@@ -0,0 +1,59 @@
+# Protocols
+
+Protocols in liquidsoap are used to resolve requests URIs. The syntax is: `protocol:arguments`,
+for instance: `http://www.example.com`, `say:Something to say` etc.
+
+Most protocols are written using the script language. You can look at the file `protocols.liq` for a list
+of them.
+
+In particular, the `process:` protocol can use an external command to prepare resolve a request. Here's an example
+using the AWS command-line to download a file from S3:
+
+```liquidsoap
+def s3_protocol(~rlog,~maxtime,arg) =
+  extname = file.extension(leading_dot=false,dir_sep="/",arg)
+  [process_uri(extname=extname,"aws s3 cp s3:#{arg} $(output)")]
+end
+protocol.add("s3",s3_protocol,doc="Fetch files from s3 using the AWS CLI",
+             syntax="s3://uri")
+```
+
+Each protocol needs to register a handler, here the `s3_protocol` function. This function takes
+the protocol arguments and returns a list of new requests or files. Liquidsoap will then call
+this function, collect the returned list and keep resolving requests from the list until it finds a
+suitable file.
+
+This makes it possible to create your own custom resolution chain, including for instance cue-points. Here's an example:
+
+```liquidsoap
+def cue_protocol(~rlog,~maxtime,arg) =
+  [process_uri(extname="wav",uri=uri,"ffmpeg -y -i $(input) -af -ss 10 -t 30 $(output)")]
+end
+protocol.add("cue_cut",cue_protocol)
+```
+
+This protocol returns 30s of data from the input file, stating at the 10s mark.
+
+Likewise, you can apply a normalization program:
+
+```liquidsoap
+def normalization_protocol(~rlog,~maxtime,arg) =
+  # "normalize" command here is just an example..
+  [process_uri(extname="wav",uri=arg,"normalize $(inpuit)")]
+end
+protocol.add("normalize",normalization_protoco)
+```
+
+Now, you can push requests of the form:
+
+```
+normalize:cue_cut:http://www.server.com/file.mp3
+```
+
+and the file will be cut and normalized
+before being played by liquidsoap.
+
+When defining custom protocols, you should pay attention to two variables:
+
+- `rlog` is the logging function. Messages passed to this function will be registered with the request and can be used to debug any issue
+- `maxtime` is the maximum time (in UNIX epoch) that the requests should run. After that time, it should return and be considered timed out. You may want to read from `protocols.liq` to see how to enforce this when calling external processes.
diff --git a/website/content/doc-2.2.5/protocols.md b/website/content/doc-2.2.5/protocols.md
new file mode 100644
index 00000000..e60483aa
--- /dev/null
+++ b/website/content/doc-2.2.5/protocols.md
@@ -0,0 +1,120 @@
+### annotate
+
+Add metadata to a request
+
+The syntax is `annotate:key="val",key2="val2",...:uri`.
+
+### autocue
+
+Adding automatically computed cues/crossfade metadata
+
+The syntax is `autocue:uri`.
+
+### ffmpeg
+
+Decode any file to wave using ffmpeg
+
+The syntax is `ffmpeg:uri`.
+
+### file
+
+File protocol. Only local files are supported
+
+The syntax is `file:///path/to/file`. This protocol is static.
+
+### gtts
+
+Generate speech synthesis using Google translate's text-to-speech API. This requires the `gtts-cli` binary.  Result may be mono.
+
+The syntax is `gtts:Text to read`. This protocol is static.
+
+### http
+
+Download http URLs using curl
+
+The syntax is `http://...`.
+
+### https
+
+Download http URLs using curl
+
+The syntax is `https://...`.
+
+### mpd
+
+Finds all files with a tag equal to a given value using mpd.
+
+The syntax is `mpd:tag=value`.
+
+### pico2wave
+
+Generate speech synthesis using pico2wave. Result may be mono.
+
+The syntax is `pico2wave:Text to read`. This protocol is static.
+
+### polly
+
+Generate speech synthesis using AWS polly service. Result might be mono, needs aws binary in the path.
+
+The syntax is `polly:Text to read`. This protocol is static.
+
+### process
+
+Resolve a request using an arbitrary process. `<cmd>` is interpolated with: `[("input",<input>),("output",<output>),("colon",":")]`. `uri` is an optional child request, `<output>` is the name of a fresh temporary file and has extension `.<extname>`. `<input>` is an optional input file name as returned while resolving `uri`.
+
+The syntax is `process:<extname>,<cmd>[:uri]`.
+
+### replaygain
+
+Compute ReplayGain value. Adds returned value as `"replaygain_track_gain"` metadata
+
+The syntax is `replaygain:uri`.
+
+### s3
+
+Fetch files from s3 using the AWS CLI
+
+The syntax is `s3://uri`.
+
+### say
+
+Generate speech synthesis using text2wave. Result is always stereo.
+
+The syntax is `say:Text to read`. This protocol is static.
+
+### stereo
+
+Convert a file to stereo (currently decodes to wav).
+
+The syntax is `stereo:<uri>`. This protocol is static.
+
+### synth
+
+Syntesize audio. Parameters are optional.
+
+The syntax is `synth:shape=sine,frequency=440.,duration=10.`. This protocol is static.
+
+### text2wave
+
+Generate speech synthesis using text2wave. Result may be mono.
+
+The syntax is `text2wave:Text to read`. This protocol is static.
+
+### tmp
+
+Mark the given uri as temporary. Useful when chaining protocols
+
+The syntax is `tmp:uri`.
+
+### youtube-dl
+
+Resolve a request using youtube-dl.
+
+The syntax is `youtube-dl:uri`.
+
+### youtube-pl
+
+Resolve a request as a youtube playlist using youtube-dl. You typically want to use this as `playlist("youtube-pl:...")`.
+
+The syntax is `youtube-pl:uri`.
+
diff --git a/website/content/doc-2.2.5/publications.md b/website/content/doc-2.2.5/publications.md
new file mode 100644
index 00000000..44aaf1d8
--- /dev/null
+++ b/website/content/doc-2.2.5/publications.md
@@ -0,0 +1,28 @@
+---
+header-includes: |
+  \DeclareUnicodeCharacter{03BB}{$\lambda$}
+...
+
+# The theory behind Liquidsoap
+
+## Publications
+
+### Liquidsoap: a High-Level Programming Language for Multimedia Streaming
+
+Many of the advanced features of the Liquidsoap language are described in
+[Liquidsoap: a High-Level Programming Language for Multimedia Streaming](/assets/docs/bbm10.pdf).
+The article details in particular Liquidsoap's handling of heterogeneous stream
+contents (e.g. audio and video), as well as the model for clocks in the
+language.
+
+### De la webradio lambda à la &lambda;-webradio
+
+The first published presentation of Liquidsoap was made in
+[De la webradio lambda à la &lambda;-webradio](/assets/docs/bm08.pdf)
+(_Baelde D. and Mimram S. in proceedings of Journées Francophnes des Languages Applicatifs (JFLA), pages 47-61, 2008_)
+-- yes, it's in French, sorry. It gives a broad description of the Liquidsoap
+tool and explains the theory behind the language, which is formalized as a
+variant of the typed &lambda;-calculus with labels and optional arguments. The
+article describes the typing inference algorithm as well as some properties of
+the language (confluence) and of typing (subject reduction, admissible rules,
+termination of typed terms).
diff --git a/website/content/doc-2.2.5/quick_start.md b/website/content/doc-2.2.5/quick_start.md
new file mode 100644
index 00000000..e3a37334
--- /dev/null
+++ b/website/content/doc-2.2.5/quick_start.md
@@ -0,0 +1,240 @@
+# Quickstart
+
+## The Internet radio toolchain
+
+[Liquidsoap](index.html) is a general audio stream generator, but is mainly intended for Internet radios. Before starting with the proper Liquidsoap tutorial let's describe quickly the components of the internet radio toolchain, in case the reader is not familiar with it.
+
+The chain is made of:
+
+- the stream generator (Liquidsoap, [ices](https://www.icecast.org/ices/), or for example a DJ-software running on your local PC) which creates an audio stream (Ogg Vorbis or MP3);
+- the streaming media server ([Icecast](http://www.icecast.org), [HLS](https://en.wikipedia.org/wiki/HTTP_Live_Streaming) (via a HTTP server), ...) which relays several streams from their sources to their listeners;
+- the media player (iTunes, VLC, a web browser, ...) which gets the audio stream from the streaming media server and plays it to the listener's speakers.
+
+![Internet radio toolchain](/assets/img/schema-webradio-inkscape.png)
+
+The stream is always passed from the stream generator to the server, whether or not there are listeners. It is then sent by the server to every listener. The more listeners you have, the more bandwidth you need.
+
+If you use Icecast, you can broadcast more than one audio feed using the same server. Each audio feed or stream is identified by its "mount point" on the server. If you connect to the `foo.ogg` mount point, the URL of your stream will be [http://localhost:8000/foo.ogg](http://localhost:8000/foo.ogg) -- assuming that your Icecast is on localhost on port 8000. If you need further information on this you might want to read Icecast's [documentation](http://www.icecast.org). A proper setup of a streaming server is required for running Liquidsoap.
+
+Now, let's create an audio stream.
+
+## Starting to use Liquidsoap
+
+We assume that you have a fully installed Liquidsoap. In particular the library `stdlib.liq` and its accompanying scripts should have been installed, otherwise Liquidsoap won't know the operators which have been defined there.
+
+### Sources
+
+A stream is built with Liquidsoap by using or creating sources. A source is a media stream containing audio and/or video, track marks and metadata. In the following picture we represent a stream which has at least three tracks (one of which starts before the snapshot), and a few metadata packets (notice that they do not necessarily coincide with new tracks).
+
+![A stream](/assets/img/stream.png)
+
+Liquidsoap provides many functions for creating sources from scratch (e.g. `playlist`), and also for creating complex sources by putting together simpler ones (e.g. `switch` in the following example). Eventually, sources are plugged into outputs (typically named `output.*`) which continuously pull the source's content and output it to speakers, to a file, to a streaming server, etc. These outputs what brings life into your sources.
+
+### That source is fallible!
+
+A couple of things can go wrong in your streaming system.
+In Liquidsoap,
+we say that a source is _infallible_ if it is always available.
+Otherwise, it is _fallible_, meaning that something could go wrong and the source would not be available.
+By default, an output requires that its input source is infallible,
+otherwise it complains that "That source is fallible!"
+
+For example, a normal `playlist` is fallible.
+Firstly, because it could contain only invalid files, or at least spend too
+much time on invalid files to be able to prepare a valid one on time.
+Moreover, a playlist could contain remote files, which may not
+be accessible quickly at all times.
+A queue of user requests is another example of fallible source.
+Also, if `file.ogg` is a valid local file,
+then `single("file.ogg")` is an infallible source.
+
+When an output complains about its source being fallible, you have to turn it into
+an infallible one. Many solutions are available.
+The function `mksafe` takes a source and returns an infallible
+source, streaming silence when the input stream becomes unavailable.
+In a radio-like stream, silence is not the preferred solution, and you
+will probably prefer to `fallback` on an infallible
+"security" source:
+
+```liquidsoap
+fallback([your_fallible_source_here, single("failure.ogg")])
+```
+
+Finally, if you do not care about failures, you can pass the parameter
+`fallible=true` to most outputs. In that case, the output
+will accept a fallible source, and stop whenever the source fails
+and restart when it is ready to produce data again.
+
+## One-line expressions
+
+Liquidsoap is a scripting language. Many simple setups can be achieved by evaluating one-line expressions.
+
+### Playlists
+
+In the first example we'll play a playlist. Let's put a list of audio files in
+`playlist.pls`: one filename per line, lines starting with a `#` are
+ignored. You can also put remote files' URLs, if your liquidsoap has
+[support](help.html#plugins) for the corresponding protocols.
+Then just run:
+
+```liquidsoap
+liquidsoap 'output(playlist("playlist.pls"))'
+```
+
+Other playlist formats are supported, such as M3U and, depending on your
+configuration, XSPF.
+Instead of giving the filename of a playlist, you can also use a directory
+name, and liquidsoap will recursively look for audio files in it.
+
+Depending on your configuration, the output `output` will use AO, Alsa or OSS, or won't do anything if you do not have support for these libs. In that case, the next example is for you.
+
+### Streaming out to a server
+
+**Note:** in the following, we assume that you have installed the following optional dependencies:
+
+- `cry` for icecast output
+- `vorbis` for ogg/vorbis encoding
+- `ffmpeg` for ffmpeg encoding
+
+Liquidsoap is capable of playing audio on your speakers, but it can also send audio to a streaming server such as Icecast or Shoutcast.
+One instance of liquidsoap can stream one audio feed in many formats (and even many audio feeds in many formats!).
+
+You may already have an Icecast server. Otherwise you can install and configure your own Icecast server. The configuration typically consists in setting the admin and source passwords, in `/etc/icecast2/icecast.xml`. These passwords should really be changed if your server is visible from the hostile internet, unless you want people to kick your source as admins, or add their own source and steal your bandwidth.
+
+We are now going to send an audio stream, encoded as Ogg Vorbis, to an Icecast server:
+
+```liquidsoap
+liquidsoap \
+  'output.icecast(%vorbis,
+     host = "localhost", port = 8000,
+     password = "hackme", mount = "liq.ogg",
+     mksafe(playlist("playlist.m3u")))'
+```
+
+The main difference with the previous is that we used `output.icecast` instead of `output`. The second difference is the use of the `mksafe` which turns your fallible playlist source into an infallible source.
+
+If you want to use HLS instead for streaming, you can do:
+
+```liquidsoap
+liquidsoap \
+  'output.file.hls(
+    "/path/to/hls/directory",
+    [("aac",
+      %ffmpeg(
+        format="mpegts",
+        %audio(codec="aac", b="128k")
+      ))],
+     mksafe(playlist("playlist.m3u")))'
+```
+
+Once started, this will place all the files required for HLS stream into the local path `"/path/to/hls/directory"` which you can then server over HTTP.
+The HLS output has many interesting options, including callbacks to upload its files and more. See the [HLS Output](hls_output.html) page for more details.
+
+### Input from another streaming server
+
+Liquidsoap can use another stream as an audio source. This may be useful if you do some live shows.
+
+```liquidsoap
+liquidsoap \
+  'output(input.http("https://icecast.radiofrance.fr/fip-hifi.aac"))'
+```
+
+### Input from the soundcard
+
+If you're lucky and have a working ALSA support, try one of these... but beware that ALSA may not work out of the box.
+
+```liquidsoap
+liquidsoap 'output.alsa(input.alsa())'
+```
+
+```liquidsoap
+liquidsoap 'output.alsa(bufferize = false,
+                        input.alsa(bufferize = false))'
+```
+
+### Other examples
+
+You can play with many more examples. Here are a few more. To build your own,
+lookup the [API documentation](reference.html) to check what functions are available, and what parameters they accept.
+
+```liquidsoap
+# Listen to your playlist, but normalize the volume
+liquidsoap 'output(normalize(playlist("playlist_file")))'
+```
+
+```liquidsoap
+# ... same, but also add smart cross-fading
+liquidsoap 'output(crossfade(
+              normalize(playlist("playlist_file"))))'
+```
+
+## Script files
+
+We have seen how to create a very basic stream using one-line expressions. If you need something a little bit more complicated, they will prove uneasy to manage. In order to make your code more readable, you can write it down to a file, named with the extension `.liq` (eg: `myscript.liq`).
+
+To run the script:
+
+```liquidsoap
+liquidsoap myscript.liq
+```
+
+On UNIX, you can also put `#!/path/to/your/liquidsoap` as the first line of your script ("shebang"). Don't forget to make the file executable:
+
+```
+chmod u+x myscript.liq
+```
+
+Then you'll be able to run it like this:
+
+```
+./myscript.liq
+```
+
+Usually, the path of the liquidsoap executable is `/usr/bin/liquidsoap`, and we'll use this in the following.
+
+## A simple radio
+
+In this section, we build a basic radio station that plays songs randomly chosen from a playlist, adds a few jingles (more or less one every four songs), and output an Ogg Vorbis stream to an Icecast server.
+
+Before reading the code of the corresponding liquidsoap script, it might be useful to visualize the streaming process with the following tree-like diagram. The idea is that the audio streams flows through this diagram, following the arrows. In this case the nodes (`fallback` and `random`) select one of the incoming streams and relay it. The final node `output.icecast` is an output: it actively pulls the data out of the graph and sends it to the world.
+
+![Graph for 'basic-radio.liq'](/assets/img/basic-radio-graph.png)
+
+```liquidsoap
+#!/usr/bin/liquidsoap
+# Log dir
+log.file.path.set("/tmp/basic-radio.log")
+
+# Music
+myplaylist = playlist("~/radio/music.m3u")
+# Some jingles
+jingles = playlist("~/radio/jingles.m3u")
+# If something goes wrong, we'll play this
+security = single("~/radio/sounds/default.ogg")
+
+# Start building the feed with music
+radio = myplaylist
+# Now add some jingles
+radio = random(weights = [1, 4],[jingles, radio])
+# And finally the security
+radio = fallback(track_sensitive = false, [radio, security])
+
+# Stream it out
+output.icecast(%vorbis,
+  host = "localhost", port = 8000,
+  password = "hackme", mount = "basic-radio.ogg",
+  radio)
+```
+
+## What's next?
+
+You can first have a look at a [more complex example](complete_case.html). There is also a second tutorial about [advanced techniques](advanced.html).
+
+You should definitely learn [how to get help](help.html).
+If you know enough liquidsoap for your use, you'll only need to refer to the
+[scripting reference](reference.html), or see the [cookbook](cookbook.html).
+At some point,
+you might read more about Liquidsoap's [scripting language](language.html).
+For a better understanding of liquidsoap,
+it is also useful to read a bit about the notions of
+[sources](sources.html) and [requests](requests.html).
diff --git a/website/content/doc-2.2.5/radiopi.md b/website/content/doc-2.2.5/radiopi.md
new file mode 100644
index 00000000..c53cd45d
--- /dev/null
+++ b/website/content/doc-2.2.5/radiopi.md
@@ -0,0 +1,342 @@
+# RadioPi
+
+[RadioPi](http://www.radiopi.org) is the web radio of the ECP (Ecole Centrale de Paris). RadioPi runs many channels.
+There are topical channels (Reggae, Hip-Hop, Jazz, ...). On top of that, they periodically broadcast live shows,
+which are relayed on all channels.
+
+We met a RadioPi manager right after having released Liquidsoap 0.2.0, and he was seduced by the system. They needed
+quite complex features, which they were at that time fulfilling using dirty tricks, loads of obfuscated scripts.
+Using Liquidsoap now allow them to do all they want in an integrated way, but also provided new features.
+
+### The migration process
+
+Quite easy actually. They used to have many instances Ices2, each of these calling a Perl script to get the next song.
+Other scripts were used for switching channels to live shows.
+
+Now they have this single Liquidsoap script, no more. It calls external scripts to interact with their web-based song
+scheduling system. And they won new features: blank detection and distributed encoding.
+
+The first machine gets its files from a ftp server opened on the second machine.
+Liquidsoap handles download automatically.
+
+Each file is given by an external script, `radiopilote-getnext`,
+whose answer looks as follows (except that it's on a single line):
+
+```
+annotate:file_id="3541",length="400.613877551",\
+  type="chansons",title="John Holt - Holigan",\
+  artist="RadioPi - Canal reggae",\
+  album="Studio One SeleKta! - Album Studio 1 12",\
+  canal="reggae":ftp://***:***@host/files/3541.mp3
+```
+
+Note that we use annotate to pass some variables to liquidsoap...
+
+```liquidsoap
+#!/usr/bin/liquidsoap
+
+# Standard settings
+log.file.set(true)
+log.file.path.set("/var/log/liquidsoap/pi.log")
+log.stdout.set(false)
+init.daemon.set(true)
+init.daemon.pidfile.path.set("/var/run/liquidsoap/pi.pid")
+
+# Enable telnet server
+settings.server.telnet.set(true)
+
+# Enable harbor for any external
+# connection
+settings.harbor.bind_addrs.set(["0.0.0.0"])
+
+# Verbose logs
+log.level.set(4)
+
+# We use the scheduler intensively,
+# therefore we create many queues.
+settings.scheduler.generic_queues.set(5)
+settings.scheduler.fast_queues.set(3)
+settings.scheduler.non_blocking_queues.set(3)
+
+# === Settings ===
+
+# The host to request files
+stream = "XXXxXXXx"
+# The command to request files
+scripts = "ssh XXxxxXXX@#{stream} '/path/to/scripts/"
+# A substitution on the returned path
+sed = " | sed -e s#/path/to/files/#ftp://user:password@#{stream}/#'"
+
+# Enable replay gain
+enable_replaygain_metadata ()
+
+pass = "XXxXXXXx"
+ice_host = "localhost"
+
+descr = "RadioPi"
+url = "http://radiopi.org"
+
+# === Live ===
+
+# A live source, on which we strip blank (make the source
+# unavailable when streaming blank)
+live =
+  blank.strip(
+    input.harbor(id="live", port=8000, password=pass,
+                 buffer=8.,max=20.,"live.ogg"),
+    length=10., threshold=-50.)
+
+# This source relays the live data, when available,
+# to the other streamer, in uncompressed format (WAV)
+output.icecast(%wav, host=stream,
+               port=8005, password=pass,
+               mount="live.ogg", fallible=true,
+               live)
+
+# This source relays the live source to "live.ogg". This
+# is used for debugging purposes, to see what is sent
+# to the harbor source.
+output.icecast(%vorbis, host="127.0.0.1",
+               port=8080, password=pass,
+               mount="live.ogg", fallible=true,
+               live)
+
+# This source starts an archive of the live stream
+# when available
+title = '$(if $(title),"$(title)",\
+         "Emission inconnue")$(if $(artist), \
+         " par  $(artist)") - %m-%d-%Y, %H:%M:%S'
+output.file(%vorbis, reopen_on_metadata=true,
+            fallible=true,
+            "/data/archives/brutes/" ^ title ^ ".ogg",
+            live)
+
+# === Channels ===
+
+# Specialize the output functions by partial application
+output.icecast = output.icecast(description=descr, url=url)
+out = output.icecast(host=ice_host,port=8080,password=pass,fallible=true)
+out_aac32 = out(%fdkaac(bitrate=32))
+out_aac = out(%fdkaac(bitrate=64))
+out = out(%mp3)
+
+# A file for playing during failures
+interlude =
+  single("/home/radiopi/fallback.mp3")
+
+# Lastfm submission
+def lastfm (m) =
+  if (m["type"] == "chansons") then
+    if (m["canal"] == "reggae" or m["canal"] == "Jazz" or m["canal"] == "That70Sound") then
+      canal =
+        if (m["canal"] == "That70Sound") then
+       "70sound"
+    else
+       m["canal"]
+    end
+      user = "radiopi-" ^ canal
+      lastfm.submit(user=user,password="xXXxx",m)
+    end
+  end
+end
+
+# === Basic sources ===
+
+# Custom crossfade to deal with jingles..
+def crossfade (~start_next=5.,~fade_in=3.,~fade_out=3.,
+               ~default=(fun (a,b) -> sequence([a, b])),
+               ~high=-15., ~medium=-32., ~margin=4.,
+               ~width=2.,~conservative=false,s)
+  fade.out = fade.out(type="sin",duration=fade_out)
+  fade.in  = fade.in(type="sin",duration=fade_in)
+  add = fun (a,b) -> add(normalize=false,[b, a])
+  log = log(label="crossfade")
+
+  def transition(a,b,ma,mb,sa,sb)
+
+    list.iter(fun(x)-> log(level=4,"Before: #{x}"),ma)
+    list.iter(fun(x)-> log(level=4,"After : #{x}"),mb)
+
+    if ma["type"] == "jingles" or mb["type"] == "jingles" then
+      log("Old or new file is a jingle: sequenced transition.")
+      sequence([sa, sb])
+    elsif
+      # If A and B are not too loud and close, fully cross-fade them.
+      a <= medium and b <= medium and abs(a - b) <= margin
+    then
+      log("Old <= medium, new <= medium and |old-new| <= margin.")
+      log("Old and new source are not too loud and close.")
+      log("Transition: crossed, fade-in, fade-out.")
+      add(fade.out(sa),fade.in(sb))
+
+    elsif
+      # If B is significantly louder than A, only fade-out A.
+      # We don't want to fade almost silent things, ask for >medium.
+      b >= a + margin and a >= medium and b <= high
+    then
+      log("new >= old + margin, old >= medium and new <= high.")
+      log("New source is significantly louder than old one.")
+      log("Transition: crossed, fade-out.")
+      add(fade.out(sa),sb)
+
+    elsif
+      # Opposite as the previous one.
+      a >= b + margin and b >= medium and a <= high
+    then
+      log("old >= new + margin, new >= medium and old <= high")
+      log("Old source is significantly louder than new one.")
+      log("Transition: crossed, fade-in.")
+      add(sa,fade.in(sb))
+
+    elsif
+      # Do not fade if it's already very low.
+      b >= a + margin and a <= medium and b <= high
+    then
+      log("new >= old + margin, old <= medium and new <= high.")
+      log("Do not fade if it's already very low.")
+      log("Transition: crossed, no fade.")
+      add(sa,sb)
+
+    # What to do with a loud end and a quiet beginning ?
+    # A good idea is to use a jingle to separate the two tracks,
+    # but that's another story.
+
+    else
+      # Otherwise, A and B are just too loud to overlap nicely,
+      # or the difference between them is too large and overlapping would
+      # completely mask one of them.
+      log("No transition: using default.")
+      default(sa, sb)
+    end
+  end
+
+  cross(width=width, duration=start_next, conservative=conservative,
+              transition,s)
+end
+
+# Create a radiopilote-driven source
+def channel_radiopilote(~skip=true,name)
+  log("Creating canal #{name}")
+
+  # Request function
+  def request () =
+    log("Request for #{name}")
+    ret = list.hd(process.read.lines(scripts^"radiopilote-getnext "^quote(name)^sed))
+    log("Got answer: #{ret} for #{name}")
+    [request.create(ret)]
+  end
+
+  # Create the request.dynamic.list source
+  # Set conservative to true to queue
+  # several songs in advance
+  source =
+    request.dynamic.list(conservative=true, length=400.,
+                    id="dyn_"^name,request,
+                    timeout=60.)
+
+  # Apply normalization using replaygain
+  # information
+  source =   amplify(1.,override="replay_gain", source)
+
+  # Skip blank when asked to
+  source =
+    if skip then
+      blank.skip(source, length=10., threshold=-40.)
+    else
+      source
+    end
+
+  # Submit new tracks on lastfm
+  source = on_metadata(lastfm,source)
+
+  # Tell the system when a new track
+  # is played
+  source = on_metadata(fun (meta) ->
+                    system(scripts ^ "radiopilote-feedback "
+                           ^quote(meta["canal"])^" "
+                           ^quote(meta["file_id"]) ^ "'"), source)
+
+  # Finally apply a smart crossfading
+  crossfade(source)
+end
+
+# Basic source
+jazz = channel_radiopilote("jazz")
+discoqueen = channel_radiopilote("discoqueen")
+# Avoid skipping blank with classic music !!
+classique = channel_radiopilote(skip=false,"classique")
+That70Sound = channel_radiopilote("That70Sound")
+metal = channel_radiopilote("metal")
+reggae = channel_radiopilote("reggae")
+Rock = channel_radiopilote("Rock")
+
+# Group those sources in a separate
+# clock (good for multithreading/multicore)
+clock.assign_new([jazz,That70Sound,metal,reggae])
+
+# === Mixing live ===
+
+# To create a channel from a basic source, add:
+# - a new-track notification for radiopilote
+# - metadata rewriting
+# - the live shows
+# - the failsafe 'interlude' source to channels
+# - blank detection
+def mklive(source) =
+  # Transition function: if transitioning
+  # to the live, fade out the old source
+  # if transitioning from live, fade.in
+  # the new source. NOTE: We cannot
+  # skip the current song because
+  # reloading new songs for all the
+  # sources when live starts costs too much
+  # CPU.
+  def trans(old,new) =
+    if source.id(new) == source.id(live) then
+      log("Transition to live!")
+      add([new,fade.out(old)])
+    elsif source.id(old) == source.id(live) then
+      log("Transitioning from live!")
+      add([fade.in(new),old])
+    else
+      log("Dummy transition")
+      new
+    end
+  end
+  fallback(track_sensitive=false,
+    transitions=[trans,trans,trans],
+    [live,source,interlude])
+end
+
+# Create a channel using mklive(), encode and output it to icecast.
+def mkoutput(~out=out,mount,source,name,genre)
+  out(id=mount,mount=mount,name=name,genre=genre,
+     mklive(source)
+     )
+end
+
+# === Outputs ===
+
+mkoutput("jazz", jazz, "RadioPi - Canal Jazz","jazz")
+mkoutput("discoqueen", discoqueen, "RadioPi - Canal DiscoQueen","discoqueen")
+mkoutput("classique", classique, "RadioPi - Canal Classique","classique")
+mkoutput("That70Sound", That70Sound,
+                       "RadioPi - Canal That70Sound","That70Sound")
+mkoutput("metal", metal, "RadioPi - Canal Metal","metal")
+mkoutput("reggae", reggae, "RadioPi - Canal Reggae","reggae")
+mkoutput("Rock", Rock, "RadioPi - Canal Rock","Rock")
+
+# Test outouts
+mkoutput(out=out_aac,"reggae.aacp", reggae, "RadioPi - Canal Reggae \
+                                     (64 kbits AAC+ test stream)","reggae")
+mkoutput(out=out_aac32,"reggae.aacp32", reggae, "RadioPi - Canal Reggae \
+                                      (32 kbits AAC+ test stream)","reggae")
+```
+
+The other machine has a similar configuration except that files are local, but this is exactly the same for liquidsoap !
+
+Using harbor, the live connects directly to liquidsoap, using port `8000` (icecast runs on port `8080`).
+Then, liquidsoap starts a relay to the other encoder, and both switch their channels to the new live.
+
+Additionally, a file output is started upon live connection, in order to backup the stream. You could also add a relay to
+icecast in order to manually check what's received by the harbor.
diff --git a/website/content/doc-2.2.5/reference-deprecated.md b/website/content/doc-2.2.5/reference-deprecated.md
new file mode 100644
index 00000000..27968ab3
--- /dev/null
+++ b/website/content/doc-2.2.5/reference-deprecated.md
@@ -0,0 +1,2364 @@
+- [Liquidsoap](#liquidsoap)
+- [Uncategorized](#uncategorized)
+
+## Liquidsoap
+
+### `deprecated`
+
+Mark a function as deprecated.
+
+Type:
+
+```
+('a, string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`): Old function name.
+- `(unlabeled)` (of type `string`): New function name.
+
+### `register_flow`
+
+Deprecated: flow is no longer maintained Register a radio on Liquidsoap Flows.
+
+Type:
+
+```
+(?server : string, ?user : string, ?password : string, ?email : string,
+ radio : string, website : string, description : string, genre : string,
+ streams : [string * string], 'b
+ .{on_metadata : ((([string * string]) -> unit)) -> 'a}) -> 'a
+```
+
+Arguments:
+
+- `server` (of type `string`, which defaults to `""`)
+- `user` (of type `string`, which defaults to `"default"`)
+- `password` (of type `string`, which defaults to `"default"`)
+- `email` (of type `string`, which defaults to `""`)
+- `radio` (of type `string`): Name of the radio.
+- `website` (of type `string`): URL of the website of the radio.
+- `description` (of type `string`): Description of the radio.
+- `genre` (of type `string`): Genre of the radio (rock or rap or etc.).
+- `streams` (of type `[string * string]`): List of streams for the radio described by a pair of strings consisting of the format of the stream and the url of the stream. The format should be of the form "ogg/128k" consisting of the codec and the bitrate, separated by "/".
+- `(unlabeled)` (of type `'b.{on_metadata : ((([string * string]) -> unit)) -> 'a}`)
+
+## Uncategorized
+
+### `add_decoder`
+
+Deprecated: use `decoder.add`.
+
+Type:
+
+```
+(name : string, description : string, ?mimes : [string],
+ ?file_extensions : [string], ?priority : int, test : ((string) -> int),
+ string) -> unit
+```
+
+Arguments:
+
+- `name` (of type `string`)
+- `description` (of type `string`)
+- `mimes` (of type `[string]`, which defaults to `[]`)
+- `file_extensions` (of type `[string]`, which defaults to `[]`)
+- `priority` (of type `int`, which defaults to `1`)
+- `test` (of type `(string) -> int`)
+- `(unlabeled)` (of type `string`)
+
+### `add_metadata_resolver`
+
+Deprecated: use `decoder.metadata.add`.
+
+Type:
+
+```
+(string, ((metadata : [string * string], string) -> [string * string])) ->
+unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `(metadata : [string * string], string) -> [string * string]`)
+
+### `add_oblivious_decoder`
+
+Deprecated: use `decoder.oblivious.add`.
+
+Type:
+
+```
+(name : string, description : string, test : ((string) -> int),
+ ?priority : int, ?mimes : [string], ?file_extensions : [string],
+ ?buffer : float, ((string) -> string)) -> unit
+```
+
+Arguments:
+
+- `name` (of type `string`)
+- `description` (of type `string`)
+- `test` (of type `(string) -> int`)
+- `priority` (of type `int`, which defaults to `1`)
+- `mimes` (of type `[string]`, which defaults to `[]`)
+- `file_extensions` (of type `[string]`, which defaults to `[]`)
+- `buffer` (of type `float`, which defaults to `5.`)
+- `(unlabeled)` (of type `(string) -> string`)
+
+### `add_playlist_parser`
+
+Deprecated: use `playlist.parse.register` instead
+
+Type:
+
+```
+(format : string, strict : bool,
+ ((?pwd : string, string) -> [[string * string] * string])) -> unit
+```
+
+Arguments:
+
+- `format` (of type `string`)
+- `strict` (of type `bool`)
+- `(unlabeled)` (of type `(?pwd : string, string) -> [[string * string] * string]`)
+
+### `add_protocol`
+
+Deprecated: use `protocol.add`.
+
+Type:
+
+```
+(?temporary : bool, ?static : bool, ?syntax : string, ?doc : string, string,
+ ((rlog : ((string) -> unit), maxtime : float, string) -> [string])) -> unit
+```
+
+Arguments:
+
+- `temporary` (of type `bool`, which defaults to `false`)
+- `static` (of type `bool`, which defaults to `false`)
+- `syntax` (of type `string`, which defaults to `"Undocumented"`)
+- `doc` (of type `string`, which defaults to `"Undocumented"`)
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `(rlog : ((string) -> unit), maxtime : float, string) -> [string]`)
+
+### `add_timeout`
+
+Deprecated: this function has been replaced by `thread.run.recurrent`.
+
+Type:
+
+```
+(?fast : bool, float, (() -> float)) -> unit
+```
+
+Arguments:
+
+- `fast` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `float`)
+- `(unlabeled)` (of type `() -> float`)
+
+### `at`
+
+Deprecated: use `at` instead.
+
+Type:
+
+```
+({bool}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{bool}`)
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `audio_to_stereo`
+
+Deprecated: use `source.stereo`
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm(stereo), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `base64.decode`
+
+Deprecated: this function has been replaced by `string.base64.decode`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `base64.encode`
+
+Deprecated: this function has been replaced by `string.base64.encode`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `compress.old`
+
+Deprecated: use `compress`
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm('a)
+.{gain? : never, rms? : never}, 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `cue_cut`
+
+Deprecated: integrated into requests resolution.
+
+Type:
+
+```
+(?id : string?, ?cue_in_metadata : string, ?cue_out_metadata : string,
+ ?on_cue_in : (() -> unit), ?on_cue_out : (() -> unit), 'a) -> 'a
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `""`)
+- `cue_in_metadata` (of type `string`, which defaults to `""`)
+- `cue_out_metadata` (of type `string`, which defaults to `""`)
+- `on_cue_in` (of type `() -> unit`, which defaults to `{()}`)
+- `on_cue_out` (of type `() -> unit`, which defaults to `{()}`)
+- `(unlabeled)` (of type `'a`)
+
+### `drop_audio`
+
+Deprecated: use `source.drop.audio`
+
+Type:
+
+```
+(?id : string?, source(audio='a, 'b)) -> source('b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `drop_metadata`
+
+Deprecated: use `source.drop.metadata`
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `drop_midi`
+
+Deprecated: use `source.drop.midi`
+
+Type:
+
+```
+(?id : string?, source(midi='a, 'b)) -> source('b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(midi='a, 'b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `drop_video`
+
+Deprecated: use `source.drop.video`
+
+Type:
+
+```
+(?id : string?, source(video='a, 'b)) -> source('b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(video='a, 'b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `eat_blank`
+
+Deprecated: use `blank.eat` instead
+
+Type:
+
+```
+(?id : string?, ?at_beginning : bool, ?max_blank : {float},
+ ?min_noise : {float}, ?start_blank : bool, ?threshold : {float},
+ ?track_sensitive : {bool}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `at_beginning` (of type `bool`, which defaults to `false`)
+- `max_blank` (of type `{float}`, which defaults to `20.`)
+- `min_noise` (of type `{float}`, which defaults to `0.`)
+- `start_blank` (of type `bool`, which defaults to `false`)
+- `threshold` (of type `{float}`, which defaults to `-40.`)
+- `track_sensitive` (of type `{bool}`, which defaults to `true`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `empty`
+
+Deprecated: this function has been replaced by `source.fail`.
+
+Type:
+
+```
+(?id : string?) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `error.kind`
+
+Deprecated: use error method instead
+
+Type:
+
+```
+('b.{kind : 'a}) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'b.{kind : 'a}`)
+
+### `error.message`
+
+Deprecated: use error method instead
+
+Type:
+
+```
+('b.{message : 'a}) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'b.{message : 'a}`)
+
+### `exec_at`
+
+Deprecated: this function has been replaced by `thread.when`.
+
+Type:
+
+```
+(?freq : float, pred : (() -> bool), (() -> 'a)) -> unit
+```
+
+Arguments:
+
+- `freq` (of type `float`, which defaults to `1.`)
+- `pred` (of type `() -> bool`)
+- `(unlabeled)` (of type `() -> 'a`)
+
+### `fade.final`
+
+Deprecated: was designed for transitions only and is not needed anymore. Use `file.out` instead.
+
+Type:
+
+```
+(?id : string, ?duration : float, ?type : string, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"fade.final"`)
+- `duration` (of type `float`, which defaults to `3.`)
+- `type` (of type `string`, which defaults to `"lin"`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source(audio=pcm('B), 'A)?
+where 'A is a set of tracks to be muxed into a source`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `fade.initial`
+
+Deprecated: was designed for transitions only and is not needed anymore. Use `fade.in` instead.
+
+Type:
+
+```
+(?id : string, ?duration : float, ?type : string, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"fade.initial"`)
+- `duration` (of type `float`, which defaults to `3.`)
+- `type` (of type `string`, which defaults to `"lin"`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `file.unlink`
+
+Deprecated: use `file.remove` instead.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `garbage_collect`
+
+Deprecated: use `runtime.gc.full_major` instead
+
+Type:
+
+```
+() -> unit
+```
+
+### `get_mime`
+
+Deprecated: use `file.mime`
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `get_process_lines`
+
+Deprecated: use `process.read.lines` instead.
+
+Type:
+
+```
+(?timeout : float, ?env : [string * string], ?inherit_env : bool,
+ ?log_errors : bool, string) -> [string]
+```
+
+Arguments:
+
+- `timeout` (of type `float`, which defaults to `-1.`)
+- `env` (of type `[string * string]`, which defaults to `[]`)
+- `inherit_env` (of type `bool`, which defaults to `true`)
+- `log_errors` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+### `get_process_output`
+
+Deprecated: use `process.read` instead.
+
+Type:
+
+```
+(?timeout : float, ?env : [string * string], ?inherit_env : bool,
+ ?log_errors : bool, string) -> string
+```
+
+Arguments:
+
+- `timeout` (of type `float`, which defaults to `-1.`)
+- `env` (of type `[string * string]`, which defaults to `[]`)
+- `inherit_env` (of type `bool`, which defaults to `true`)
+- `log_errors` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+### `getenv`
+
+Deprecated: use `environment.get`
+
+Type:
+
+```
+(?string, string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `string`)
+
+### `getpid`
+
+Deprecated: use `getpid`
+
+Type:
+
+```
+() -> int
+```
+
+### `gettimeofday`
+
+Deprecated: use `time` instead
+
+Type:
+
+```
+() -> float
+```
+
+### `gmtime`
+
+Deprecated: use `time.utc` instead
+
+Type:
+
+```
+(float?) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float?`)
+
+Methods:
+
+- `day` (of type `int`): Day of month.
+- `dst` (of type `bool`): Daylight time savings in effect.
+- `hour` (of type `int`): Hours.
+- `min` (of type `int`): Minutes.
+- `month` (of type `int`): Month of year.
+- `sec` (of type `int`): Seconds.
+- `week_day` (of type `int`): Day of week (Sunday is 0 or 7, Saturday is 6).
+- `year` (of type `int`): Year.
+- `year_day` (of type `int`): Day of year, between `1` and `366`.
+
+### `https.delete`
+
+Deprecated: use `http.delete` instead.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`)
+- `http_version` (of type `string?`, which defaults to `null`)
+- `redirect` (of type `bool`, which defaults to `true`)
+- `timeout` (of type `float?`, which defaults to `10.`)
+- `normalize_url` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `https.get`
+
+Deprecated: use `http.get` instead.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string) -> string
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`)
+- `http_version` (of type `string?`, which defaults to `null`)
+- `redirect` (of type `bool`, which defaults to `true`)
+- `timeout` (of type `float?`, which defaults to `10.`)
+- `normalize_url` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `https.head`
+
+Deprecated: use `http.head` instead.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`)
+- `http_version` (of type `string?`, which defaults to `null`)
+- `redirect` (of type `bool`, which defaults to `true`)
+- `timeout` (of type `float?`, which defaults to `10.`)
+- `normalize_url` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `https.post`
+
+Deprecated: use `http.post` instead.
+
+Type:
+
+```
+(?data : {string}, ?headers : [string * string], ?http_version : string?,
+ ?redirect : bool, ?timeout : float?, ?normalize_url : bool, string) ->
+string
+```
+
+Arguments:
+
+- `data` (of type `{string}`, which defaults to `""`)
+- `headers` (of type `[string * string]`, which defaults to `[]`)
+- `http_version` (of type `string?`, which defaults to `null`)
+- `redirect` (of type `bool`, which defaults to `true`)
+- `timeout` (of type `float?`, which defaults to `10.`)
+- `normalize_url` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `https.put`
+
+Deprecated: use `http.put` instead.
+
+Type:
+
+```
+(?data : {string}, ?headers : [string * string], ?http_version : string?,
+ ?redirect : bool, ?timeout : float?, ?normalize_url : bool, string) ->
+string
+```
+
+Arguments:
+
+- `data` (of type `{string}`, which defaults to `""`)
+- `headers` (of type `[string * string]`, which defaults to `[]`)
+- `http_version` (of type `string?`, which defaults to `null`)
+- `redirect` (of type `bool`, which defaults to `true`)
+- `timeout` (of type `float?`, which defaults to `10.`)
+- `normalize_url` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `id`
+
+Deprecated: this function will be removed in a future release
+
+Type:
+
+```
+(?id : 'a?, 'b) -> 'b
+```
+
+Arguments:
+
+- `id` (of type `'a?`, which defaults to `null`)
+- `(unlabeled)` (of type `'b`)
+
+### `in`
+
+Deprecated: use `input` instead.
+
+Type:
+
+```
+(?id : string?, ?start : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?fallible : bool) -> source(audio=pcm('A))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `start` (of type `bool`, which defaults to `true`)
+- `on_start` (of type `() -> unit`, which defaults to `{()}`)
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`)
+- `fallible` (of type `bool`, which defaults to `false`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.external`
+
+Deprecated: this function has been replaced by `input.external.rawaudio`.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?channels : int, ?max : float,
+ ?restart : bool, ?restart_on_error : bool, ?samplerate : int, {string}) ->
+source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `buffer` (of type `float`, which defaults to `2.`)
+- `channels` (of type `int`, which defaults to `2`)
+- `max` (of type `float`, which defaults to `10.`)
+- `restart` (of type `bool`, which defaults to `true`)
+- `restart_on_error` (of type `bool`, which defaults to `false`)
+- `samplerate` (of type `int`, which defaults to `44100`)
+- `(unlabeled)` (of type `{string}`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.https`
+
+Deprecated: use `input.http` instead
+
+Type:
+
+```
+(?id : string?, ?clock_safe : bool, ?debug : bool,
+ ?deduplicate_metadata : bool, ?float_args : [string * float],
+ ?format : string?, ?int_args : [string * int], ?max_buffer : float,
+ ?metadata_filter : (([string * string]) -> [string * string])?,
+ ?new_track_on_metadata : bool, ?on_connect : (([string * string]) -> unit),
+ ?on_disconnect : (() -> unit),
+ ?on_error : ((error
+               .{
+                 kind : string,
+                 message : string,
+                 trace : [
+                          {
+                            position_end : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            position_start : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            to_string : (?prefix : string) -> string
+                          }]
+               }) -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?poll_delay : float,
+ ?self_sync : {bool?}, ?start : bool, ?string_args : [string * string],
+ ?timeout : float, ?trim_url : bool, ?user_agent : string, {string}) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `clock_safe` (of type `bool`, which defaults to `false`)
+- `debug` (of type `bool`, which defaults to `false`)
+- `deduplicate_metadata` (of type `bool`, which defaults to `true`)
+- `float_args` (of type `[string * float]`, which defaults to `[]`)
+- `format` (of type `string?`, which defaults to `null`)
+- `int_args` (of type `[string * int]`, which defaults to `[]`)
+- `max_buffer` (of type `float`, which defaults to `5.`)
+- `metadata_filter` (of type `(([string * string]) -> [string * string])?`, which defaults to `null`)
+- `new_track_on_metadata` (of type `bool`, which defaults to `true`)
+- `on_connect` (of type `([string * string]) -> unit`, which defaults to `fun (_) -> ()`)
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`)
+- `on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }) -> unit`, which defaults to `fun (_) -> ()`)
+- `on_start` (of type `() -> unit`, which defaults to `{()}`)
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`)
+- `poll_delay` (of type `float`, which defaults to `2.`)
+- `self_sync` (of type `{bool?}`, which defaults to `null`)
+- `start` (of type `bool`, which defaults to `true`)
+- `string_args` (of type `[string * string]`, which defaults to `[]`)
+- `timeout` (of type `float`, which defaults to `10.`)
+- `trim_url` (of type `bool`, which defaults to `true`)
+- `user_agent` (of type `string`, which defaults to `"Liquidsoap/2.2.5 (Unix; OCaml 4.14.1)"`)
+- `(unlabeled)` (of type `{string}`)
+
+Methods:
+
+- `buffer_length` (of type `() -> float`): Get the buffer's length in seconds.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_url` (of type `({string}) -> unit`): Set the source's url.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `status` (of type `() -> string`): Return the current status of the source, either "stopped" (the source isn't trying to relay the HTTP stream), "starting" (polling task is about to begin) "polling" (attempting to connect to the HTTP stream), "connected <url>" (connected to <url>, buffering or playing back the stream) or "stopping" (source is stopping).
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `url` (of type `() -> string`): Return the source's current url.
+
+### `json_of`
+
+Deprecated: use `json.stringify` instead
+
+Type:
+
+```
+(?compact : bool, ?json5 : bool, 'a) -> string
+```
+
+Arguments:
+
+- `compact` (of type `bool`, which defaults to `false`): Output compact text.
+- `json5` (of type `bool`, which defaults to `false`): Use json5 extended spec.
+- `(unlabeled)` (of type `'a`)
+
+### `list.mem_assoc`
+
+Deprecated: use `list.assoc.mem` instead
+
+Type:
+
+```
+('a, ['a * 'b]) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `['a * 'b] where 'a is an orderable type`)
+
+### `localtime`
+
+Deprecated: use `time.local` instead
+
+Type:
+
+```
+(float?) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float?`)
+
+Methods:
+
+- `day` (of type `int`): Day of month.
+- `dst` (of type `bool`): Daylight time savings in effect.
+- `hour` (of type `int`): Hours.
+- `min` (of type `int`): Minutes.
+- `month` (of type `int`): Month of year.
+- `sec` (of type `int`): Seconds.
+- `week_day` (of type `int`): Day of week (Sunday is 0 or 7, Saturday is 6).
+- `year` (of type `int`): Year.
+- `year_day` (of type `int`): Day of year, between `1` and `366`.
+
+### `map_metadata`
+
+Deprecated: use metadata.map
+
+Type:
+
+```
+(?id : string?, ?update : bool, ?strip : bool, ?insert_missing : bool,
+ (([string * string]) -> [string * string]), source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"metadata.map"`)
+- `update` (of type `bool`, which defaults to `true`)
+- `strip` (of type `bool`, which defaults to `false`)
+- `insert_missing` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `([string * string]) -> [string * string]`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `merge_tracks`
+
+Deprecated: use `source.tracks` and `source`
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mkavailable`
+
+Deprecated: use `source.available` instead.
+
+Type:
+
+```
+(?id : string, ?track_sensitive : {bool}, ?active : {bool},
+ ?available : {bool}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"mkavailable"`)
+- `track_sensitive` (of type `{bool}`, which defaults to `true`)
+- `active` (of type `{bool}`, which defaults to `false`)
+- `available` (of type `{bool}`, which defaults to `true`)
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mux_audio`
+
+Deprecated: use `source.mux.audio`.
+
+Type:
+
+```
+(?id : string?, audio : source(audio='A, 'B), source('a)) -> source(audio='A,
+'a) where 'a is a set of tracks to be muxed into a source, 'A is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `audio` (of type `source(audio='B, 'A) where 'B is a track`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mux_midi`
+
+Deprecated: use `source.mux.midi`
+
+Type:
+
+```
+(?id : string?, midi : source(midi='A, 'B), source('a)) -> source(midi='A,
+'a) where 'a is a set of tracks to be muxed into a source, 'A is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `midi` (of type `source(midi='B, 'A) where 'B is a track`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mux_video`
+
+Deprecated: use `source.mux.video`.
+
+Type:
+
+```
+(?id : string?, video : source(video='A, 'B), source('a)) -> source(video='A,
+'a) where 'a is a set of tracks to be muxed into a source, 'A is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `video` (of type `source(video='B, 'A) where 'B is a track`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `of_json`
+
+Deprecated: use `json.parse` instead
+
+Type:
+
+```
+(default : 'a, string) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a`): Default value if string cannot be parsed.
+- `(unlabeled)` (of type `string`)
+
+### `on_blank`
+
+Deprecated: use `blank.detect` instead
+
+Type:
+
+```
+(?id : string?, ?max_blank : {float}, ?min_noise : {float},
+ ?on_noise : (() -> unit), ?start_blank : bool, ?threshold : {float},
+ ?track_sensitive : {bool}, (() -> unit), source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `max_blank` (of type `{float}`, which defaults to `20.`)
+- `min_noise` (of type `{float}`, which defaults to `0.`)
+- `on_noise` (of type `() -> unit`, which defaults to `{()}`)
+- `start_blank` (of type `bool`, which defaults to `false`)
+- `threshold` (of type `{float}`, which defaults to `-40.`)
+- `track_sensitive` (of type `{bool}`, which defaults to `true`)
+- `(unlabeled)` (of type `() -> unit`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `on_end`
+
+Deprecated: use `source.on_end` instead.
+
+Type:
+
+```
+(?id : string?, ?delay : {float}, source('a),
+ ((float, [string * string]) -> unit)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `delay` (of type `{float}`, which defaults to `5.`)
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `(float, [string * string]) -> unit`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `out`
+
+Deprecated: use `output` instead.
+
+Type:
+
+```
+(source(audio=pcm('A))) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source(audio=pcm('A))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.preferred`
+
+
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool, source(audio=pcm('A))) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `fallible` (of type `bool`, which defaults to `false`)
+- `on_start` (of type `() -> unit`, which defaults to `{()}`)
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`)
+- `start` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `source(audio=pcm('A))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `playlist.once`
+
+Deprecated: this function has been replaced with `playlist`, setting `reload_mode` argument to `"never"` and `loop` to `false`.
+
+Type:
+
+```
+(?id : string?, ?random : bool, ?reload_mode : string, ?prefetch : int?,
+ ?filter : ((request) -> bool), string) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `random` (of type `bool`, which defaults to `false`)
+- `reload_mode` (of type `string`, which defaults to `""`)
+- `prefetch` (of type `int?`, which defaults to `null`)
+- `filter` (of type `(request) -> bool`, which defaults to `fun (_) -> true`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `add` (of type `(request) -> bool`): Add a request to the queue. Requests are resolved before being added. Returns `true` if the request was successfully added.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `length` (of type `() -> int`): 
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `reload` (of type `(?empty_queue : bool, ?uri : string?) -> unit`): 
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `remaining_files` (of type `() -> [string]`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): Set the queue of requests. Requests are resolved before being added to the queue. You are responsible for destroying the requests currently in the queue.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `playlist.reloadable`
+
+Deprecated: use `playlist` instead
+
+Type:
+
+```
+(?id : string?, ?mime_type : string, ?mode : string,
+ ?on_track : (() -> unit), ?prefix : string, ?reload : int,
+ ?reload_mode : string, string) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `mime_type` (of type `string`, which defaults to `""`)
+- `mode` (of type `string`, which defaults to `"randomize"`)
+- `on_track` (of type `() -> unit`, which defaults to `{()}`)
+- `prefix` (of type `string`, which defaults to `""`)
+- `reload` (of type `int`, which defaults to `0`)
+- `reload_mode` (of type `string`, which defaults to `"seconds"`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `add` (of type `(request) -> bool`): Add a request to the queue. Requests are resolved before being added. Returns `true` if the request was successfully added.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `length` (of type `() -> int`): 
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `reload` (of type `(?empty_queue : bool, ?uri : string?) -> unit`): 
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `remaining_files` (of type `() -> [string]`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): Set the queue of requests. Requests are resolved before being added to the queue. You are responsible for destroying the requests currently in the queue.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `playlist.safe`
+
+Deprecated: use mksafe and playlist instead.
+
+Type:
+
+```
+(?id : string?, ?mime_type : string, ?mode : string,
+ ?on_track : (() -> unit), ?prefix : string, ?reload : int,
+ ?reload_mode : string, string) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `mime_type` (of type `string`, which defaults to `""`)
+- `mode` (of type `string`, which defaults to `"randomize"`)
+- `on_track` (of type `() -> unit`, which defaults to `{()}`)
+- `prefix` (of type `string`, which defaults to `""`)
+- `reload` (of type `int`, which defaults to `0`)
+- `reload_mode` (of type `string`, which defaults to `"seconds"`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)? where 'A is a set of internal tracks`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `quote`
+
+Deprecated: this function has been replaced by `string.quote`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `request.create.raw`
+
+Deprecated: use `request.create` instead.
+
+Type:
+
+```
+(?indicators : [string], ?cue_in_metadata : string?,
+ ?cue_out_metadata : string?, ?persistent : bool, ?resolve_metadata : bool,
+ ?excluded_metadata_resolvers : [string], ?temporary : bool, string) ->
+request
+```
+
+Arguments:
+
+- `indicators` (of type `[string]`, which defaults to `[]`)
+- `cue_in_metadata` (of type `string?`, which defaults to `"liq_cue_in"`)
+- `cue_out_metadata` (of type `string?`, which defaults to `"liq_cue_out"`)
+- `persistent` (of type `bool`, which defaults to `false`)
+- `resolve_metadata` (of type `bool`, which defaults to `true`)
+- `excluded_metadata_resolvers` (of type `[string]`, which defaults to `[]`)
+- `temporary` (of type `bool`, which defaults to `false`)
+- `(unlabeled)` (of type `string`)
+
+### `request.dynamic.list`
+
+Deprecated: use `request.dynamic` instead
+
+Type:
+
+```
+(?id : string?, ?available : {bool}, ?prefetch : int?,
+ ?retry_delay : {float}, ?timeout : float, (() -> [request])) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `available` (of type `{bool}`, which defaults to `true`)
+- `prefetch` (of type `int?`, which defaults to `null`)
+- `retry_delay` (of type `{float}`, which defaults to `0.1`)
+- `timeout` (of type `float`, which defaults to `20.`)
+- `(unlabeled)` (of type `() -> [request]`)
+
+Methods:
+
+- `add` (of type `(request) -> bool`): Add a request to the queue. Requests are resolved before being added. Returns `true` if the request was successfully added.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): Set the queue of requests. Requests are resolved before being added to the queue. You are responsible for destroying the requests currently in the queue.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `request.ready`
+
+Deprecated: use `request.resolved`
+
+Type:
+
+```
+(request) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `rewrite_metadata`
+
+Deprecated: this function has been replaced by `metadata.map`.
+
+Type:
+
+```
+([string * string], ?insert_missing : bool, ?update : bool, ?strip : bool,
+ source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+- `insert_missing` (of type `bool`, which defaults to `true`)
+- `update` (of type `bool`, which defaults to `true`)
+- `strip` (of type `bool`, which defaults to `false`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `run_process`
+
+Deprecated: use `process.run` instead
+
+Type:
+
+```
+(?env : [string * string], ?inherit_env : bool, ?rwdirs : [string],
+ ?rodirs : [string], ?network : bool?, ?timeout : float?, string) ->
+string * string * (string * string)
+```
+
+Arguments:
+
+- `env` (of type `[string * string]`, which defaults to `[]`)
+- `inherit_env` (of type `bool`, which defaults to `true`)
+- `rwdirs` (of type `[string]`, which defaults to `["default"]`)
+- `rodirs` (of type `[string]`, which defaults to `["default"]`)
+- `network` (of type `bool?`, which defaults to `null`)
+- `timeout` (of type `float?`, which defaults to `null`)
+- `(unlabeled)` (of type `string`)
+
+### `say_metadata`
+
+Deprecated: use `source.say_metadata` instead
+
+Type:
+
+```
+(source('a), pattern : string) -> source('a)
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+- `pattern` (of type `string`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `cancel_pending` (of type `() -> unit`): Cancel any pending appended source.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `(?cancel_pending : bool) -> unit`): Skip the current track. Pending appended source are cancelled by default. Pass `cancel_pending=false` to keep it.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `setenv`
+
+Deprecated: use `environment.set`
+
+Type:
+
+```
+(string, string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+### `skip_blank`
+
+Deprecated: use `blank.skip` instead
+
+Type:
+
+```
+(?id : string?, ?threshold : float, ?max_blank : float, ?min_noise : float,
+ ?track_sensitive : bool, source(audio=pcm('a), 'b).{skip : () -> unit}) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"blank.skip"`)
+- `threshold` (of type `float`, which defaults to `-40.`)
+- `max_blank` (of type `float`, which defaults to `20.`)
+- `min_noise` (of type `float`, which defaults to `0.`)
+- `track_sensitive` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b).{skip : () -> unit}`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `sleep`
+
+Deprecated: use `thread.pause`
+
+Type:
+
+```
+(float) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `string.utf8.escape`
+
+Deprecated: this function has been replaced by `string.escape`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string_of`
+
+Deprecated: use `string`.
+
+Type:
+
+```
+('a) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+
+### `string_of_float`
+
+Deprecated: use `string.float`.
+
+Type:
+
+```
+(float) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `strip_blank`
+
+Deprecated: use `blank.strip` instead
+
+Type:
+
+```
+(?id : string?, ?max_blank : {float}, ?min_noise : {float},
+ ?start_blank : bool, ?threshold : {float}, ?track_sensitive : {bool},
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `max_blank` (of type `{float}`, which defaults to `20.`)
+- `min_noise` (of type `{float}`, which defaults to `0.`)
+- `start_blank` (of type `bool`, which defaults to `false`)
+- `threshold` (of type `{float}`, which defaults to `-40.`)
+- `track_sensitive` (of type `{bool}`, which defaults to `true`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `system`
+
+Deprecated: use `process.run` instead.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `status` (of type `string.{code : int, description : string}`): Status when process ended, can be one of `"exit"` (the program exited, the `status` code is then relevant), `"killed"` (the program was killed by signal given in `status` code), `"stopped"` (the program was stopped by signal given in `status` code) or `"exception"` (the program raised and exception detailed in the `description`).
+- `stderr` (of type `string`): Messages written by process on standard error stream.
+- `stdout` (of type `string`): Messages written by process on standard output stream.
+
+### `test_process`
+
+Deprecated: use `process.test` instead.
+
+Type:
+
+```
+(?timeout : float, ?env : [string * string], ?inherit_env : bool, string) ->
+bool
+```
+
+Arguments:
+
+- `timeout` (of type `float`, which defaults to `-1.`)
+- `env` (of type `[string * string]`, which defaults to `[]`)
+- `inherit_env` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+### `video.line`
+
+Deprecated: use `video.add_line`.
+
+Type:
+
+```
+(?id : string?, ?alpha : {float}, ?color : {int}, {int * int}, {int * int},
+ source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `alpha` (of type `{float}`, which defaults to `1.`)
+- `color` (of type `{int}`, which defaults to `0`)
+- `(unlabeled)` (of type `{int * int}`)
+- `(unlabeled)` (of type `{int * int}`)
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.rectangle`
+
+Deprecated: use `video.add_rectangle`.
+
+Type:
+
+```
+(?id : string?, ?alpha : {float}, ?color : {int}, height : {int},
+ width : {int}, ?x : {int}, ?y : {int}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `alpha` (of type `{float}`, which defaults to `1.`)
+- `color` (of type `{int}`, which defaults to `0`)
+- `height` (of type `{int}`)
+- `width` (of type `{int}`)
+- `x` (of type `{int}`, which defaults to `0`)
+- `y` (of type `{int}`, which defaults to `0`)
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.transparent`
+
+Deprecated: use `video.alpha.of_color`
+
+Type:
+
+```
+(?id : string?, ?color : int, ?precision : float, source(video=canvas('a),
+ 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `color` (of type `int`, which defaults to `0`)
+- `precision` (of type `float`, which defaults to `0.2`)
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `which`
+
+Deprecated: this function has been replaced by `file.which`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
diff --git a/website/content/doc-2.2.5/reference-extras.md b/website/content/doc-2.2.5/reference-extras.md
new file mode 100644
index 00000000..33f4af9e
--- /dev/null
+++ b/website/content/doc-2.2.5/reference-extras.md
@@ -0,0 +1,32869 @@
+# Liquidsoap scripting language reference
+
+The **Source / ...** categories contain all functions that return sources.
+The **Input** functions are those which build elementary sources
+(playing files, synthesizing sound, etc.).
+The **Output** functions are those which take a source and register it
+for being streamed to the outside (file, soundcard, audio server, etc.).
+The **Visualization** functions are experimental ones that let you
+visualize in real-time some aspects of the audio stream.
+The **Sound Processing** functions are those which basically work on the source
+as a continuous audio stream. They would typically be mixers of streams,
+audio effects or analysis.
+Finally, **Track Processing** functions are basically all
+others, often having a behaviour that depends on or affects the extra
+information that liquidsoap puts in streams: track limits and metadata.
+
+- [Interaction](#interaction)
+- [Internet](#internet)
+- [Metadata](#metadata)
+- [Source / Audio processing](#source-audio-processing)
+- [Source / FFmpeg filter](#source-ffmpeg-filter)
+- [Source / Fade](#source-fade)
+- [Source / Input](#source-input)
+- [Source / Output](#source-output)
+- [Source / Sound synthesis](#source-sound-synthesis)
+- [Source / Track processing](#source-track-processing)
+- [Source / Video processing](#source-video-processing)
+- [Source / Visualization](#source-visualization)
+- [Uncategorized](#uncategorized)
+
+## Interaction
+
+### `add_skip_command`
+
+Add a skip telnet command to a source when it does not have one by default.
+
+Type:
+
+```
+(source('b).{skip : () -> 'a}) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('b).{skip : () -> 'a}`): The source to attach the command to.
+
+### `audioscrobbler.submit.full`
+
+Submit songs using audioscrobbler, respecting the full protocol: First signal song as now playing when starting, and then submit song when it ends.
+
+Type:
+
+```
+(user : string, password : string, ?host : string, ?port : int,
+ ?source : string, ?length : bool, ?delay : float, ?force : bool, source('A)) ->
+source('A)
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `host` (of type `string`, which defaults to `"post.audioscrobbler.com"`)
+- `port` (of type `int`, which defaults to `80`)
+- `source` (of type `string`, which defaults to `"broadcast"`): Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intended for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `delay` (of type `float`, which defaults to `10.`): Submit song when there is only this delay left, in seconds.
+- `force` (of type `bool`, which defaults to `false`): If remaining time is null, the song will be assumed to be skipped or cut, and not submitted. Set to zero to disable this behaviour.
+- `(unlabeled)` (of type `source('A)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `compress.multiband.interactive`
+
+Create a multiband compressor whose parameters are interactive variables.
+
+Type:
+
+```
+(?id : string?, ?bands : int, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a).{gain? : never, rms? : never}, 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Id of the source. Variable names are prefixed with this.
+- `bands` (of type `int`, which defaults to `5`): Number of bands.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Source to compress.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `interactive.bool`
+
+Read a boolean from an interactive input.
+
+Type:
+
+```
+(?description : string, ?osc : string, string, bool) -> () -> bool
+```
+
+Arguments:
+
+- `description` (of type `string`, which defaults to `""`): Description of the variable.
+- `osc` (of type `string`, which defaults to `""`): OSC address.
+- `(unlabeled)` (of type `string`): Name of the variable.
+- `(unlabeled)` (of type `bool`): Initial value.
+
+Methods:
+
+- `remove` (of type `() -> unit`): 
+- `set` (of type `(bool) -> unit`): 
+
+### `interactive.float`
+
+Read a float from an interactive input.
+
+Type:
+
+```
+(?min : float, ?max : float, ?step : float, ?description : string,
+ ?unit : string, ?osc : string, string, float) -> () -> float
+```
+
+Arguments:
+
+- `min` (of type `float`, which defaults to `-inf`): Minimal value.
+- `max` (of type `float`, which defaults to `inf`): Maximal value.
+- `step` (of type `float`, which defaults to `0.1`): Typical variation of the value.
+- `description` (of type `string`, which defaults to `""`): Description of the variable.
+- `unit` (of type `string`, which defaults to `""`): Unit for the variable.
+- `osc` (of type `string`, which defaults to `""`): OSC address.
+- `(unlabeled)` (of type `string`): Name of the variable.
+- `(unlabeled)` (of type `float`): Initial value.
+
+Methods:
+
+- `remove` (of type `() -> unit`): 
+- `set` (of type `(float) -> unit`): 
+
+### `interactive.harbor`
+
+Expose interactive variables through habor http server. Once this is called, with default parameters, you can browse <http://localhost:8000/interactive> to change the value of interactive variables using sliders.
+
+Type:
+
+```
+(?transport : http_transport
+ .{default_port : int, name : string, protocol : string}, ?port : int,
+ ?uri : string) -> unit
+```
+
+Arguments:
+
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{default_port=80, protocol="http", name="unix"}`): Http transport. Use `http.transport.ssl` or http.transport.secure_transport`, when available, to enable HTTPS output
+- `port` (of type `int`, which defaults to `8000`): Port of the server.
+- `uri` (of type `string`, which defaults to `"/interactive"`): URI of the server.
+
+### `interactive.int`
+
+Read an integer from an interactive input.
+
+Type:
+
+```
+(?description : string, ?osc : string, string, int) -> () -> int
+```
+
+Arguments:
+
+- `description` (of type `string`, which defaults to `""`): Description of the variable.
+- `osc` (of type `string`, which defaults to `""`): OSC address.
+- `(unlabeled)` (of type `string`): Name of the variable.
+- `(unlabeled)` (of type `int`): Initial value.
+
+Methods:
+
+- `remove` (of type `() -> unit`): 
+- `set` (of type `(int) -> unit`): 
+
+### `interactive.load`
+
+Load the value of interactive variables from a file.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Name of the file.
+
+### `interactive.persistent`
+
+Make the value of interactive variables persistent: they are loaded from the given file and stored there whenever updated. This function should be called after all interactive variables have been defined (variables not declared yet will not be loaded).
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Name of the file.
+
+### `interactive.save`
+
+Save the value of all interactive variables in a file.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Name of the file.
+
+### `interactive.string`
+
+Read a string from an interactive input.
+
+Type:
+
+```
+(?description : string, ?osc : string, string, string) -> () -> string
+```
+
+Arguments:
+
+- `description` (of type `string`, which defaults to `""`): Description of the variable.
+- `osc` (of type `string`, which defaults to `""`): OSC address.
+- `(unlabeled)` (of type `string`): Name of the variable.
+- `(unlabeled)` (of type `string`): Initial value.
+
+Methods:
+
+- `remove` (of type `() -> unit`): 
+- `set` (of type `(string) -> unit`): 
+
+### `interactive.unit`
+
+Register a callback when a unit interactive input is set.
+
+Type:
+
+```
+(?description : string, ?osc : string, string, (() -> unit)) -> unit
+```
+
+Arguments:
+
+- `description` (of type `string`, which defaults to `""`): Description of the variable.
+- `osc` (of type `string`, which defaults to `""`): OSC address.
+- `(unlabeled)` (of type `string`): Name of the variable.
+- `(unlabeled)` (of type `() -> unit`): Function triggered when the value is set.
+
+Methods:
+
+- `remove` (of type `() -> unit`): 
+- `set` (of type `() -> unit`): 
+
+### `lastfm.nowplaying`
+
+Submit metadata to lastfm.fm using the audioscrobbler protocol (nowplaying mode).
+
+Type:
+
+```
+(user : string, password : string, ?length : bool, [string * string]) -> unit
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `lastfm.submit`
+
+Submit metadata to lastfm.fm using the audioscrobbler protocol.
+
+Type:
+
+```
+(user : string, password : string, ?source : string, ?length : bool,
+ [string * string]) -> unit
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `source` (of type `string`, which defaults to `"broadcast"`): Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intended for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `lastfm.submit.full`
+
+Submit songs to lastfm using audioscrobbler, respecting the full protocol: First signal song as now playing when starting, and then submit song when it ends.
+
+Type:
+
+```
+(user : string, password : string, ?source : string, ?length : bool,
+ ?delay : float, ?force : bool, source('A)) -> source('A)
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `source` (of type `string`, which defaults to `"broadcast"`): Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intended for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `delay` (of type `float`, which defaults to `10.`): Submit song when there is only this delay left, in seconds. If remaining time is less than this value, the song will be assumed to be skipped or cut, and not submitted. Set to zero to disable this behaviour.
+- `force` (of type `bool`, which defaults to `false`): If remaining time is null, the song will be assumed to be skipped or cut, and not submitted. Set to zero to disable this behaviour.
+- `(unlabeled)` (of type `source('A)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `librefm.nowplaying`
+
+Submit metadata to libre.fm using the audioscrobbler protocol (nowplaying mode).
+
+Type:
+
+```
+(user : string, password : string, ?length : bool, [string * string]) -> unit
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `librefm.submit`
+
+Submit metadata to libre.fm using the audioscrobbler protocol.
+
+Type:
+
+```
+(user : string, password : string, ?source : string, ?length : bool,
+ [string * string]) -> unit
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `source` (of type `string`, which defaults to `"broadcast"`): Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intended for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `librefm.submit.full`
+
+Submit songs to librefm using audioscrobbler, respecting the full protocol: First signal song as now playing when starting, and then submit song when it ends.
+
+Type:
+
+```
+(user : string, password : string, ?source : string, ?length : bool,
+ ?delay : float, ?force : bool, source('A)) -> source('A)
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `source` (of type `string`, which defaults to `"broadcast"`): Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intended for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `delay` (of type `float`, which defaults to `10.`): Submit song when there is only this delay left, in seconds. If remaining time is less than this value, the song will be assumed to be skipped or cut, and not submitted. Set to zero to disable this behaviour.
+- `force` (of type `bool`, which defaults to `false`): If remaining time is null, the song will be assumed to be skipped or cut, and not submitted. Set to zero to disable this behaviour.
+- `(unlabeled)` (of type `source('A)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Internet
+
+### `harbor.http.middleware.cors`
+
+Harbor middleware to add CORS headers
+
+Type:
+
+```
+(?origin : string?,
+ ?origin_callback : ((
+                      {
+                        body : (?timeout : float) -> string,
+                        data : (?timeout : float) -> string,
+                        headers : [string * string],
+                        http_version : string,
+                        method : string,
+                        path : string,
+                        query : [string * string]
+                      }) -> string?)?,
+ ?methods : [string], ?allowed_headers : [string]?,
+ ?exposed_headers : [string], ?credentials : bool, ?max_age : int?,
+ ?preflight_continue : bool, ?options_status_code : int) ->
+(
+ {
+   body : (?timeout : float) -> string,
+   data : (?timeout : float) -> string,
+   headers : [string * string],
+   http_version : string,
+   method : string,
+   path : string,
+   query : [string * string]
+ }, (() -> string)
+ .{
+   content_type : ((string?) -> unit)
+   .{current : () -> string?
+   },
+   data : (({string}) -> unit)
+   .{current : () -> {string}
+   },
+   header : (string, string) -> unit,
+   headers : (([string * string]) -> unit)
+   .{current : () -> [string * string]
+   },
+   html : ({string}) -> unit,
+   http_version : ((string) -> unit)
+   .{current : () -> string
+   },
+   json : (?compact : bool, 'a) -> unit,
+   multipart_form : (?boundary : string?,
+                     [
+                      {
+                        attributes : [string * string],
+                        contents : {string},
+                        headers : ['b * 'c],
+                        name : string
+                      }]) -> unit,
+   redirect : (?status_code : int, string) -> unit,
+   send_status : ('d.{write : (string) -> unit}) -> unit,
+   status_code : ((int) -> unit)
+   .{current : () -> int
+   },
+   status_message : ((string?) -> unit)
+   .{current : () -> string?
+   },
+   status_sent : () -> bool
+ },
+ ((
+   {
+     body : (?timeout : float) -> string,
+     data : (?timeout : float) -> string,
+     headers : [string * string],
+     http_version : string,
+     method : string,
+     path : string,
+     query : [string * string]
+   }, (() -> string)
+   .{
+     content_type : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     data : (({string}) -> unit)
+     .{current : () -> {string}
+     },
+     header : (string, string) -> unit,
+     headers : (([string * string]) -> unit)
+     .{current : () -> [string * string]
+     },
+     html : ({string}) -> unit,
+     http_version : ((string) -> unit)
+     .{current : () -> string
+     },
+     json : (?compact : bool, 'a) -> unit,
+     multipart_form : (?boundary : string?,
+                       [
+                        {
+                          attributes : [string * string],
+                          contents : {string},
+                          headers : ['b * 'c],
+                          name : string
+                        }]) -> unit,
+     redirect : (?status_code : int, string) -> unit,
+     send_status : ('d.{write : (string) -> unit}) -> unit,
+     status_code : ((int) -> unit)
+     .{current : () -> int
+     },
+     status_message : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     status_sent : () -> bool
+   }) -> unit)) -> unit
+```
+
+Arguments:
+
+- `origin` (of type `string?`, which defaults to `"*"`): Configures the Access-Control-Allow-Origin CORS header
+- `origin_callback` (of type `((
+  {
+    body : (?timeout : float) -> string,
+    data : (?timeout : float) -> string,
+    headers : [string * string],
+    http_version : string,
+    method : string,
+    path : string,
+    query : [string * string]
+  }) -> string?)?`, which defaults to `null`): Origin callback for advanced uses. If passed, overrides `origin` argument. Takes the request as input and returns the allowed origin. Return `null` to skip all CORS headers.
+- `methods` (of type `[string]`, which defaults to `["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"]`): Configures the Access-Control-Allow-Methods CORS header.
+- `allowed_headers` (of type `[string]?`, which defaults to `null`): Configures the Access-Control-Allow-Headers CORS header. If not specified, defaults to reflecting the headers specified in the request's Access-Control-Request-Headers header.
+- `exposed_headers` (of type `[string]`, which defaults to `[]`): Configures the Access-Control-Expose-Headers CORS header. If not specified, no custom headers are exposed.
+- `credentials` (of type `bool`, which defaults to `false`): Configures the Access-Control-Allow-Credentials CORS header. Set to true to pass the header, otherwise it is omitted.
+- `max_age` (of type `int?`, which defaults to `null`): Configures the Access-Control-Max-Age CORS header. Set to an integer to pass the header, otherwise it is omitted.
+- `preflight_continue` (of type `bool`, which defaults to `false`): Pass the CORS preflight response to the nexnhandler.
+- `options_status_code` (of type `int`, which defaults to `204`): Provides a status code to use for successful OPTIONS requests, since some legacy browsers (IE11, various SmartTVs) choke on 204.
+
+### `server.harbor`
+
+Start an interface for the "telnet" server over http.
+
+Type:
+
+```
+(?transport : http_transport
+ .{default_port : int, name : string, protocol : string}, ?port : int,
+ ?uri : string) -> unit
+```
+
+Arguments:
+
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{default_port=80, protocol="http", name="unix"}`): Http transport. Use `http.transport.ssl` or http.transport.secure_transport`, when available, to enable HTTPS output
+- `port` (of type `int`, which defaults to `8000`): Port of the server.
+- `uri` (of type `string`, which defaults to `"/telnet"`): URI of the server.
+
+## Metadata
+
+### `source.say_metadata`
+
+Append speech-synthesized tracks reading the metadata.
+
+Type:
+
+```
+(?id : string?, ?pattern : (([string * string]) -> string), source('a)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"source.say_metadata"`)
+- `pattern` (of type `([string * string]) -> string`, which defaults to `<fun>`): Pattern to use
+- `(unlabeled)` (of type `source('a)`): The source to use
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `cancel_pending` (of type `() -> unit`): Cancel any pending appended source.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `(?cancel_pending : bool) -> unit`): Skip the current track. Pending appended source are cancelled by default. Pass `cancel_pending=false` to keep it.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Audio processing
+
+### `accelerate`
+
+Accelerate a stream by dropping frames. This is useful for testing scripts.
+
+Type:
+
+```
+(?id : string?, ?randomize : {float}, ?ratio : {float}, source('a)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `randomize` (of type `{float}`, which defaults to `1.`): Randomization (0 means no randomization).
+- `ratio` (of type `{float}`, which defaults to `2.`): A value higher than 1 means speeding up.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `bass_boost`
+
+Add some bass to the sound.
+
+Type:
+
+```
+(?frequency : {float}, ?gain : {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `frequency` (of type `{float}`, which defaults to `200.`): Frequency below which sound is considered as bass.
+- `gain` (of type `{float}`, which defaults to `10.`): Amount of boosting (dB).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Source whose bass should be boosted
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `comb`
+
+Comb filter
+
+Type:
+
+```
+(?id : string?, ?delay : float, ?feedback : {float}, source(audio=pcm('a),
+ 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"comb"`): Force the value of the track ID.
+- `delay` (of type `float`, which defaults to `0.001`): Delay in seconds.
+- `feedback` (of type `{float}`, which defaults to `-6.`): Feedback coefficient in dB.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `compand`
+
+Compand the signal.
+
+Type:
+
+```
+(?id : string?, ?mu : float, source(audio=source(pcm('a)), 'b)) ->
+source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"compand"`): Force the value of the track ID.
+- `mu` (of type `float`, which defaults to `1.`)
+- `(unlabeled)` (of type `source(audio=source(pcm('a)), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `compress`
+
+Compress the signal.
+
+Type:
+
+```
+(?id : string?, ?attack : {float}, ?release : {float}, ?lookahead : {float},
+ ?threshold : {float}, ?track_sensitive : bool, ?knee : {float},
+ ?pre_gain : {float}, ?gain : {float}, ?ratio : {float}, ?window : {float},
+ ?wet : {float}, source(audio=pcm('a), 'b)) -> source(audio=pcm('a)
+.{gain? : never, rms? : never}, 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `attack` (of type `{float}`, which defaults to `50.`): Attack time (ms).
+- `release` (of type `{float}`, which defaults to `400.`): Release time (ms).
+- `lookahead` (of type `{float}`, which defaults to `0.`): Lookahead (ms).
+- `threshold` (of type `{float}`, which defaults to `-10.`): Threshold level (dB).
+- `track_sensitive` (of type `bool`, which defaults to `false`): Reset on every track.
+- `knee` (of type `{float}`, which defaults to `1.`): Knee width (dB).
+- `pre_gain` (of type `{float}`, which defaults to `0.`): Pre-amplification (dB).
+- `gain` (of type `{float}`, which defaults to `0.`): Post-amplification (dB).
+- `ratio` (of type `{float}`, which defaults to `2.`): Gain reduction ratio (reduction is ratio:1). Must be at least 1.
+- `window` (of type `{float}`, which defaults to `0.`): RMS window length (second). `0.` means peak mode.
+- `wet` (of type `{float}`, which defaults to `1.`): How much of input sound to output (between 0 and 1, 0 means only original sound, 1 means only compressed sound).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `compress.exponential`
+
+Exponential compressor.
+
+Type:
+
+```
+(?id : string?, ?mu : float, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `mu` (of type `float`, which defaults to `2.`): Exponential compression factor, typically greater than 1.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `compress.multiband`
+
+Multiband compression. The list in argument specifies
+- the `frequency` below which we should apply compression (it is above previous band)
+- the `attack` time (ms)
+- the `release` time (ms)
+- the compression `ratio`
+- the `threshold` for compression
+- the `gain` for the band
+
+Type:
+
+```
+(?limit : bool, ?wet : {float}, source(audio=pcm('a), 'b),
+ [
+  {
+    attack : {float},
+    frequency : {float},
+    gain : {float},
+    ratio : {float},
+    release : {float},
+    threshold : {float}
+  }]) -> source(audio=pcm('a).{gain? : never, rms? : never}, 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `limit` (of type `bool`, which defaults to `true`): Also apply limiting to bands.
+- `wet` (of type `{float}`, which defaults to `1.`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Parameters for compression bands.
+- `(unlabeled)` (of type `[
+ {
+   attack : {float},
+   frequency : {float},
+   gain : {float},
+   ratio : {float},
+   release : {float},
+   threshold : {float}
+ }]`): Source on which multiband compression should be applied.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `dry_wet`
+
+Mix between dry and wet sources. Useful for testing effects. Typically:
+```
+c = interactive.float("wetness", min=0., max=1., 1.)
+s = dry_wet(c, s, effect(s))
+```
+and vary `c` to hear the difference between the source without and with the effect.
+
+Type:
+
+```
+(?power : bool, {float}, source('a), source('a)) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `power` (of type `bool`, which defaults to `false`): If `true` use constant power mixing.
+- `(unlabeled)` (of type `{float}`): Wetness coefficient, from 0 (fully dry) to  1 (fully wet).
+- `(unlabeled)` (of type `source('a) where 'a is a set of internal tracks`): Dry source.
+- `(unlabeled)` (of type `source('a) where 'a is a set of internal tracks`): Wet source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.low_high`
+
+A bandpass filter obtained by chaining a low-pass and a high-pass filter.
+
+Type:
+
+```
+(?id : string?, low : {float}, high : {float}, ?q : float, source('a)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `low` (of type `{float}`): Lower frequency of the bandpass filter.
+- `high` (of type `{float}`): Higher frequency of the bandpass filter.
+- `q` (of type `float`, which defaults to `1.`): Q factor.
+- `(unlabeled)` (of type `source('a)`): Force the value of the source ID.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `helium`
+
+Increases the pitch, making voices sound like on helium.
+
+Type:
+
+```
+(source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `limit`
+
+A limiter. This is a `compress` with tweaked parameters.
+
+Type:
+
+```
+(?id : string?, ?attack : {float}, ?release : {float}, ?ratio : {float},
+ ?threshold : {float}, ?pre_gain : {float}, ?gain : {float},
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a)
+.{gain? : never, rms? : never}, 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `attack` (of type `{float}`, which defaults to `50.`)
+- `release` (of type `{float}`, which defaults to `200.`)
+- `ratio` (of type `{float}`, which defaults to `20.`)
+- `threshold` (of type `{float}`, which defaults to `-2.`)
+- `pre_gain` (of type `{float}`, which defaults to `0.`)
+- `gain` (of type `{float}`, which defaults to `0.`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mic_filter`
+
+Remove low frequencies often produced by microphones.
+
+Type:
+
+```
+(?frequency : float, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `frequency` (of type `float`, which defaults to `200.`): Frequency under which sound should be lowered.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mix`
+
+Mixing table controllable via source methods and optional server/telnet commands.
+
+Type:
+
+```
+(?id : string?, ?namespace : string?, ?register_server_commands : bool,
+ [source(audio=pcm('a), 'b).{id? : string}]) -> source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `namespace` (of type `string?`, which defaults to `null`): Namespace for the source commands. Uses source ID when `null`.
+- `register_server_commands` (of type `bool`, which defaults to `true`): Register corresponding server commands
+- `(unlabeled)` (of type `[source(audio=pcm('a), 'b).{id? : string}]
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `inputs` (of type `[
+ {
+   id : string,
+   selected : (() -> bool)
+   .{set : (bool) -> unit
+   },
+   single : (() -> bool)
+   .{set : (bool) -> unit
+   },
+   source : source(audio=pcm('B),
+   'A)
+   .{id? : string
+   },
+   volume : (() -> float)
+   .{set : (float) -> unit
+   }
+ }]
+where
+  'A is a set of tracks to be muxed into a source and a set of internal tracks`): 
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `nrj`
+
+Compress and normalize, producing a more uniform and "full" sound.
+
+Type:
+
+```
+(source(audio=pcm('a), 'b)) -> source(audio=pcm('a)
+.{gain? : never, rms? : never}, 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): 
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `sky`
+
+Multiband-compression.
+
+Type:
+
+```
+(source(audio=pcm('a), 'b)) -> source(audio=pcm('a)
+.{gain? : never, rms? : never}, 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / FFmpeg filter
+
+### `ffmpeg.filter.a3dscope`
+
+Ffmpeg filter: Convert input audio to 3d scope video output.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?size : string?, ?s : string?, ?fov : float?,
+ ?roll : float?, ?pitch : float?, ?yaw : float?, ?xzoom : float?,
+ ?yzoom : float?, ?zzoom : float?, ?xpos : float?, ?ypos : float?,
+ ?zpos : float?, ?length : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `fov` (of type `float?`, which defaults to `null`): set camera FoV. (default: 90.)
+- `roll` (of type `float?`, which defaults to `null`): set camera roll. (default: 0.)
+- `pitch` (of type `float?`, which defaults to `null`): set camera pitch. (default: 0.)
+- `yaw` (of type `float?`, which defaults to `null`): set camera yaw. (default: 0.)
+- `xzoom` (of type `float?`, which defaults to `null`): set camera zoom. (default: 1.)
+- `yzoom` (of type `float?`, which defaults to `null`): set camera zoom. (default: 1.)
+- `zzoom` (of type `float?`, which defaults to `null`): set camera zoom. (default: 1.)
+- `xpos` (of type `float?`, which defaults to `null`): set camera position. (default: 0.)
+- `ypos` (of type `float?`, which defaults to `null`): set camera position. (default: 0.)
+- `zpos` (of type `float?`, which defaults to `null`): set camera position. (default: 0.)
+- `length` (of type `int?`, which defaults to `null`): set length. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.a3dscope.create`
+
+Ffmpeg filter: Convert input audio to 3d scope video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?size : string?, ?s : string?, ?fov : float?,
+ ?roll : float?, ?pitch : float?, ?yaw : float?, ?xzoom : float?,
+ ?yzoom : float?, ?zzoom : float?, ?xpos : float?, ?ypos : float?,
+ ?zpos : float?, ?length : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `fov` (of type `float?`, which defaults to `null`): set camera FoV. (default: 90.)
+- `roll` (of type `float?`, which defaults to `null`): set camera roll. (default: 0.)
+- `pitch` (of type `float?`, which defaults to `null`): set camera pitch. (default: 0.)
+- `yaw` (of type `float?`, which defaults to `null`): set camera yaw. (default: 0.)
+- `xzoom` (of type `float?`, which defaults to `null`): set camera zoom. (default: 1.)
+- `yzoom` (of type `float?`, which defaults to `null`): set camera zoom. (default: 1.)
+- `zzoom` (of type `float?`, which defaults to `null`): set camera zoom. (default: 1.)
+- `xpos` (of type `float?`, which defaults to `null`): set camera position. (default: 0.)
+- `ypos` (of type `float?`, which defaults to `null`): set camera position. (default: 0.)
+- `zpos` (of type `float?`, which defaults to `null`): set camera position. (default: 0.)
+- `length` (of type `int?`, which defaults to `null`): set length. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.abench`
+
+Ffmpeg filter: Benchmark part of a filtergraph.
+
+Type:
+
+```
+(?action : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `action` (of type `int?`, which defaults to `null`): set action. (default: 0, possible values: 0 (start), 1 (stop))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.abench.create`
+
+Ffmpeg filter: Benchmark part of a filtergraph.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?action : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `action` (of type `int?`, which defaults to `null`): set action. (default: 0, possible values: 0 (start), 1 (stop))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.abitscope`
+
+Ffmpeg filter: Convert input audio to audio bit scope video output.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?size : string?, ?s : string?,
+ ?colors : string?, ?mode : int?, ?m : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 1024x256)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 1024x256)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `mode` (of type `int?`, which defaults to `null`): set output mode. (default: 0, possible values: 0 (bars), 1 (trace))
+- `m` (of type `int?`, which defaults to `null`): set output mode. (default: 0, possible values: 0 (bars), 1 (trace))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.abitscope.create`
+
+Ffmpeg filter: Convert input audio to audio bit scope video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?size : string?, ?s : string?,
+ ?colors : string?, ?mode : int?, ?m : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 1024x256)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 1024x256)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `mode` (of type `int?`, which defaults to `null`): set output mode. (default: 0, possible values: 0 (bars), 1 (trace))
+- `m` (of type `int?`, which defaults to `null`): set output mode. (default: 0, possible values: 0 (bars), 1 (trace))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acompressor`
+
+Ffmpeg filter: Audio compressor.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?threshold : float?, ?ratio : float?,
+ ?attack : float?, ?release : float?, ?makeup : float?, ?knee : float?,
+ ?link : int?, ?detection : int?, ?level_sc : float?, ?mix : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set make up gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.82843)
+- `link` (of type `int?`, which defaults to `null`): set link type. (default: 0, possible values: 0 (average), 1 (maximum))
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acompressor.create`
+
+Ffmpeg filter: Audio compressor.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?threshold : float?, ?ratio : float?,
+ ?attack : float?, ?release : float?, ?makeup : float?, ?knee : float?,
+ ?link : int?, ?detection : int?, ?level_sc : float?, ?mix : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set make up gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.82843)
+- `link` (of type `int?`, which defaults to `null`): set link type. (default: 0, possible values: 0 (average), 1 (maximum))
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acontrast`
+
+Ffmpeg filter: Simple audio dynamic range compression/expansion filter.
+
+Type:
+
+```
+(?contrast : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `contrast` (of type `float?`, which defaults to `null`): set contrast. (default: 33.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acontrast.create`
+
+Ffmpeg filter: Simple audio dynamic range compression/expansion filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?contrast : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `contrast` (of type `float?`, which defaults to `null`): set contrast. (default: 33.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acopy`
+
+Ffmpeg filter: Copy the input audio unchanged to the output.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acopy.create`
+
+Ffmpeg filter: Copy the input audio unchanged to the output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acrossfade`
+
+Ffmpeg filter: Cross fade two input audio streams.
+
+Type:
+
+```
+(?nb_samples : int?, ?ns : int?, ?duration : int?, ?d : int?,
+ ?overlap : bool?, ?o : bool?, ?curve1 : int?, ?c1 : int?, ?curve2 : int?,
+ ?c2 : int?, ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `nb_samples` (of type `int?`, which defaults to `null`): set number of samples for cross fade duration. (default: 44100)
+- `ns` (of type `int?`, which defaults to `null`): set number of samples for cross fade duration. (default: 44100)
+- `duration` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 0)
+- `overlap` (of type `bool?`, which defaults to `null`): overlap 1st stream end with 2nd stream start. (default: true)
+- `o` (of type `bool?`, which defaults to `null`): overlap 1st stream end with 2nd stream start. (default: true)
+- `curve1` (of type `int?`, which defaults to `null`): set fade curve type for 1st stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `c1` (of type `int?`, which defaults to `null`): set fade curve type for 1st stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `curve2` (of type `int?`, which defaults to `null`): set fade curve type for 2nd stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `c2` (of type `int?`, which defaults to `null`): set fade curve type for 2nd stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acrossfade.create`
+
+Ffmpeg filter: Cross fade two input audio streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?nb_samples : int?, ?ns : int?, ?duration : int?, ?d : int?,
+ ?overlap : bool?, ?o : bool?, ?curve1 : int?, ?c1 : int?, ?curve2 : int?,
+ ?c2 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `nb_samples` (of type `int?`, which defaults to `null`): set number of samples for cross fade duration. (default: 44100)
+- `ns` (of type `int?`, which defaults to `null`): set number of samples for cross fade duration. (default: 44100)
+- `duration` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 0)
+- `overlap` (of type `bool?`, which defaults to `null`): overlap 1st stream end with 2nd stream start. (default: true)
+- `o` (of type `bool?`, which defaults to `null`): overlap 1st stream end with 2nd stream start. (default: true)
+- `curve1` (of type `int?`, which defaults to `null`): set fade curve type for 1st stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `c1` (of type `int?`, which defaults to `null`): set fade curve type for 1st stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `curve2` (of type `int?`, which defaults to `null`): set fade curve type for 2nd stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `c2` (of type `int?`, which defaults to `null`): set fade curve type for 2nd stream. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acrossover`
+
+Ffmpeg filter: Split audio into per-bands streams. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?split : string?, ?order : int?, ?level : float?, ?gain : string?,
+ ?precision : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `split` (of type `string?`, which defaults to `null`): set split frequencies. (default: 500)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 1, possible values: 0 (2nd), 1 (4th), 2 (6th), 3 (8th), 4 (10th), 5 (12th), 6 (14th), 7 (16th), 8 (18th), 9 (20th))
+- `level` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `gain` (of type `string?`, which defaults to `null`): set output bands gain. (default: 1.f)
+- `precision` (of type `int?`, which defaults to `null`): set processing precision. (default: 0, possible values: 0 (auto), 1 (float), 2 (double))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acrossover.create`
+
+Ffmpeg filter: Split audio into per-bands streams. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?split : string?, ?order : int?, ?level : float?, ?gain : string?,
+ ?precision : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `split` (of type `string?`, which defaults to `null`): set split frequencies. (default: 500)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 1, possible values: 0 (2nd), 1 (4th), 2 (6th), 3 (8th), 4 (10th), 5 (12th), 6 (14th), 7 (16th), 8 (18th), 9 (20th))
+- `level` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `gain` (of type `string?`, which defaults to `null`): set output bands gain. (default: 1.f)
+- `precision` (of type `int?`, which defaults to `null`): set processing precision. (default: 0, possible values: 0 (auto), 1 (float), 2 (double))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acrusher`
+
+Ffmpeg filter: Reduce audio bit resolution.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?bits : float?, ?mix : float?,
+ ?mode : int?, ?dc : float?, ?aa : float?, ?samples : float?, ?lfo : bool?,
+ ?lforange : float?, ?lforate : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `bits` (of type `float?`, which defaults to `null`): set bit reduction. (default: 8.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 0.5)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (lin), 1 (log))
+- `dc` (of type `float?`, which defaults to `null`): set DC. (default: 1.)
+- `aa` (of type `float?`, which defaults to `null`): set anti-aliasing. (default: 0.5)
+- `samples` (of type `float?`, which defaults to `null`): set sample reduction. (default: 1.)
+- `lfo` (of type `bool?`, which defaults to `null`): enable LFO. (default: false)
+- `lforange` (of type `float?`, which defaults to `null`): set LFO depth. (default: 20.)
+- `lforate` (of type `float?`, which defaults to `null`): set LFO rate. (default: 0.3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acrusher.create`
+
+Ffmpeg filter: Reduce audio bit resolution.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?bits : float?, ?mix : float?,
+ ?mode : int?, ?dc : float?, ?aa : float?, ?samples : float?, ?lfo : bool?,
+ ?lforange : float?, ?lforate : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `bits` (of type `float?`, which defaults to `null`): set bit reduction. (default: 8.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 0.5)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (lin), 1 (log))
+- `dc` (of type `float?`, which defaults to `null`): set DC. (default: 1.)
+- `aa` (of type `float?`, which defaults to `null`): set anti-aliasing. (default: 0.5)
+- `samples` (of type `float?`, which defaults to `null`): set sample reduction. (default: 1.)
+- `lfo` (of type `bool?`, which defaults to `null`): enable LFO. (default: false)
+- `lforange` (of type `float?`, which defaults to `null`): set LFO depth. (default: 20.)
+- `lforate` (of type `float?`, which defaults to `null`): set LFO rate. (default: 0.3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.acue`
+
+Ffmpeg filter: Delay filtering to match a cue.
+
+Type:
+
+```
+(?cue : int?, ?preroll : int?, ?buffer : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `cue` (of type `int?`, which defaults to `null`): cue unix timestamp in microseconds. (default: 0)
+- `preroll` (of type `int?`, which defaults to `null`): preroll duration in seconds. (default: 0)
+- `buffer` (of type `int?`, which defaults to `null`): buffer duration in seconds. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.acue.create`
+
+Ffmpeg filter: Delay filtering to match a cue.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cue : int?, ?preroll : int?, ?buffer : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cue` (of type `int?`, which defaults to `null`): cue unix timestamp in microseconds. (default: 0)
+- `preroll` (of type `int?`, which defaults to `null`): preroll duration in seconds. (default: 0)
+- `buffer` (of type `int?`, which defaults to `null`): buffer duration in seconds. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.addroi`
+
+Ffmpeg filter: Add region of interest to frame.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?w : string?, ?h : string?, ?qoffset : string?,
+ ?clear : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): Region distance from left edge of frame.. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): Region distance from top edge of frame.. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): Region width.. (default: 0)
+- `h` (of type `string?`, which defaults to `null`): Region height.. (default: 0)
+- `qoffset` (of type `string?`, which defaults to `null`): Quantisation offset to apply in the region.. (default: -1/10)
+- `clear` (of type `bool?`, which defaults to `null`): Remove any existing regions of interest before adding the new one.. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.addroi.create`
+
+Ffmpeg filter: Add region of interest to frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?w : string?, ?h : string?, ?qoffset : string?,
+ ?clear : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): Region distance from left edge of frame.. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): Region distance from top edge of frame.. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): Region width.. (default: 0)
+- `h` (of type `string?`, which defaults to `null`): Region height.. (default: 0)
+- `qoffset` (of type `string?`, which defaults to `null`): Quantisation offset to apply in the region.. (default: -1/10)
+- `clear` (of type `bool?`, which defaults to `null`): Remove any existing regions of interest before adding the new one.. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adeclick`
+
+Ffmpeg filter: Remove impulsive noise from input audio.
+
+Type:
+
+```
+(?window : float?, ?w : float?, ?overlap : float?, ?o : float?,
+ ?arorder : float?, ?a : float?, ?threshold : float?, ?t : float?,
+ ?burst : float?, ?b : float?, ?method : int?, ?m : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `window` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `w` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `o` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `arorder` (of type `float?`, which defaults to `null`): set autoregression order. (default: 2.)
+- `a` (of type `float?`, which defaults to `null`): set autoregression order. (default: 2.)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 2.)
+- `t` (of type `float?`, which defaults to `null`): set threshold. (default: 2.)
+- `burst` (of type `float?`, which defaults to `null`): set burst fusion. (default: 2.)
+- `b` (of type `float?`, which defaults to `null`): set burst fusion. (default: 2.)
+- `method` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `m` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adeclick.create`
+
+Ffmpeg filter: Remove impulsive noise from input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?window : float?, ?w : float?, ?overlap : float?, ?o : float?,
+ ?arorder : float?, ?a : float?, ?threshold : float?, ?t : float?,
+ ?burst : float?, ?b : float?, ?method : int?, ?m : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `window` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `w` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `o` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `arorder` (of type `float?`, which defaults to `null`): set autoregression order. (default: 2.)
+- `a` (of type `float?`, which defaults to `null`): set autoregression order. (default: 2.)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 2.)
+- `t` (of type `float?`, which defaults to `null`): set threshold. (default: 2.)
+- `burst` (of type `float?`, which defaults to `null`): set burst fusion. (default: 2.)
+- `b` (of type `float?`, which defaults to `null`): set burst fusion. (default: 2.)
+- `method` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `m` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adeclip`
+
+Ffmpeg filter: Remove clipping from input audio.
+
+Type:
+
+```
+(?window : float?, ?w : float?, ?overlap : float?, ?o : float?,
+ ?arorder : float?, ?a : float?, ?threshold : float?, ?t : float?,
+ ?hsize : int?, ?n : int?, ?method : int?, ?m : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `window` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `w` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `o` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `arorder` (of type `float?`, which defaults to `null`): set autoregression order. (default: 8.)
+- `a` (of type `float?`, which defaults to `null`): set autoregression order. (default: 8.)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 10.)
+- `t` (of type `float?`, which defaults to `null`): set threshold. (default: 10.)
+- `hsize` (of type `int?`, which defaults to `null`): set histogram size. (default: 1000)
+- `n` (of type `int?`, which defaults to `null`): set histogram size. (default: 1000)
+- `method` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `m` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adeclip.create`
+
+Ffmpeg filter: Remove clipping from input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?window : float?, ?w : float?, ?overlap : float?, ?o : float?,
+ ?arorder : float?, ?a : float?, ?threshold : float?, ?t : float?,
+ ?hsize : int?, ?n : int?, ?method : int?, ?m : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `window` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `w` (of type `float?`, which defaults to `null`): set window size. (default: 55.)
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `o` (of type `float?`, which defaults to `null`): set window overlap. (default: 75.)
+- `arorder` (of type `float?`, which defaults to `null`): set autoregression order. (default: 8.)
+- `a` (of type `float?`, which defaults to `null`): set autoregression order. (default: 8.)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 10.)
+- `t` (of type `float?`, which defaults to `null`): set threshold. (default: 10.)
+- `hsize` (of type `int?`, which defaults to `null`): set histogram size. (default: 1000)
+- `n` (of type `int?`, which defaults to `null`): set histogram size. (default: 1000)
+- `method` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `m` (of type `int?`, which defaults to `null`): set overlap method. (default: 0, possible values: 0 (add), 0 (a), 1 (save), 1 (s))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adecorrelate`
+
+Ffmpeg filter: Apply decorrelation to input audio.
+
+Type:
+
+```
+(?stages : int?, ?seed : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `stages` (of type `int?`, which defaults to `null`): set filtering stages. (default: 6)
+- `seed` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adecorrelate.create`
+
+Ffmpeg filter: Apply decorrelation to input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?stages : int?, ?seed : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `stages` (of type `int?`, which defaults to `null`): set filtering stages. (default: 6)
+- `seed` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adelay`
+
+Ffmpeg filter: Delay one or more audio channels.
+
+Type:
+
+```
+(?delays : string?, ?all : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `delays` (of type `string?`, which defaults to `null`): set list of delays for each channel
+- `all` (of type `bool?`, which defaults to `null`): use last available delay for remained channels. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adelay.create`
+
+Ffmpeg filter: Delay one or more audio channels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?delays : string?, ?all : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `delays` (of type `string?`, which defaults to `null`): set list of delays for each channel
+- `all` (of type `bool?`, which defaults to `null`): use last available delay for remained channels. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adenorm`
+
+Ffmpeg filter: Remedy denormals by adding extremely low-level noise.
+
+Type:
+
+```
+(?level : float?, ?type : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level` (of type `float?`, which defaults to `null`): set level. (default: -351.)
+- `type` (of type `int?`, which defaults to `null`): set type. (default: 0, possible values: 0 (dc), 1 (ac), 2 (square), 3 (pulse))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adenorm.create`
+
+Ffmpeg filter: Remedy denormals by adding extremely low-level noise.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level : float?, ?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level` (of type `float?`, which defaults to `null`): set level. (default: -351.)
+- `type` (of type `int?`, which defaults to `null`): set type. (default: 0, possible values: 0 (dc), 1 (ac), 2 (square), 3 (pulse))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aderivative`
+
+Ffmpeg filter: Compute derivative of input audio.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aderivative.create`
+
+Ffmpeg filter: Compute derivative of input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adrawgraph`
+
+Ffmpeg filter: Draw a graph using input audio metadata.
+
+Type:
+
+```
+(?m1 : string?, ?fg1 : string?, ?m2 : string?, ?fg2 : string?, ?m3 : string?,
+ ?fg3 : string?, ?m4 : string?, ?fg4 : string?, ?bg : string?, ?min : float?,
+ ?max : float?, ?mode : int?, ?slide : int?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `m1` (of type `string?`, which defaults to `null`): set 1st metadata key. (default: )
+- `fg1` (of type `string?`, which defaults to `null`): set 1st foreground color expression. (default: 0xffff0000)
+- `m2` (of type `string?`, which defaults to `null`): set 2nd metadata key. (default: )
+- `fg2` (of type `string?`, which defaults to `null`): set 2nd foreground color expression. (default: 0xff00ff00)
+- `m3` (of type `string?`, which defaults to `null`): set 3rd metadata key. (default: )
+- `fg3` (of type `string?`, which defaults to `null`): set 3rd foreground color expression. (default: 0xffff00ff)
+- `m4` (of type `string?`, which defaults to `null`): set 4th metadata key. (default: )
+- `fg4` (of type `string?`, which defaults to `null`): set 4th foreground color expression. (default: 0xffffff00)
+- `bg` (of type `string?`, which defaults to `null`): set background color. (default: white)
+- `min` (of type `float?`, which defaults to `null`): set minimal value. (default: -1.)
+- `max` (of type `float?`, which defaults to `null`): set maximal value. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set graph mode. (default: 2, possible values: 0 (bar), 1 (dot), 2 (line))
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 0, possible values: 0 (frame), 1 (replace), 2 (scroll), 3 (rscroll), 4 (picture))
+- `size` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `s` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adrawgraph.create`
+
+Ffmpeg filter: Draw a graph using input audio metadata.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?m1 : string?, ?fg1 : string?, ?m2 : string?, ?fg2 : string?, ?m3 : string?,
+ ?fg3 : string?, ?m4 : string?, ?fg4 : string?, ?bg : string?, ?min : float?,
+ ?max : float?, ?mode : int?, ?slide : int?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `m1` (of type `string?`, which defaults to `null`): set 1st metadata key. (default: )
+- `fg1` (of type `string?`, which defaults to `null`): set 1st foreground color expression. (default: 0xffff0000)
+- `m2` (of type `string?`, which defaults to `null`): set 2nd metadata key. (default: )
+- `fg2` (of type `string?`, which defaults to `null`): set 2nd foreground color expression. (default: 0xff00ff00)
+- `m3` (of type `string?`, which defaults to `null`): set 3rd metadata key. (default: )
+- `fg3` (of type `string?`, which defaults to `null`): set 3rd foreground color expression. (default: 0xffff00ff)
+- `m4` (of type `string?`, which defaults to `null`): set 4th metadata key. (default: )
+- `fg4` (of type `string?`, which defaults to `null`): set 4th foreground color expression. (default: 0xffffff00)
+- `bg` (of type `string?`, which defaults to `null`): set background color. (default: white)
+- `min` (of type `float?`, which defaults to `null`): set minimal value. (default: -1.)
+- `max` (of type `float?`, which defaults to `null`): set maximal value. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set graph mode. (default: 2, possible values: 0 (bar), 1 (dot), 2 (line))
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 0, possible values: 0 (frame), 1 (replace), 2 (scroll), 3 (rscroll), 4 (picture))
+- `size` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `s` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adrc`
+
+Ffmpeg filter: Audio Spectral Dynamic Range Controller.
+
+Type:
+
+```
+(?transfer : string?, ?attack : float?, ?release : float?,
+ ?channels : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `transfer` (of type `string?`, which defaults to `null`): set the transfer expression. (default: p)
+- `attack` (of type `float?`, which defaults to `null`): set the attack. (default: 50.)
+- `release` (of type `float?`, which defaults to `null`): set the release. (default: 100.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adrc.create`
+
+Ffmpeg filter: Audio Spectral Dynamic Range Controller.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?transfer : string?, ?attack : float?, ?release : float?,
+ ?channels : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `transfer` (of type `string?`, which defaults to `null`): set the transfer expression. (default: p)
+- `attack` (of type `float?`, which defaults to `null`): set the attack. (default: 50.)
+- `release` (of type `float?`, which defaults to `null`): set the release. (default: 100.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adynamicequalizer`
+
+Ffmpeg filter: Apply Dynamic Equalization of input audio.
+
+Type:
+
+```
+(?threshold : float?, ?dfrequency : float?, ?dqfactor : float?,
+ ?tfrequency : float?, ?tqfactor : float?, ?attack : float?,
+ ?release : float?, ?ratio : float?, ?makeup : float?, ?range : float?,
+ ?mode : int?, ?dftype : int?, ?tftype : int?, ?direction : int?,
+ ?auto : int?, ?precision : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set detection threshold. (default: 0.)
+- `dfrequency` (of type `float?`, which defaults to `null`): set detection frequency. (default: 1000.)
+- `dqfactor` (of type `float?`, which defaults to `null`): set detection Q factor. (default: 1.)
+- `tfrequency` (of type `float?`, which defaults to `null`): set target frequency. (default: 1000.)
+- `tqfactor` (of type `float?`, which defaults to `null`): set target Q factor. (default: 1.)
+- `attack` (of type `float?`, which defaults to `null`): set attack duration. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release duration. (default: 200.)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio factor. (default: 1.)
+- `makeup` (of type `float?`, which defaults to `null`): set makeup gain. (default: 0.)
+- `range` (of type `float?`, which defaults to `null`): set max gain. (default: 50.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: -1 (listen), 0 (cut), 1 (boost))
+- `dftype` (of type `int?`, which defaults to `null`): set detection filter type. (default: 0, possible values: 0 (bandpass), 1 (lowpass), 2 (highpass), 3 (peak))
+- `tftype` (of type `int?`, which defaults to `null`): set target filter type. (default: 0, possible values: 0 (bell), 1 (lowshelf), 2 (highshelf))
+- `direction` (of type `int?`, which defaults to `null`): set direction. (default: 0, possible values: 0 (downward), 1 (upward))
+- `auto` (of type `int?`, which defaults to `null`): set auto threshold. (default: -1, possible values: -1 (disabled), 0 (off), 1 (on))
+- `precision` (of type `int?`, which defaults to `null`): set processing precision. (default: 0, possible values: 0 (auto), 1 (float), 2 (double))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adynamicequalizer.create`
+
+Ffmpeg filter: Apply Dynamic Equalization of input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : float?, ?dfrequency : float?, ?dqfactor : float?,
+ ?tfrequency : float?, ?tqfactor : float?, ?attack : float?,
+ ?release : float?, ?ratio : float?, ?makeup : float?, ?range : float?,
+ ?mode : int?, ?dftype : int?, ?tftype : int?, ?direction : int?,
+ ?auto : int?, ?precision : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set detection threshold. (default: 0.)
+- `dfrequency` (of type `float?`, which defaults to `null`): set detection frequency. (default: 1000.)
+- `dqfactor` (of type `float?`, which defaults to `null`): set detection Q factor. (default: 1.)
+- `tfrequency` (of type `float?`, which defaults to `null`): set target frequency. (default: 1000.)
+- `tqfactor` (of type `float?`, which defaults to `null`): set target Q factor. (default: 1.)
+- `attack` (of type `float?`, which defaults to `null`): set attack duration. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release duration. (default: 200.)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio factor. (default: 1.)
+- `makeup` (of type `float?`, which defaults to `null`): set makeup gain. (default: 0.)
+- `range` (of type `float?`, which defaults to `null`): set max gain. (default: 50.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: -1 (listen), 0 (cut), 1 (boost))
+- `dftype` (of type `int?`, which defaults to `null`): set detection filter type. (default: 0, possible values: 0 (bandpass), 1 (lowpass), 2 (highpass), 3 (peak))
+- `tftype` (of type `int?`, which defaults to `null`): set target filter type. (default: 0, possible values: 0 (bell), 1 (lowshelf), 2 (highshelf))
+- `direction` (of type `int?`, which defaults to `null`): set direction. (default: 0, possible values: 0 (downward), 1 (upward))
+- `auto` (of type `int?`, which defaults to `null`): set auto threshold. (default: -1, possible values: -1 (disabled), 0 (off), 1 (on))
+- `precision` (of type `int?`, which defaults to `null`): set processing precision. (default: 0, possible values: 0 (auto), 1 (float), 2 (double))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.adynamicsmooth`
+
+Ffmpeg filter: Apply Dynamic Smoothing of input audio.
+
+Type:
+
+```
+(?sensitivity : float?, ?basefreq : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sensitivity` (of type `float?`, which defaults to `null`): set smooth sensitivity. (default: 2.)
+- `basefreq` (of type `float?`, which defaults to `null`): set base frequency. (default: 22050.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.adynamicsmooth.create`
+
+Ffmpeg filter: Apply Dynamic Smoothing of input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sensitivity : float?, ?basefreq : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sensitivity` (of type `float?`, which defaults to `null`): set smooth sensitivity. (default: 2.)
+- `basefreq` (of type `float?`, which defaults to `null`): set base frequency. (default: 22050.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aecho`
+
+Ffmpeg filter: Add echoing to the audio.
+
+Type:
+
+```
+(?in_gain : float?, ?out_gain : float?, ?delays : string?, ?decays : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `in_gain` (of type `float?`, which defaults to `null`): set signal input gain. (default: 0.6)
+- `out_gain` (of type `float?`, which defaults to `null`): set signal output gain. (default: 0.3)
+- `delays` (of type `string?`, which defaults to `null`): set list of signal delays. (default: 1000)
+- `decays` (of type `string?`, which defaults to `null`): set list of signal decays. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aecho.create`
+
+Ffmpeg filter: Add echoing to the audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?in_gain : float?, ?out_gain : float?, ?delays : string?, ?decays : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `in_gain` (of type `float?`, which defaults to `null`): set signal input gain. (default: 0.6)
+- `out_gain` (of type `float?`, which defaults to `null`): set signal output gain. (default: 0.3)
+- `delays` (of type `string?`, which defaults to `null`): set list of signal delays. (default: 1000)
+- `decays` (of type `string?`, which defaults to `null`): set list of signal decays. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aemphasis`
+
+Ffmpeg filter: Audio emphasis.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?mode : int?, ?type : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set filter mode. (default: 0, possible values: 0 (reproduction), 1 (production))
+- `type` (of type `int?`, which defaults to `null`): set filter type. (default: 4, possible values: 0 (col), 1 (emi), 2 (bsi), 3 (riaa), 4 (cd), 5 (50fm), 6 (75fm), 7 (50kf), 8 (75kf))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aemphasis.create`
+
+Ffmpeg filter: Audio emphasis.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?mode : int?, ?type : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set filter mode. (default: 0, possible values: 0 (reproduction), 1 (production))
+- `type` (of type `int?`, which defaults to `null`): set filter type. (default: 4, possible values: 0 (col), 1 (emi), 2 (bsi), 3 (riaa), 4 (cd), 5 (50fm), 6 (75fm), 7 (50kf), 8 (75kf))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aeval`
+
+Ffmpeg filter: Filter audio signal according to a specified expression.
+
+Type:
+
+```
+(?exprs : string?, ?channel_layout : string?, ?c : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `exprs` (of type `string?`, which defaults to `null`): set the '|'-separated list of channels expressions
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel layout
+- `c` (of type `string?`, which defaults to `null`): set channel layout
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aeval.create`
+
+Ffmpeg filter: Filter audio signal according to a specified expression.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?exprs : string?, ?channel_layout : string?, ?c : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `exprs` (of type `string?`, which defaults to `null`): set the '|'-separated list of channels expressions
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel layout
+- `c` (of type `string?`, which defaults to `null`): set channel layout
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aevalsrc`
+
+Ffmpeg filter: Generate an audio signal generated by an expression.
+
+Type:
+
+```
+(?exprs : string?, ?nb_samples : int?, ?n : int?, ?sample_rate : string?,
+ ?s : string?, ?duration : int?, ?d : int?, ?channel_layout : string?,
+ ?c : string?, ffmpeg.filter.graph) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `exprs` (of type `string?`, which defaults to `null`): set the '|'-separated list of channels expressions
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `sample_rate` (of type `string?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `s` (of type `string?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `duration` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel layout
+- `c` (of type `string?`, which defaults to `null`): set channel layout
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.aevalsrc.create`
+
+Ffmpeg filter: Generate an audio signal generated by an expression.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?exprs : string?, ?nb_samples : int?, ?n : int?, ?sample_rate : string?,
+ ?s : string?, ?duration : int?, ?d : int?, ?channel_layout : string?,
+ ?c : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `exprs` (of type `string?`, which defaults to `null`): set the '|'-separated list of channels expressions
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `sample_rate` (of type `string?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `s` (of type `string?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `duration` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel layout
+- `c` (of type `string?`, which defaults to `null`): set channel layout
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aexciter`
+
+Ffmpeg filter: Enhance high frequency part of audio.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?amount : float?, ?drive : float?,
+ ?blend : float?, ?freq : float?, ?ceil : float?, ?listen : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `amount` (of type `float?`, which defaults to `null`): set amount. (default: 1.)
+- `drive` (of type `float?`, which defaults to `null`): set harmonics. (default: 8.5)
+- `blend` (of type `float?`, which defaults to `null`): set blend harmonics. (default: 0.)
+- `freq` (of type `float?`, which defaults to `null`): set scope. (default: 7500.)
+- `ceil` (of type `float?`, which defaults to `null`): set ceiling. (default: 9999.)
+- `listen` (of type `bool?`, which defaults to `null`): enable listen mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aexciter.create`
+
+Ffmpeg filter: Enhance high frequency part of audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?amount : float?, ?drive : float?,
+ ?blend : float?, ?freq : float?, ?ceil : float?, ?listen : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `amount` (of type `float?`, which defaults to `null`): set amount. (default: 1.)
+- `drive` (of type `float?`, which defaults to `null`): set harmonics. (default: 8.5)
+- `blend` (of type `float?`, which defaults to `null`): set blend harmonics. (default: 0.)
+- `freq` (of type `float?`, which defaults to `null`): set scope. (default: 7500.)
+- `ceil` (of type `float?`, which defaults to `null`): set ceiling. (default: 9999.)
+- `listen` (of type `bool?`, which defaults to `null`): enable listen mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afade`
+
+Ffmpeg filter: Fade in/out input audio.
+
+Type:
+
+```
+(?type : int?, ?t : int?, ?start_sample : int?, ?ss : int?,
+ ?nb_samples : int?, ?ns : int?, ?start_time : int?, ?st : int?,
+ ?duration : int?, ?d : int?, ?curve : int?, ?c : int?, ?silence : float?,
+ ?unity : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `t` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `start_sample` (of type `int?`, which defaults to `null`): set number of first sample to start fading. (default: 0)
+- `ss` (of type `int?`, which defaults to `null`): set number of first sample to start fading. (default: 0)
+- `nb_samples` (of type `int?`, which defaults to `null`): set number of samples for fade duration. (default: 44100)
+- `ns` (of type `int?`, which defaults to `null`): set number of samples for fade duration. (default: 44100)
+- `start_time` (of type `int?`, which defaults to `null`): set time to start fading. (default: 0)
+- `st` (of type `int?`, which defaults to `null`): set time to start fading. (default: 0)
+- `duration` (of type `int?`, which defaults to `null`): set fade duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set fade duration. (default: 0)
+- `curve` (of type `int?`, which defaults to `null`): set fade curve type. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `c` (of type `int?`, which defaults to `null`): set fade curve type. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `silence` (of type `float?`, which defaults to `null`): set the silence gain. (default: 0.)
+- `unity` (of type `float?`, which defaults to `null`): set the unity gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.afade.create`
+
+Ffmpeg filter: Fade in/out input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?type : int?, ?t : int?, ?start_sample : int?, ?ss : int?,
+ ?nb_samples : int?, ?ns : int?, ?start_time : int?, ?st : int?,
+ ?duration : int?, ?d : int?, ?curve : int?, ?c : int?, ?silence : float?,
+ ?unity : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `t` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `start_sample` (of type `int?`, which defaults to `null`): set number of first sample to start fading. (default: 0)
+- `ss` (of type `int?`, which defaults to `null`): set number of first sample to start fading. (default: 0)
+- `nb_samples` (of type `int?`, which defaults to `null`): set number of samples for fade duration. (default: 44100)
+- `ns` (of type `int?`, which defaults to `null`): set number of samples for fade duration. (default: 44100)
+- `start_time` (of type `int?`, which defaults to `null`): set time to start fading. (default: 0)
+- `st` (of type `int?`, which defaults to `null`): set time to start fading. (default: 0)
+- `duration` (of type `int?`, which defaults to `null`): set fade duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set fade duration. (default: 0)
+- `curve` (of type `int?`, which defaults to `null`): set fade curve type. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `c` (of type `int?`, which defaults to `null`): set fade curve type. (default: 0, possible values: -1 (nofade), 0 (tri), 1 (qsin), 2 (esin), 3 (hsin), 4 (log), 5 (ipar), 6 (qua), 7 (cub), 8 (squ), 9 (cbr), 10 (par), 11 (exp), 12 (iqsin), 13 (ihsin), 14 (dese), 15 (desi), 16 (losi), 17 (sinc), 18 (isinc), 19 (quat), 20 (quatr), 21 (qsin2), 22 (hsin2))
+- `silence` (of type `float?`, which defaults to `null`): set the silence gain. (default: 0.)
+- `unity` (of type `float?`, which defaults to `null`): set the unity gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afdelaysrc`
+
+Ffmpeg filter: Generate a Fractional delay FIR coefficients.
+
+Type:
+
+```
+(?delay : float?, ?d : float?, ?sample_rate : int?, ?r : int?,
+ ?nb_samples : int?, ?n : int?, ?taps : int?, ?t : int?,
+ ?channel_layout : string?, ?c : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `delay` (of type `float?`, which defaults to `null`): set fractional delay. (default: 0.)
+- `d` (of type `float?`, which defaults to `null`): set fractional delay. (default: 0.)
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `taps` (of type `int?`, which defaults to `null`): set number of taps for delay filter. (default: 0)
+- `t` (of type `int?`, which defaults to `null`): set number of taps for delay filter. (default: 0)
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel layout. (default: stereo)
+- `c` (of type `string?`, which defaults to `null`): set channel layout. (default: stereo)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.afdelaysrc.create`
+
+Ffmpeg filter: Generate a Fractional delay FIR coefficients.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?delay : float?, ?d : float?, ?sample_rate : int?, ?r : int?,
+ ?nb_samples : int?, ?n : int?, ?taps : int?, ?t : int?,
+ ?channel_layout : string?, ?c : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `delay` (of type `float?`, which defaults to `null`): set fractional delay. (default: 0.)
+- `d` (of type `float?`, which defaults to `null`): set fractional delay. (default: 0.)
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `taps` (of type `int?`, which defaults to `null`): set number of taps for delay filter. (default: 0)
+- `t` (of type `int?`, which defaults to `null`): set number of taps for delay filter. (default: 0)
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel layout. (default: stereo)
+- `c` (of type `string?`, which defaults to `null`): set channel layout. (default: stereo)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afftdn`
+
+Ffmpeg filter: Denoise audio samples using FFT.
+
+Type:
+
+```
+(?noise_reduction : float?, ?nr : float?, ?noise_floor : float?,
+ ?nf : float?, ?noise_type : int?, ?nt : int?, ?band_noise : string?,
+ ?bn : string?, ?residual_floor : float?, ?rf : float?, ?track_noise : bool?,
+ ?tn : bool?, ?track_residual : bool?, ?tr : bool?, ?output_mode : int?,
+ ?om : int?, ?adaptivity : float?, ?ad : float?, ?floor_offset : float?,
+ ?fo : float?, ?noise_link : int?, ?nl : int?, ?band_multiplier : float?,
+ ?bm : float?, ?sample_noise : int?, ?sn : int?, ?gain_smooth : int?,
+ ?gs : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `noise_reduction` (of type `float?`, which defaults to `null`): set the noise reduction. (default: 12.)
+- `nr` (of type `float?`, which defaults to `null`): set the noise reduction. (default: 12.)
+- `noise_floor` (of type `float?`, which defaults to `null`): set the noise floor. (default: -50.)
+- `nf` (of type `float?`, which defaults to `null`): set the noise floor. (default: -50.)
+- `noise_type` (of type `int?`, which defaults to `null`): set the noise type. (default: 0, possible values: 0 (white), 0 (w), 1 (vinyl), 1 (v), 2 (shellac), 2 (s), 3 (custom), 3 (c))
+- `nt` (of type `int?`, which defaults to `null`): set the noise type. (default: 0, possible values: 0 (white), 0 (w), 1 (vinyl), 1 (v), 2 (shellac), 2 (s), 3 (custom), 3 (c))
+- `band_noise` (of type `string?`, which defaults to `null`): set the custom bands noise
+- `bn` (of type `string?`, which defaults to `null`): set the custom bands noise
+- `residual_floor` (of type `float?`, which defaults to `null`): set the residual floor. (default: -38.)
+- `rf` (of type `float?`, which defaults to `null`): set the residual floor. (default: -38.)
+- `track_noise` (of type `bool?`, which defaults to `null`): track noise. (default: false)
+- `tn` (of type `bool?`, which defaults to `null`): track noise. (default: false)
+- `track_residual` (of type `bool?`, which defaults to `null`): track residual. (default: false)
+- `tr` (of type `bool?`, which defaults to `null`): track residual. (default: false)
+- `output_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (input), 0 (i), 1 (output), 1 (o), 2 (noise), 2 (n))
+- `om` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (input), 0 (i), 1 (output), 1 (o), 2 (noise), 2 (n))
+- `adaptivity` (of type `float?`, which defaults to `null`): set adaptivity factor. (default: 0.5)
+- `ad` (of type `float?`, which defaults to `null`): set adaptivity factor. (default: 0.5)
+- `floor_offset` (of type `float?`, which defaults to `null`): set noise floor offset factor. (default: 1.)
+- `fo` (of type `float?`, which defaults to `null`): set noise floor offset factor. (default: 1.)
+- `noise_link` (of type `int?`, which defaults to `null`): set the noise floor link. (default: 1, possible values: 0 (none), 1 (min), 2 (max), 3 (average))
+- `nl` (of type `int?`, which defaults to `null`): set the noise floor link. (default: 1, possible values: 0 (none), 1 (min), 2 (max), 3 (average))
+- `band_multiplier` (of type `float?`, which defaults to `null`): set band multiplier. (default: 1.25)
+- `bm` (of type `float?`, which defaults to `null`): set band multiplier. (default: 1.25)
+- `sample_noise` (of type `int?`, which defaults to `null`): set sample noise mode. (default: 0, possible values: 0 (none), 1 (start), 1 (begin), 2 (stop), 2 (end))
+- `sn` (of type `int?`, which defaults to `null`): set sample noise mode. (default: 0, possible values: 0 (none), 1 (start), 1 (begin), 2 (stop), 2 (end))
+- `gain_smooth` (of type `int?`, which defaults to `null`): set gain smooth radius. (default: 0)
+- `gs` (of type `int?`, which defaults to `null`): set gain smooth radius. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.afftdn.create`
+
+Ffmpeg filter: Denoise audio samples using FFT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?noise_reduction : float?, ?nr : float?, ?noise_floor : float?,
+ ?nf : float?, ?noise_type : int?, ?nt : int?, ?band_noise : string?,
+ ?bn : string?, ?residual_floor : float?, ?rf : float?, ?track_noise : bool?,
+ ?tn : bool?, ?track_residual : bool?, ?tr : bool?, ?output_mode : int?,
+ ?om : int?, ?adaptivity : float?, ?ad : float?, ?floor_offset : float?,
+ ?fo : float?, ?noise_link : int?, ?nl : int?, ?band_multiplier : float?,
+ ?bm : float?, ?sample_noise : int?, ?sn : int?, ?gain_smooth : int?,
+ ?gs : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `noise_reduction` (of type `float?`, which defaults to `null`): set the noise reduction. (default: 12.)
+- `nr` (of type `float?`, which defaults to `null`): set the noise reduction. (default: 12.)
+- `noise_floor` (of type `float?`, which defaults to `null`): set the noise floor. (default: -50.)
+- `nf` (of type `float?`, which defaults to `null`): set the noise floor. (default: -50.)
+- `noise_type` (of type `int?`, which defaults to `null`): set the noise type. (default: 0, possible values: 0 (white), 0 (w), 1 (vinyl), 1 (v), 2 (shellac), 2 (s), 3 (custom), 3 (c))
+- `nt` (of type `int?`, which defaults to `null`): set the noise type. (default: 0, possible values: 0 (white), 0 (w), 1 (vinyl), 1 (v), 2 (shellac), 2 (s), 3 (custom), 3 (c))
+- `band_noise` (of type `string?`, which defaults to `null`): set the custom bands noise
+- `bn` (of type `string?`, which defaults to `null`): set the custom bands noise
+- `residual_floor` (of type `float?`, which defaults to `null`): set the residual floor. (default: -38.)
+- `rf` (of type `float?`, which defaults to `null`): set the residual floor. (default: -38.)
+- `track_noise` (of type `bool?`, which defaults to `null`): track noise. (default: false)
+- `tn` (of type `bool?`, which defaults to `null`): track noise. (default: false)
+- `track_residual` (of type `bool?`, which defaults to `null`): track residual. (default: false)
+- `tr` (of type `bool?`, which defaults to `null`): track residual. (default: false)
+- `output_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (input), 0 (i), 1 (output), 1 (o), 2 (noise), 2 (n))
+- `om` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (input), 0 (i), 1 (output), 1 (o), 2 (noise), 2 (n))
+- `adaptivity` (of type `float?`, which defaults to `null`): set adaptivity factor. (default: 0.5)
+- `ad` (of type `float?`, which defaults to `null`): set adaptivity factor. (default: 0.5)
+- `floor_offset` (of type `float?`, which defaults to `null`): set noise floor offset factor. (default: 1.)
+- `fo` (of type `float?`, which defaults to `null`): set noise floor offset factor. (default: 1.)
+- `noise_link` (of type `int?`, which defaults to `null`): set the noise floor link. (default: 1, possible values: 0 (none), 1 (min), 2 (max), 3 (average))
+- `nl` (of type `int?`, which defaults to `null`): set the noise floor link. (default: 1, possible values: 0 (none), 1 (min), 2 (max), 3 (average))
+- `band_multiplier` (of type `float?`, which defaults to `null`): set band multiplier. (default: 1.25)
+- `bm` (of type `float?`, which defaults to `null`): set band multiplier. (default: 1.25)
+- `sample_noise` (of type `int?`, which defaults to `null`): set sample noise mode. (default: 0, possible values: 0 (none), 1 (start), 1 (begin), 2 (stop), 2 (end))
+- `sn` (of type `int?`, which defaults to `null`): set sample noise mode. (default: 0, possible values: 0 (none), 1 (start), 1 (begin), 2 (stop), 2 (end))
+- `gain_smooth` (of type `int?`, which defaults to `null`): set gain smooth radius. (default: 0)
+- `gs` (of type `int?`, which defaults to `null`): set gain smooth radius. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afftfilt`
+
+Ffmpeg filter: Apply arbitrary expressions to samples in frequency domain.
+
+Type:
+
+```
+(?real : string?, ?imag : string?, ?win_size : int?, ?win_func : int?,
+ ?overlap : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `real` (of type `string?`, which defaults to `null`): set channels real expressions. (default: re)
+- `imag` (of type `string?`, which defaults to `null`): set channels imaginary expressions. (default: im)
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 4096)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.75)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.afftfilt.create`
+
+Ffmpeg filter: Apply arbitrary expressions to samples in frequency domain.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?real : string?, ?imag : string?, ?win_size : int?, ?win_func : int?,
+ ?overlap : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `real` (of type `string?`, which defaults to `null`): set channels real expressions. (default: re)
+- `imag` (of type `string?`, which defaults to `null`): set channels imaginary expressions. (default: im)
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 4096)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.75)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afifo`
+
+Ffmpeg filter: Buffer input frames and send them when they are requested.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.afifo.create`
+
+Ffmpeg filter: Buffer input frames and send them when they are requested.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afir`
+
+Ffmpeg filter: Apply Finite Impulse Response filter with supplied coefficients in additional stream(s). This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?dry : float?, ?wet : float?, ?length : float?, ?gtype : int?,
+ ?irgain : float?, ?irfmt : int?, ?maxir : float?, ?response : bool?,
+ ?channel : int?, ?size : string?, ?rate : string?, ?minp : int?,
+ ?maxp : int?, ?nbirs : int?, ?ir : int?, ?precision : int?, ?irload : int?,
+ ffmpeg.filter.graph, [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `dry` (of type `float?`, which defaults to `null`): set dry gain. (default: 1.)
+- `wet` (of type `float?`, which defaults to `null`): set wet gain. (default: 1.)
+- `length` (of type `float?`, which defaults to `null`): set IR length. (default: 1.)
+- `gtype` (of type `int?`, which defaults to `null`): set IR auto gain type. (default: 0, possible values: -1 (none), 0 (peak), 1 (dc), 2 (gn), 3 (ac), 4 (rms))
+- `irgain` (of type `float?`, which defaults to `null`): set IR gain. (default: 1.)
+- `irfmt` (of type `int?`, which defaults to `null`): set IR format. (default: 1, possible values: 0 (mono), 1 (input))
+- `maxir` (of type `float?`, which defaults to `null`): set max IR length. (default: 30.)
+- `response` (of type `bool?`, which defaults to `null`): show IR frequency response. (default: false)
+- `channel` (of type `int?`, which defaults to `null`): set IR channel to display frequency response. (default: 0)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `minp` (of type `int?`, which defaults to `null`): set min partition size. (default: 8192)
+- `maxp` (of type `int?`, which defaults to `null`): set max partition size. (default: 8192)
+- `nbirs` (of type `int?`, which defaults to `null`): set number of input IRs. (default: 1)
+- `ir` (of type `int?`, which defaults to `null`): select IR. (default: 0)
+- `precision` (of type `int?`, which defaults to `null`): set processing precision. (default: 0, possible values: 0 (auto), 1 (float), 2 (double))
+- `irload` (of type `int?`, which defaults to `null`): set IR loading type. (default: 0, possible values: 0 (init), 1 (access))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.afir.create`
+
+Ffmpeg filter: Apply Finite Impulse Response filter with supplied coefficients in additional stream(s). This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dry : float?, ?wet : float?, ?length : float?, ?gtype : int?,
+ ?irgain : float?, ?irfmt : int?, ?maxir : float?, ?response : bool?,
+ ?channel : int?, ?size : string?, ?rate : string?, ?minp : int?,
+ ?maxp : int?, ?nbirs : int?, ?ir : int?, ?precision : int?, ?irload : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dry` (of type `float?`, which defaults to `null`): set dry gain. (default: 1.)
+- `wet` (of type `float?`, which defaults to `null`): set wet gain. (default: 1.)
+- `length` (of type `float?`, which defaults to `null`): set IR length. (default: 1.)
+- `gtype` (of type `int?`, which defaults to `null`): set IR auto gain type. (default: 0, possible values: -1 (none), 0 (peak), 1 (dc), 2 (gn), 3 (ac), 4 (rms))
+- `irgain` (of type `float?`, which defaults to `null`): set IR gain. (default: 1.)
+- `irfmt` (of type `int?`, which defaults to `null`): set IR format. (default: 1, possible values: 0 (mono), 1 (input))
+- `maxir` (of type `float?`, which defaults to `null`): set max IR length. (default: 30.)
+- `response` (of type `bool?`, which defaults to `null`): show IR frequency response. (default: false)
+- `channel` (of type `int?`, which defaults to `null`): set IR channel to display frequency response. (default: 0)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `minp` (of type `int?`, which defaults to `null`): set min partition size. (default: 8192)
+- `maxp` (of type `int?`, which defaults to `null`): set max partition size. (default: 8192)
+- `nbirs` (of type `int?`, which defaults to `null`): set number of input IRs. (default: 1)
+- `ir` (of type `int?`, which defaults to `null`): select IR. (default: 0)
+- `precision` (of type `int?`, which defaults to `null`): set processing precision. (default: 0, possible values: 0 (auto), 1 (float), 2 (double))
+- `irload` (of type `int?`, which defaults to `null`): set IR loading type. (default: 0, possible values: 0 (init), 1 (access))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afireqsrc`
+
+Ffmpeg filter: Generate a FIR equalizer coefficients audio stream.
+
+Type:
+
+```
+(?preset : int?, ?p : int?, ?gains : string?, ?g : string?, ?bands : string?,
+ ?b : string?, ?taps : int?, ?t : int?, ?sample_rate : int?, ?r : int?,
+ ?nb_samples : int?, ?n : int?, ?interp : int?, ?i : int?, ?phase : int?,
+ ?h : int?, ffmpeg.filter.graph) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `preset` (of type `int?`, which defaults to `null`): set equalizer preset. (default: 0, possible values: -1 (custom), 0 (flat), 1 (acoustic), 2 (bass), 3 (beats), 4 (classic), 5 (clear), 6 (deep bass), 7 (dubstep), 8 (electronic), 9 (hardstyle), 10 (hip-hop), 11 (jazz), 12 (metal), 13 (movie), 14 (pop), 15 (r&b), 16 (rock), 17 (vocal booster))
+- `p` (of type `int?`, which defaults to `null`): set equalizer preset. (default: 0, possible values: -1 (custom), 0 (flat), 1 (acoustic), 2 (bass), 3 (beats), 4 (classic), 5 (clear), 6 (deep bass), 7 (dubstep), 8 (electronic), 9 (hardstyle), 10 (hip-hop), 11 (jazz), 12 (metal), 13 (movie), 14 (pop), 15 (r&b), 16 (rock), 17 (vocal booster))
+- `gains` (of type `string?`, which defaults to `null`): set gain values per band. (default: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+- `g` (of type `string?`, which defaults to `null`): set gain values per band. (default: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+- `bands` (of type `string?`, which defaults to `null`): set central frequency values per band. (default: 25 40 63 100 160 250 400 630 1000 1600 2500 4000 6300 10000 16000 24000)
+- `b` (of type `string?`, which defaults to `null`): set central frequency values per band. (default: 25 40 63 100 160 250 400 630 1000 1600 2500 4000 6300 10000 16000 24000)
+- `taps` (of type `int?`, which defaults to `null`): set number of taps. (default: 4096)
+- `t` (of type `int?`, which defaults to `null`): set number of taps. (default: 4096)
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `interp` (of type `int?`, which defaults to `null`): set the interpolation. (default: 0, possible values: 0 (linear), 1 (cubic))
+- `i` (of type `int?`, which defaults to `null`): set the interpolation. (default: 0, possible values: 0 (linear), 1 (cubic))
+- `phase` (of type `int?`, which defaults to `null`): set the phase. (default: 1, possible values: 0 (linear), 1 (min))
+- `h` (of type `int?`, which defaults to `null`): set the phase. (default: 1, possible values: 0 (linear), 1 (min))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.afireqsrc.create`
+
+Ffmpeg filter: Generate a FIR equalizer coefficients audio stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?preset : int?, ?p : int?, ?gains : string?, ?g : string?, ?bands : string?,
+ ?b : string?, ?taps : int?, ?t : int?, ?sample_rate : int?, ?r : int?,
+ ?nb_samples : int?, ?n : int?, ?interp : int?, ?i : int?, ?phase : int?,
+ ?h : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `preset` (of type `int?`, which defaults to `null`): set equalizer preset. (default: 0, possible values: -1 (custom), 0 (flat), 1 (acoustic), 2 (bass), 3 (beats), 4 (classic), 5 (clear), 6 (deep bass), 7 (dubstep), 8 (electronic), 9 (hardstyle), 10 (hip-hop), 11 (jazz), 12 (metal), 13 (movie), 14 (pop), 15 (r&b), 16 (rock), 17 (vocal booster))
+- `p` (of type `int?`, which defaults to `null`): set equalizer preset. (default: 0, possible values: -1 (custom), 0 (flat), 1 (acoustic), 2 (bass), 3 (beats), 4 (classic), 5 (clear), 6 (deep bass), 7 (dubstep), 8 (electronic), 9 (hardstyle), 10 (hip-hop), 11 (jazz), 12 (metal), 13 (movie), 14 (pop), 15 (r&b), 16 (rock), 17 (vocal booster))
+- `gains` (of type `string?`, which defaults to `null`): set gain values per band. (default: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+- `g` (of type `string?`, which defaults to `null`): set gain values per band. (default: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+- `bands` (of type `string?`, which defaults to `null`): set central frequency values per band. (default: 25 40 63 100 160 250 400 630 1000 1600 2500 4000 6300 10000 16000 24000)
+- `b` (of type `string?`, which defaults to `null`): set central frequency values per band. (default: 25 40 63 100 160 250 400 630 1000 1600 2500 4000 6300 10000 16000 24000)
+- `taps` (of type `int?`, which defaults to `null`): set number of taps. (default: 4096)
+- `t` (of type `int?`, which defaults to `null`): set number of taps. (default: 4096)
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `interp` (of type `int?`, which defaults to `null`): set the interpolation. (default: 0, possible values: 0 (linear), 1 (cubic))
+- `i` (of type `int?`, which defaults to `null`): set the interpolation. (default: 0, possible values: 0 (linear), 1 (cubic))
+- `phase` (of type `int?`, which defaults to `null`): set the phase. (default: 1, possible values: 0 (linear), 1 (min))
+- `h` (of type `int?`, which defaults to `null`): set the phase. (default: 1, possible values: 0 (linear), 1 (min))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afirsrc`
+
+Ffmpeg filter: Generate a FIR coefficients audio stream.
+
+Type:
+
+```
+(?taps : int?, ?t : int?, ?frequency : string?, ?f : string?,
+ ?magnitude : string?, ?m : string?, ?phase : string?, ?p : string?,
+ ?sample_rate : int?, ?r : int?, ?nb_samples : int?, ?n : int?,
+ ?win_func : int?, ?w : int?, ffmpeg.filter.graph) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `taps` (of type `int?`, which defaults to `null`): set number of taps. (default: 1025)
+- `t` (of type `int?`, which defaults to `null`): set number of taps. (default: 1025)
+- `frequency` (of type `string?`, which defaults to `null`): set frequency points. (default: 0 1)
+- `f` (of type `string?`, which defaults to `null`): set frequency points. (default: 0 1)
+- `magnitude` (of type `string?`, which defaults to `null`): set magnitude values. (default: 1 1)
+- `m` (of type `string?`, which defaults to `null`): set magnitude values. (default: 1 1)
+- `phase` (of type `string?`, which defaults to `null`): set phase values. (default: 0 0)
+- `p` (of type `string?`, which defaults to `null`): set phase values. (default: 0 0)
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `w` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.afirsrc.create`
+
+Ffmpeg filter: Generate a FIR coefficients audio stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?taps : int?, ?t : int?, ?frequency : string?, ?f : string?,
+ ?magnitude : string?, ?m : string?, ?phase : string?, ?p : string?,
+ ?sample_rate : int?, ?r : int?, ?nb_samples : int?, ?n : int?,
+ ?win_func : int?, ?w : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `taps` (of type `int?`, which defaults to `null`): set number of taps. (default: 1025)
+- `t` (of type `int?`, which defaults to `null`): set number of taps. (default: 1025)
+- `frequency` (of type `string?`, which defaults to `null`): set frequency points. (default: 0 1)
+- `f` (of type `string?`, which defaults to `null`): set frequency points. (default: 0 1)
+- `magnitude` (of type `string?`, which defaults to `null`): set magnitude values. (default: 1 1)
+- `m` (of type `string?`, which defaults to `null`): set magnitude values. (default: 1 1)
+- `phase` (of type `string?`, which defaults to `null`): set phase values. (default: 0 0)
+- `p` (of type `string?`, which defaults to `null`): set phase values. (default: 0 0)
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `w` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aformat`
+
+Ffmpeg filter: Convert the input audio to one of the specified formats.
+
+Type:
+
+```
+(?sample_fmts : string?, ?f : string?, ?sample_rates : string?, ?r : string?,
+ ?channel_layouts : string?, ?cl : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_fmts` (of type `string?`, which defaults to `null`): A '|'-separated list of sample formats.
+- `f` (of type `string?`, which defaults to `null`): A '|'-separated list of sample formats.
+- `sample_rates` (of type `string?`, which defaults to `null`): A '|'-separated list of sample rates.
+- `r` (of type `string?`, which defaults to `null`): A '|'-separated list of sample rates.
+- `channel_layouts` (of type `string?`, which defaults to `null`): A '|'-separated list of channel layouts.
+- `cl` (of type `string?`, which defaults to `null`): A '|'-separated list of channel layouts.
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aformat.create`
+
+Ffmpeg filter: Convert the input audio to one of the specified formats.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_fmts : string?, ?f : string?, ?sample_rates : string?, ?r : string?,
+ ?channel_layouts : string?, ?cl : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sample_fmts` (of type `string?`, which defaults to `null`): A '|'-separated list of sample formats.
+- `f` (of type `string?`, which defaults to `null`): A '|'-separated list of sample formats.
+- `sample_rates` (of type `string?`, which defaults to `null`): A '|'-separated list of sample rates.
+- `r` (of type `string?`, which defaults to `null`): A '|'-separated list of sample rates.
+- `channel_layouts` (of type `string?`, which defaults to `null`): A '|'-separated list of channel layouts.
+- `cl` (of type `string?`, which defaults to `null`): A '|'-separated list of channel layouts.
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afreqshift`
+
+Ffmpeg filter: Apply frequency shifting to input audio.
+
+Type:
+
+```
+(?shift : float?, ?level : float?, ?order : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `shift` (of type `float?`, which defaults to `null`): set frequency shift. (default: 0.)
+- `level` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.afreqshift.create`
+
+Ffmpeg filter: Apply frequency shifting to input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?shift : float?, ?level : float?, ?order : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `shift` (of type `float?`, which defaults to `null`): set frequency shift. (default: 0.)
+- `level` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.afwtdn`
+
+Ffmpeg filter: Denoise audio stream using Wavelets.
+
+Type:
+
+```
+(?sigma : float?, ?levels : int?, ?wavet : int?, ?percent : float?,
+ ?profile : bool?, ?adaptive : bool?, ?samples : int?, ?softness : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set noise sigma. (default: 0.)
+- `levels` (of type `int?`, which defaults to `null`): set number of wavelet levels. (default: 10)
+- `wavet` (of type `int?`, which defaults to `null`): set wavelet type. (default: 4, possible values: 0 (sym2), 1 (sym4), 2 (rbior68), 3 (deb10), 4 (sym10), 5 (coif5), 6 (bl3))
+- `percent` (of type `float?`, which defaults to `null`): set percent of full denoising. (default: 85.)
+- `profile` (of type `bool?`, which defaults to `null`): profile noise. (default: false)
+- `adaptive` (of type `bool?`, which defaults to `null`): adaptive profiling of noise. (default: false)
+- `samples` (of type `int?`, which defaults to `null`): set frame size in number of samples. (default: 8192)
+- `softness` (of type `float?`, which defaults to `null`): set thresholding softness. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.afwtdn.create`
+
+Ffmpeg filter: Denoise audio stream using Wavelets.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigma : float?, ?levels : int?, ?wavet : int?, ?percent : float?,
+ ?profile : bool?, ?adaptive : bool?, ?samples : int?, ?softness : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set noise sigma. (default: 0.)
+- `levels` (of type `int?`, which defaults to `null`): set number of wavelet levels. (default: 10)
+- `wavet` (of type `int?`, which defaults to `null`): set wavelet type. (default: 4, possible values: 0 (sym2), 1 (sym4), 2 (rbior68), 3 (deb10), 4 (sym10), 5 (coif5), 6 (bl3))
+- `percent` (of type `float?`, which defaults to `null`): set percent of full denoising. (default: 85.)
+- `profile` (of type `bool?`, which defaults to `null`): profile noise. (default: false)
+- `adaptive` (of type `bool?`, which defaults to `null`): adaptive profiling of noise. (default: false)
+- `samples` (of type `int?`, which defaults to `null`): set frame size in number of samples. (default: 8192)
+- `softness` (of type `float?`, which defaults to `null`): set thresholding softness. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.agate`
+
+Ffmpeg filter: Audio gate.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?range : float?, ?threshold : float?,
+ ?ratio : float?, ?attack : float?, ?release : float?, ?makeup : float?,
+ ?knee : float?, ?detection : int?, ?link : int?, ?level_sc : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `range` (of type `float?`, which defaults to `null`): set max gain reduction. (default: 0.06125)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set makeup gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.828427125)
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `link` (of type `int?`, which defaults to `null`): set link. (default: 0, possible values: 0 (average), 1 (maximum))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.agate.create`
+
+Ffmpeg filter: Audio gate.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?range : float?, ?threshold : float?,
+ ?ratio : float?, ?attack : float?, ?release : float?, ?makeup : float?,
+ ?knee : float?, ?detection : int?, ?link : int?, ?level_sc : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `range` (of type `float?`, which defaults to `null`): set max gain reduction. (default: 0.06125)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set makeup gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.828427125)
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `link` (of type `int?`, which defaults to `null`): set link. (default: 0, possible values: 0 (average), 1 (maximum))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.agraphmonitor`
+
+Ffmpeg filter: Show various filtergraph stats.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?opacity : float?, ?o : float?, ?mode : int?,
+ ?m : int?, ?flags : int?, ?f : int?, ?rate : string?, ?r : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `opacity` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `o` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `f` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.agraphmonitor.create`
+
+Ffmpeg filter: Show various filtergraph stats.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?opacity : float?, ?o : float?, ?mode : int?,
+ ?m : int?, ?flags : int?, ?f : int?, ?rate : string?, ?r : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `opacity` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `o` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `f` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ahistogram`
+
+Ffmpeg filter: Convert input audio to histogram video output.
+
+Type:
+
+```
+(?dmode : int?, ?rate : string?, ?r : string?, ?size : string?, ?s : string?,
+ ?scale : int?, ?ascale : int?, ?acount : int?, ?rheight : float?,
+ ?slide : int?, ?hmode : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dmode` (of type `int?`, which defaults to `null`): set method to display channels. (default: 0, possible values: 0 (single), 1 (separate))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `scale` (of type `int?`, which defaults to `null`): set display scale. (default: 3, possible values: 3 (log), 1 (sqrt), 2 (cbrt), 0 (lin), 4 (rlog))
+- `ascale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 1, possible values: 1 (log), 0 (lin))
+- `acount` (of type `int?`, which defaults to `null`): how much frames to accumulate. (default: 1)
+- `rheight` (of type `float?`, which defaults to `null`): set histogram ratio of window height. (default: 0.1)
+- `slide` (of type `int?`, which defaults to `null`): set sonogram sliding. (default: 0, possible values: 0 (replace), 1 (scroll))
+- `hmode` (of type `int?`, which defaults to `null`): set histograms mode. (default: 0, possible values: 0 (abs), 1 (sign))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.ahistogram.create`
+
+Ffmpeg filter: Convert input audio to histogram video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dmode : int?, ?rate : string?, ?r : string?, ?size : string?, ?s : string?,
+ ?scale : int?, ?ascale : int?, ?acount : int?, ?rheight : float?,
+ ?slide : int?, ?hmode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dmode` (of type `int?`, which defaults to `null`): set method to display channels. (default: 0, possible values: 0 (single), 1 (separate))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `scale` (of type `int?`, which defaults to `null`): set display scale. (default: 3, possible values: 3 (log), 1 (sqrt), 2 (cbrt), 0 (lin), 4 (rlog))
+- `ascale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 1, possible values: 1 (log), 0 (lin))
+- `acount` (of type `int?`, which defaults to `null`): how much frames to accumulate. (default: 1)
+- `rheight` (of type `float?`, which defaults to `null`): set histogram ratio of window height. (default: 0.1)
+- `slide` (of type `int?`, which defaults to `null`): set sonogram sliding. (default: 0, possible values: 0 (replace), 1 (scroll))
+- `hmode` (of type `int?`, which defaults to `null`): set histograms mode. (default: 0, possible values: 0 (abs), 1 (sign))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aiir`
+
+Ffmpeg filter: Apply Infinite Impulse Response filter with supplied coefficients. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?zeros : string?, ?z : string?, ?poles : string?, ?p : string?,
+ ?gains : string?, ?k : string?, ?dry : float?, ?wet : float?,
+ ?format : int?, ?f : int?, ?process : int?, ?r : int?, ?precision : int?,
+ ?e : int?, ?normalize : bool?, ?n : bool?, ?mix : float?, ?response : bool?,
+ ?channel : int?, ?size : string?, ?rate : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `zeros` (of type `string?`, which defaults to `null`): set B/numerator/zeros/reflection coefficients. (default: 1+0i 1-0i)
+- `z` (of type `string?`, which defaults to `null`): set B/numerator/zeros/reflection coefficients. (default: 1+0i 1-0i)
+- `poles` (of type `string?`, which defaults to `null`): set A/denominator/poles/ladder coefficients. (default: 1+0i 1-0i)
+- `p` (of type `string?`, which defaults to `null`): set A/denominator/poles/ladder coefficients. (default: 1+0i 1-0i)
+- `gains` (of type `string?`, which defaults to `null`): set channels gains. (default: 1|1)
+- `k` (of type `string?`, which defaults to `null`): set channels gains. (default: 1|1)
+- `dry` (of type `float?`, which defaults to `null`): set dry gain. (default: 1.)
+- `wet` (of type `float?`, which defaults to `null`): set wet gain. (default: 1.)
+- `format` (of type `int?`, which defaults to `null`): set coefficients format. (default: 1, possible values: -2 (ll), -1 (sf), 0 (tf), 1 (zp), 2 (pr), 3 (pd), 4 (sp))
+- `f` (of type `int?`, which defaults to `null`): set coefficients format. (default: 1, possible values: -2 (ll), -1 (sf), 0 (tf), 1 (zp), 2 (pr), 3 (pd), 4 (sp))
+- `process` (of type `int?`, which defaults to `null`): set kind of processing. (default: 1, possible values: 0 (d), 1 (s), 2 (p))
+- `r` (of type `int?`, which defaults to `null`): set kind of processing. (default: 1, possible values: 0 (d), 1 (s), 2 (p))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: 0, possible values: 0 (dbl), 1 (flt), 2 (i32), 3 (i16))
+- `e` (of type `int?`, which defaults to `null`): set precision. (default: 0, possible values: 0 (dbl), 1 (flt), 2 (i32), 3 (i16))
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: true)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: true)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `response` (of type `bool?`, which defaults to `null`): show IR frequency response. (default: false)
+- `channel` (of type `int?`, which defaults to `null`): set IR channel to display frequency response. (default: 0)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aiir.create`
+
+Ffmpeg filter: Apply Infinite Impulse Response filter with supplied coefficients. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?zeros : string?, ?z : string?, ?poles : string?, ?p : string?,
+ ?gains : string?, ?k : string?, ?dry : float?, ?wet : float?,
+ ?format : int?, ?f : int?, ?process : int?, ?r : int?, ?precision : int?,
+ ?e : int?, ?normalize : bool?, ?n : bool?, ?mix : float?, ?response : bool?,
+ ?channel : int?, ?size : string?, ?rate : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `zeros` (of type `string?`, which defaults to `null`): set B/numerator/zeros/reflection coefficients. (default: 1+0i 1-0i)
+- `z` (of type `string?`, which defaults to `null`): set B/numerator/zeros/reflection coefficients. (default: 1+0i 1-0i)
+- `poles` (of type `string?`, which defaults to `null`): set A/denominator/poles/ladder coefficients. (default: 1+0i 1-0i)
+- `p` (of type `string?`, which defaults to `null`): set A/denominator/poles/ladder coefficients. (default: 1+0i 1-0i)
+- `gains` (of type `string?`, which defaults to `null`): set channels gains. (default: 1|1)
+- `k` (of type `string?`, which defaults to `null`): set channels gains. (default: 1|1)
+- `dry` (of type `float?`, which defaults to `null`): set dry gain. (default: 1.)
+- `wet` (of type `float?`, which defaults to `null`): set wet gain. (default: 1.)
+- `format` (of type `int?`, which defaults to `null`): set coefficients format. (default: 1, possible values: -2 (ll), -1 (sf), 0 (tf), 1 (zp), 2 (pr), 3 (pd), 4 (sp))
+- `f` (of type `int?`, which defaults to `null`): set coefficients format. (default: 1, possible values: -2 (ll), -1 (sf), 0 (tf), 1 (zp), 2 (pr), 3 (pd), 4 (sp))
+- `process` (of type `int?`, which defaults to `null`): set kind of processing. (default: 1, possible values: 0 (d), 1 (s), 2 (p))
+- `r` (of type `int?`, which defaults to `null`): set kind of processing. (default: 1, possible values: 0 (d), 1 (s), 2 (p))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: 0, possible values: 0 (dbl), 1 (flt), 2 (i32), 3 (i16))
+- `e` (of type `int?`, which defaults to `null`): set precision. (default: 0, possible values: 0 (dbl), 1 (flt), 2 (i32), 3 (i16))
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: true)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: true)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `response` (of type `bool?`, which defaults to `null`): show IR frequency response. (default: false)
+- `channel` (of type `int?`, which defaults to `null`): set IR channel to display frequency response. (default: 0)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aintegral`
+
+Ffmpeg filter: Compute integral of input audio.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aintegral.create`
+
+Ffmpeg filter: Compute integral of input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ainterleave`
+
+Ffmpeg filter: Temporally interleave audio inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?nb_inputs : int?, ?n : int?, ?duration : int?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `nb_inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `n` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `duration` (of type `int?`, which defaults to `null`): how to determine the end-of-stream. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.ainterleave.create`
+
+Ffmpeg filter: Temporally interleave audio inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?nb_inputs : int?, ?n : int?, ?duration : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `nb_inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `n` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `duration` (of type `int?`, which defaults to `null`): how to determine the end-of-stream. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.alatency`
+
+Ffmpeg filter: Report audio filtering latency.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.alatency.create`
+
+Ffmpeg filter: Report audio filtering latency.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.alimiter`
+
+Ffmpeg filter: Audio lookahead limiter.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?limit : float?, ?attack : float?,
+ ?release : float?, ?asc : bool?, ?asc_level : float?, ?level : bool?,
+ ?latency : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `limit` (of type `float?`, which defaults to `null`): set limit. (default: 1.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 5.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 50.)
+- `asc` (of type `bool?`, which defaults to `null`): enable asc. (default: false)
+- `asc_level` (of type `float?`, which defaults to `null`): set asc level. (default: 0.5)
+- `level` (of type `bool?`, which defaults to `null`): auto level. (default: true)
+- `latency` (of type `bool?`, which defaults to `null`): compensate delay. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.alimiter.create`
+
+Ffmpeg filter: Audio lookahead limiter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?limit : float?, ?attack : float?,
+ ?release : float?, ?asc : bool?, ?asc_level : float?, ?level : bool?,
+ ?latency : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `limit` (of type `float?`, which defaults to `null`): set limit. (default: 1.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 5.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 50.)
+- `asc` (of type `bool?`, which defaults to `null`): enable asc. (default: false)
+- `asc_level` (of type `float?`, which defaults to `null`): set asc level. (default: 0.5)
+- `level` (of type `bool?`, which defaults to `null`): auto level. (default: true)
+- `latency` (of type `bool?`, which defaults to `null`): compensate delay. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.allpass`
+
+Ffmpeg filter: Apply a two-pole all-pass filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?mix : float?, ?m : float?,
+ ?channels : string?, ?c : string?, ?normalize : bool?, ?n : bool?,
+ ?order : int?, ?o : int?, ?transform : int?, ?a : int?, ?precision : int?,
+ ?r : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 2)
+- `o` (of type `int?`, which defaults to `null`): set filter order. (default: 2)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.allpass.create`
+
+Ffmpeg filter: Apply a two-pole all-pass filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?mix : float?, ?m : float?,
+ ?channels : string?, ?c : string?, ?normalize : bool?, ?n : bool?,
+ ?order : int?, ?o : int?, ?transform : int?, ?a : int?, ?precision : int?,
+ ?r : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 2)
+- `o` (of type `int?`, which defaults to `null`): set filter order. (default: 2)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.allrgb`
+
+Ffmpeg filter: Generate all RGB colors.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.allrgb.create`
+
+Ffmpeg filter: Generate all RGB colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.allyuv`
+
+Ffmpeg filter: Generate all yuv colors.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.allyuv.create`
+
+Ffmpeg filter: Generate all yuv colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aloop`
+
+Ffmpeg filter: Loop audio samples.
+
+Type:
+
+```
+(?loop : int?, ?size : int?, ?start : int?, ?time : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `loop` (of type `int?`, which defaults to `null`): number of loops. (default: 0)
+- `size` (of type `int?`, which defaults to `null`): max number of samples to loop. (default: 0)
+- `start` (of type `int?`, which defaults to `null`): set the loop start sample. (default: 0)
+- `time` (of type `int?`, which defaults to `null`): set the loop start time. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aloop.create`
+
+Ffmpeg filter: Loop audio samples.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?loop : int?, ?size : int?, ?start : int?, ?time : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `loop` (of type `int?`, which defaults to `null`): number of loops. (default: 0)
+- `size` (of type `int?`, which defaults to `null`): max number of samples to loop. (default: 0)
+- `start` (of type `int?`, which defaults to `null`): set the loop start sample. (default: 0)
+- `time` (of type `int?`, which defaults to `null`): set the loop start time. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.alphaextract`
+
+Ffmpeg filter: Extract an alpha channel as a grayscale image component.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.alphaextract.create`
+
+Ffmpeg filter: Extract an alpha channel as a grayscale image component.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.alphamerge`
+
+Ffmpeg filter: Copy the luma value of the second input into the alpha channel of the first input.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.alphamerge.create`
+
+Ffmpeg filter: Copy the luma value of the second input into the alpha channel of the first input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.amerge`
+
+Ffmpeg filter: Merge two or more audio streams into a single multi-channel stream. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): specify the number of inputs. (default: 2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.amerge.create`
+
+Ffmpeg filter: Merge two or more audio streams into a single multi-channel stream. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): specify the number of inputs. (default: 2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ametadata`
+
+Ffmpeg filter: Manipulate audio frame metadata.
+
+Type:
+
+```
+(?mode : int?, ?key : string?, ?value : string?, ?function : int?,
+ ?expr : string?, ?file : string?, ?direct : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (add), 2 (modify), 3 (delete), 4 (print))
+- `key` (of type `string?`, which defaults to `null`): set metadata key
+- `value` (of type `string?`, which defaults to `null`): set metadata value
+- `function` (of type `int?`, which defaults to `null`): function for comparing values. (default: 0, possible values: 0 (same_str), 1 (starts_with), 2 (less), 3 (equal), 4 (greater), 5 (expr), 6 (ends_with))
+- `expr` (of type `string?`, which defaults to `null`): set expression for expr function
+- `file` (of type `string?`, which defaults to `null`): set file where to print metadata information
+- `direct` (of type `bool?`, which defaults to `null`): reduce buffering when printing to user-set file or pipe. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.ametadata.create`
+
+Ffmpeg filter: Manipulate audio frame metadata.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?key : string?, ?value : string?, ?function : int?,
+ ?expr : string?, ?file : string?, ?direct : bool?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (add), 2 (modify), 3 (delete), 4 (print))
+- `key` (of type `string?`, which defaults to `null`): set metadata key
+- `value` (of type `string?`, which defaults to `null`): set metadata value
+- `function` (of type `int?`, which defaults to `null`): function for comparing values. (default: 0, possible values: 0 (same_str), 1 (starts_with), 2 (less), 3 (equal), 4 (greater), 5 (expr), 6 (ends_with))
+- `expr` (of type `string?`, which defaults to `null`): set expression for expr function
+- `file` (of type `string?`, which defaults to `null`): set file where to print metadata information
+- `direct` (of type `bool?`, which defaults to `null`): reduce buffering when printing to user-set file or pipe. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.amix`
+
+Ffmpeg filter: Audio mixing. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?duration : int?, ?dropout_transition : float?,
+ ?weights : string?, ?normalize : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Number of inputs.. (default: 2)
+- `duration` (of type `int?`, which defaults to `null`): How to determine the end-of-stream.. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `dropout_transition` (of type `float?`, which defaults to `null`): Transition time, in seconds, for volume renormalization when an input stream ends.. (default: 2.)
+- `weights` (of type `string?`, which defaults to `null`): Set weight for each input.. (default: 1 1)
+- `normalize` (of type `bool?`, which defaults to `null`): Scale inputs. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.amix.create`
+
+Ffmpeg filter: Audio mixing. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?duration : int?, ?dropout_transition : float?,
+ ?weights : string?, ?normalize : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Number of inputs.. (default: 2)
+- `duration` (of type `int?`, which defaults to `null`): How to determine the end-of-stream.. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `dropout_transition` (of type `float?`, which defaults to `null`): Transition time, in seconds, for volume renormalization when an input stream ends.. (default: 2.)
+- `weights` (of type `string?`, which defaults to `null`): Set weight for each input.. (default: 1 1)
+- `normalize` (of type `bool?`, which defaults to `null`): Scale inputs. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.amovie`
+
+Ffmpeg filter: Read audio from a movie source. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?filename : string?, ?format_name : string?, ?f : string?,
+ ?stream_index : int?, ?si : int?, ?seek_point : float?, ?sp : float?,
+ ?streams : string?, ?s : string?, ?loop : int?, ?discontinuity : int?,
+ ?dec_threads : int?, ?format_opts : string?, ffmpeg.filter.graph) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`)
+- `format_name` (of type `string?`, which defaults to `null`): set format name
+- `f` (of type `string?`, which defaults to `null`): set format name
+- `stream_index` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `si` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `seek_point` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `sp` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `streams` (of type `string?`, which defaults to `null`): set streams
+- `s` (of type `string?`, which defaults to `null`): set streams
+- `loop` (of type `int?`, which defaults to `null`): set loop count. (default: 1)
+- `discontinuity` (of type `int?`, which defaults to `null`): set discontinuity threshold. (default: 0)
+- `dec_threads` (of type `int?`, which defaults to `null`): set the number of threads for decoding. (default: 0)
+- `format_opts` (of type `string?`, which defaults to `null`): set format options for the opened file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.amovie.create`
+
+Ffmpeg filter: Read audio from a movie source. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?format_name : string?, ?f : string?,
+ ?stream_index : int?, ?si : int?, ?seek_point : float?, ?sp : float?,
+ ?streams : string?, ?s : string?, ?loop : int?, ?discontinuity : int?,
+ ?dec_threads : int?, ?format_opts : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`)
+- `format_name` (of type `string?`, which defaults to `null`): set format name
+- `f` (of type `string?`, which defaults to `null`): set format name
+- `stream_index` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `si` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `seek_point` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `sp` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `streams` (of type `string?`, which defaults to `null`): set streams
+- `s` (of type `string?`, which defaults to `null`): set streams
+- `loop` (of type `int?`, which defaults to `null`): set loop count. (default: 1)
+- `discontinuity` (of type `int?`, which defaults to `null`): set discontinuity threshold. (default: 0)
+- `dec_threads` (of type `int?`, which defaults to `null`): set the number of threads for decoding. (default: 0)
+- `format_opts` (of type `string?`, which defaults to `null`): set format options for the opened file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.amplify`
+
+Ffmpeg filter: Amplify changes between successive video frames.
+
+Type:
+
+```
+(?radius : int?, ?factor : float?, ?threshold : float?, ?tolerance : float?,
+ ?low : float?, ?high : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set radius. (default: 2)
+- `factor` (of type `float?`, which defaults to `null`): set factor. (default: 2.)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 10.)
+- `tolerance` (of type `float?`, which defaults to `null`): set tolerance. (default: 0.)
+- `low` (of type `float?`, which defaults to `null`): set low limit for amplification. (default: 65535.)
+- `high` (of type `float?`, which defaults to `null`): set high limit for amplification. (default: 65535.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.amplify.create`
+
+Ffmpeg filter: Amplify changes between successive video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?radius : int?, ?factor : float?, ?threshold : float?, ?tolerance : float?,
+ ?low : float?, ?high : float?, ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set radius. (default: 2)
+- `factor` (of type `float?`, which defaults to `null`): set factor. (default: 2.)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 10.)
+- `tolerance` (of type `float?`, which defaults to `null`): set tolerance. (default: 0.)
+- `low` (of type `float?`, which defaults to `null`): set low limit for amplification. (default: 65535.)
+- `high` (of type `float?`, which defaults to `null`): set high limit for amplification. (default: 65535.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.amultiply`
+
+Ffmpeg filter: Multiply two audio streams.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.amultiply.create`
+
+Ffmpeg filter: Multiply two audio streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anequalizer`
+
+Ffmpeg filter: Apply high-order audio parametric multi band equalizer. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?params : string?, ?curves : bool?, ?size : string?, ?mgain : float?,
+ ?fscale : int?, ?colors : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `params` (of type `string?`, which defaults to `null`): Default: 
+- `curves` (of type `bool?`, which defaults to `null`): draw frequency response curves. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `mgain` (of type `float?`, which defaults to `null`): set max gain. (default: 60.)
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 1, possible values: 0 (lin), 1 (log))
+- `colors` (of type `string?`, which defaults to `null`): set channels curves colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.anequalizer.create`
+
+Ffmpeg filter: Apply high-order audio parametric multi band equalizer. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?params : string?, ?curves : bool?, ?size : string?, ?mgain : float?,
+ ?fscale : int?, ?colors : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `params` (of type `string?`, which defaults to `null`): Default: 
+- `curves` (of type `bool?`, which defaults to `null`): draw frequency response curves. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: hd720)
+- `mgain` (of type `float?`, which defaults to `null`): set max gain. (default: 60.)
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 1, possible values: 0 (lin), 1 (log))
+- `colors` (of type `string?`, which defaults to `null`): set channels curves colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anlmdn`
+
+Ffmpeg filter: Reduce broadband noise from stream using Non-Local Means.
+
+Type:
+
+```
+(?strength : float?, ?s : float?, ?patch : int?, ?p : int?, ?research : int?,
+ ?r : int?, ?output : int?, ?o : int?, ?smooth : float?, ?m : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set denoising strength. (default: 1e-05)
+- `s` (of type `float?`, which defaults to `null`): set denoising strength. (default: 1e-05)
+- `patch` (of type `int?`, which defaults to `null`): set patch duration. (default: 2000)
+- `p` (of type `int?`, which defaults to `null`): set patch duration. (default: 2000)
+- `research` (of type `int?`, which defaults to `null`): set research duration. (default: 6000)
+- `r` (of type `int?`, which defaults to `null`): set research duration. (default: 6000)
+- `output` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (i), 1 (o), 2 (n))
+- `o` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (i), 1 (o), 2 (n))
+- `smooth` (of type `float?`, which defaults to `null`): set smooth factor. (default: 11.)
+- `m` (of type `float?`, which defaults to `null`): set smooth factor. (default: 11.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.anlmdn.create`
+
+Ffmpeg filter: Reduce broadband noise from stream using Non-Local Means.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?strength : float?, ?s : float?, ?patch : int?, ?p : int?, ?research : int?,
+ ?r : int?, ?output : int?, ?o : int?, ?smooth : float?, ?m : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set denoising strength. (default: 1e-05)
+- `s` (of type `float?`, which defaults to `null`): set denoising strength. (default: 1e-05)
+- `patch` (of type `int?`, which defaults to `null`): set patch duration. (default: 2000)
+- `p` (of type `int?`, which defaults to `null`): set patch duration. (default: 2000)
+- `research` (of type `int?`, which defaults to `null`): set research duration. (default: 6000)
+- `r` (of type `int?`, which defaults to `null`): set research duration. (default: 6000)
+- `output` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (i), 1 (o), 2 (n))
+- `o` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (i), 1 (o), 2 (n))
+- `smooth` (of type `float?`, which defaults to `null`): set smooth factor. (default: 11.)
+- `m` (of type `float?`, which defaults to `null`): set smooth factor. (default: 11.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anlmf`
+
+Ffmpeg filter: Apply Normalized Least-Mean-Fourth algorithm to first audio stream.
+
+Type:
+
+```
+(?order : int?, ?mu : float?, ?eps : float?, ?leakage : float?,
+ ?out_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.audio,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): set the filter order. (default: 256)
+- `mu` (of type `float?`, which defaults to `null`): set the filter mu. (default: 0.75)
+- `eps` (of type `float?`, which defaults to `null`): set the filter eps. (default: 1.)
+- `leakage` (of type `float?`, which defaults to `null`): set the filter leakage. (default: 0.)
+- `out_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 2, possible values: 0 (i), 1 (d), 2 (o), 3 (n), 4 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.anlmf.create`
+
+Ffmpeg filter: Apply Normalized Least-Mean-Fourth algorithm to first audio stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?order : int?, ?mu : float?, ?eps : float?, ?leakage : float?,
+ ?out_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): set the filter order. (default: 256)
+- `mu` (of type `float?`, which defaults to `null`): set the filter mu. (default: 0.75)
+- `eps` (of type `float?`, which defaults to `null`): set the filter eps. (default: 1.)
+- `leakage` (of type `float?`, which defaults to `null`): set the filter leakage. (default: 0.)
+- `out_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 2, possible values: 0 (i), 1 (d), 2 (o), 3 (n), 4 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anlms`
+
+Ffmpeg filter: Apply Normalized Least-Mean-Squares algorithm to first audio stream.
+
+Type:
+
+```
+(?order : int?, ?mu : float?, ?eps : float?, ?leakage : float?,
+ ?out_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.audio,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): set the filter order. (default: 256)
+- `mu` (of type `float?`, which defaults to `null`): set the filter mu. (default: 0.75)
+- `eps` (of type `float?`, which defaults to `null`): set the filter eps. (default: 1.)
+- `leakage` (of type `float?`, which defaults to `null`): set the filter leakage. (default: 0.)
+- `out_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 2, possible values: 0 (i), 1 (d), 2 (o), 3 (n), 4 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.anlms.create`
+
+Ffmpeg filter: Apply Normalized Least-Mean-Squares algorithm to first audio stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?order : int?, ?mu : float?, ?eps : float?, ?leakage : float?,
+ ?out_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): set the filter order. (default: 256)
+- `mu` (of type `float?`, which defaults to `null`): set the filter mu. (default: 0.75)
+- `eps` (of type `float?`, which defaults to `null`): set the filter eps. (default: 1.)
+- `leakage` (of type `float?`, which defaults to `null`): set the filter leakage. (default: 0.)
+- `out_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 2, possible values: 0 (i), 1 (d), 2 (o), 3 (n), 4 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anoisesrc`
+
+Ffmpeg filter: Generate a noise audio signal.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ?amplitude : float?, ?a : float?,
+ ?duration : int?, ?d : int?, ?color : int?, ?colour : int?, ?c : int?,
+ ?seed : int?, ?s : int?, ?nb_samples : int?, ?n : int?, ?density : float?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 48000)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 48000)
+- `amplitude` (of type `float?`, which defaults to `null`): set amplitude. (default: 1.)
+- `a` (of type `float?`, which defaults to `null`): set amplitude. (default: 1.)
+- `duration` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `color` (of type `int?`, which defaults to `null`): set noise color. (default: 0, possible values: 0 (white), 1 (pink), 2 (brown), 3 (blue), 4 (violet), 5 (velvet))
+- `colour` (of type `int?`, which defaults to `null`): set noise color. (default: 0, possible values: 0 (white), 1 (pink), 2 (brown), 3 (blue), 4 (violet), 5 (velvet))
+- `c` (of type `int?`, which defaults to `null`): set noise color. (default: 0, possible values: 0 (white), 1 (pink), 2 (brown), 3 (blue), 4 (violet), 5 (velvet))
+- `seed` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `s` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `density` (of type `float?`, which defaults to `null`): set density. (default: 0.05)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.anoisesrc.create`
+
+Ffmpeg filter: Generate a noise audio signal.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ?amplitude : float?, ?a : float?,
+ ?duration : int?, ?d : int?, ?color : int?, ?colour : int?, ?c : int?,
+ ?seed : int?, ?s : int?, ?nb_samples : int?, ?n : int?, ?density : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 48000)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 48000)
+- `amplitude` (of type `float?`, which defaults to `null`): set amplitude. (default: 1.)
+- `a` (of type `float?`, which defaults to `null`): set amplitude. (default: 1.)
+- `duration` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `color` (of type `int?`, which defaults to `null`): set noise color. (default: 0, possible values: 0 (white), 1 (pink), 2 (brown), 3 (blue), 4 (violet), 5 (velvet))
+- `colour` (of type `int?`, which defaults to `null`): set noise color. (default: 0, possible values: 0 (white), 1 (pink), 2 (brown), 3 (blue), 4 (violet), 5 (velvet))
+- `c` (of type `int?`, which defaults to `null`): set noise color. (default: 0, possible values: 0 (white), 1 (pink), 2 (brown), 3 (blue), 4 (violet), 5 (velvet))
+- `seed` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `s` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `density` (of type `float?`, which defaults to `null`): set density. (default: 0.05)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anull`
+
+Ffmpeg filter: Pass the source unchanged to the output.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.anull.create`
+
+Ffmpeg filter: Pass the source unchanged to the output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anullsink`
+
+Ffmpeg filter: Do absolutely nothing with the input audio.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.anullsink.create`
+
+Ffmpeg filter: Do absolutely nothing with the input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `unit`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.anullsrc`
+
+Ffmpeg filter: Null audio source, return empty audio frames.
+
+Type:
+
+```
+(?channel_layout : string?, ?cl : string?, ?sample_rate : string?,
+ ?r : string?, ?nb_samples : int?, ?n : int?, ?duration : int?, ?d : int?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel_layout. (default: stereo)
+- `cl` (of type `string?`, which defaults to `null`): set channel_layout. (default: stereo)
+- `sample_rate` (of type `string?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `string?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `duration` (of type `int?`, which defaults to `null`): set the audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set the audio duration. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.anullsrc.create`
+
+Ffmpeg filter: Null audio source, return empty audio frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?channel_layout : string?, ?cl : string?, ?sample_rate : string?,
+ ?r : string?, ?nb_samples : int?, ?n : int?, ?duration : int?, ?d : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `channel_layout` (of type `string?`, which defaults to `null`): set channel_layout. (default: stereo)
+- `cl` (of type `string?`, which defaults to `null`): set channel_layout. (default: stereo)
+- `sample_rate` (of type `string?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `string?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `duration` (of type `int?`, which defaults to `null`): set the audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set the audio duration. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.apad`
+
+Ffmpeg filter: Pad audio with silence.
+
+Type:
+
+```
+(?packet_size : int?, ?pad_len : int?, ?whole_len : int?, ?pad_dur : int?,
+ ?whole_dur : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `packet_size` (of type `int?`, which defaults to `null`): set silence packet size. (default: 4096)
+- `pad_len` (of type `int?`, which defaults to `null`): set number of samples of silence to add. (default: -1)
+- `whole_len` (of type `int?`, which defaults to `null`): set minimum target number of samples in the audio stream. (default: -1)
+- `pad_dur` (of type `int?`, which defaults to `null`): set duration of silence to add. (default: -1)
+- `whole_dur` (of type `int?`, which defaults to `null`): set minimum target duration in the audio stream. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.apad.create`
+
+Ffmpeg filter: Pad audio with silence.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?packet_size : int?, ?pad_len : int?, ?whole_len : int?, ?pad_dur : int?,
+ ?whole_dur : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `packet_size` (of type `int?`, which defaults to `null`): set silence packet size. (default: 4096)
+- `pad_len` (of type `int?`, which defaults to `null`): set number of samples of silence to add. (default: -1)
+- `whole_len` (of type `int?`, which defaults to `null`): set minimum target number of samples in the audio stream. (default: -1)
+- `pad_dur` (of type `int?`, which defaults to `null`): set duration of silence to add. (default: -1)
+- `whole_dur` (of type `int?`, which defaults to `null`): set minimum target duration in the audio stream. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aperms`
+
+Ffmpeg filter: Set permissions for the output audio frame.
+
+Type:
+
+```
+(?mode : int?, ?seed : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select permissions mode. (default: 0, possible values: 0 (none), 1 (ro), 2 (rw), 3 (toggle), 4 (random))
+- `seed` (of type `int?`, which defaults to `null`): set the seed for the random mode. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aperms.create`
+
+Ffmpeg filter: Set permissions for the output audio frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?seed : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select permissions mode. (default: 0, possible values: 0 (none), 1 (ro), 2 (rw), 3 (toggle), 4 (random))
+- `seed` (of type `int?`, which defaults to `null`): set the seed for the random mode. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aphasemeter`
+
+Ffmpeg filter: Convert input audio to phase meter video output. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?size : string?, ?s : string?, ?rc : int?,
+ ?gc : int?, ?bc : int?, ?mpc : string?, ?video : bool?, ?phasing : bool?,
+ ?tolerance : float?, ?t : float?, ?angle : float?, ?a : float?,
+ ?duration : int?, ?d : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 800x400)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 800x400)
+- `rc` (of type `int?`, which defaults to `null`): set red contrast. (default: 2)
+- `gc` (of type `int?`, which defaults to `null`): set green contrast. (default: 7)
+- `bc` (of type `int?`, which defaults to `null`): set blue contrast. (default: 1)
+- `mpc` (of type `string?`, which defaults to `null`): set median phase color. (default: none)
+- `video` (of type `bool?`, which defaults to `null`): set video output. (default: true)
+- `phasing` (of type `bool?`, which defaults to `null`): set mono and out-of-phase detection output. (default: false)
+- `tolerance` (of type `float?`, which defaults to `null`): set phase tolerance for mono detection. (default: 0.)
+- `t` (of type `float?`, which defaults to `null`): set phase tolerance for mono detection. (default: 0.)
+- `angle` (of type `float?`, which defaults to `null`): set angle threshold for out-of-phase detection. (default: 170.)
+- `a` (of type `float?`, which defaults to `null`): set angle threshold for out-of-phase detection. (default: 170.)
+- `duration` (of type `int?`, which defaults to `null`): set minimum mono or out-of-phase duration in seconds. (default: 2000000)
+- `d` (of type `int?`, which defaults to `null`): set minimum mono or out-of-phase duration in seconds. (default: 2000000)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aphasemeter.create`
+
+Ffmpeg filter: Convert input audio to phase meter video output. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?size : string?, ?s : string?, ?rc : int?,
+ ?gc : int?, ?bc : int?, ?mpc : string?, ?video : bool?, ?phasing : bool?,
+ ?tolerance : float?, ?t : float?, ?angle : float?, ?a : float?,
+ ?duration : int?, ?d : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 800x400)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 800x400)
+- `rc` (of type `int?`, which defaults to `null`): set red contrast. (default: 2)
+- `gc` (of type `int?`, which defaults to `null`): set green contrast. (default: 7)
+- `bc` (of type `int?`, which defaults to `null`): set blue contrast. (default: 1)
+- `mpc` (of type `string?`, which defaults to `null`): set median phase color. (default: none)
+- `video` (of type `bool?`, which defaults to `null`): set video output. (default: true)
+- `phasing` (of type `bool?`, which defaults to `null`): set mono and out-of-phase detection output. (default: false)
+- `tolerance` (of type `float?`, which defaults to `null`): set phase tolerance for mono detection. (default: 0.)
+- `t` (of type `float?`, which defaults to `null`): set phase tolerance for mono detection. (default: 0.)
+- `angle` (of type `float?`, which defaults to `null`): set angle threshold for out-of-phase detection. (default: 170.)
+- `a` (of type `float?`, which defaults to `null`): set angle threshold for out-of-phase detection. (default: 170.)
+- `duration` (of type `int?`, which defaults to `null`): set minimum mono or out-of-phase duration in seconds. (default: 2000000)
+- `d` (of type `int?`, which defaults to `null`): set minimum mono or out-of-phase duration in seconds. (default: 2000000)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aphaser`
+
+Ffmpeg filter: Add a phasing effect to the audio.
+
+Type:
+
+```
+(?in_gain : float?, ?out_gain : float?, ?delay : float?, ?decay : float?,
+ ?speed : float?, ?type : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `in_gain` (of type `float?`, which defaults to `null`): set input gain. (default: 0.4)
+- `out_gain` (of type `float?`, which defaults to `null`): set output gain. (default: 0.74)
+- `delay` (of type `float?`, which defaults to `null`): set delay in milliseconds. (default: 3.)
+- `decay` (of type `float?`, which defaults to `null`): set decay. (default: 0.4)
+- `speed` (of type `float?`, which defaults to `null`): set modulation speed. (default: 0.5)
+- `type` (of type `int?`, which defaults to `null`): set modulation type. (default: 1, possible values: 1 (triangular), 1 (t), 0 (sinusoidal), 0 (s))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aphaser.create`
+
+Ffmpeg filter: Add a phasing effect to the audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?in_gain : float?, ?out_gain : float?, ?delay : float?, ?decay : float?,
+ ?speed : float?, ?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `in_gain` (of type `float?`, which defaults to `null`): set input gain. (default: 0.4)
+- `out_gain` (of type `float?`, which defaults to `null`): set output gain. (default: 0.74)
+- `delay` (of type `float?`, which defaults to `null`): set delay in milliseconds. (default: 3.)
+- `decay` (of type `float?`, which defaults to `null`): set decay. (default: 0.4)
+- `speed` (of type `float?`, which defaults to `null`): set modulation speed. (default: 0.5)
+- `type` (of type `int?`, which defaults to `null`): set modulation type. (default: 1, possible values: 1 (triangular), 1 (t), 0 (sinusoidal), 0 (s))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aphaseshift`
+
+Ffmpeg filter: Apply phase shifting to input audio.
+
+Type:
+
+```
+(?shift : float?, ?level : float?, ?order : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `shift` (of type `float?`, which defaults to `null`): set phase shift. (default: 0.)
+- `level` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aphaseshift.create`
+
+Ffmpeg filter: Apply phase shifting to input audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?shift : float?, ?level : float?, ?order : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `shift` (of type `float?`, which defaults to `null`): set phase shift. (default: 0.)
+- `level` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.apsnr`
+
+Ffmpeg filter: Measure Audio Peak Signal-to-Noise Ratio.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.apsnr.create`
+
+Ffmpeg filter: Measure Audio Peak Signal-to-Noise Ratio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.apsyclip`
+
+Ffmpeg filter: Audio Psychoacoustic Clipper.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?clip : float?, ?diff : bool?,
+ ?adaptive : float?, ?iterations : int?, ?level : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `clip` (of type `float?`, which defaults to `null`): set clip level. (default: 1.)
+- `diff` (of type `bool?`, which defaults to `null`): enable difference. (default: false)
+- `adaptive` (of type `float?`, which defaults to `null`): set adaptive distortion. (default: 0.5)
+- `iterations` (of type `int?`, which defaults to `null`): set iterations. (default: 10)
+- `level` (of type `bool?`, which defaults to `null`): set auto level. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.apsyclip.create`
+
+Ffmpeg filter: Audio Psychoacoustic Clipper.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?clip : float?, ?diff : bool?,
+ ?adaptive : float?, ?iterations : int?, ?level : bool?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `clip` (of type `float?`, which defaults to `null`): set clip level. (default: 1.)
+- `diff` (of type `bool?`, which defaults to `null`): enable difference. (default: false)
+- `adaptive` (of type `float?`, which defaults to `null`): set adaptive distortion. (default: 0.5)
+- `iterations` (of type `int?`, which defaults to `null`): set iterations. (default: 10)
+- `level` (of type `bool?`, which defaults to `null`): set auto level. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.apulsator`
+
+Ffmpeg filter: Audio pulsator.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?mode : int?, ?amount : float?,
+ ?offset_l : float?, ?offset_r : float?, ?width : float?, ?timing : int?,
+ ?bpm : float?, ?ms : int?, ?hz : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (sine), 1 (triangle), 2 (square), 3 (sawup), 4 (sawdown))
+- `amount` (of type `float?`, which defaults to `null`): set modulation. (default: 1.)
+- `offset_l` (of type `float?`, which defaults to `null`): set offset L. (default: 0.)
+- `offset_r` (of type `float?`, which defaults to `null`): set offset R. (default: 0.5)
+- `width` (of type `float?`, which defaults to `null`): set pulse width. (default: 1.)
+- `timing` (of type `int?`, which defaults to `null`): set timing. (default: 2, possible values: 0 (bpm), 1 (ms), 2 (hz))
+- `bpm` (of type `float?`, which defaults to `null`): set BPM. (default: 120.)
+- `ms` (of type `int?`, which defaults to `null`): set ms. (default: 500)
+- `hz` (of type `float?`, which defaults to `null`): set frequency. (default: 2.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.apulsator.create`
+
+Ffmpeg filter: Audio pulsator.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?mode : int?, ?amount : float?,
+ ?offset_l : float?, ?offset_r : float?, ?width : float?, ?timing : int?,
+ ?bpm : float?, ?ms : int?, ?hz : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (sine), 1 (triangle), 2 (square), 3 (sawup), 4 (sawdown))
+- `amount` (of type `float?`, which defaults to `null`): set modulation. (default: 1.)
+- `offset_l` (of type `float?`, which defaults to `null`): set offset L. (default: 0.)
+- `offset_r` (of type `float?`, which defaults to `null`): set offset R. (default: 0.5)
+- `width` (of type `float?`, which defaults to `null`): set pulse width. (default: 1.)
+- `timing` (of type `int?`, which defaults to `null`): set timing. (default: 2, possible values: 0 (bpm), 1 (ms), 2 (hz))
+- `bpm` (of type `float?`, which defaults to `null`): set BPM. (default: 120.)
+- `ms` (of type `int?`, which defaults to `null`): set ms. (default: 500)
+- `hz` (of type `float?`, which defaults to `null`): set frequency. (default: 2.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.arealtime`
+
+Ffmpeg filter: Slow down filtering to match realtime.
+
+Type:
+
+```
+(?limit : int?, ?speed : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `limit` (of type `int?`, which defaults to `null`): sleep time limit. (default: 2000000)
+- `speed` (of type `float?`, which defaults to `null`): speed factor. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.arealtime.create`
+
+Ffmpeg filter: Slow down filtering to match realtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?limit : int?, ?speed : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `limit` (of type `int?`, which defaults to `null`): sleep time limit. (default: 2000000)
+- `speed` (of type `float?`, which defaults to `null`): speed factor. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aresample`
+
+Ffmpeg filter: Resample audio data.
+
+Type:
+
+```
+(?sample_rate : int?, ?ich : int?, ?in_channel_count : int?, ?och : int?,
+ ?out_channel_count : int?, ?uch : int?, ?used_channel_count : int?,
+ ?isr : int?, ?in_sample_rate : int?, ?osr : int?, ?out_sample_rate : int?,
+ ?isf : string?, ?in_sample_fmt : string?, ?osf : string?,
+ ?out_sample_fmt : string?, ?tsf : string?, ?internal_sample_fmt : string?,
+ ?icl : string?, ?in_channel_layout : string?, ?ocl : string?,
+ ?out_channel_layout : string?, ?clev : float?, ?center_mix_level : float?,
+ ?slev : float?, ?surround_mix_level : float?, ?lfe_mix_level : float?,
+ ?rmvol : float?, ?rematrix_volume : float?, ?rematrix_maxval : float?,
+ ?flags : int?, ?swr_flags : int?, ?dither_scale : float?,
+ ?dither_method : int?, ?filter_size : int?, ?phase_shift : int?,
+ ?linear_interp : bool?, ?exact_rational : bool?, ?cutoff : float?,
+ ?resample_cutoff : float?, ?resampler : int?, ?precision : float?,
+ ?cheby : bool?, ?min_comp : float?, ?min_hard_comp : float?,
+ ?comp_duration : float?, ?max_soft_comp : float?, ?async : float?,
+ ?first_pts : int?, ?matrix_encoding : int?, ?filter_type : int?,
+ ?kaiser_beta : float?, ?output_sample_bits : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): Default: 0
+- `ich` (of type `int?`, which defaults to `null`): set input channel count (Deprecated, use ichl). (default: 0)
+- `in_channel_count` (of type `int?`, which defaults to `null`): set input channel count (Deprecated, use in_chlayout). (default: 0)
+- `och` (of type `int?`, which defaults to `null`): set output channel count (Deprecated, use ochl). (default: 0)
+- `out_channel_count` (of type `int?`, which defaults to `null`): set output channel count (Deprecated, use out_chlayout). (default: 0)
+- `uch` (of type `int?`, which defaults to `null`): set used channel count. (default: 0)
+- `used_channel_count` (of type `int?`, which defaults to `null`): set used channel count. (default: 0)
+- `isr` (of type `int?`, which defaults to `null`): set input sample rate. (default: 0)
+- `in_sample_rate` (of type `int?`, which defaults to `null`): set input sample rate. (default: 0)
+- `osr` (of type `int?`, which defaults to `null`): set output sample rate. (default: 0)
+- `out_sample_rate` (of type `int?`, which defaults to `null`): set output sample rate. (default: 0)
+- `isf` (of type `string?`, which defaults to `null`): set input sample format
+- `in_sample_fmt` (of type `string?`, which defaults to `null`): set input sample format
+- `osf` (of type `string?`, which defaults to `null`): set output sample format
+- `out_sample_fmt` (of type `string?`, which defaults to `null`): set output sample format
+- `tsf` (of type `string?`, which defaults to `null`): set internal sample format
+- `internal_sample_fmt` (of type `string?`, which defaults to `null`): set internal sample format
+- `icl` (of type `string?`, which defaults to `null`): set input channel layout (Deprecated, use ichl)
+- `in_channel_layout` (of type `string?`, which defaults to `null`): set input channel layout (Deprecated, use in_chlayout)
+- `ocl` (of type `string?`, which defaults to `null`): set output channel layout (Deprecated, use ochl)
+- `out_channel_layout` (of type `string?`, which defaults to `null`): set output channel layout (Deprecated, use out_chlayout)
+- `clev` (of type `float?`, which defaults to `null`): set center mix level. (default: 0.707106781187)
+- `center_mix_level` (of type `float?`, which defaults to `null`): set center mix level. (default: 0.707106781187)
+- `slev` (of type `float?`, which defaults to `null`): set surround mix level. (default: 0.707106781187)
+- `surround_mix_level` (of type `float?`, which defaults to `null`): set surround mix Level. (default: 0.707106781187)
+- `lfe_mix_level` (of type `float?`, which defaults to `null`): set LFE mix level. (default: 0.)
+- `rmvol` (of type `float?`, which defaults to `null`): set rematrix volume. (default: 1.)
+- `rematrix_volume` (of type `float?`, which defaults to `null`): set rematrix volume. (default: 1.)
+- `rematrix_maxval` (of type `float?`, which defaults to `null`): set rematrix maxval. (default: 0.)
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 0, possible values: 1 (res))
+- `swr_flags` (of type `int?`, which defaults to `null`): set flags. (default: 0, possible values: 1 (res))
+- `dither_scale` (of type `float?`, which defaults to `null`): set dither scale. (default: 1.)
+- `dither_method` (of type `int?`, which defaults to `null`): set dither method. (default: 0, possible values: 1 (rectangular), 2 (triangular), 3 (triangular_hp), 65 (lipshitz), 69 (shibata), 70 (low_shibata), 71 (high_shibata), 66 (f_weighted), 67 (modified_e_weighted), 68 (improved_e_weighted))
+- `filter_size` (of type `int?`, which defaults to `null`): set swr resampling filter size. (default: 32)
+- `phase_shift` (of type `int?`, which defaults to `null`): set swr resampling phase shift. (default: 10)
+- `linear_interp` (of type `bool?`, which defaults to `null`): enable linear interpolation. (default: true)
+- `exact_rational` (of type `bool?`, which defaults to `null`): enable exact rational. (default: true)
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency ratio. (default: 0.)
+- `resample_cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency ratio. (default: 0.)
+- `resampler` (of type `int?`, which defaults to `null`): set resampling Engine. (default: 0, possible values: 0 (swr), 1 (soxr))
+- `precision` (of type `float?`, which defaults to `null`): set soxr resampling precision (in bits). (default: 20.)
+- `cheby` (of type `bool?`, which defaults to `null`): enable soxr Chebyshev passband & higher-precision irrational ratio approximation. (default: false)
+- `min_comp` (of type `float?`, which defaults to `null`): set minimum difference between timestamps and audio data (in seconds) below which no timestamp compensation of either kind is applied. (default: 3.40282346639e+38)
+- `min_hard_comp` (of type `float?`, which defaults to `null`): set minimum difference between timestamps and audio data (in seconds) to trigger padding/trimming the data.. (default: 0.1)
+- `comp_duration` (of type `float?`, which defaults to `null`): set duration (in seconds) over which data is stretched/squeezed to make it match the timestamps.. (default: 1.)
+- `max_soft_comp` (of type `float?`, which defaults to `null`): set maximum factor by which data is stretched/squeezed to make it match the timestamps.. (default: 0.)
+- `async` (of type `float?`, which defaults to `null`): simplified 1 parameter audio timestamp matching, 0(disabled), 1(filling and trimming), >1(maximum stretch/squeeze in samples per second). (default: 0.)
+- `first_pts` (of type `int?`, which defaults to `null`): Assume the first pts should be this value (in samples).. (default: -9223372036854775808)
+- `matrix_encoding` (of type `int?`, which defaults to `null`): set matrixed stereo encoding. (default: 0, possible values: 0 (none), 1 (dolby), 2 (dplii))
+- `filter_type` (of type `int?`, which defaults to `null`): select swr filter type. (default: 2, possible values: 0 (cubic), 1 (blackman_nuttall), 2 (kaiser))
+- `kaiser_beta` (of type `float?`, which defaults to `null`): set swr Kaiser window beta. (default: 9.)
+- `output_sample_bits` (of type `int?`, which defaults to `null`): set swr number of output sample bits. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aresample.create`
+
+Ffmpeg filter: Resample audio data.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_rate : int?, ?ich : int?, ?in_channel_count : int?, ?och : int?,
+ ?out_channel_count : int?, ?uch : int?, ?used_channel_count : int?,
+ ?isr : int?, ?in_sample_rate : int?, ?osr : int?, ?out_sample_rate : int?,
+ ?isf : string?, ?in_sample_fmt : string?, ?osf : string?,
+ ?out_sample_fmt : string?, ?tsf : string?, ?internal_sample_fmt : string?,
+ ?icl : string?, ?in_channel_layout : string?, ?ocl : string?,
+ ?out_channel_layout : string?, ?clev : float?, ?center_mix_level : float?,
+ ?slev : float?, ?surround_mix_level : float?, ?lfe_mix_level : float?,
+ ?rmvol : float?, ?rematrix_volume : float?, ?rematrix_maxval : float?,
+ ?flags : int?, ?swr_flags : int?, ?dither_scale : float?,
+ ?dither_method : int?, ?filter_size : int?, ?phase_shift : int?,
+ ?linear_interp : bool?, ?exact_rational : bool?, ?cutoff : float?,
+ ?resample_cutoff : float?, ?resampler : int?, ?precision : float?,
+ ?cheby : bool?, ?min_comp : float?, ?min_hard_comp : float?,
+ ?comp_duration : float?, ?max_soft_comp : float?, ?async : float?,
+ ?first_pts : int?, ?matrix_encoding : int?, ?filter_type : int?,
+ ?kaiser_beta : float?, ?output_sample_bits : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): Default: 0
+- `ich` (of type `int?`, which defaults to `null`): set input channel count (Deprecated, use ichl). (default: 0)
+- `in_channel_count` (of type `int?`, which defaults to `null`): set input channel count (Deprecated, use in_chlayout). (default: 0)
+- `och` (of type `int?`, which defaults to `null`): set output channel count (Deprecated, use ochl). (default: 0)
+- `out_channel_count` (of type `int?`, which defaults to `null`): set output channel count (Deprecated, use out_chlayout). (default: 0)
+- `uch` (of type `int?`, which defaults to `null`): set used channel count. (default: 0)
+- `used_channel_count` (of type `int?`, which defaults to `null`): set used channel count. (default: 0)
+- `isr` (of type `int?`, which defaults to `null`): set input sample rate. (default: 0)
+- `in_sample_rate` (of type `int?`, which defaults to `null`): set input sample rate. (default: 0)
+- `osr` (of type `int?`, which defaults to `null`): set output sample rate. (default: 0)
+- `out_sample_rate` (of type `int?`, which defaults to `null`): set output sample rate. (default: 0)
+- `isf` (of type `string?`, which defaults to `null`): set input sample format
+- `in_sample_fmt` (of type `string?`, which defaults to `null`): set input sample format
+- `osf` (of type `string?`, which defaults to `null`): set output sample format
+- `out_sample_fmt` (of type `string?`, which defaults to `null`): set output sample format
+- `tsf` (of type `string?`, which defaults to `null`): set internal sample format
+- `internal_sample_fmt` (of type `string?`, which defaults to `null`): set internal sample format
+- `icl` (of type `string?`, which defaults to `null`): set input channel layout (Deprecated, use ichl)
+- `in_channel_layout` (of type `string?`, which defaults to `null`): set input channel layout (Deprecated, use in_chlayout)
+- `ocl` (of type `string?`, which defaults to `null`): set output channel layout (Deprecated, use ochl)
+- `out_channel_layout` (of type `string?`, which defaults to `null`): set output channel layout (Deprecated, use out_chlayout)
+- `clev` (of type `float?`, which defaults to `null`): set center mix level. (default: 0.707106781187)
+- `center_mix_level` (of type `float?`, which defaults to `null`): set center mix level. (default: 0.707106781187)
+- `slev` (of type `float?`, which defaults to `null`): set surround mix level. (default: 0.707106781187)
+- `surround_mix_level` (of type `float?`, which defaults to `null`): set surround mix Level. (default: 0.707106781187)
+- `lfe_mix_level` (of type `float?`, which defaults to `null`): set LFE mix level. (default: 0.)
+- `rmvol` (of type `float?`, which defaults to `null`): set rematrix volume. (default: 1.)
+- `rematrix_volume` (of type `float?`, which defaults to `null`): set rematrix volume. (default: 1.)
+- `rematrix_maxval` (of type `float?`, which defaults to `null`): set rematrix maxval. (default: 0.)
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 0, possible values: 1 (res))
+- `swr_flags` (of type `int?`, which defaults to `null`): set flags. (default: 0, possible values: 1 (res))
+- `dither_scale` (of type `float?`, which defaults to `null`): set dither scale. (default: 1.)
+- `dither_method` (of type `int?`, which defaults to `null`): set dither method. (default: 0, possible values: 1 (rectangular), 2 (triangular), 3 (triangular_hp), 65 (lipshitz), 69 (shibata), 70 (low_shibata), 71 (high_shibata), 66 (f_weighted), 67 (modified_e_weighted), 68 (improved_e_weighted))
+- `filter_size` (of type `int?`, which defaults to `null`): set swr resampling filter size. (default: 32)
+- `phase_shift` (of type `int?`, which defaults to `null`): set swr resampling phase shift. (default: 10)
+- `linear_interp` (of type `bool?`, which defaults to `null`): enable linear interpolation. (default: true)
+- `exact_rational` (of type `bool?`, which defaults to `null`): enable exact rational. (default: true)
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency ratio. (default: 0.)
+- `resample_cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency ratio. (default: 0.)
+- `resampler` (of type `int?`, which defaults to `null`): set resampling Engine. (default: 0, possible values: 0 (swr), 1 (soxr))
+- `precision` (of type `float?`, which defaults to `null`): set soxr resampling precision (in bits). (default: 20.)
+- `cheby` (of type `bool?`, which defaults to `null`): enable soxr Chebyshev passband & higher-precision irrational ratio approximation. (default: false)
+- `min_comp` (of type `float?`, which defaults to `null`): set minimum difference between timestamps and audio data (in seconds) below which no timestamp compensation of either kind is applied. (default: 3.40282346639e+38)
+- `min_hard_comp` (of type `float?`, which defaults to `null`): set minimum difference between timestamps and audio data (in seconds) to trigger padding/trimming the data.. (default: 0.1)
+- `comp_duration` (of type `float?`, which defaults to `null`): set duration (in seconds) over which data is stretched/squeezed to make it match the timestamps.. (default: 1.)
+- `max_soft_comp` (of type `float?`, which defaults to `null`): set maximum factor by which data is stretched/squeezed to make it match the timestamps.. (default: 0.)
+- `async` (of type `float?`, which defaults to `null`): simplified 1 parameter audio timestamp matching, 0(disabled), 1(filling and trimming), >1(maximum stretch/squeeze in samples per second). (default: 0.)
+- `first_pts` (of type `int?`, which defaults to `null`): Assume the first pts should be this value (in samples).. (default: -9223372036854775808)
+- `matrix_encoding` (of type `int?`, which defaults to `null`): set matrixed stereo encoding. (default: 0, possible values: 0 (none), 1 (dolby), 2 (dplii))
+- `filter_type` (of type `int?`, which defaults to `null`): select swr filter type. (default: 2, possible values: 0 (cubic), 1 (blackman_nuttall), 2 (kaiser))
+- `kaiser_beta` (of type `float?`, which defaults to `null`): set swr Kaiser window beta. (default: 9.)
+- `output_sample_bits` (of type `int?`, which defaults to `null`): set swr number of output sample bits. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.areverse`
+
+Ffmpeg filter: Reverse an audio clip.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.areverse.create`
+
+Ffmpeg filter: Reverse an audio clip.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.arls`
+
+Ffmpeg filter: Apply Recursive Least Squares algorithm to first audio stream.
+
+Type:
+
+```
+(?order : int?, ?lambda : float?, ?delta : float?, ?out_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): set the filter order. (default: 16)
+- `lambda` (of type `float?`, which defaults to `null`): set the filter lambda. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set the filter delta. (default: 2.)
+- `out_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 2, possible values: 0 (i), 1 (d), 2 (o), 3 (n), 4 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.arls.create`
+
+Ffmpeg filter: Apply Recursive Least Squares algorithm to first audio stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?order : int?, ?lambda : float?, ?delta : float?, ?out_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): set the filter order. (default: 16)
+- `lambda` (of type `float?`, which defaults to `null`): set the filter lambda. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set the filter delta. (default: 2.)
+- `out_mode` (of type `int?`, which defaults to `null`): set output mode. (default: 2, possible values: 0 (i), 1 (d), 2 (o), 3 (n), 4 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.arnndn`
+
+Ffmpeg filter: Reduce noise from speech using Recurrent Neural Networks.
+
+Type:
+
+```
+(?model : string?, ?m : string?, ?mix : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `model` (of type `string?`, which defaults to `null`): set model name
+- `m` (of type `string?`, which defaults to `null`): set model name
+- `mix` (of type `float?`, which defaults to `null`): set output vs input mix. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.arnndn.create`
+
+Ffmpeg filter: Reduce noise from speech using Recurrent Neural Networks.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?model : string?, ?m : string?, ?mix : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `model` (of type `string?`, which defaults to `null`): set model name
+- `m` (of type `string?`, which defaults to `null`): set model name
+- `mix` (of type `float?`, which defaults to `null`): set output vs input mix. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asdr`
+
+Ffmpeg filter: Measure Audio Signal-to-Distortion Ratio.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asdr.create`
+
+Ffmpeg filter: Measure Audio Signal-to-Distortion Ratio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asegment`
+
+Ffmpeg filter: Segment audio stream. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?timestamps : string?, ?samples : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `timestamps` (of type `string?`, which defaults to `null`): timestamps of input at which to split input
+- `samples` (of type `string?`, which defaults to `null`): samples at which to split input
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asegment.create`
+
+Ffmpeg filter: Segment audio stream. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?timestamps : string?, ?samples : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `timestamps` (of type `string?`, which defaults to `null`): timestamps of input at which to split input
+- `samples` (of type `string?`, which defaults to `null`): samples at which to split input
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aselect`
+
+Ffmpeg filter: Select audio frames to pass in output. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?expr : string?, ?e : string?, ?outputs : int?, ?n : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `e` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `outputs` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `n` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aselect.create`
+
+Ffmpeg filter: Select audio frames to pass in output. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?expr : string?, ?e : string?, ?outputs : int?, ?n : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `e` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `outputs` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `n` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asendcmd`
+
+Ffmpeg filter: Send commands to filters.
+
+Type:
+
+```
+(?commands : string?, ?c : string?, ?filename : string?, ?f : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `commands` (of type `string?`, which defaults to `null`): set commands
+- `c` (of type `string?`, which defaults to `null`): set commands
+- `filename` (of type `string?`, which defaults to `null`): set commands file
+- `f` (of type `string?`, which defaults to `null`): set commands file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asendcmd.create`
+
+Ffmpeg filter: Send commands to filters.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?commands : string?, ?c : string?, ?filename : string?, ?f : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `commands` (of type `string?`, which defaults to `null`): set commands
+- `c` (of type `string?`, which defaults to `null`): set commands
+- `filename` (of type `string?`, which defaults to `null`): set commands file
+- `f` (of type `string?`, which defaults to `null`): set commands file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asetnsamples`
+
+Ffmpeg filter: Set the number of samples for each output audio frames.
+
+Type:
+
+```
+(?nb_out_samples : int?, ?n : int?, ?pad : bool?, ?p : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `nb_out_samples` (of type `int?`, which defaults to `null`): set the number of per-frame output samples. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of per-frame output samples. (default: 1024)
+- `pad` (of type `bool?`, which defaults to `null`): pad last frame with zeros. (default: true)
+- `p` (of type `bool?`, which defaults to `null`): pad last frame with zeros. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asetnsamples.create`
+
+Ffmpeg filter: Set the number of samples for each output audio frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?nb_out_samples : int?, ?n : int?, ?pad : bool?, ?p : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `nb_out_samples` (of type `int?`, which defaults to `null`): set the number of per-frame output samples. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of per-frame output samples. (default: 1024)
+- `pad` (of type `bool?`, which defaults to `null`): pad last frame with zeros. (default: true)
+- `p` (of type `bool?`, which defaults to `null`): pad last frame with zeros. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asetpts`
+
+Ffmpeg filter: Set PTS for the output audio frame.
+
+Type:
+
+```
+(?expr : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): Expression determining the frame timestamp. (default: PTS)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asetpts.create`
+
+Ffmpeg filter: Set PTS for the output audio frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?expr : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): Expression determining the frame timestamp. (default: PTS)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asetrate`
+
+Ffmpeg filter: Change the sample rate without altering the data.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asetrate.create`
+
+Ffmpeg filter: Change the sample rate without altering the data.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asettb`
+
+Ffmpeg filter: Set timebase for the audio output link.
+
+Type:
+
+```
+(?expr : string?, ?tb : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `tb` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asettb.create`
+
+Ffmpeg filter: Set timebase for the audio output link.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?expr : string?, ?tb : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `tb` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ashowinfo`
+
+Ffmpeg filter: Show textual information for each audio frame.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.ashowinfo.create`
+
+Ffmpeg filter: Show textual information for each audio frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asidedata`
+
+Ffmpeg filter: Manipulate audio frame side data.
+
+Type:
+
+```
+(?mode : int?, ?type : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (delete))
+- `type` (of type `int?`, which defaults to `null`): set side data type. (default: -1, possible values: 0 (PANSCAN), 1 (A53_CC), 2 (STEREO3D), 3 (MATRIXENCODING), 4 (DOWNMIX_INFO), 5 (REPLAYGAIN), 6 (DISPLAYMATRIX), 7 (AFD), 8 (MOTION_VECTORS), 9 (SKIP_SAMPLES), 10 (AUDIO_SERVICE_TYPE), 11 (MASTERING_DISPLAY_METADATA), 12 (GOP_TIMECODE), 13 (SPHERICAL), 14 (CONTENT_LIGHT_LEVEL), 15 (ICC_PROFILE), 16 (S12M_TIMECOD), 17 (DYNAMIC_HDR_PLUS), 18 (REGIONS_OF_INTEREST), 22 (DETECTION_BOUNDING_BOXES), 20 (SEI_UNREGISTERED))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asidedata.create`
+
+Ffmpeg filter: Manipulate audio frame side data.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (delete))
+- `type` (of type `int?`, which defaults to `null`): set side data type. (default: -1, possible values: 0 (PANSCAN), 1 (A53_CC), 2 (STEREO3D), 3 (MATRIXENCODING), 4 (DOWNMIX_INFO), 5 (REPLAYGAIN), 6 (DISPLAYMATRIX), 7 (AFD), 8 (MOTION_VECTORS), 9 (SKIP_SAMPLES), 10 (AUDIO_SERVICE_TYPE), 11 (MASTERING_DISPLAY_METADATA), 12 (GOP_TIMECODE), 13 (SPHERICAL), 14 (CONTENT_LIGHT_LEVEL), 15 (ICC_PROFILE), 16 (S12M_TIMECOD), 17 (DYNAMIC_HDR_PLUS), 18 (REGIONS_OF_INTEREST), 22 (DETECTION_BOUNDING_BOXES), 20 (SEI_UNREGISTERED))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asisdr`
+
+Ffmpeg filter: Measure Audio Scale-Invariant Signal-to-Distortion Ratio.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asisdr.create`
+
+Ffmpeg filter: Measure Audio Scale-Invariant Signal-to-Distortion Ratio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asoftclip`
+
+Ffmpeg filter: Audio Soft Clipper.
+
+Type:
+
+```
+(?type : int?, ?threshold : float?, ?output : float?, ?param : float?,
+ ?oversample : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set softclip type. (default: 0, possible values: -1 (hard), 0 (tanh), 1 (atan), 2 (cubic), 3 (exp), 4 (alg), 5 (quintic), 6 (sin), 7 (erf))
+- `threshold` (of type `float?`, which defaults to `null`): set softclip threshold. (default: 1.)
+- `output` (of type `float?`, which defaults to `null`): set softclip output gain. (default: 1.)
+- `param` (of type `float?`, which defaults to `null`): set softclip parameter. (default: 1.)
+- `oversample` (of type `int?`, which defaults to `null`): set oversample factor. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asoftclip.create`
+
+Ffmpeg filter: Audio Soft Clipper.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?type : int?, ?threshold : float?, ?output : float?, ?param : float?,
+ ?oversample : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set softclip type. (default: 0, possible values: -1 (hard), 0 (tanh), 1 (atan), 2 (cubic), 3 (exp), 4 (alg), 5 (quintic), 6 (sin), 7 (erf))
+- `threshold` (of type `float?`, which defaults to `null`): set softclip threshold. (default: 1.)
+- `output` (of type `float?`, which defaults to `null`): set softclip output gain. (default: 1.)
+- `param` (of type `float?`, which defaults to `null`): set softclip parameter. (default: 1.)
+- `oversample` (of type `int?`, which defaults to `null`): set oversample factor. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.aspectralstats`
+
+Ffmpeg filter: Show frequency domain statistics about audio frames.
+
+Type:
+
+```
+(?win_size : int?, ?win_func : int?, ?overlap : float?, ?measure : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `win_size` (of type `int?`, which defaults to `null`): set the window size. (default: 2048)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.5)
+- `measure` (of type `int?`, which defaults to `null`): select the parameters which are measured. (default: 4294967295, possible values: 0 (none), 4294967295 (all), 1 (mean), 2 (variance), 4 (centroid), 8 (spread), 16 (skewness), 32 (kurtosis), 64 (entropy), 128 (flatness), 256 (crest), 512 (flux), 1024 (slope), 2048 (decrease), 4096 (rolloff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.aspectralstats.create`
+
+Ffmpeg filter: Show frequency domain statistics about audio frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?win_size : int?, ?win_func : int?, ?overlap : float?, ?measure : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `win_size` (of type `int?`, which defaults to `null`): set the window size. (default: 2048)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.5)
+- `measure` (of type `int?`, which defaults to `null`): select the parameters which are measured. (default: 4294967295, possible values: 0 (none), 4294967295 (all), 1 (mean), 2 (variance), 4 (centroid), 8 (spread), 16 (skewness), 32 (kurtosis), 64 (entropy), 128 (flatness), 256 (crest), 512 (flux), 1024 (slope), 2048 (decrease), 4096 (rolloff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asplit`
+
+Ffmpeg filter: Pass on the audio input to N audio outputs. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?outputs : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `outputs` (of type `int?`, which defaults to `null`): set number of outputs. (default: 2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asplit.create`
+
+Ffmpeg filter: Pass on the audio input to N audio outputs. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?outputs : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `outputs` (of type `int?`, which defaults to `null`): set number of outputs. (default: 2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ass`
+
+Ffmpeg filter: Render ASS subtitles onto input video using the libass library.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?original_size : string?,
+ ?fontsdir : string?, ?alpha : bool?, ?shaping : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `f` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `original_size` (of type `string?`, which defaults to `null`): set the size of the original video (used to scale fonts)
+- `fontsdir` (of type `string?`, which defaults to `null`): set the directory containing the fonts to read
+- `alpha` (of type `bool?`, which defaults to `null`): enable processing of alpha channel. (default: false)
+- `shaping` (of type `int?`, which defaults to `null`): set shaping engine. (default: -1, possible values: -1 (auto), 0 (simple), 1 (complex))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.ass.create`
+
+Ffmpeg filter: Render ASS subtitles onto input video using the libass library.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?original_size : string?,
+ ?fontsdir : string?, ?alpha : bool?, ?shaping : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `f` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `original_size` (of type `string?`, which defaults to `null`): set the size of the original video (used to scale fonts)
+- `fontsdir` (of type `string?`, which defaults to `null`): set the directory containing the fonts to read
+- `alpha` (of type `bool?`, which defaults to `null`): enable processing of alpha channel. (default: false)
+- `shaping` (of type `int?`, which defaults to `null`): set shaping engine. (default: -1, possible values: -1 (auto), 0 (simple), 1 (complex))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.astats`
+
+Ffmpeg filter: Show time domain statistics about audio frames.
+
+Type:
+
+```
+(?length : float?, ?metadata : bool?, ?reset : int?,
+ ?measure_perchannel : int?, ?measure_overall : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `length` (of type `float?`, which defaults to `null`): set the window length. (default: 0.05)
+- `metadata` (of type `bool?`, which defaults to `null`): inject metadata in the filtergraph. (default: false)
+- `reset` (of type `int?`, which defaults to `null`): Set the number of frames over which cumulative stats are calculated before being reset. (default: 0)
+- `measure_perchannel` (of type `int?`, which defaults to `null`): Select the parameters which are measured per channel. (default: 4294967295, possible values: 0 (none), 4294967295 (all), 16384 (Bit_depth), 2048 (Crest_factor), 1 (DC_offset), 32768 (Dynamic_range), 16777216 (Entropy), 4096 (Flat_factor), 16 (Max_difference), 4 (Max_level), 32 (Mean_difference), 8 (Min_difference), 2 (Min_level), 4194304 (Noise_floor), 8388608 (Noise_floor_count), 1048576 (Number_of_Infs), 524288 (Number_of_NaNs), 2097152 (Number_of_denormals), 262144 (Number_of_samples), 8192 (Peak_count), 128 (Peak_level), 64 (RMS_difference), 256 (RMS_level), 512 (RMS_peak), 1024 (RMS_trough), 65536 (Zero_crossings), 131072 (Zero_crossings_rate), 33554432 (Abs_Peak_count))
+- `measure_overall` (of type `int?`, which defaults to `null`): Select the parameters which are measured overall. (default: 4294967295, possible values: 0 (none), 4294967295 (all), 16384 (Bit_depth), 2048 (Crest_factor), 1 (DC_offset), 32768 (Dynamic_range), 16777216 (Entropy), 4096 (Flat_factor), 16 (Max_difference), 4 (Max_level), 32 (Mean_difference), 8 (Min_difference), 2 (Min_level), 4194304 (Noise_floor), 8388608 (Noise_floor_count), 1048576 (Number_of_Infs), 524288 (Number_of_NaNs), 2097152 (Number_of_denormals), 262144 (Number_of_samples), 8192 (Peak_count), 128 (Peak_level), 64 (RMS_difference), 256 (RMS_level), 512 (RMS_peak), 1024 (RMS_trough), 65536 (Zero_crossings), 131072 (Zero_crossings_rate), 33554432 (Abs_Peak_count))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.astats.create`
+
+Ffmpeg filter: Show time domain statistics about audio frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?length : float?, ?metadata : bool?, ?reset : int?,
+ ?measure_perchannel : int?, ?measure_overall : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `length` (of type `float?`, which defaults to `null`): set the window length. (default: 0.05)
+- `metadata` (of type `bool?`, which defaults to `null`): inject metadata in the filtergraph. (default: false)
+- `reset` (of type `int?`, which defaults to `null`): Set the number of frames over which cumulative stats are calculated before being reset. (default: 0)
+- `measure_perchannel` (of type `int?`, which defaults to `null`): Select the parameters which are measured per channel. (default: 4294967295, possible values: 0 (none), 4294967295 (all), 16384 (Bit_depth), 2048 (Crest_factor), 1 (DC_offset), 32768 (Dynamic_range), 16777216 (Entropy), 4096 (Flat_factor), 16 (Max_difference), 4 (Max_level), 32 (Mean_difference), 8 (Min_difference), 2 (Min_level), 4194304 (Noise_floor), 8388608 (Noise_floor_count), 1048576 (Number_of_Infs), 524288 (Number_of_NaNs), 2097152 (Number_of_denormals), 262144 (Number_of_samples), 8192 (Peak_count), 128 (Peak_level), 64 (RMS_difference), 256 (RMS_level), 512 (RMS_peak), 1024 (RMS_trough), 65536 (Zero_crossings), 131072 (Zero_crossings_rate), 33554432 (Abs_Peak_count))
+- `measure_overall` (of type `int?`, which defaults to `null`): Select the parameters which are measured overall. (default: 4294967295, possible values: 0 (none), 4294967295 (all), 16384 (Bit_depth), 2048 (Crest_factor), 1 (DC_offset), 32768 (Dynamic_range), 16777216 (Entropy), 4096 (Flat_factor), 16 (Max_difference), 4 (Max_level), 32 (Mean_difference), 8 (Min_difference), 2 (Min_level), 4194304 (Noise_floor), 8388608 (Noise_floor_count), 1048576 (Number_of_Infs), 524288 (Number_of_NaNs), 2097152 (Number_of_denormals), 262144 (Number_of_samples), 8192 (Peak_count), 128 (Peak_level), 64 (RMS_difference), 256 (RMS_level), 512 (RMS_peak), 1024 (RMS_trough), 65536 (Zero_crossings), 131072 (Zero_crossings_rate), 33554432 (Abs_Peak_count))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.astreamselect`
+
+Ffmpeg filter: Select audio streams This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?map : string?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): number of input streams. (default: 2)
+- `map` (of type `string?`, which defaults to `null`): input indexes to remap to outputs
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.astreamselect.create`
+
+Ffmpeg filter: Select audio streams This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?map : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): number of input streams. (default: 2)
+- `map` (of type `string?`, which defaults to `null`): input indexes to remap to outputs
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asubboost`
+
+Ffmpeg filter: Boost subwoofer frequencies.
+
+Type:
+
+```
+(?dry : float?, ?wet : float?, ?boost : float?, ?decay : float?,
+ ?feedback : float?, ?cutoff : float?, ?slope : float?, ?delay : float?,
+ ?channels : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `dry` (of type `float?`, which defaults to `null`): set dry gain. (default: 1.)
+- `wet` (of type `float?`, which defaults to `null`): set wet gain. (default: 1.)
+- `boost` (of type `float?`, which defaults to `null`): set max boost. (default: 2.)
+- `decay` (of type `float?`, which defaults to `null`): set decay. (default: 0.)
+- `feedback` (of type `float?`, which defaults to `null`): set feedback. (default: 0.9)
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff. (default: 100.)
+- `slope` (of type `float?`, which defaults to `null`): set slope. (default: 0.5)
+- `delay` (of type `float?`, which defaults to `null`): set delay. (default: 20.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asubboost.create`
+
+Ffmpeg filter: Boost subwoofer frequencies.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dry : float?, ?wet : float?, ?boost : float?, ?decay : float?,
+ ?feedback : float?, ?cutoff : float?, ?slope : float?, ?delay : float?,
+ ?channels : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dry` (of type `float?`, which defaults to `null`): set dry gain. (default: 1.)
+- `wet` (of type `float?`, which defaults to `null`): set wet gain. (default: 1.)
+- `boost` (of type `float?`, which defaults to `null`): set max boost. (default: 2.)
+- `decay` (of type `float?`, which defaults to `null`): set decay. (default: 0.)
+- `feedback` (of type `float?`, which defaults to `null`): set feedback. (default: 0.9)
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff. (default: 100.)
+- `slope` (of type `float?`, which defaults to `null`): set slope. (default: 0.5)
+- `delay` (of type `float?`, which defaults to `null`): set delay. (default: 20.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asubcut`
+
+Ffmpeg filter: Cut subwoofer frequencies.
+
+Type:
+
+```
+(?cutoff : float?, ?order : int?, ?level : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency. (default: 20.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 10)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asubcut.create`
+
+Ffmpeg filter: Cut subwoofer frequencies.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cutoff : float?, ?order : int?, ?level : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency. (default: 20.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 10)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asupercut`
+
+Ffmpeg filter: Cut super frequencies.
+
+Type:
+
+```
+(?cutoff : float?, ?order : int?, ?level : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency. (default: 20000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 10)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asupercut.create`
+
+Ffmpeg filter: Cut super frequencies.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cutoff : float?, ?order : int?, ?level : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `cutoff` (of type `float?`, which defaults to `null`): set cutoff frequency. (default: 20000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 10)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asuperpass`
+
+Ffmpeg filter: Apply high order Butterworth band-pass filter.
+
+Type:
+
+```
+(?centerf : float?, ?order : int?, ?qfactor : float?, ?level : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `centerf` (of type `float?`, which defaults to `null`): set center frequency. (default: 1000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 4)
+- `qfactor` (of type `float?`, which defaults to `null`): set Q-factor. (default: 1.)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asuperpass.create`
+
+Ffmpeg filter: Apply high order Butterworth band-pass filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?centerf : float?, ?order : int?, ?qfactor : float?, ?level : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `centerf` (of type `float?`, which defaults to `null`): set center frequency. (default: 1000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 4)
+- `qfactor` (of type `float?`, which defaults to `null`): set Q-factor. (default: 1.)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.asuperstop`
+
+Ffmpeg filter: Apply high order Butterworth band-stop filter.
+
+Type:
+
+```
+(?centerf : float?, ?order : int?, ?qfactor : float?, ?level : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `centerf` (of type `float?`, which defaults to `null`): set center frequency. (default: 1000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 4)
+- `qfactor` (of type `float?`, which defaults to `null`): set Q-factor. (default: 1.)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.asuperstop.create`
+
+Ffmpeg filter: Apply high order Butterworth band-stop filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?centerf : float?, ?order : int?, ?qfactor : float?, ?level : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `centerf` (of type `float?`, which defaults to `null`): set center frequency. (default: 1000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 4)
+- `qfactor` (of type `float?`, which defaults to `null`): set Q-factor. (default: 1.)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.atadenoise`
+
+Ffmpeg filter: Apply an Adaptive Temporal Averaging Denoiser.
+
+Type:
+
+```
+(?0a : float?, ?0b : float?, ?1a : float?, ?1b : float?, ?2a : float?,
+ ?2b : float?, ?s : int?, ?p : int?, ?a : int?, ?0s : float?, ?1s : float?,
+ ?2s : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `0a` (of type `float?`, which defaults to `null`): set threshold A for 1st plane. (default: 0.02)
+- `0b` (of type `float?`, which defaults to `null`): set threshold B for 1st plane. (default: 0.04)
+- `1a` (of type `float?`, which defaults to `null`): set threshold A for 2nd plane. (default: 0.02)
+- `1b` (of type `float?`, which defaults to `null`): set threshold B for 2nd plane. (default: 0.04)
+- `2a` (of type `float?`, which defaults to `null`): set threshold A for 3rd plane. (default: 0.02)
+- `2b` (of type `float?`, which defaults to `null`): set threshold B for 3rd plane. (default: 0.04)
+- `s` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 9)
+- `p` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 7)
+- `a` (of type `int?`, which defaults to `null`): set variant of algorithm. (default: 0, possible values: 0 (p), 1 (s))
+- `0s` (of type `float?`, which defaults to `null`): set sigma for 1st plane. (default: 32767.)
+- `1s` (of type `float?`, which defaults to `null`): set sigma for 2nd plane. (default: 32767.)
+- `2s` (of type `float?`, which defaults to `null`): set sigma for 3rd plane. (default: 32767.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.atadenoise.create`
+
+Ffmpeg filter: Apply an Adaptive Temporal Averaging Denoiser.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?0a : float?, ?0b : float?, ?1a : float?, ?1b : float?, ?2a : float?,
+ ?2b : float?, ?s : int?, ?p : int?, ?a : int?, ?0s : float?, ?1s : float?,
+ ?2s : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `0a` (of type `float?`, which defaults to `null`): set threshold A for 1st plane. (default: 0.02)
+- `0b` (of type `float?`, which defaults to `null`): set threshold B for 1st plane. (default: 0.04)
+- `1a` (of type `float?`, which defaults to `null`): set threshold A for 2nd plane. (default: 0.02)
+- `1b` (of type `float?`, which defaults to `null`): set threshold B for 2nd plane. (default: 0.04)
+- `2a` (of type `float?`, which defaults to `null`): set threshold A for 3rd plane. (default: 0.02)
+- `2b` (of type `float?`, which defaults to `null`): set threshold B for 3rd plane. (default: 0.04)
+- `s` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 9)
+- `p` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 7)
+- `a` (of type `int?`, which defaults to `null`): set variant of algorithm. (default: 0, possible values: 0 (p), 1 (s))
+- `0s` (of type `float?`, which defaults to `null`): set sigma for 1st plane. (default: 32767.)
+- `1s` (of type `float?`, which defaults to `null`): set sigma for 2nd plane. (default: 32767.)
+- `2s` (of type `float?`, which defaults to `null`): set sigma for 3rd plane. (default: 32767.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.atempo`
+
+Ffmpeg filter: Adjust audio tempo.
+
+Type:
+
+```
+(?tempo : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `tempo` (of type `float?`, which defaults to `null`): set tempo scale factor. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.atempo.create`
+
+Ffmpeg filter: Adjust audio tempo.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?tempo : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `tempo` (of type `float?`, which defaults to `null`): set tempo scale factor. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.atilt`
+
+Ffmpeg filter: Apply spectral tilt to audio.
+
+Type:
+
+```
+(?freq : float?, ?slope : float?, ?width : float?, ?order : int?,
+ ?level : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `freq` (of type `float?`, which defaults to `null`): set central frequency. (default: 10000.)
+- `slope` (of type `float?`, which defaults to `null`): set filter slope. (default: 0.)
+- `width` (of type `float?`, which defaults to `null`): set filter width. (default: 1000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 5)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.atilt.create`
+
+Ffmpeg filter: Apply spectral tilt to audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?freq : float?, ?slope : float?, ?width : float?, ?order : int?,
+ ?level : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `freq` (of type `float?`, which defaults to `null`): set central frequency. (default: 10000.)
+- `slope` (of type `float?`, which defaults to `null`): set filter slope. (default: 0.)
+- `width` (of type `float?`, which defaults to `null`): set filter width. (default: 1000.)
+- `order` (of type `int?`, which defaults to `null`): set filter order. (default: 5)
+- `level` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.atrim`
+
+Ffmpeg filter: Pick one continuous section from the input, drop the rest.
+
+Type:
+
+```
+(?start : int?, ?starti : int?, ?end : int?, ?endi : int?, ?start_pts : int?,
+ ?end_pts : int?, ?duration : int?, ?durationi : int?, ?start_sample : int?,
+ ?end_sample : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `start` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `starti` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `end` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `endi` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `start_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be  passed. (default: -9223372036854775808)
+- `end_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: -9223372036854775808)
+- `duration` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `durationi` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `start_sample` (of type `int?`, which defaults to `null`): Number of the first audio sample that should be passed to the output. (default: -1)
+- `end_sample` (of type `int?`, which defaults to `null`): Number of the first audio sample that should be dropped again. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.atrim.create`
+
+Ffmpeg filter: Pick one continuous section from the input, drop the rest.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?start : int?, ?starti : int?, ?end : int?, ?endi : int?, ?start_pts : int?,
+ ?end_pts : int?, ?duration : int?, ?durationi : int?, ?start_sample : int?,
+ ?end_sample : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `start` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `starti` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `end` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `endi` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `start_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be  passed. (default: -9223372036854775808)
+- `end_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: -9223372036854775808)
+- `duration` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `durationi` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `start_sample` (of type `int?`, which defaults to `null`): Number of the first audio sample that should be passed to the output. (default: -1)
+- `end_sample` (of type `int?`, which defaults to `null`): Number of the first audio sample that should be dropped again. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.avectorscope`
+
+Ffmpeg filter: Convert input audio to vectorscope video output.
+
+Type:
+
+```
+(?mode : int?, ?m : int?, ?rate : string?, ?r : string?, ?size : string?,
+ ?s : string?, ?rc : int?, ?gc : int?, ?bc : int?, ?ac : int?, ?rf : int?,
+ ?gf : int?, ?bf : int?, ?af : int?, ?zoom : float?, ?draw : int?,
+ ?scale : int?, ?swap : bool?, ?mirror : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (lissajous), 1 (lissajous_xy), 2 (polar))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (lissajous), 1 (lissajous_xy), 2 (polar))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 400x400)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 400x400)
+- `rc` (of type `int?`, which defaults to `null`): set red contrast. (default: 40)
+- `gc` (of type `int?`, which defaults to `null`): set green contrast. (default: 160)
+- `bc` (of type `int?`, which defaults to `null`): set blue contrast. (default: 80)
+- `ac` (of type `int?`, which defaults to `null`): set alpha contrast. (default: 255)
+- `rf` (of type `int?`, which defaults to `null`): set red fade. (default: 15)
+- `gf` (of type `int?`, which defaults to `null`): set green fade. (default: 10)
+- `bf` (of type `int?`, which defaults to `null`): set blue fade. (default: 5)
+- `af` (of type `int?`, which defaults to `null`): set alpha fade. (default: 5)
+- `zoom` (of type `float?`, which defaults to `null`): set zoom factor. (default: 1.)
+- `draw` (of type `int?`, which defaults to `null`): set draw mode. (default: 0, possible values: 0 (dot), 1 (line), 2 (aaline))
+- `scale` (of type `int?`, which defaults to `null`): set amplitude scale mode. (default: 0, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log))
+- `swap` (of type `bool?`, which defaults to `null`): swap x axis with y axis. (default: true)
+- `mirror` (of type `int?`, which defaults to `null`): mirror axis. (default: 0, possible values: 0 (none), 1 (x), 2 (y), 3 (xy))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.avectorscope.create`
+
+Ffmpeg filter: Convert input audio to vectorscope video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?m : int?, ?rate : string?, ?r : string?, ?size : string?,
+ ?s : string?, ?rc : int?, ?gc : int?, ?bc : int?, ?ac : int?, ?rf : int?,
+ ?gf : int?, ?bf : int?, ?af : int?, ?zoom : float?, ?draw : int?,
+ ?scale : int?, ?swap : bool?, ?mirror : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (lissajous), 1 (lissajous_xy), 2 (polar))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (lissajous), 1 (lissajous_xy), 2 (polar))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 400x400)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 400x400)
+- `rc` (of type `int?`, which defaults to `null`): set red contrast. (default: 40)
+- `gc` (of type `int?`, which defaults to `null`): set green contrast. (default: 160)
+- `bc` (of type `int?`, which defaults to `null`): set blue contrast. (default: 80)
+- `ac` (of type `int?`, which defaults to `null`): set alpha contrast. (default: 255)
+- `rf` (of type `int?`, which defaults to `null`): set red fade. (default: 15)
+- `gf` (of type `int?`, which defaults to `null`): set green fade. (default: 10)
+- `bf` (of type `int?`, which defaults to `null`): set blue fade. (default: 5)
+- `af` (of type `int?`, which defaults to `null`): set alpha fade. (default: 5)
+- `zoom` (of type `float?`, which defaults to `null`): set zoom factor. (default: 1.)
+- `draw` (of type `int?`, which defaults to `null`): set draw mode. (default: 0, possible values: 0 (dot), 1 (line), 2 (aaline))
+- `scale` (of type `int?`, which defaults to `null`): set amplitude scale mode. (default: 0, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log))
+- `swap` (of type `bool?`, which defaults to `null`): swap x axis with y axis. (default: true)
+- `mirror` (of type `int?`, which defaults to `null`): mirror axis. (default: 0, possible values: 0 (none), 1 (x), 2 (y), 3 (xy))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.avgblur`
+
+Ffmpeg filter: Apply Average Blur filter.
+
+Type:
+
+```
+(?sizeX : int?, ?planes : int?, ?sizeY : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sizeX` (of type `int?`, which defaults to `null`): set horizontal size. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `sizeY` (of type `int?`, which defaults to `null`): set vertical size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.avgblur.create`
+
+Ffmpeg filter: Apply Average Blur filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sizeX : int?, ?planes : int?, ?sizeY : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sizeX` (of type `int?`, which defaults to `null`): set horizontal size. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `sizeY` (of type `int?`, which defaults to `null`): set vertical size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.avgblur_opencl`
+
+Ffmpeg filter: Apply average blur filter
+
+Type:
+
+```
+(?sizeX : int?, ?planes : int?, ?sizeY : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sizeX` (of type `int?`, which defaults to `null`): set horizontal size. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `sizeY` (of type `int?`, which defaults to `null`): set vertical size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.avgblur_opencl.create`
+
+Ffmpeg filter: Apply average blur filter. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sizeX : int?, ?planes : int?, ?sizeY : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sizeX` (of type `int?`, which defaults to `null`): set horizontal size. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `sizeY` (of type `int?`, which defaults to `null`): set vertical size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.avsynctest`
+
+Ffmpeg filter: Generate an Audio Video Sync Test.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?framerate : string?, ?fr : string?,
+ ?samplerate : int?, ?sr : int?, ?amplitude : float?, ?a : float?,
+ ?period : int?, ?p : int?, ?delay : int?, ?dl : int?, ?cycle : bool?,
+ ?c : bool?, ?duration : int?, ?d : int?, ?fg : string?, ?bg : string?,
+ ?ag : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.audio * ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: hd720)
+- `framerate` (of type `string?`, which defaults to `null`): set frame rate. (default: 30)
+- `fr` (of type `string?`, which defaults to `null`): set frame rate. (default: 30)
+- `samplerate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `sr` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `amplitude` (of type `float?`, which defaults to `null`): set beep amplitude. (default: 0.7)
+- `a` (of type `float?`, which defaults to `null`): set beep amplitude. (default: 0.7)
+- `period` (of type `int?`, which defaults to `null`): set beep period. (default: 3)
+- `p` (of type `int?`, which defaults to `null`): set beep period. (default: 3)
+- `delay` (of type `int?`, which defaults to `null`): set flash delay. (default: 0)
+- `dl` (of type `int?`, which defaults to `null`): set flash delay. (default: 0)
+- `cycle` (of type `bool?`, which defaults to `null`): set delay cycle. (default: false)
+- `c` (of type `bool?`, which defaults to `null`): set delay cycle. (default: false)
+- `duration` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `fg` (of type `string?`, which defaults to `null`): set foreground color. (default: white)
+- `bg` (of type `string?`, which defaults to `null`): set background color. (default: black)
+- `ag` (of type `string?`, which defaults to `null`): set additional color. (default: gray)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.avsynctest.create`
+
+Ffmpeg filter: Generate an Audio Video Sync Test.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?framerate : string?, ?fr : string?,
+ ?samplerate : int?, ?sr : int?, ?amplitude : float?, ?a : float?,
+ ?period : int?, ?p : int?, ?delay : int?, ?dl : int?, ?cycle : bool?,
+ ?c : bool?, ?duration : int?, ?d : int?, ?fg : string?, ?bg : string?,
+ ?ag : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: hd720)
+- `framerate` (of type `string?`, which defaults to `null`): set frame rate. (default: 30)
+- `fr` (of type `string?`, which defaults to `null`): set frame rate. (default: 30)
+- `samplerate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `sr` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `amplitude` (of type `float?`, which defaults to `null`): set beep amplitude. (default: 0.7)
+- `a` (of type `float?`, which defaults to `null`): set beep amplitude. (default: 0.7)
+- `period` (of type `int?`, which defaults to `null`): set beep period. (default: 3)
+- `p` (of type `int?`, which defaults to `null`): set beep period. (default: 3)
+- `delay` (of type `int?`, which defaults to `null`): set flash delay. (default: 0)
+- `dl` (of type `int?`, which defaults to `null`): set flash delay. (default: 0)
+- `cycle` (of type `bool?`, which defaults to `null`): set delay cycle. (default: false)
+- `c` (of type `bool?`, which defaults to `null`): set delay cycle. (default: false)
+- `duration` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set duration. (default: 0)
+- `fg` (of type `string?`, which defaults to `null`): set foreground color. (default: white)
+- `bg` (of type `string?`, which defaults to `null`): set background color. (default: black)
+- `ag` (of type `string?`, which defaults to `null`): set additional color. (default: gray)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio * ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.axcorrelate`
+
+Ffmpeg filter: Cross-correlate two audio streams.
+
+Type:
+
+```
+(?size : int?, ?algo : int?, ffmpeg.filter.graph, ffmpeg.filter.audio,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `size` (of type `int?`, which defaults to `null`): set the segment size. (default: 256)
+- `algo` (of type `int?`, which defaults to `null`): set the algorithm. (default: 2, possible values: 0 (slow), 1 (fast), 2 (best))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.axcorrelate.create`
+
+Ffmpeg filter: Cross-correlate two audio streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : int?, ?algo : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `int?`, which defaults to `null`): set the segment size. (default: 256)
+- `algo` (of type `int?`, which defaults to `null`): set the algorithm. (default: 2, possible values: 0 (slow), 1 (fast), 2 (best))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.azmq`
+
+Ffmpeg filter: Receive commands through ZMQ and broker them to filters.
+
+Type:
+
+```
+(?bind_address : string?, ?b : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `bind_address` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `b` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.azmq.create`
+
+Ffmpeg filter: Receive commands through ZMQ and broker them to filters.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?bind_address : string?, ?b : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `bind_address` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `b` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.backgroundkey`
+
+Ffmpeg filter: Turns a static background into transparency.
+
+Type:
+
+```
+(?threshold : float?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set the scene change threshold. (default: 0.08)
+- `similarity` (of type `float?`, which defaults to `null`): set the similarity. (default: 0.1)
+- `blend` (of type `float?`, which defaults to `null`): set the blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.backgroundkey.create`
+
+Ffmpeg filter: Turns a static background into transparency.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : float?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set the scene change threshold. (default: 0.08)
+- `similarity` (of type `float?`, which defaults to `null`): set the similarity. (default: 0.1)
+- `blend` (of type `float?`, which defaults to `null`): set the blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bandpass`
+
+Ffmpeg filter: Apply a two-pole Butterworth band-pass filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?csg : bool?, ?mix : float?, ?m : float?,
+ ?channels : string?, ?c : string?, ?normalize : bool?, ?n : bool?,
+ ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `csg` (of type `bool?`, which defaults to `null`): use constant skirt gain. (default: false)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.bandpass.create`
+
+Ffmpeg filter: Apply a two-pole Butterworth band-pass filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?csg : bool?, ?mix : float?, ?m : float?,
+ ?channels : string?, ?c : string?, ?normalize : bool?, ?n : bool?,
+ ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `csg` (of type `bool?`, which defaults to `null`): use constant skirt gain. (default: false)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bandreject`
+
+Ffmpeg filter: Apply a two-pole Butterworth band-reject filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?mix : float?, ?m : float?,
+ ?channels : string?, ?c : string?, ?normalize : bool?, ?n : bool?,
+ ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.bandreject.create`
+
+Ffmpeg filter: Apply a two-pole Butterworth band-reject filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?mix : float?, ?m : float?,
+ ?channels : string?, ?c : string?, ?normalize : bool?, ?n : bool?,
+ ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bass`
+
+Ffmpeg filter: Boost or cut lower frequencies.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.bass.create`
+
+Ffmpeg filter: Boost or cut lower frequencies.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bbox`
+
+Ffmpeg filter: Compute bounding box for each frame.
+
+Type:
+
+```
+(?min_val : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `min_val` (of type `int?`, which defaults to `null`): set minimum luminance value for bounding box. (default: 16)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bbox.create`
+
+Ffmpeg filter: Compute bounding box for each frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?min_val : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `min_val` (of type `int?`, which defaults to `null`): set minimum luminance value for bounding box. (default: 16)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bench`
+
+Ffmpeg filter: Benchmark part of a filtergraph.
+
+Type:
+
+```
+(?action : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `action` (of type `int?`, which defaults to `null`): set action. (default: 0, possible values: 0 (start), 1 (stop))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bench.create`
+
+Ffmpeg filter: Benchmark part of a filtergraph.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?action : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `action` (of type `int?`, which defaults to `null`): set action. (default: 0, possible values: 0 (start), 1 (stop))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bilateral`
+
+Ffmpeg filter: Apply Bilateral filter.
+
+Type:
+
+```
+(?sigmaS : float?, ?sigmaR : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sigmaS` (of type `float?`, which defaults to `null`): set spatial sigma. (default: 0.1)
+- `sigmaR` (of type `float?`, which defaults to `null`): set range sigma. (default: 0.1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bilateral.create`
+
+Ffmpeg filter: Apply Bilateral filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigmaS : float?, ?sigmaR : float?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `sigmaS` (of type `float?`, which defaults to `null`): set spatial sigma. (default: 0.1)
+- `sigmaR` (of type `float?`, which defaults to `null`): set range sigma. (default: 0.1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bilateral_cuda`
+
+Ffmpeg filter: GPU accelerated bilateral filter
+
+Type:
+
+```
+(?sigmaS : float?, ?sigmaR : float?, ?window_size : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sigmaS` (of type `float?`, which defaults to `null`): set spatial sigma. (default: 0.1)
+- `sigmaR` (of type `float?`, which defaults to `null`): set range sigma. (default: 0.1)
+- `window_size` (of type `int?`, which defaults to `null`): set neighbours window_size. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bilateral_cuda.create`
+
+Ffmpeg filter: GPU accelerated bilateral filter. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigmaS : float?, ?sigmaR : float?, ?window_size : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sigmaS` (of type `float?`, which defaults to `null`): set spatial sigma. (default: 0.1)
+- `sigmaR` (of type `float?`, which defaults to `null`): set range sigma. (default: 0.1)
+- `window_size` (of type `int?`, which defaults to `null`): set neighbours window_size. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.biquad`
+
+Ffmpeg filter: Apply a biquad IIR filter with the given coefficients.
+
+Type:
+
+```
+(?a0 : float?, ?a1 : float?, ?a2 : float?, ?b0 : float?, ?b1 : float?,
+ ?b2 : float?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `a0` (of type `float?`, which defaults to `null`): Default: 1.
+- `a1` (of type `float?`, which defaults to `null`): Default: 0.
+- `a2` (of type `float?`, which defaults to `null`): Default: 0.
+- `b0` (of type `float?`, which defaults to `null`): Default: 0.
+- `b1` (of type `float?`, which defaults to `null`): Default: 0.
+- `b2` (of type `float?`, which defaults to `null`): Default: 0.
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.biquad.create`
+
+Ffmpeg filter: Apply a biquad IIR filter with the given coefficients.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?a0 : float?, ?a1 : float?, ?a2 : float?, ?b0 : float?, ?b1 : float?,
+ ?b2 : float?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `a0` (of type `float?`, which defaults to `null`): Default: 1.
+- `a1` (of type `float?`, which defaults to `null`): Default: 0.
+- `a2` (of type `float?`, which defaults to `null`): Default: 0.
+- `b0` (of type `float?`, which defaults to `null`): Default: 0.
+- `b1` (of type `float?`, which defaults to `null`): Default: 0.
+- `b2` (of type `float?`, which defaults to `null`): Default: 0.
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bitplanenoise`
+
+Ffmpeg filter: Measure bit plane noise.
+
+Type:
+
+```
+(?bitplane : int?, ?filter : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `bitplane` (of type `int?`, which defaults to `null`): set bit plane to use for measuring noise. (default: 1)
+- `filter` (of type `bool?`, which defaults to `null`): show noisy pixels. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bitplanenoise.create`
+
+Ffmpeg filter: Measure bit plane noise.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?bitplane : int?, ?filter : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `bitplane` (of type `int?`, which defaults to `null`): set bit plane to use for measuring noise. (default: 1)
+- `filter` (of type `bool?`, which defaults to `null`): show noisy pixels. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bitstream.aac_adtstoasc`
+
+FFmpeg aac_adtstoasc bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.av1_frame_merge`
+
+FFmpeg av1_frame_merge bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.av1_frame_split`
+
+FFmpeg av1_frame_split bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.av1_metadata`
+
+FFmpeg av1_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?chroma_sample_position : int?, ?color_primaries : int?,
+ ?color_range : int?, ?delete_padding : bool?, ?matrix_coefficients : int?,
+ ?num_ticks_per_picture : int?, ?td : int?, ?tick_rate : string?,
+ ?transfer_characteristics : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `chroma_sample_position` (of type `int?`, which defaults to `null`): Set chroma sample position (section 6.4.2). (default: -1, possible values: 0 (unknown), 1 (vertical), 2 (colocated))
+- `color_primaries` (of type `int?`, which defaults to `null`): Set color primaries (section 6.4.2). (default: -1)
+- `color_range` (of type `int?`, which defaults to `null`): Set color range flag (section 6.4.2). (default: -1, possible values: 0 (tv), 1 (pc))
+- `delete_padding` (of type `bool?`, which defaults to `null`): Delete all Padding OBUs. (default: false)
+- `matrix_coefficients` (of type `int?`, which defaults to `null`): Set matrix coefficients (section 6.4.2). (default: -1)
+- `num_ticks_per_picture` (of type `int?`, which defaults to `null`): Set display ticks per picture for CFR streams. (default: -1)
+- `td` (of type `int?`, which defaults to `null`): Temporal Delimiter OBU. (default: 0, possible values: 0 (pass), 1 (insert), 2 (remove))
+- `tick_rate` (of type `string?`, which defaults to `null`): Set display tick rate (time_scale / num_units_in_display_tick). (default: 0/1)
+- `transfer_characteristics` (of type `int?`, which defaults to `null`): Set transfer characteristics (section 6.4.2). (default: -1)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.chomp.audio`
+
+FFmpeg chomp.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.chomp.video`
+
+FFmpeg chomp.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.dca_core`
+
+FFmpeg dca_core bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.dts2pts`
+
+FFmpeg dts2pts bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.dump_extra.audio`
+
+FFmpeg dump_extra.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?freq : int?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `freq` (of type `int?`, which defaults to `null`): When to dump extradata. (default: 0, possible values: 0 (k), 0 (keyframe), 1 (e), 1 (all))
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.dump_extra.video`
+
+FFmpeg dump_extra.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?freq : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `freq` (of type `int?`, which defaults to `null`): When to dump extradata. (default: 0, possible values: 0 (k), 0 (keyframe), 1 (e), 1 (all))
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.dv_error_marker`
+
+FFmpeg dv_error_marker bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?color : string?, ?sta : int?, source(video=ffmpeg.copy('a),
+ 'b)) -> source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color` (of type `string?`, which defaults to `null`): set color. (default: yellow)
+- `sta` (of type `int?`, which defaults to `null`): specify which error status value to match. (default: 65534, possible values: 1 (ok), 4 (Aa), 16 (Ba), 64 (Ca), 128 (erri), 32768 (erru), 32896 (err), 1024 (Ab), 4096 (Bb), 16384 (Cb), 1028 (A), 4112 (B), 16448 (C), 84 (a), 21504 (b), 11050 (res), 54484 (notok), 54485 (notres))
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.eac3_core`
+
+FFmpeg eac3_core bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.evc_frame_merge`
+
+FFmpeg evc_frame_merge bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.extract_extradata`
+
+FFmpeg extract_extradata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?remove : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `remove` (of type `int?`, which defaults to `null`): remove the extradata from the bitstream. (default: 0)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.filter_units`
+
+FFmpeg filter_units bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?discard : int?, ?discard_flags : int?,
+ ?pass_types : string?, ?remove_types : string?,
+ source(video=ffmpeg.copy('a), 'b)) -> source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `discard` (of type `int?`, which defaults to `null`): Remove the selected frames. (default: -16, possible values: -16 (none), 0 (default), 8 (nonref), 16 (bidir), 24 (nonintra), 32 (nonkey), 48 (all))
+- `discard_flags` (of type `int?`, which defaults to `null`): flags to control the discard frame behavior. (default: 0, possible values: 1 (keep_non_vcl))
+- `pass_types` (of type `string?`, which defaults to `null`): List of unit types to pass through the filter.
+- `remove_types` (of type `string?`, which defaults to `null`): List of unit types to remove in the filter.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.h264_metadata`
+
+FFmpeg h264_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?aud : int?, ?chroma_sample_loc_type : int?,
+ ?colour_primaries : int?, ?crop_bottom : int?, ?crop_left : int?,
+ ?crop_right : int?, ?crop_top : int?, ?delete_filler : int?,
+ ?display_orientation : int?, ?fixed_frame_rate_flag : int?, ?flip : int?,
+ ?level : int?, ?matrix_coefficients : int?,
+ ?overscan_appropriate_flag : int?, ?rotate : float?,
+ ?sample_aspect_ratio : string?, ?sei_user_data : string?,
+ ?tick_rate : string?, ?transfer_characteristics : int?,
+ ?video_format : int?, ?video_full_range_flag : int?,
+ ?zero_new_constraint_set_flags : bool?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `aud` (of type `int?`, which defaults to `null`): Access Unit Delimiter NAL units. (default: 0, possible values: 0 (pass), 1 (insert), 2 (remove))
+- `chroma_sample_loc_type` (of type `int?`, which defaults to `null`): Set chroma sample location type (figure E-1). (default: -1)
+- `colour_primaries` (of type `int?`, which defaults to `null`): Set colour primaries (table E-3). (default: -1)
+- `crop_bottom` (of type `int?`, which defaults to `null`): Set bottom border crop offset. (default: -1)
+- `crop_left` (of type `int?`, which defaults to `null`): Set left border crop offset. (default: -1)
+- `crop_right` (of type `int?`, which defaults to `null`): Set right border crop offset. (default: -1)
+- `crop_top` (of type `int?`, which defaults to `null`): Set top border crop offset. (default: -1)
+- `delete_filler` (of type `int?`, which defaults to `null`): Delete all filler (both NAL and SEI). (default: 0)
+- `display_orientation` (of type `int?`, which defaults to `null`): Display orientation SEI. (default: 0, possible values: 0 (pass), 1 (insert), 2 (remove), 3 (extract))
+- `fixed_frame_rate_flag` (of type `int?`, which defaults to `null`): Set VUI fixed frame rate flag. (default: -1)
+- `flip` (of type `int?`, which defaults to `null`): Set flip in display orientation SEI. (default: 0, possible values: 1 (horizontal), 2 (vertical))
+- `level` (of type `int?`, which defaults to `null`): Set level (table A-1). (default: -2, possible values: -1 (auto), 10 (1), 9 (1b), 11 (1.1), 12 (1.2), 13 (1.3), 20 (2), 21 (2.1), 22 (2.2), 30 (3), 31 (3.1), 32 (3.2), 40 (4), 41 (4.1), 42 (4.2), 50 (5), 51 (5.1), 52 (5.2), 60 (6), 61 (6.1), 62 (6.2))
+- `matrix_coefficients` (of type `int?`, which defaults to `null`): Set matrix coefficients (table E-5). (default: -1)
+- `overscan_appropriate_flag` (of type `int?`, which defaults to `null`): Set VUI overscan appropriate flag. (default: -1)
+- `rotate` (of type `float?`, which defaults to `null`): Set rotation in display orientation SEI (anticlockwise angle in degrees). (default: nan)
+- `sample_aspect_ratio` (of type `string?`, which defaults to `null`): Set sample aspect ratio (table E-1). (default: 0/1)
+- `sei_user_data` (of type `string?`, which defaults to `null`): Insert SEI user data (UUID+string)
+- `tick_rate` (of type `string?`, which defaults to `null`): Set VUI tick rate (time_scale / num_units_in_tick). (default: 0/1)
+- `transfer_characteristics` (of type `int?`, which defaults to `null`): Set transfer characteristics (table E-4). (default: -1)
+- `video_format` (of type `int?`, which defaults to `null`): Set video format (table E-2). (default: -1)
+- `video_full_range_flag` (of type `int?`, which defaults to `null`): Set video full range flag. (default: -1)
+- `zero_new_constraint_set_flags` (of type `bool?`, which defaults to `null`): Set constraint_set4_flag / constraint_set5_flag to zero. (default: false)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.h264_mp4toannexb`
+
+FFmpeg h264_mp4toannexb bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.h264_redundant_pps`
+
+FFmpeg h264_redundant_pps bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.hapqa_extract`
+
+FFmpeg hapqa_extract bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?texture : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `texture` (of type `int?`, which defaults to `null`): texture to keep. (default: 0, possible values: 0 (color), 1 (alpha))
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.hevc_metadata`
+
+FFmpeg hevc_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?aud : int?, ?chroma_sample_loc_type : int?,
+ ?colour_primaries : int?, ?crop_bottom : int?, ?crop_left : int?,
+ ?crop_right : int?, ?crop_top : int?, ?level : int?,
+ ?matrix_coefficients : int?, ?num_ticks_poc_diff_one : int?,
+ ?sample_aspect_ratio : string?, ?tick_rate : string?,
+ ?transfer_characteristics : int?, ?video_format : int?,
+ ?video_full_range_flag : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `aud` (of type `int?`, which defaults to `null`): Access Unit Delimiter NAL units. (default: 0, possible values: 0 (pass), 1 (insert), 2 (remove))
+- `chroma_sample_loc_type` (of type `int?`, which defaults to `null`): Set chroma sample location type (figure E-1). (default: -1)
+- `colour_primaries` (of type `int?`, which defaults to `null`): Set colour primaries (table E-3). (default: -1)
+- `crop_bottom` (of type `int?`, which defaults to `null`): Set bottom border crop offset. (default: -1)
+- `crop_left` (of type `int?`, which defaults to `null`): Set left border crop offset. (default: -1)
+- `crop_right` (of type `int?`, which defaults to `null`): Set right border crop offset. (default: -1)
+- `crop_top` (of type `int?`, which defaults to `null`): Set top border crop offset. (default: -1)
+- `level` (of type `int?`, which defaults to `null`): Set level (tables A.6 and A.7). (default: -2, possible values: -1 (auto), 30 (1), 60 (2), 63 (2.1), 90 (3), 93 (3.1), 120 (4), 123 (4.1), 150 (5), 153 (5.1), 156 (5.2), 180 (6), 183 (6.1), 186 (6.2), 255 (8.5))
+- `matrix_coefficients` (of type `int?`, which defaults to `null`): Set matrix coefficients (table E-5). (default: -1)
+- `num_ticks_poc_diff_one` (of type `int?`, which defaults to `null`): Set VPS and VUI number of ticks per POC increment. (default: -1)
+- `sample_aspect_ratio` (of type `string?`, which defaults to `null`): Set sample aspect ratio (table E-1). (default: 0/1)
+- `tick_rate` (of type `string?`, which defaults to `null`): Set VPS and VUI tick rate (time_scale / num_units_in_tick). (default: 0/1)
+- `transfer_characteristics` (of type `int?`, which defaults to `null`): Set transfer characteristics (table E-4). (default: -1)
+- `video_format` (of type `int?`, which defaults to `null`): Set video format (table E-2). (default: -1)
+- `video_full_range_flag` (of type `int?`, which defaults to `null`): Set video full range flag. (default: -1)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.hevc_mp4toannexb`
+
+FFmpeg hevc_mp4toannexb bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.imxdump`
+
+FFmpeg imxdump bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.media100_to_mjpegb`
+
+FFmpeg media100_to_mjpegb bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mjpeg2jpeg`
+
+FFmpeg mjpeg2jpeg bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mjpegadump`
+
+FFmpeg mjpegadump bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mov2textsub.audio`
+
+FFmpeg mov2textsub.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mov2textsub.video`
+
+FFmpeg mov2textsub.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mp3decomp`
+
+FFmpeg mp3decomp bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mpeg2_metadata`
+
+FFmpeg mpeg2_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?colour_primaries : int?, ?display_aspect_ratio : string?,
+ ?frame_rate : string?, ?matrix_coefficients : int?,
+ ?transfer_characteristics : int?, ?video_format : int?,
+ source(video=ffmpeg.copy('a), 'b)) -> source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `colour_primaries` (of type `int?`, which defaults to `null`): Set colour primaries (table 6-7). (default: -1)
+- `display_aspect_ratio` (of type `string?`, which defaults to `null`): Set display aspect ratio (table 6-3). (default: 0/1)
+- `frame_rate` (of type `string?`, which defaults to `null`): Set frame rate. (default: 0/1)
+- `matrix_coefficients` (of type `int?`, which defaults to `null`): Set matrix coefficients (table 6-9). (default: -1)
+- `transfer_characteristics` (of type `int?`, which defaults to `null`): Set transfer characteristics (table 6-8). (default: -1)
+- `video_format` (of type `int?`, which defaults to `null`): Set video format (table 6-6). (default: -1)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.mpeg4_unpack_bframes`
+
+FFmpeg mpeg4_unpack_bframes bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.noise.audio`
+
+FFmpeg noise.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?amount : string?, ?drop : string?, ?dropamount : int?,
+ source(audio=ffmpeg.copy('a), 'b)) -> source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `amount` (of type `string?`, which defaults to `null`)
+- `drop` (of type `string?`, which defaults to `null`)
+- `dropamount` (of type `int?`, which defaults to `null`): Default: 0
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.noise.video`
+
+FFmpeg noise.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?amount : string?, ?drop : string?, ?dropamount : int?,
+ source(video=ffmpeg.copy('a), 'b)) -> source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `amount` (of type `string?`, which defaults to `null`)
+- `drop` (of type `string?`, which defaults to `null`)
+- `dropamount` (of type `int?`, which defaults to `null`): Default: 0
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.null.audio`
+
+FFmpeg null.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.null.video`
+
+FFmpeg null.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.opus_metadata`
+
+FFmpeg opus_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?gain : int?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `gain` (of type `int?`, which defaults to `null`): Gain, actual amplification is pow(10, gain/(20.0*256)). (default: 0)
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.pcm_rechunk`
+
+FFmpeg pcm_rechunk bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?frame_rate : string?, ?n : int?, ?nb_out_samples : int?,
+ ?p : bool?, ?pad : bool?, ?r : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frame_rate` (of type `string?`, which defaults to `null`): set number of packets per second. (default: 0/1)
+- `n` (of type `int?`, which defaults to `null`): set the number of per-packet output samples. (default: 1024)
+- `nb_out_samples` (of type `int?`, which defaults to `null`): set the number of per-packet output samples. (default: 1024)
+- `p` (of type `bool?`, which defaults to `null`): pad last packet with zeros. (default: true)
+- `pad` (of type `bool?`, which defaults to `null`): pad last packet with zeros. (default: true)
+- `r` (of type `string?`, which defaults to `null`): set number of packets per second. (default: 0/1)
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.prores_metadata`
+
+FFmpeg prores_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?color_primaries : int?, ?color_trc : int?,
+ ?colorspace : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color_primaries` (of type `int?`, which defaults to `null`): select color primaries. (default: -1, possible values: -1 (auto), 0 (unknown), 1 (bt709), 5 (bt470bg), 6 (smpte170m), 9 (bt2020), 11 (smpte431), 12 (smpte432))
+- `color_trc` (of type `int?`, which defaults to `null`): select color transfer. (default: -1, possible values: -1 (auto), 0 (unknown), 1 (bt709), 16 (smpte2084), 18 (arib-std-b67))
+- `colorspace` (of type `int?`, which defaults to `null`): select colorspace. (default: -1, possible values: -1 (auto), 0 (unknown), 1 (bt709), 6 (smpte170m), 9 (bt2020nc))
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.remove_extra.audio`
+
+FFmpeg remove_extra.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?freq : int?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `freq` (of type `int?`, which defaults to `null`): Default: 0, possible values: 2 (k), 0 (keyframe), 1 (e), 1 (all)
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.remove_extra.video`
+
+FFmpeg remove_extra.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?freq : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `freq` (of type `int?`, which defaults to `null`): Default: 0, possible values: 2 (k), 0 (keyframe), 1 (e), 1 (all)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.setts.audio`
+
+FFmpeg setts.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?dts : string?, ?duration : string?, ?pts : string?,
+ ?time_base : string?, ?ts : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `dts` (of type `string?`, which defaults to `null`): set expression for packet DTS
+- `duration` (of type `string?`, which defaults to `null`): set expression for packet duration. (default: DURATION)
+- `pts` (of type `string?`, which defaults to `null`): set expression for packet PTS
+- `time_base` (of type `string?`, which defaults to `null`): set output timebase. (default: 0/1)
+- `ts` (of type `string?`, which defaults to `null`): set expression for packet PTS and DTS. (default: TS)
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.setts.video`
+
+FFmpeg setts.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?dts : string?, ?duration : string?, ?pts : string?,
+ ?time_base : string?, ?ts : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `dts` (of type `string?`, which defaults to `null`): set expression for packet DTS
+- `duration` (of type `string?`, which defaults to `null`): set expression for packet duration. (default: DURATION)
+- `pts` (of type `string?`, which defaults to `null`): set expression for packet PTS
+- `time_base` (of type `string?`, which defaults to `null`): set output timebase. (default: 0/1)
+- `ts` (of type `string?`, which defaults to `null`): set expression for packet PTS and DTS. (default: TS)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.text2movsub.audio`
+
+FFmpeg text2movsub.audio bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.text2movsub.video`
+
+FFmpeg text2movsub.video bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.trace_headers`
+
+FFmpeg trace_headers bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.truehd_core`
+
+FFmpeg truehd_core bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) ->
+source(audio=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.vp9_metadata`
+
+FFmpeg vp9_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?color_range : int?, ?color_space : int?,
+ source(video=ffmpeg.copy('a), 'b)) -> source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color_range` (of type `int?`, which defaults to `null`): Set colour range (section 7.2.2). (default: -1, possible values: 0 (tv), 1 (pc))
+- `color_space` (of type `int?`, which defaults to `null`): Set colour space (section 7.2.2). (default: -1, possible values: 0 (unknown), 1 (bt601), 2 (bt709), 3 (smpte170), 4 (smpte240), 5 (bt2020), 7 (rgb))
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.vp9_raw_reorder`
+
+FFmpeg vp9_raw_reorder bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.vp9_superframe`
+
+FFmpeg vp9_superframe bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.vp9_superframe_split`
+
+FFmpeg vp9_superframe_split bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.vvc_metadata`
+
+FFmpeg vvc_metadata bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, ?aud : int?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `aud` (of type `int?`, which defaults to `null`): Access Unit Delimiter NAL units. (default: 0, possible values: 0 (pass), 1 (insert), 2 (remove))
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.bitstream.vvc_mp4toannexb`
+
+FFmpeg vvc_mp4toannexb bitstream filter. See ffmpeg documentation for more details.
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=ffmpeg.copy('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.filter.blackdetect`
+
+Ffmpeg filter: Detect video intervals that are (almost) black.
+
+Type:
+
+```
+(?d : float?, ?black_min_duration : float?, ?picture_black_ratio_th : float?,
+ ?pic_th : float?, ?pixel_black_th : float?, ?pix_th : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `d` (of type `float?`, which defaults to `null`): set minimum detected black duration in seconds. (default: 2.)
+- `black_min_duration` (of type `float?`, which defaults to `null`): set minimum detected black duration in seconds. (default: 2.)
+- `picture_black_ratio_th` (of type `float?`, which defaults to `null`): set the picture black ratio threshold. (default: 0.98)
+- `pic_th` (of type `float?`, which defaults to `null`): set the picture black ratio threshold. (default: 0.98)
+- `pixel_black_th` (of type `float?`, which defaults to `null`): set the pixel black threshold. (default: 0.1)
+- `pix_th` (of type `float?`, which defaults to `null`): set the pixel black threshold. (default: 0.1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.blackdetect.create`
+
+Ffmpeg filter: Detect video intervals that are (almost) black.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?d : float?, ?black_min_duration : float?, ?picture_black_ratio_th : float?,
+ ?pic_th : float?, ?pixel_black_th : float?, ?pix_th : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `d` (of type `float?`, which defaults to `null`): set minimum detected black duration in seconds. (default: 2.)
+- `black_min_duration` (of type `float?`, which defaults to `null`): set minimum detected black duration in seconds. (default: 2.)
+- `picture_black_ratio_th` (of type `float?`, which defaults to `null`): set the picture black ratio threshold. (default: 0.98)
+- `pic_th` (of type `float?`, which defaults to `null`): set the picture black ratio threshold. (default: 0.98)
+- `pixel_black_th` (of type `float?`, which defaults to `null`): set the pixel black threshold. (default: 0.1)
+- `pix_th` (of type `float?`, which defaults to `null`): set the pixel black threshold. (default: 0.1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.blackframe`
+
+Ffmpeg filter: Detect frames that are (almost) black.
+
+Type:
+
+```
+(?amount : int?, ?threshold : int?, ?thresh : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `amount` (of type `int?`, which defaults to `null`): percentage of the pixels that have to be below the threshold for the frame to be considered black. (default: 98)
+- `threshold` (of type `int?`, which defaults to `null`): threshold below which a pixel value is considered black. (default: 32)
+- `thresh` (of type `int?`, which defaults to `null`): threshold below which a pixel value is considered black. (default: 32)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.blackframe.create`
+
+Ffmpeg filter: Detect frames that are (almost) black.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?amount : int?, ?threshold : int?, ?thresh : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `amount` (of type `int?`, which defaults to `null`): percentage of the pixels that have to be below the threshold for the frame to be considered black. (default: 98)
+- `threshold` (of type `int?`, which defaults to `null`): threshold below which a pixel value is considered black. (default: 32)
+- `thresh` (of type `int?`, which defaults to `null`): threshold below which a pixel value is considered black. (default: 32)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.blend`
+
+Ffmpeg filter: Blend two video frames into each other.
+
+Type:
+
+```
+(?c0_mode : int?, ?c1_mode : int?, ?c2_mode : int?, ?c3_mode : int?,
+ ?all_mode : int?, ?c0_expr : string?, ?c1_expr : string?,
+ ?c2_expr : string?, ?c3_expr : string?, ?all_expr : string?,
+ ?c0_opacity : float?, ?c1_opacity : float?, ?c2_opacity : float?,
+ ?c3_opacity : float?, ?all_opacity : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0_mode` (of type `int?`, which defaults to `null`): set component #0 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c1_mode` (of type `int?`, which defaults to `null`): set component #1 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c2_mode` (of type `int?`, which defaults to `null`): set component #2 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c3_mode` (of type `int?`, which defaults to `null`): set component #3 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `all_mode` (of type `int?`, which defaults to `null`): set blend mode for all components. (default: -1, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c0_expr` (of type `string?`, which defaults to `null`): set color component #0 expression
+- `c1_expr` (of type `string?`, which defaults to `null`): set color component #1 expression
+- `c2_expr` (of type `string?`, which defaults to `null`): set color component #2 expression
+- `c3_expr` (of type `string?`, which defaults to `null`): set color component #3 expression
+- `all_expr` (of type `string?`, which defaults to `null`): set expression for all color components
+- `c0_opacity` (of type `float?`, which defaults to `null`): set color component #0 opacity. (default: 1.)
+- `c1_opacity` (of type `float?`, which defaults to `null`): set color component #1 opacity. (default: 1.)
+- `c2_opacity` (of type `float?`, which defaults to `null`): set color component #2 opacity. (default: 1.)
+- `c3_opacity` (of type `float?`, which defaults to `null`): set color component #3 opacity. (default: 1.)
+- `all_opacity` (of type `float?`, which defaults to `null`): set opacity for all color components. (default: 1.)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.blend.create`
+
+Ffmpeg filter: Blend two video frames into each other.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0_mode : int?, ?c1_mode : int?, ?c2_mode : int?, ?c3_mode : int?,
+ ?all_mode : int?, ?c0_expr : string?, ?c1_expr : string?,
+ ?c2_expr : string?, ?c3_expr : string?, ?all_expr : string?,
+ ?c0_opacity : float?, ?c1_opacity : float?, ?c2_opacity : float?,
+ ?c3_opacity : float?, ?all_opacity : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0_mode` (of type `int?`, which defaults to `null`): set component #0 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c1_mode` (of type `int?`, which defaults to `null`): set component #1 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c2_mode` (of type `int?`, which defaults to `null`): set component #2 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c3_mode` (of type `int?`, which defaults to `null`): set component #3 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `all_mode` (of type `int?`, which defaults to `null`): set blend mode for all components. (default: -1, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c0_expr` (of type `string?`, which defaults to `null`): set color component #0 expression
+- `c1_expr` (of type `string?`, which defaults to `null`): set color component #1 expression
+- `c2_expr` (of type `string?`, which defaults to `null`): set color component #2 expression
+- `c3_expr` (of type `string?`, which defaults to `null`): set color component #3 expression
+- `all_expr` (of type `string?`, which defaults to `null`): set expression for all color components
+- `c0_opacity` (of type `float?`, which defaults to `null`): set color component #0 opacity. (default: 1.)
+- `c1_opacity` (of type `float?`, which defaults to `null`): set color component #1 opacity. (default: 1.)
+- `c2_opacity` (of type `float?`, which defaults to `null`): set color component #2 opacity. (default: 1.)
+- `c3_opacity` (of type `float?`, which defaults to `null`): set color component #3 opacity. (default: 1.)
+- `all_opacity` (of type `float?`, which defaults to `null`): set opacity for all color components. (default: 1.)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.blockdetect`
+
+Ffmpeg filter: Blockdetect filter.
+
+Type:
+
+```
+(?period_min : int?, ?period_max : int?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `period_min` (of type `int?`, which defaults to `null`): Minimum period to search for. (default: 3)
+- `period_max` (of type `int?`, which defaults to `null`): Maximum period to search for. (default: 24)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.blockdetect.create`
+
+Ffmpeg filter: Blockdetect filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?period_min : int?, ?period_max : int?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `period_min` (of type `int?`, which defaults to `null`): Minimum period to search for. (default: 3)
+- `period_max` (of type `int?`, which defaults to `null`): Maximum period to search for. (default: 24)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.blurdetect`
+
+Ffmpeg filter: Blurdetect filter.
+
+Type:
+
+```
+(?high : float?, ?low : float?, ?radius : int?, ?block_pct : int?,
+ ?block_width : int?, ?block_height : int?, ?planes : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `high` (of type `float?`, which defaults to `null`): set high threshold. (default: 0.117647058824)
+- `low` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.0588235294118)
+- `radius` (of type `int?`, which defaults to `null`): search radius for maxima detection. (default: 50)
+- `block_pct` (of type `int?`, which defaults to `null`): block pooling threshold when calculating blurriness. (default: 80)
+- `block_width` (of type `int?`, which defaults to `null`): block size for block-based abbreviation of blurriness. (default: -1)
+- `block_height` (of type `int?`, which defaults to `null`): block size for block-based abbreviation of blurriness. (default: -1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.blurdetect.create`
+
+Ffmpeg filter: Blurdetect filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?high : float?, ?low : float?, ?radius : int?, ?block_pct : int?,
+ ?block_width : int?, ?block_height : int?, ?planes : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `high` (of type `float?`, which defaults to `null`): set high threshold. (default: 0.117647058824)
+- `low` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.0588235294118)
+- `radius` (of type `int?`, which defaults to `null`): search radius for maxima detection. (default: 50)
+- `block_pct` (of type `int?`, which defaults to `null`): block pooling threshold when calculating blurriness. (default: 80)
+- `block_width` (of type `int?`, which defaults to `null`): block size for block-based abbreviation of blurriness. (default: -1)
+- `block_height` (of type `int?`, which defaults to `null`): block size for block-based abbreviation of blurriness. (default: -1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bm3d`
+
+Ffmpeg filter: Block-Matching 3D denoiser. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?sigma : float?, ?block : int?, ?bstep : int?, ?group : int?, ?range : int?,
+ ?mstep : int?, ?thmse : float?, ?hdthr : float?, ?estim : int?,
+ ?ref : bool?, ?planes : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set denoising strength. (default: 1.)
+- `block` (of type `int?`, which defaults to `null`): set size of local patch. (default: 16)
+- `bstep` (of type `int?`, which defaults to `null`): set sliding step for processing blocks. (default: 4)
+- `group` (of type `int?`, which defaults to `null`): set maximal number of similar blocks. (default: 1)
+- `range` (of type `int?`, which defaults to `null`): set block matching range. (default: 9)
+- `mstep` (of type `int?`, which defaults to `null`): set step for block matching. (default: 1)
+- `thmse` (of type `float?`, which defaults to `null`): set threshold of mean square error for block matching. (default: 0.)
+- `hdthr` (of type `float?`, which defaults to `null`): set hard threshold for 3D transfer domain. (default: 2.7)
+- `estim` (of type `int?`, which defaults to `null`): set filtering estimation mode. (default: 0, possible values: 0 (basic), 1 (final))
+- `ref` (of type `bool?`, which defaults to `null`): have reference stream. (default: false)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.bm3d.create`
+
+Ffmpeg filter: Block-Matching 3D denoiser. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigma : float?, ?block : int?, ?bstep : int?, ?group : int?, ?range : int?,
+ ?mstep : int?, ?thmse : float?, ?hdthr : float?, ?estim : int?,
+ ?ref : bool?, ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set denoising strength. (default: 1.)
+- `block` (of type `int?`, which defaults to `null`): set size of local patch. (default: 16)
+- `bstep` (of type `int?`, which defaults to `null`): set sliding step for processing blocks. (default: 4)
+- `group` (of type `int?`, which defaults to `null`): set maximal number of similar blocks. (default: 1)
+- `range` (of type `int?`, which defaults to `null`): set block matching range. (default: 9)
+- `mstep` (of type `int?`, which defaults to `null`): set step for block matching. (default: 1)
+- `thmse` (of type `float?`, which defaults to `null`): set threshold of mean square error for block matching. (default: 0.)
+- `hdthr` (of type `float?`, which defaults to `null`): set hard threshold for 3D transfer domain. (default: 2.7)
+- `estim` (of type `int?`, which defaults to `null`): set filtering estimation mode. (default: 0, possible values: 0 (basic), 1 (final))
+- `ref` (of type `bool?`, which defaults to `null`): have reference stream. (default: false)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.boxblur`
+
+Ffmpeg filter: Blur the input.
+
+Type:
+
+```
+(?luma_radius : string?, ?lr : string?, ?luma_power : int?, ?lp : int?,
+ ?chroma_radius : string?, ?cr : string?, ?chroma_power : int?, ?cp : int?,
+ ?alpha_radius : string?, ?ar : string?, ?alpha_power : int?, ?ap : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_radius` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `lr` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `luma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `lp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `chroma_radius` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `cr` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `chroma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `cp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `alpha_radius` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `ar` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `alpha_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `ap` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.boxblur.create`
+
+Ffmpeg filter: Blur the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_radius : string?, ?lr : string?, ?luma_power : int?, ?lp : int?,
+ ?chroma_radius : string?, ?cr : string?, ?chroma_power : int?, ?cp : int?,
+ ?alpha_radius : string?, ?ar : string?, ?alpha_power : int?, ?ap : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_radius` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `lr` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `luma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `lp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `chroma_radius` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `cr` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `chroma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `cp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `alpha_radius` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `ar` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `alpha_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `ap` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.boxblur_opencl`
+
+Ffmpeg filter: Apply boxblur filter to input video
+
+Type:
+
+```
+(?luma_radius : string?, ?lr : string?, ?luma_power : int?, ?lp : int?,
+ ?chroma_radius : string?, ?cr : string?, ?chroma_power : int?, ?cp : int?,
+ ?alpha_radius : string?, ?ar : string?, ?alpha_power : int?, ?ap : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_radius` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `lr` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `luma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `lp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `chroma_radius` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `cr` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `chroma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `cp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `alpha_radius` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `ar` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `alpha_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `ap` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.boxblur_opencl.create`
+
+Ffmpeg filter: Apply boxblur filter to input video. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_radius : string?, ?lr : string?, ?luma_power : int?, ?lp : int?,
+ ?chroma_radius : string?, ?cr : string?, ?chroma_power : int?, ?cp : int?,
+ ?alpha_radius : string?, ?ar : string?, ?alpha_power : int?, ?ap : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_radius` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `lr` (of type `string?`, which defaults to `null`): Radius of the luma blurring box. (default: 2)
+- `luma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `lp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to luma. (default: 2)
+- `chroma_radius` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `cr` (of type `string?`, which defaults to `null`): Radius of the chroma blurring box
+- `chroma_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `cp` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to chroma. (default: -1)
+- `alpha_radius` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `ar` (of type `string?`, which defaults to `null`): Radius of the alpha blurring box
+- `alpha_power` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `ap` (of type `int?`, which defaults to `null`): How many times should the boxblur be applied to alpha. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bs2b`
+
+Ffmpeg filter: Bauer stereo-to-binaural filter.
+
+Type:
+
+```
+(?profile : int?, ?fcut : int?, ?feed : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `profile` (of type `int?`, which defaults to `null`): Apply a pre-defined crossfeed level. (default: 2949820, possible values: 2949820 (default), 3932860 (cmoy), 6226570 (jmeier))
+- `fcut` (of type `int?`, which defaults to `null`): Set cut frequency (in Hz). (default: 0)
+- `feed` (of type `int?`, which defaults to `null`): Set feed level (in Hz). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.bs2b.create`
+
+Ffmpeg filter: Bauer stereo-to-binaural filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?profile : int?, ?fcut : int?, ?feed : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `profile` (of type `int?`, which defaults to `null`): Apply a pre-defined crossfeed level. (default: 2949820, possible values: 2949820 (default), 3932860 (cmoy), 6226570 (jmeier))
+- `fcut` (of type `int?`, which defaults to `null`): Set cut frequency (in Hz). (default: 0)
+- `feed` (of type `int?`, which defaults to `null`): Set feed level (in Hz). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bwdif`
+
+Ffmpeg filter: Deinterlace the input image.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 1, possible values: 0 (send_frame), 1 (send_field))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bwdif.create`
+
+Ffmpeg filter: Deinterlace the input image.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 1, possible values: 0 (send_frame), 1 (send_field))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.bwdif_cuda`
+
+Ffmpeg filter: Deinterlace CUDA frames
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 0, possible values: 0 (send_frame), 1 (send_field), 2 (send_frame_nospatial), 3 (send_field_nospatial))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.bwdif_cuda.create`
+
+Ffmpeg filter: Deinterlace CUDA frames. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 0, possible values: 0 (send_frame), 1 (send_field), 2 (send_frame_nospatial), 3 (send_field_nospatial))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.cas`
+
+Ffmpeg filter: Contrast Adaptive Sharpen.
+
+Type:
+
+```
+(?strength : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set the sharpening strength. (default: 0.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.cas.create`
+
+Ffmpeg filter: Contrast Adaptive Sharpen.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?strength : float?, ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set the sharpening strength. (default: 0.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ccrepack`
+
+Ffmpeg filter: Repack CEA-708 closed caption metadata
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.ccrepack.create`
+
+Ffmpeg filter: Repack CEA-708 closed caption metadata. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.cellauto`
+
+Ffmpeg filter: Create pattern generated by an elementary cellular automaton.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?pattern : string?, ?p : string?,
+ ?rate : string?, ?r : string?, ?size : string?, ?s : string?, ?rule : int?,
+ ?random_fill_ratio : float?, ?ratio : float?, ?random_seed : int?,
+ ?seed : int?, ?scroll : bool?, ?start_full : bool?, ?full : bool?,
+ ?stitch : bool?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): read initial pattern from file
+- `f` (of type `string?`, which defaults to `null`): read initial pattern from file
+- `pattern` (of type `string?`, which defaults to `null`): set initial pattern
+- `p` (of type `string?`, which defaults to `null`): set initial pattern
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `rule` (of type `int?`, which defaults to `null`): set rule. (default: 110)
+- `random_fill_ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `random_seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `scroll` (of type `bool?`, which defaults to `null`): scroll pattern downward. (default: true)
+- `start_full` (of type `bool?`, which defaults to `null`): start filling the whole video. (default: false)
+- `full` (of type `bool?`, which defaults to `null`): start filling the whole video. (default: true)
+- `stitch` (of type `bool?`, which defaults to `null`): stitch boundaries. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.cellauto.create`
+
+Ffmpeg filter: Create pattern generated by an elementary cellular automaton.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?pattern : string?, ?p : string?,
+ ?rate : string?, ?r : string?, ?size : string?, ?s : string?, ?rule : int?,
+ ?random_fill_ratio : float?, ?ratio : float?, ?random_seed : int?,
+ ?seed : int?, ?scroll : bool?, ?start_full : bool?, ?full : bool?,
+ ?stitch : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): read initial pattern from file
+- `f` (of type `string?`, which defaults to `null`): read initial pattern from file
+- `pattern` (of type `string?`, which defaults to `null`): set initial pattern
+- `p` (of type `string?`, which defaults to `null`): set initial pattern
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `rule` (of type `int?`, which defaults to `null`): set rule. (default: 110)
+- `random_fill_ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `random_seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `scroll` (of type `bool?`, which defaults to `null`): scroll pattern downward. (default: true)
+- `start_full` (of type `bool?`, which defaults to `null`): start filling the whole video. (default: false)
+- `full` (of type `bool?`, which defaults to `null`): start filling the whole video. (default: true)
+- `stitch` (of type `bool?`, which defaults to `null`): stitch boundaries. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.channelmap`
+
+Ffmpeg filter: Remap audio channels.
+
+Type:
+
+```
+(?map : string?, ?channel_layout : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `map` (of type `string?`, which defaults to `null`): A comma-separated list of input channel numbers in output order.
+- `channel_layout` (of type `string?`, which defaults to `null`): Output channel layout.
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.channelmap.create`
+
+Ffmpeg filter: Remap audio channels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?map : string?, ?channel_layout : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `map` (of type `string?`, which defaults to `null`): A comma-separated list of input channel numbers in output order.
+- `channel_layout` (of type `string?`, which defaults to `null`): Output channel layout.
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.channelsplit`
+
+Ffmpeg filter: Split audio into per-channel streams. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?channel_layout : string?, ?channels : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `channel_layout` (of type `string?`, which defaults to `null`): Input channel layout.. (default: stereo)
+- `channels` (of type `string?`, which defaults to `null`): Channels to extract.. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.channelsplit.create`
+
+Ffmpeg filter: Split audio into per-channel streams. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?channel_layout : string?, ?channels : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `channel_layout` (of type `string?`, which defaults to `null`): Input channel layout.. (default: stereo)
+- `channels` (of type `string?`, which defaults to `null`): Channels to extract.. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.chorus`
+
+Ffmpeg filter: Add a chorus effect to the audio.
+
+Type:
+
+```
+(?in_gain : float?, ?out_gain : float?, ?delays : string?, ?decays : string?,
+ ?speeds : string?, ?depths : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `in_gain` (of type `float?`, which defaults to `null`): set input gain. (default: 0.4)
+- `out_gain` (of type `float?`, which defaults to `null`): set output gain. (default: 0.4)
+- `delays` (of type `string?`, which defaults to `null`): set delays
+- `decays` (of type `string?`, which defaults to `null`): set decays
+- `speeds` (of type `string?`, which defaults to `null`): set speeds
+- `depths` (of type `string?`, which defaults to `null`): set depths
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.chorus.create`
+
+Ffmpeg filter: Add a chorus effect to the audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?in_gain : float?, ?out_gain : float?, ?delays : string?, ?decays : string?,
+ ?speeds : string?, ?depths : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `in_gain` (of type `float?`, which defaults to `null`): set input gain. (default: 0.4)
+- `out_gain` (of type `float?`, which defaults to `null`): set output gain. (default: 0.4)
+- `delays` (of type `string?`, which defaults to `null`): set delays
+- `decays` (of type `string?`, which defaults to `null`): set decays
+- `speeds` (of type `string?`, which defaults to `null`): set speeds
+- `depths` (of type `string?`, which defaults to `null`): set depths
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.chromahold`
+
+Ffmpeg filter: Turns a certain color range into gray.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?, ?yuv : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the chromahold key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the chromahold similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the chromahold blend value. (default: 0.)
+- `yuv` (of type `bool?`, which defaults to `null`): color parameter is in yuv instead of rgb. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.chromahold.create`
+
+Ffmpeg filter: Turns a certain color range into gray.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?, ?yuv : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the chromahold key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the chromahold similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the chromahold blend value. (default: 0.)
+- `yuv` (of type `bool?`, which defaults to `null`): color parameter is in yuv instead of rgb. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.chromakey`
+
+Ffmpeg filter: Turns a certain color into transparency. Operates on YUV colors.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?, ?yuv : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the chromakey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the chromakey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the chromakey key blend value. (default: 0.)
+- `yuv` (of type `bool?`, which defaults to `null`): color parameter is in yuv instead of rgb. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.chromakey.create`
+
+Ffmpeg filter: Turns a certain color into transparency. Operates on YUV colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?, ?yuv : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the chromakey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the chromakey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the chromakey key blend value. (default: 0.)
+- `yuv` (of type `bool?`, which defaults to `null`): color parameter is in yuv instead of rgb. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.chromakey_cuda`
+
+Ffmpeg filter: GPU accelerated chromakey filter
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?, ?yuv : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the chromakey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the chromakey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the chromakey key blend value. (default: 0.)
+- `yuv` (of type `bool?`, which defaults to `null`): color parameter is in yuv instead of rgb. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.chromakey_cuda.create`
+
+Ffmpeg filter: GPU accelerated chromakey filter. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?, ?yuv : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the chromakey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the chromakey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the chromakey key blend value. (default: 0.)
+- `yuv` (of type `bool?`, which defaults to `null`): color parameter is in yuv instead of rgb. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.chromanr`
+
+Ffmpeg filter: Reduce chrominance noise.
+
+Type:
+
+```
+(?thres : float?, ?sizew : int?, ?sizeh : int?, ?stepw : int?, ?steph : int?,
+ ?threy : float?, ?threu : float?, ?threv : float?, ?distance : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `thres` (of type `float?`, which defaults to `null`): set y+u+v threshold. (default: 30.)
+- `sizew` (of type `int?`, which defaults to `null`): set horizontal patch size. (default: 5)
+- `sizeh` (of type `int?`, which defaults to `null`): set vertical patch size. (default: 5)
+- `stepw` (of type `int?`, which defaults to `null`): set horizontal step. (default: 1)
+- `steph` (of type `int?`, which defaults to `null`): set vertical step. (default: 1)
+- `threy` (of type `float?`, which defaults to `null`): set y threshold. (default: 200.)
+- `threu` (of type `float?`, which defaults to `null`): set u threshold. (default: 200.)
+- `threv` (of type `float?`, which defaults to `null`): set v threshold. (default: 200.)
+- `distance` (of type `int?`, which defaults to `null`): set distance type. (default: 0, possible values: 0 (manhattan), 1 (euclidean))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.chromanr.create`
+
+Ffmpeg filter: Reduce chrominance noise.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?thres : float?, ?sizew : int?, ?sizeh : int?, ?stepw : int?, ?steph : int?,
+ ?threy : float?, ?threu : float?, ?threv : float?, ?distance : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `thres` (of type `float?`, which defaults to `null`): set y+u+v threshold. (default: 30.)
+- `sizew` (of type `int?`, which defaults to `null`): set horizontal patch size. (default: 5)
+- `sizeh` (of type `int?`, which defaults to `null`): set vertical patch size. (default: 5)
+- `stepw` (of type `int?`, which defaults to `null`): set horizontal step. (default: 1)
+- `steph` (of type `int?`, which defaults to `null`): set vertical step. (default: 1)
+- `threy` (of type `float?`, which defaults to `null`): set y threshold. (default: 200.)
+- `threu` (of type `float?`, which defaults to `null`): set u threshold. (default: 200.)
+- `threv` (of type `float?`, which defaults to `null`): set v threshold. (default: 200.)
+- `distance` (of type `int?`, which defaults to `null`): set distance type. (default: 0, possible values: 0 (manhattan), 1 (euclidean))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.chromashift`
+
+Ffmpeg filter: Shift chroma.
+
+Type:
+
+```
+(?cbh : int?, ?cbv : int?, ?crh : int?, ?crv : int?, ?edge : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cbh` (of type `int?`, which defaults to `null`): shift chroma-blue horizontally. (default: 0)
+- `cbv` (of type `int?`, which defaults to `null`): shift chroma-blue vertically. (default: 0)
+- `crh` (of type `int?`, which defaults to `null`): shift chroma-red horizontally. (default: 0)
+- `crv` (of type `int?`, which defaults to `null`): shift chroma-red vertically. (default: 0)
+- `edge` (of type `int?`, which defaults to `null`): set edge operation. (default: 0, possible values: 0 (smear), 1 (wrap))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.chromashift.create`
+
+Ffmpeg filter: Shift chroma.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cbh : int?, ?cbv : int?, ?crh : int?, ?crv : int?, ?edge : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cbh` (of type `int?`, which defaults to `null`): shift chroma-blue horizontally. (default: 0)
+- `cbv` (of type `int?`, which defaults to `null`): shift chroma-blue vertically. (default: 0)
+- `crh` (of type `int?`, which defaults to `null`): shift chroma-red horizontally. (default: 0)
+- `crv` (of type `int?`, which defaults to `null`): shift chroma-red vertically. (default: 0)
+- `edge` (of type `int?`, which defaults to `null`): set edge operation. (default: 0, possible values: 0 (smear), 1 (wrap))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ciescope`
+
+Ffmpeg filter: Video CIE scope.
+
+Type:
+
+```
+(?system : int?, ?cie : int?, ?gamuts : int?, ?size : int?, ?s : int?,
+ ?intensity : float?, ?i : float?, ?contrast : float?, ?corrgamma : bool?,
+ ?showwhite : bool?, ?gamma : float?, ?fill : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `system` (of type `int?`, which defaults to `null`): set color system. (default: 7, possible values: 0 (ntsc), 0 (470m), 1 (ebu), 1 (470bg), 2 (smpte), 3 (240m), 4 (apple), 5 (widergb), 6 (cie1931), 7 (hdtv), 7 (rec709), 8 (uhdtv), 8 (rec2020), 9 (dcip3))
+- `cie` (of type `int?`, which defaults to `null`): set cie system. (default: 0, possible values: 0 (xyy), 1 (ucs), 2 (luv))
+- `gamuts` (of type `int?`, which defaults to `null`): set what gamuts to draw. (default: 0, possible values: 1 (ntsc), 1 (470m), 2 (ebu), 2 (470bg), 4 (smpte), 8 (240m), 16 (apple), 32 (widergb), 64 (cie1931), 128 (hdtv), 128 (rec709), 256 (uhdtv), 256 (rec2020), 512 (dcip3))
+- `size` (of type `int?`, which defaults to `null`): set ciescope size. (default: 512)
+- `s` (of type `int?`, which defaults to `null`): set ciescope size. (default: 512)
+- `intensity` (of type `float?`, which defaults to `null`): set ciescope intensity. (default: 0.001)
+- `i` (of type `float?`, which defaults to `null`): set ciescope intensity. (default: 0.001)
+- `contrast` (of type `float?`, which defaults to `null`): Default: 0.75
+- `corrgamma` (of type `bool?`, which defaults to `null`): Default: true
+- `showwhite` (of type `bool?`, which defaults to `null`): Default: false
+- `gamma` (of type `float?`, which defaults to `null`): Default: 2.6
+- `fill` (of type `bool?`, which defaults to `null`): fill with CIE colors. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.ciescope.create`
+
+Ffmpeg filter: Video CIE scope.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?system : int?, ?cie : int?, ?gamuts : int?, ?size : int?, ?s : int?,
+ ?intensity : float?, ?i : float?, ?contrast : float?, ?corrgamma : bool?,
+ ?showwhite : bool?, ?gamma : float?, ?fill : bool?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `system` (of type `int?`, which defaults to `null`): set color system. (default: 7, possible values: 0 (ntsc), 0 (470m), 1 (ebu), 1 (470bg), 2 (smpte), 3 (240m), 4 (apple), 5 (widergb), 6 (cie1931), 7 (hdtv), 7 (rec709), 8 (uhdtv), 8 (rec2020), 9 (dcip3))
+- `cie` (of type `int?`, which defaults to `null`): set cie system. (default: 0, possible values: 0 (xyy), 1 (ucs), 2 (luv))
+- `gamuts` (of type `int?`, which defaults to `null`): set what gamuts to draw. (default: 0, possible values: 1 (ntsc), 1 (470m), 2 (ebu), 2 (470bg), 4 (smpte), 8 (240m), 16 (apple), 32 (widergb), 64 (cie1931), 128 (hdtv), 128 (rec709), 256 (uhdtv), 256 (rec2020), 512 (dcip3))
+- `size` (of type `int?`, which defaults to `null`): set ciescope size. (default: 512)
+- `s` (of type `int?`, which defaults to `null`): set ciescope size. (default: 512)
+- `intensity` (of type `float?`, which defaults to `null`): set ciescope intensity. (default: 0.001)
+- `i` (of type `float?`, which defaults to `null`): set ciescope intensity. (default: 0.001)
+- `contrast` (of type `float?`, which defaults to `null`): Default: 0.75
+- `corrgamma` (of type `bool?`, which defaults to `null`): Default: true
+- `showwhite` (of type `bool?`, which defaults to `null`): Default: false
+- `gamma` (of type `float?`, which defaults to `null`): Default: 2.6
+- `fill` (of type `bool?`, which defaults to `null`): fill with CIE colors. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.codecview`
+
+Ffmpeg filter: Visualize information about some codecs.
+
+Type:
+
+```
+(?mv : int?, ?qp : bool?, ?mv_type : int?, ?mvt : int?, ?frame_type : int?,
+ ?ft : int?, ?block : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mv` (of type `int?`, which defaults to `null`): set motion vectors to visualize. (default: 0, possible values: 1 (pf), 2 (bf), 4 (bb))
+- `qp` (of type `bool?`, which defaults to `null`): Default: false
+- `mv_type` (of type `int?`, which defaults to `null`): set motion vectors type. (default: 0, possible values: 1 (fp), 2 (bp))
+- `mvt` (of type `int?`, which defaults to `null`): set motion vectors type. (default: 0, possible values: 1 (fp), 2 (bp))
+- `frame_type` (of type `int?`, which defaults to `null`): set frame types to visualize motion vectors of. (default: 0, possible values: 1 (if), 2 (pf), 4 (bf))
+- `ft` (of type `int?`, which defaults to `null`): set frame types to visualize motion vectors of. (default: 0, possible values: 1 (if), 2 (pf), 4 (bf))
+- `block` (of type `bool?`, which defaults to `null`): set block partitioning structure to visualize. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.codecview.create`
+
+Ffmpeg filter: Visualize information about some codecs.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mv : int?, ?qp : bool?, ?mv_type : int?, ?mvt : int?, ?frame_type : int?,
+ ?ft : int?, ?block : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mv` (of type `int?`, which defaults to `null`): set motion vectors to visualize. (default: 0, possible values: 1 (pf), 2 (bf), 4 (bb))
+- `qp` (of type `bool?`, which defaults to `null`): Default: false
+- `mv_type` (of type `int?`, which defaults to `null`): set motion vectors type. (default: 0, possible values: 1 (fp), 2 (bp))
+- `mvt` (of type `int?`, which defaults to `null`): set motion vectors type. (default: 0, possible values: 1 (fp), 2 (bp))
+- `frame_type` (of type `int?`, which defaults to `null`): set frame types to visualize motion vectors of. (default: 0, possible values: 1 (if), 2 (pf), 4 (bf))
+- `ft` (of type `int?`, which defaults to `null`): set frame types to visualize motion vectors of. (default: 0, possible values: 1 (if), 2 (pf), 4 (bf))
+- `block` (of type `bool?`, which defaults to `null`): set block partitioning structure to visualize. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.color`
+
+Ffmpeg filter: Provide an uniformly colored input.
+
+Type:
+
+```
+(?color : string?, ?c : string?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.color.create`
+
+Ffmpeg filter: Provide an uniformly colored input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?c : string?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorbalance`
+
+Ffmpeg filter: Adjust the color balance.
+
+Type:
+
+```
+(?rs : float?, ?gs : float?, ?bs : float?, ?rm : float?, ?gm : float?,
+ ?bm : float?, ?rh : float?, ?gh : float?, ?bh : float?, ?pl : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rs` (of type `float?`, which defaults to `null`): set red shadows. (default: 0.)
+- `gs` (of type `float?`, which defaults to `null`): set green shadows. (default: 0.)
+- `bs` (of type `float?`, which defaults to `null`): set blue shadows. (default: 0.)
+- `rm` (of type `float?`, which defaults to `null`): set red midtones. (default: 0.)
+- `gm` (of type `float?`, which defaults to `null`): set green midtones. (default: 0.)
+- `bm` (of type `float?`, which defaults to `null`): set blue midtones. (default: 0.)
+- `rh` (of type `float?`, which defaults to `null`): set red highlights. (default: 0.)
+- `gh` (of type `float?`, which defaults to `null`): set green highlights. (default: 0.)
+- `bh` (of type `float?`, which defaults to `null`): set blue highlights. (default: 0.)
+- `pl` (of type `bool?`, which defaults to `null`): preserve lightness. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorbalance.create`
+
+Ffmpeg filter: Adjust the color balance.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rs : float?, ?gs : float?, ?bs : float?, ?rm : float?, ?gm : float?,
+ ?bm : float?, ?rh : float?, ?gh : float?, ?bh : float?, ?pl : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rs` (of type `float?`, which defaults to `null`): set red shadows. (default: 0.)
+- `gs` (of type `float?`, which defaults to `null`): set green shadows. (default: 0.)
+- `bs` (of type `float?`, which defaults to `null`): set blue shadows. (default: 0.)
+- `rm` (of type `float?`, which defaults to `null`): set red midtones. (default: 0.)
+- `gm` (of type `float?`, which defaults to `null`): set green midtones. (default: 0.)
+- `bm` (of type `float?`, which defaults to `null`): set blue midtones. (default: 0.)
+- `rh` (of type `float?`, which defaults to `null`): set red highlights. (default: 0.)
+- `gh` (of type `float?`, which defaults to `null`): set green highlights. (default: 0.)
+- `bh` (of type `float?`, which defaults to `null`): set blue highlights. (default: 0.)
+- `pl` (of type `bool?`, which defaults to `null`): preserve lightness. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorchannelmixer`
+
+Ffmpeg filter: Adjust colors by mixing color channels.
+
+Type:
+
+```
+(?rr : float?, ?rg : float?, ?rb : float?, ?ra : float?, ?gr : float?,
+ ?gg : float?, ?gb : float?, ?ga : float?, ?br : float?, ?bg : float?,
+ ?bb : float?, ?ba : float?, ?ar : float?, ?ag : float?, ?ab : float?,
+ ?aa : float?, ?pc : int?, ?pa : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rr` (of type `float?`, which defaults to `null`): set the red gain for the red channel. (default: 1.)
+- `rg` (of type `float?`, which defaults to `null`): set the green gain for the red channel. (default: 0.)
+- `rb` (of type `float?`, which defaults to `null`): set the blue gain for the red channel. (default: 0.)
+- `ra` (of type `float?`, which defaults to `null`): set the alpha gain for the red channel. (default: 0.)
+- `gr` (of type `float?`, which defaults to `null`): set the red gain for the green channel. (default: 0.)
+- `gg` (of type `float?`, which defaults to `null`): set the green gain for the green channel. (default: 1.)
+- `gb` (of type `float?`, which defaults to `null`): set the blue gain for the green channel. (default: 0.)
+- `ga` (of type `float?`, which defaults to `null`): set the alpha gain for the green channel. (default: 0.)
+- `br` (of type `float?`, which defaults to `null`): set the red gain for the blue channel. (default: 0.)
+- `bg` (of type `float?`, which defaults to `null`): set the green gain for the blue channel. (default: 0.)
+- `bb` (of type `float?`, which defaults to `null`): set the blue gain for the blue channel. (default: 1.)
+- `ba` (of type `float?`, which defaults to `null`): set the alpha gain for the blue channel. (default: 0.)
+- `ar` (of type `float?`, which defaults to `null`): set the red gain for the alpha channel. (default: 0.)
+- `ag` (of type `float?`, which defaults to `null`): set the green gain for the alpha channel. (default: 0.)
+- `ab` (of type `float?`, which defaults to `null`): set the blue gain for the alpha channel. (default: 0.)
+- `aa` (of type `float?`, which defaults to `null`): set the alpha gain for the alpha channel. (default: 1.)
+- `pc` (of type `int?`, which defaults to `null`): set the preserve color mode. (default: 0, possible values: 0 (none), 1 (lum), 2 (max), 3 (avg), 4 (sum), 5 (nrm), 6 (pwr))
+- `pa` (of type `float?`, which defaults to `null`): set the preserve color amount. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorchannelmixer.create`
+
+Ffmpeg filter: Adjust colors by mixing color channels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rr : float?, ?rg : float?, ?rb : float?, ?ra : float?, ?gr : float?,
+ ?gg : float?, ?gb : float?, ?ga : float?, ?br : float?, ?bg : float?,
+ ?bb : float?, ?ba : float?, ?ar : float?, ?ag : float?, ?ab : float?,
+ ?aa : float?, ?pc : int?, ?pa : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rr` (of type `float?`, which defaults to `null`): set the red gain for the red channel. (default: 1.)
+- `rg` (of type `float?`, which defaults to `null`): set the green gain for the red channel. (default: 0.)
+- `rb` (of type `float?`, which defaults to `null`): set the blue gain for the red channel. (default: 0.)
+- `ra` (of type `float?`, which defaults to `null`): set the alpha gain for the red channel. (default: 0.)
+- `gr` (of type `float?`, which defaults to `null`): set the red gain for the green channel. (default: 0.)
+- `gg` (of type `float?`, which defaults to `null`): set the green gain for the green channel. (default: 1.)
+- `gb` (of type `float?`, which defaults to `null`): set the blue gain for the green channel. (default: 0.)
+- `ga` (of type `float?`, which defaults to `null`): set the alpha gain for the green channel. (default: 0.)
+- `br` (of type `float?`, which defaults to `null`): set the red gain for the blue channel. (default: 0.)
+- `bg` (of type `float?`, which defaults to `null`): set the green gain for the blue channel. (default: 0.)
+- `bb` (of type `float?`, which defaults to `null`): set the blue gain for the blue channel. (default: 1.)
+- `ba` (of type `float?`, which defaults to `null`): set the alpha gain for the blue channel. (default: 0.)
+- `ar` (of type `float?`, which defaults to `null`): set the red gain for the alpha channel. (default: 0.)
+- `ag` (of type `float?`, which defaults to `null`): set the green gain for the alpha channel. (default: 0.)
+- `ab` (of type `float?`, which defaults to `null`): set the blue gain for the alpha channel. (default: 0.)
+- `aa` (of type `float?`, which defaults to `null`): set the alpha gain for the alpha channel. (default: 1.)
+- `pc` (of type `int?`, which defaults to `null`): set the preserve color mode. (default: 0, possible values: 0 (none), 1 (lum), 2 (max), 3 (avg), 4 (sum), 5 (nrm), 6 (pwr))
+- `pa` (of type `float?`, which defaults to `null`): set the preserve color amount. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorchart`
+
+Ffmpeg filter: Generate color checker chart.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ?patch_size : string?, ?preset : int?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `patch_size` (of type `string?`, which defaults to `null`): set the single patch size. (default: 64x64)
+- `preset` (of type `int?`, which defaults to `null`): set the color checker chart preset. (default: 0, possible values: 0 (reference), 1 (skintones))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.colorchart.create`
+
+Ffmpeg filter: Generate color checker chart.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?sar : string?,
+ ?patch_size : string?, ?preset : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `patch_size` (of type `string?`, which defaults to `null`): set the single patch size. (default: 64x64)
+- `preset` (of type `int?`, which defaults to `null`): set the color checker chart preset. (default: 0, possible values: 0 (reference), 1 (skintones))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorcontrast`
+
+Ffmpeg filter: Adjust color contrast between RGB components.
+
+Type:
+
+```
+(?rc : float?, ?gm : float?, ?by : float?, ?rcw : float?, ?gmw : float?,
+ ?byw : float?, ?pl : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rc` (of type `float?`, which defaults to `null`): set the red-cyan contrast. (default: 0.)
+- `gm` (of type `float?`, which defaults to `null`): set the green-magenta contrast. (default: 0.)
+- `by` (of type `float?`, which defaults to `null`): set the blue-yellow contrast. (default: 0.)
+- `rcw` (of type `float?`, which defaults to `null`): set the red-cyan weight. (default: 0.)
+- `gmw` (of type `float?`, which defaults to `null`): set the green-magenta weight. (default: 0.)
+- `byw` (of type `float?`, which defaults to `null`): set the blue-yellow weight. (default: 0.)
+- `pl` (of type `float?`, which defaults to `null`): set the amount of preserving lightness. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorcontrast.create`
+
+Ffmpeg filter: Adjust color contrast between RGB components.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rc : float?, ?gm : float?, ?by : float?, ?rcw : float?, ?gmw : float?,
+ ?byw : float?, ?pl : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rc` (of type `float?`, which defaults to `null`): set the red-cyan contrast. (default: 0.)
+- `gm` (of type `float?`, which defaults to `null`): set the green-magenta contrast. (default: 0.)
+- `by` (of type `float?`, which defaults to `null`): set the blue-yellow contrast. (default: 0.)
+- `rcw` (of type `float?`, which defaults to `null`): set the red-cyan weight. (default: 0.)
+- `gmw` (of type `float?`, which defaults to `null`): set the green-magenta weight. (default: 0.)
+- `byw` (of type `float?`, which defaults to `null`): set the blue-yellow weight. (default: 0.)
+- `pl` (of type `float?`, which defaults to `null`): set the amount of preserving lightness. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorcorrect`
+
+Ffmpeg filter: Adjust color white balance selectively for blacks and whites.
+
+Type:
+
+```
+(?rl : float?, ?bl : float?, ?rh : float?, ?bh : float?,
+ ?saturation : float?, ?analyze : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rl` (of type `float?`, which defaults to `null`): set the red shadow spot. (default: 0.)
+- `bl` (of type `float?`, which defaults to `null`): set the blue shadow spot. (default: 0.)
+- `rh` (of type `float?`, which defaults to `null`): set the red highlight spot. (default: 0.)
+- `bh` (of type `float?`, which defaults to `null`): set the blue highlight spot. (default: 0.)
+- `saturation` (of type `float?`, which defaults to `null`): set the amount of saturation. (default: 1.)
+- `analyze` (of type `int?`, which defaults to `null`): set the analyze mode. (default: 0, possible values: 0 (manual), 1 (average), 2 (minmax), 3 (median))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorcorrect.create`
+
+Ffmpeg filter: Adjust color white balance selectively for blacks and whites.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rl : float?, ?bl : float?, ?rh : float?, ?bh : float?,
+ ?saturation : float?, ?analyze : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rl` (of type `float?`, which defaults to `null`): set the red shadow spot. (default: 0.)
+- `bl` (of type `float?`, which defaults to `null`): set the blue shadow spot. (default: 0.)
+- `rh` (of type `float?`, which defaults to `null`): set the red highlight spot. (default: 0.)
+- `bh` (of type `float?`, which defaults to `null`): set the blue highlight spot. (default: 0.)
+- `saturation` (of type `float?`, which defaults to `null`): set the amount of saturation. (default: 1.)
+- `analyze` (of type `int?`, which defaults to `null`): set the analyze mode. (default: 0, possible values: 0 (manual), 1 (average), 2 (minmax), 3 (median))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorhold`
+
+Ffmpeg filter: Turns a certain color range into gray. Operates on RGB colors.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the colorhold key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the colorhold similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the colorhold blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorhold.create`
+
+Ffmpeg filter: Turns a certain color range into gray. Operates on RGB colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the colorhold key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the colorhold similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the colorhold blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorize`
+
+Ffmpeg filter: Overlay a solid color on the video stream.
+
+Type:
+
+```
+(?hue : float?, ?saturation : float?, ?lightness : float?, ?mix : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue. (default: 0.)
+- `saturation` (of type `float?`, which defaults to `null`): set the saturation. (default: 0.5)
+- `lightness` (of type `float?`, which defaults to `null`): set the lightness. (default: 0.5)
+- `mix` (of type `float?`, which defaults to `null`): set the mix of source lightness. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorize.create`
+
+Ffmpeg filter: Overlay a solid color on the video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?hue : float?, ?saturation : float?, ?lightness : float?, ?mix : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue. (default: 0.)
+- `saturation` (of type `float?`, which defaults to `null`): set the saturation. (default: 0.5)
+- `lightness` (of type `float?`, which defaults to `null`): set the lightness. (default: 0.5)
+- `mix` (of type `float?`, which defaults to `null`): set the mix of source lightness. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorkey`
+
+Ffmpeg filter: Turns a certain color into transparency. Operates on RGB colors.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the colorkey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the colorkey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the colorkey key blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorkey.create`
+
+Ffmpeg filter: Turns a certain color into transparency. Operates on RGB colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the colorkey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the colorkey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the colorkey key blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorkey_opencl`
+
+Ffmpeg filter: Turns a certain color into transparency. Operates on RGB colors.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the colorkey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the colorkey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the colorkey key blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorkey_opencl.create`
+
+Ffmpeg filter: Turns a certain color into transparency. Operates on RGB colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?color : string?, ?similarity : float?, ?blend : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `color` (of type `string?`, which defaults to `null`): set the colorkey key color. (default: black)
+- `similarity` (of type `float?`, which defaults to `null`): set the colorkey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the colorkey key blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorlevels`
+
+Ffmpeg filter: Adjust the color levels.
+
+Type:
+
+```
+(?rimin : float?, ?gimin : float?, ?bimin : float?, ?aimin : float?,
+ ?rimax : float?, ?gimax : float?, ?bimax : float?, ?aimax : float?,
+ ?romin : float?, ?gomin : float?, ?bomin : float?, ?aomin : float?,
+ ?romax : float?, ?gomax : float?, ?bomax : float?, ?aomax : float?,
+ ?preserve : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rimin` (of type `float?`, which defaults to `null`): set input red black point. (default: 0.)
+- `gimin` (of type `float?`, which defaults to `null`): set input green black point. (default: 0.)
+- `bimin` (of type `float?`, which defaults to `null`): set input blue black point. (default: 0.)
+- `aimin` (of type `float?`, which defaults to `null`): set input alpha black point. (default: 0.)
+- `rimax` (of type `float?`, which defaults to `null`): set input red white point. (default: 1.)
+- `gimax` (of type `float?`, which defaults to `null`): set input green white point. (default: 1.)
+- `bimax` (of type `float?`, which defaults to `null`): set input blue white point. (default: 1.)
+- `aimax` (of type `float?`, which defaults to `null`): set input alpha white point. (default: 1.)
+- `romin` (of type `float?`, which defaults to `null`): set output red black point. (default: 0.)
+- `gomin` (of type `float?`, which defaults to `null`): set output green black point. (default: 0.)
+- `bomin` (of type `float?`, which defaults to `null`): set output blue black point. (default: 0.)
+- `aomin` (of type `float?`, which defaults to `null`): set output alpha black point. (default: 0.)
+- `romax` (of type `float?`, which defaults to `null`): set output red white point. (default: 1.)
+- `gomax` (of type `float?`, which defaults to `null`): set output green white point. (default: 1.)
+- `bomax` (of type `float?`, which defaults to `null`): set output blue white point. (default: 1.)
+- `aomax` (of type `float?`, which defaults to `null`): set output alpha white point. (default: 1.)
+- `preserve` (of type `int?`, which defaults to `null`): set preserve color mode. (default: 0, possible values: 0 (none), 1 (lum), 2 (max), 3 (avg), 4 (sum), 5 (nrm), 6 (pwr))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorlevels.create`
+
+Ffmpeg filter: Adjust the color levels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rimin : float?, ?gimin : float?, ?bimin : float?, ?aimin : float?,
+ ?rimax : float?, ?gimax : float?, ?bimax : float?, ?aimax : float?,
+ ?romin : float?, ?gomin : float?, ?bomin : float?, ?aomin : float?,
+ ?romax : float?, ?gomax : float?, ?bomax : float?, ?aomax : float?,
+ ?preserve : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rimin` (of type `float?`, which defaults to `null`): set input red black point. (default: 0.)
+- `gimin` (of type `float?`, which defaults to `null`): set input green black point. (default: 0.)
+- `bimin` (of type `float?`, which defaults to `null`): set input blue black point. (default: 0.)
+- `aimin` (of type `float?`, which defaults to `null`): set input alpha black point. (default: 0.)
+- `rimax` (of type `float?`, which defaults to `null`): set input red white point. (default: 1.)
+- `gimax` (of type `float?`, which defaults to `null`): set input green white point. (default: 1.)
+- `bimax` (of type `float?`, which defaults to `null`): set input blue white point. (default: 1.)
+- `aimax` (of type `float?`, which defaults to `null`): set input alpha white point. (default: 1.)
+- `romin` (of type `float?`, which defaults to `null`): set output red black point. (default: 0.)
+- `gomin` (of type `float?`, which defaults to `null`): set output green black point. (default: 0.)
+- `bomin` (of type `float?`, which defaults to `null`): set output blue black point. (default: 0.)
+- `aomin` (of type `float?`, which defaults to `null`): set output alpha black point. (default: 0.)
+- `romax` (of type `float?`, which defaults to `null`): set output red white point. (default: 1.)
+- `gomax` (of type `float?`, which defaults to `null`): set output green white point. (default: 1.)
+- `bomax` (of type `float?`, which defaults to `null`): set output blue white point. (default: 1.)
+- `aomax` (of type `float?`, which defaults to `null`): set output alpha white point. (default: 1.)
+- `preserve` (of type `int?`, which defaults to `null`): set preserve color mode. (default: 0, possible values: 0 (none), 1 (lum), 2 (max), 3 (avg), 4 (sum), 5 (nrm), 6 (pwr))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colormap`
+
+Ffmpeg filter: Apply custom Color Maps to video stream.
+
+Type:
+
+```
+(?patch_size : string?, ?nb_patches : int?, ?type : int?, ?kernel : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `patch_size` (of type `string?`, which defaults to `null`): set patch size. (default: 64x64)
+- `nb_patches` (of type `int?`, which defaults to `null`): set number of patches. (default: 0)
+- `type` (of type `int?`, which defaults to `null`): set the target type used. (default: 1, possible values: 0 (relative), 1 (absolute))
+- `kernel` (of type `int?`, which defaults to `null`): set the kernel used for measuring color difference. (default: 0, possible values: 0 (euclidean), 1 (weuclidean))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colormap.create`
+
+Ffmpeg filter: Apply custom Color Maps to video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?patch_size : string?, ?nb_patches : int?, ?type : int?, ?kernel : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `patch_size` (of type `string?`, which defaults to `null`): set patch size. (default: 64x64)
+- `nb_patches` (of type `int?`, which defaults to `null`): set number of patches. (default: 0)
+- `type` (of type `int?`, which defaults to `null`): set the target type used. (default: 1, possible values: 0 (relative), 1 (absolute))
+- `kernel` (of type `int?`, which defaults to `null`): set the kernel used for measuring color difference. (default: 0, possible values: 0 (euclidean), 1 (weuclidean))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colormatrix`
+
+Ffmpeg filter: Convert color matrix.
+
+Type:
+
+```
+(?src : int?, ?dst : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `src` (of type `int?`, which defaults to `null`): set source color matrix. (default: -1, possible values: 0 (bt709), 1 (fcc), 2 (bt601), 2 (bt470), 2 (bt470bg), 2 (smpte170m), 3 (smpte240m), 4 (bt2020))
+- `dst` (of type `int?`, which defaults to `null`): set destination color matrix. (default: -1, possible values: 0 (bt709), 1 (fcc), 2 (bt601), 2 (bt470), 2 (bt470bg), 2 (smpte170m), 3 (smpte240m), 4 (bt2020))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colormatrix.create`
+
+Ffmpeg filter: Convert color matrix.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?src : int?, ?dst : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `src` (of type `int?`, which defaults to `null`): set source color matrix. (default: -1, possible values: 0 (bt709), 1 (fcc), 2 (bt601), 2 (bt470), 2 (bt470bg), 2 (smpte170m), 3 (smpte240m), 4 (bt2020))
+- `dst` (of type `int?`, which defaults to `null`): set destination color matrix. (default: -1, possible values: 0 (bt709), 1 (fcc), 2 (bt601), 2 (bt470), 2 (bt470bg), 2 (smpte170m), 3 (smpte240m), 4 (bt2020))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorspace`
+
+Ffmpeg filter: Convert between colorspaces.
+
+Type:
+
+```
+(?all : int?, ?space : int?, ?range : int?, ?primaries : int?, ?trc : int?,
+ ?format : int?, ?fast : bool?, ?dither : int?, ?wpadapt : int?,
+ ?iall : int?, ?ispace : int?, ?irange : int?, ?iprimaries : int?,
+ ?itrc : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `all` (of type `int?`, which defaults to `null`): Set all color properties together. (default: 0, possible values: 1 (bt470m), 2 (bt470bg), 3 (bt601-6-525), 4 (bt601-6-625), 5 (bt709), 6 (smpte170m), 7 (smpte240m), 8 (bt2020))
+- `space` (of type `int?`, which defaults to `null`): Output colorspace. (default: 2, possible values: 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 0 (gbr), 9 (bt2020nc), 9 (bt2020ncl))
+- `range` (of type `int?`, which defaults to `null`): Output color range. (default: 0, possible values: 1 (tv), 1 (mpeg), 2 (pc), 2 (jpeg))
+- `primaries` (of type `int?`, which defaults to `null`): Output color primaries. (default: 2, possible values: 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 10 (smpte428), 8 (film), 11 (smpte431), 12 (smpte432), 9 (bt2020), 22 (jedec-p22), 22 (ebu3213))
+- `trc` (of type `int?`, which defaults to `null`): Output transfer characteristics. (default: 2, possible values: 1 (bt709), 4 (bt470m), 4 (gamma22), 5 (bt470bg), 5 (gamma28), 6 (smpte170m), 7 (smpte240m), 8 (linear), 13 (srgb), 13 (iec61966-2-1), 11 (xvycc), 11 (iec61966-2-4), 14 (bt2020-10), 15 (bt2020-12))
+- `format` (of type `int?`, which defaults to `null`): Output pixel format. (default: -1, possible values: 0 (yuv420p), 62 (yuv420p10), 123 (yuv420p12), 4 (yuv422p), 64 (yuv422p10), 127 (yuv422p12), 5 (yuv444p), 68 (yuv444p10), 131 (yuv444p12))
+- `fast` (of type `bool?`, which defaults to `null`): Ignore primary chromaticity and gamma correction. (default: false)
+- `dither` (of type `int?`, which defaults to `null`): Dithering mode. (default: 0, possible values: 0 (none), 1 (fsb))
+- `wpadapt` (of type `int?`, which defaults to `null`): Whitepoint adaptation method. (default: 0, possible values: 0 (bradford), 1 (vonkries), 2 (identity))
+- `iall` (of type `int?`, which defaults to `null`): Set all input color properties together. (default: 0, possible values: 1 (bt470m), 2 (bt470bg), 3 (bt601-6-525), 4 (bt601-6-625), 5 (bt709), 6 (smpte170m), 7 (smpte240m), 8 (bt2020))
+- `ispace` (of type `int?`, which defaults to `null`): Input colorspace. (default: 2, possible values: 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 0 (gbr), 9 (bt2020nc), 9 (bt2020ncl))
+- `irange` (of type `int?`, which defaults to `null`): Input color range. (default: 0, possible values: 1 (tv), 1 (mpeg), 2 (pc), 2 (jpeg))
+- `iprimaries` (of type `int?`, which defaults to `null`): Input color primaries. (default: 2, possible values: 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 10 (smpte428), 8 (film), 11 (smpte431), 12 (smpte432), 9 (bt2020), 22 (jedec-p22), 22 (ebu3213))
+- `itrc` (of type `int?`, which defaults to `null`): Input transfer characteristics. (default: 2, possible values: 1 (bt709), 4 (bt470m), 4 (gamma22), 5 (bt470bg), 5 (gamma28), 6 (smpte170m), 7 (smpte240m), 8 (linear), 13 (srgb), 13 (iec61966-2-1), 11 (xvycc), 11 (iec61966-2-4), 14 (bt2020-10), 15 (bt2020-12))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorspace.create`
+
+Ffmpeg filter: Convert between colorspaces.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?all : int?, ?space : int?, ?range : int?, ?primaries : int?, ?trc : int?,
+ ?format : int?, ?fast : bool?, ?dither : int?, ?wpadapt : int?,
+ ?iall : int?, ?ispace : int?, ?irange : int?, ?iprimaries : int?,
+ ?itrc : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `all` (of type `int?`, which defaults to `null`): Set all color properties together. (default: 0, possible values: 1 (bt470m), 2 (bt470bg), 3 (bt601-6-525), 4 (bt601-6-625), 5 (bt709), 6 (smpte170m), 7 (smpte240m), 8 (bt2020))
+- `space` (of type `int?`, which defaults to `null`): Output colorspace. (default: 2, possible values: 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 0 (gbr), 9 (bt2020nc), 9 (bt2020ncl))
+- `range` (of type `int?`, which defaults to `null`): Output color range. (default: 0, possible values: 1 (tv), 1 (mpeg), 2 (pc), 2 (jpeg))
+- `primaries` (of type `int?`, which defaults to `null`): Output color primaries. (default: 2, possible values: 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 10 (smpte428), 8 (film), 11 (smpte431), 12 (smpte432), 9 (bt2020), 22 (jedec-p22), 22 (ebu3213))
+- `trc` (of type `int?`, which defaults to `null`): Output transfer characteristics. (default: 2, possible values: 1 (bt709), 4 (bt470m), 4 (gamma22), 5 (bt470bg), 5 (gamma28), 6 (smpte170m), 7 (smpte240m), 8 (linear), 13 (srgb), 13 (iec61966-2-1), 11 (xvycc), 11 (iec61966-2-4), 14 (bt2020-10), 15 (bt2020-12))
+- `format` (of type `int?`, which defaults to `null`): Output pixel format. (default: -1, possible values: 0 (yuv420p), 62 (yuv420p10), 123 (yuv420p12), 4 (yuv422p), 64 (yuv422p10), 127 (yuv422p12), 5 (yuv444p), 68 (yuv444p10), 131 (yuv444p12))
+- `fast` (of type `bool?`, which defaults to `null`): Ignore primary chromaticity and gamma correction. (default: false)
+- `dither` (of type `int?`, which defaults to `null`): Dithering mode. (default: 0, possible values: 0 (none), 1 (fsb))
+- `wpadapt` (of type `int?`, which defaults to `null`): Whitepoint adaptation method. (default: 0, possible values: 0 (bradford), 1 (vonkries), 2 (identity))
+- `iall` (of type `int?`, which defaults to `null`): Set all input color properties together. (default: 0, possible values: 1 (bt470m), 2 (bt470bg), 3 (bt601-6-525), 4 (bt601-6-625), 5 (bt709), 6 (smpte170m), 7 (smpte240m), 8 (bt2020))
+- `ispace` (of type `int?`, which defaults to `null`): Input colorspace. (default: 2, possible values: 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 0 (gbr), 9 (bt2020nc), 9 (bt2020ncl))
+- `irange` (of type `int?`, which defaults to `null`): Input color range. (default: 0, possible values: 1 (tv), 1 (mpeg), 2 (pc), 2 (jpeg))
+- `iprimaries` (of type `int?`, which defaults to `null`): Input color primaries. (default: 2, possible values: 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 10 (smpte428), 8 (film), 11 (smpte431), 12 (smpte432), 9 (bt2020), 22 (jedec-p22), 22 (ebu3213))
+- `itrc` (of type `int?`, which defaults to `null`): Input transfer characteristics. (default: 2, possible values: 1 (bt709), 4 (bt470m), 4 (gamma22), 5 (bt470bg), 5 (gamma28), 6 (smpte170m), 7 (smpte240m), 8 (linear), 13 (srgb), 13 (iec61966-2-1), 11 (xvycc), 11 (iec61966-2-4), 14 (bt2020-10), 15 (bt2020-12))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorspace_cuda`
+
+Ffmpeg filter: CUDA accelerated video color converter
+
+Type:
+
+```
+(?range : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `range` (of type `int?`, which defaults to `null`): Output video range. (default: 0, possible values: 1 (tv), 1 (mpeg), 2 (pc), 2 (jpeg))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colorspace_cuda.create`
+
+Ffmpeg filter: CUDA accelerated video color converter. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?range : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `range` (of type `int?`, which defaults to `null`): Output video range. (default: 0, possible values: 1 (tv), 1 (mpeg), 2 (pc), 2 (jpeg))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colorspectrum`
+
+Ffmpeg filter: Generate colors spectrum.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?type : int?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `type` (of type `int?`, which defaults to `null`): set the color spectrum type. (default: 0, possible values: 0 (black), 1 (white), 2 (all))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.colorspectrum.create`
+
+Ffmpeg filter: Generate colors spectrum.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?type : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `type` (of type `int?`, which defaults to `null`): set the color spectrum type. (default: 0, possible values: 0 (black), 1 (white), 2 (all))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.colortemperature`
+
+Ffmpeg filter: Adjust color temperature of video.
+
+Type:
+
+```
+(?temperature : float?, ?mix : float?, ?pl : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `temperature` (of type `float?`, which defaults to `null`): set the temperature in Kelvin. (default: 6500.)
+- `mix` (of type `float?`, which defaults to `null`): set the mix with filtered output. (default: 1.)
+- `pl` (of type `float?`, which defaults to `null`): set the amount of preserving lightness. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.colortemperature.create`
+
+Ffmpeg filter: Adjust color temperature of video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?temperature : float?, ?mix : float?, ?pl : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `temperature` (of type `float?`, which defaults to `null`): set the temperature in Kelvin. (default: 6500.)
+- `mix` (of type `float?`, which defaults to `null`): set the mix with filtered output. (default: 1.)
+- `pl` (of type `float?`, which defaults to `null`): set the amount of preserving lightness. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.compand`
+
+Ffmpeg filter: Compress or expand audio dynamic range.
+
+Type:
+
+```
+(?attacks : string?, ?decays : string?, ?points : string?,
+ ?soft-knee : float?, ?gain : float?, ?volume : float?, ?delay : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `attacks` (of type `string?`, which defaults to `null`): set time over which increase of volume is determined. (default: 0)
+- `decays` (of type `string?`, which defaults to `null`): set time over which decrease of volume is determined. (default: 0.8)
+- `points` (of type `string?`, which defaults to `null`): set points of transfer function. (default: -70/-70|-60/-20|1/0)
+- `soft-knee` (of type `float?`, which defaults to `null`): set soft-knee. (default: 0.01)
+- `gain` (of type `float?`, which defaults to `null`): set output gain. (default: 0.)
+- `volume` (of type `float?`, which defaults to `null`): set initial volume. (default: 0.)
+- `delay` (of type `float?`, which defaults to `null`): set delay for samples before sending them to volume adjuster. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.compand.create`
+
+Ffmpeg filter: Compress or expand audio dynamic range.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?attacks : string?, ?decays : string?, ?points : string?,
+ ?soft-knee : float?, ?gain : float?, ?volume : float?, ?delay : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `attacks` (of type `string?`, which defaults to `null`): set time over which increase of volume is determined. (default: 0)
+- `decays` (of type `string?`, which defaults to `null`): set time over which decrease of volume is determined. (default: 0.8)
+- `points` (of type `string?`, which defaults to `null`): set points of transfer function. (default: -70/-70|-60/-20|1/0)
+- `soft-knee` (of type `float?`, which defaults to `null`): set soft-knee. (default: 0.01)
+- `gain` (of type `float?`, which defaults to `null`): set output gain. (default: 0.)
+- `volume` (of type `float?`, which defaults to `null`): set initial volume. (default: 0.)
+- `delay` (of type `float?`, which defaults to `null`): set delay for samples before sending them to volume adjuster. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.compensationdelay`
+
+Ffmpeg filter: Audio Compensation Delay Line.
+
+Type:
+
+```
+(?mm : int?, ?cm : int?, ?m : int?, ?dry : float?, ?wet : float?,
+ ?temp : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `mm` (of type `int?`, which defaults to `null`): set mm distance. (default: 0)
+- `cm` (of type `int?`, which defaults to `null`): set cm distance. (default: 0)
+- `m` (of type `int?`, which defaults to `null`): set meter distance. (default: 0)
+- `dry` (of type `float?`, which defaults to `null`): set dry amount. (default: 0.)
+- `wet` (of type `float?`, which defaults to `null`): set wet amount. (default: 1.)
+- `temp` (of type `int?`, which defaults to `null`): set temperature °C. (default: 20)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.compensationdelay.create`
+
+Ffmpeg filter: Audio Compensation Delay Line.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mm : int?, ?cm : int?, ?m : int?, ?dry : float?, ?wet : float?,
+ ?temp : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mm` (of type `int?`, which defaults to `null`): set mm distance. (default: 0)
+- `cm` (of type `int?`, which defaults to `null`): set cm distance. (default: 0)
+- `m` (of type `int?`, which defaults to `null`): set meter distance. (default: 0)
+- `dry` (of type `float?`, which defaults to `null`): set dry amount. (default: 0.)
+- `wet` (of type `float?`, which defaults to `null`): set wet amount. (default: 1.)
+- `temp` (of type `int?`, which defaults to `null`): set temperature °C. (default: 20)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.concat`
+
+Ffmpeg filter: Concatenate audio and video streams. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?n : int?, ?v : int?, ?a : int?, ?unsafe : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): specify the number of segments. (default: 2)
+- `v` (of type `int?`, which defaults to `null`): specify the number of video streams. (default: 1)
+- `a` (of type `int?`, which defaults to `null`): specify the number of audio streams. (default: 0)
+- `unsafe` (of type `bool?`, which defaults to `null`): enable unsafe mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.concat.create`
+
+Ffmpeg filter: Concatenate audio and video streams. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : int?, ?v : int?, ?a : int?, ?unsafe : bool?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): specify the number of segments. (default: 2)
+- `v` (of type `int?`, which defaults to `null`): specify the number of video streams. (default: 1)
+- `a` (of type `int?`, which defaults to `null`): specify the number of audio streams. (default: 0)
+- `unsafe` (of type `bool?`, which defaults to `null`): enable unsafe mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.convolution`
+
+Ffmpeg filter: Apply convolution filter.
+
+Type:
+
+```
+(?0m : string?, ?1m : string?, ?2m : string?, ?3m : string?, ?0rdiv : float?,
+ ?1rdiv : float?, ?2rdiv : float?, ?3rdiv : float?, ?0bias : float?,
+ ?1bias : float?, ?2bias : float?, ?3bias : float?, ?0mode : int?,
+ ?1mode : int?, ?2mode : int?, ?3mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `0m` (of type `string?`, which defaults to `null`): set matrix for 1st plane. (default: 0 0 0 0 1 0 0 0 0)
+- `1m` (of type `string?`, which defaults to `null`): set matrix for 2nd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `2m` (of type `string?`, which defaults to `null`): set matrix for 3rd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `3m` (of type `string?`, which defaults to `null`): set matrix for 4th plane. (default: 0 0 0 0 1 0 0 0 0)
+- `0rdiv` (of type `float?`, which defaults to `null`): set rdiv for 1st plane. (default: 0.)
+- `1rdiv` (of type `float?`, which defaults to `null`): set rdiv for 2nd plane. (default: 0.)
+- `2rdiv` (of type `float?`, which defaults to `null`): set rdiv for 3rd plane. (default: 0.)
+- `3rdiv` (of type `float?`, which defaults to `null`): set rdiv for 4th plane. (default: 0.)
+- `0bias` (of type `float?`, which defaults to `null`): set bias for 1st plane. (default: 0.)
+- `1bias` (of type `float?`, which defaults to `null`): set bias for 2nd plane. (default: 0.)
+- `2bias` (of type `float?`, which defaults to `null`): set bias for 3rd plane. (default: 0.)
+- `3bias` (of type `float?`, which defaults to `null`): set bias for 4th plane. (default: 0.)
+- `0mode` (of type `int?`, which defaults to `null`): set matrix mode for 1st plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `1mode` (of type `int?`, which defaults to `null`): set matrix mode for 2nd plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `2mode` (of type `int?`, which defaults to `null`): set matrix mode for 3rd plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `3mode` (of type `int?`, which defaults to `null`): set matrix mode for 4th plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.convolution.create`
+
+Ffmpeg filter: Apply convolution filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?0m : string?, ?1m : string?, ?2m : string?, ?3m : string?, ?0rdiv : float?,
+ ?1rdiv : float?, ?2rdiv : float?, ?3rdiv : float?, ?0bias : float?,
+ ?1bias : float?, ?2bias : float?, ?3bias : float?, ?0mode : int?,
+ ?1mode : int?, ?2mode : int?, ?3mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `0m` (of type `string?`, which defaults to `null`): set matrix for 1st plane. (default: 0 0 0 0 1 0 0 0 0)
+- `1m` (of type `string?`, which defaults to `null`): set matrix for 2nd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `2m` (of type `string?`, which defaults to `null`): set matrix for 3rd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `3m` (of type `string?`, which defaults to `null`): set matrix for 4th plane. (default: 0 0 0 0 1 0 0 0 0)
+- `0rdiv` (of type `float?`, which defaults to `null`): set rdiv for 1st plane. (default: 0.)
+- `1rdiv` (of type `float?`, which defaults to `null`): set rdiv for 2nd plane. (default: 0.)
+- `2rdiv` (of type `float?`, which defaults to `null`): set rdiv for 3rd plane. (default: 0.)
+- `3rdiv` (of type `float?`, which defaults to `null`): set rdiv for 4th plane. (default: 0.)
+- `0bias` (of type `float?`, which defaults to `null`): set bias for 1st plane. (default: 0.)
+- `1bias` (of type `float?`, which defaults to `null`): set bias for 2nd plane. (default: 0.)
+- `2bias` (of type `float?`, which defaults to `null`): set bias for 3rd plane. (default: 0.)
+- `3bias` (of type `float?`, which defaults to `null`): set bias for 4th plane. (default: 0.)
+- `0mode` (of type `int?`, which defaults to `null`): set matrix mode for 1st plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `1mode` (of type `int?`, which defaults to `null`): set matrix mode for 2nd plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `2mode` (of type `int?`, which defaults to `null`): set matrix mode for 3rd plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `3mode` (of type `int?`, which defaults to `null`): set matrix mode for 4th plane. (default: 0, possible values: 0 (square), 1 (row), 2 (column))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.convolution_opencl`
+
+Ffmpeg filter: Apply convolution mask to input video
+
+Type:
+
+```
+(?0m : string?, ?1m : string?, ?2m : string?, ?3m : string?, ?0rdiv : float?,
+ ?1rdiv : float?, ?2rdiv : float?, ?3rdiv : float?, ?0bias : float?,
+ ?1bias : float?, ?2bias : float?, ?3bias : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `0m` (of type `string?`, which defaults to `null`): set matrix for 2nd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `1m` (of type `string?`, which defaults to `null`): set matrix for 2nd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `2m` (of type `string?`, which defaults to `null`): set matrix for 3rd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `3m` (of type `string?`, which defaults to `null`): set matrix for 4th plane. (default: 0 0 0 0 1 0 0 0 0)
+- `0rdiv` (of type `float?`, which defaults to `null`): set rdiv for 1nd plane. (default: 1.)
+- `1rdiv` (of type `float?`, which defaults to `null`): set rdiv for 2nd plane. (default: 1.)
+- `2rdiv` (of type `float?`, which defaults to `null`): set rdiv for 3rd plane. (default: 1.)
+- `3rdiv` (of type `float?`, which defaults to `null`): set rdiv for 4th plane. (default: 1.)
+- `0bias` (of type `float?`, which defaults to `null`): set bias for 1st plane. (default: 0.)
+- `1bias` (of type `float?`, which defaults to `null`): set bias for 2nd plane. (default: 0.)
+- `2bias` (of type `float?`, which defaults to `null`): set bias for 3rd plane. (default: 0.)
+- `3bias` (of type `float?`, which defaults to `null`): set bias for 4th plane. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.convolution_opencl.create`
+
+Ffmpeg filter: Apply convolution mask to input video. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?0m : string?, ?1m : string?, ?2m : string?, ?3m : string?, ?0rdiv : float?,
+ ?1rdiv : float?, ?2rdiv : float?, ?3rdiv : float?, ?0bias : float?,
+ ?1bias : float?, ?2bias : float?, ?3bias : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `0m` (of type `string?`, which defaults to `null`): set matrix for 2nd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `1m` (of type `string?`, which defaults to `null`): set matrix for 2nd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `2m` (of type `string?`, which defaults to `null`): set matrix for 3rd plane. (default: 0 0 0 0 1 0 0 0 0)
+- `3m` (of type `string?`, which defaults to `null`): set matrix for 4th plane. (default: 0 0 0 0 1 0 0 0 0)
+- `0rdiv` (of type `float?`, which defaults to `null`): set rdiv for 1nd plane. (default: 1.)
+- `1rdiv` (of type `float?`, which defaults to `null`): set rdiv for 2nd plane. (default: 1.)
+- `2rdiv` (of type `float?`, which defaults to `null`): set rdiv for 3rd plane. (default: 1.)
+- `3rdiv` (of type `float?`, which defaults to `null`): set rdiv for 4th plane. (default: 1.)
+- `0bias` (of type `float?`, which defaults to `null`): set bias for 1st plane. (default: 0.)
+- `1bias` (of type `float?`, which defaults to `null`): set bias for 2nd plane. (default: 0.)
+- `2bias` (of type `float?`, which defaults to `null`): set bias for 3rd plane. (default: 0.)
+- `3bias` (of type `float?`, which defaults to `null`): set bias for 4th plane. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.convolve`
+
+Ffmpeg filter: Convolve first video stream with second video stream.
+
+Type:
+
+```
+(?planes : int?, ?impulse : int?, ?noise : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to convolve. (default: 7)
+- `impulse` (of type `int?`, which defaults to `null`): when to process impulses. (default: 1, possible values: 0 (first), 1 (all))
+- `noise` (of type `float?`, which defaults to `null`): set noise. (default: 1e-07)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.convolve.create`
+
+Ffmpeg filter: Convolve first video stream with second video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?impulse : int?, ?noise : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to convolve. (default: 7)
+- `impulse` (of type `int?`, which defaults to `null`): when to process impulses. (default: 1, possible values: 0 (first), 1 (all))
+- `noise` (of type `float?`, which defaults to `null`): set noise. (default: 1e-07)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.copy`
+
+Ffmpeg filter: Copy the input video unchanged to the output.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.copy.create`
+
+Ffmpeg filter: Copy the input video unchanged to the output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.corr`
+
+Ffmpeg filter: Calculate the correlation between two video streams.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.corr.create`
+
+Ffmpeg filter: Calculate the correlation between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.cover_rect`
+
+Ffmpeg filter: Find and cover a user specified object.
+
+Type:
+
+```
+(?cover : string?, ?mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cover` (of type `string?`, which defaults to `null`): cover bitmap filename
+- `mode` (of type `int?`, which defaults to `null`): set removal mode. (default: 1, possible values: 0 (cover), 1 (blur))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.cover_rect.create`
+
+Ffmpeg filter: Find and cover a user specified object.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cover : string?, ?mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cover` (of type `string?`, which defaults to `null`): cover bitmap filename
+- `mode` (of type `int?`, which defaults to `null`): set removal mode. (default: 1, possible values: 0 (cover), 1 (blur))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.crop`
+
+Ffmpeg filter: Crop the input video.
+
+Type:
+
+```
+(?out_w : string?, ?w : string?, ?out_h : string?, ?h : string?,
+ ?x : string?, ?y : string?, ?keep_aspect : bool?, ?exact : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `out_w` (of type `string?`, which defaults to `null`): set the width crop area expression. (default: iw)
+- `w` (of type `string?`, which defaults to `null`): set the width crop area expression. (default: iw)
+- `out_h` (of type `string?`, which defaults to `null`): set the height crop area expression. (default: ih)
+- `h` (of type `string?`, which defaults to `null`): set the height crop area expression. (default: ih)
+- `x` (of type `string?`, which defaults to `null`): set the x crop area expression. (default: (in_w-out_w)/2)
+- `y` (of type `string?`, which defaults to `null`): set the y crop area expression. (default: (in_h-out_h)/2)
+- `keep_aspect` (of type `bool?`, which defaults to `null`): keep aspect ratio. (default: false)
+- `exact` (of type `bool?`, which defaults to `null`): do exact cropping. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.crop.create`
+
+Ffmpeg filter: Crop the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?out_w : string?, ?w : string?, ?out_h : string?, ?h : string?,
+ ?x : string?, ?y : string?, ?keep_aspect : bool?, ?exact : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `out_w` (of type `string?`, which defaults to `null`): set the width crop area expression. (default: iw)
+- `w` (of type `string?`, which defaults to `null`): set the width crop area expression. (default: iw)
+- `out_h` (of type `string?`, which defaults to `null`): set the height crop area expression. (default: ih)
+- `h` (of type `string?`, which defaults to `null`): set the height crop area expression. (default: ih)
+- `x` (of type `string?`, which defaults to `null`): set the x crop area expression. (default: (in_w-out_w)/2)
+- `y` (of type `string?`, which defaults to `null`): set the y crop area expression. (default: (in_h-out_h)/2)
+- `keep_aspect` (of type `bool?`, which defaults to `null`): keep aspect ratio. (default: false)
+- `exact` (of type `bool?`, which defaults to `null`): do exact cropping. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.cropdetect`
+
+Ffmpeg filter: Auto-detect crop size.
+
+Type:
+
+```
+(?limit : float?, ?round : int?, ?reset : int?, ?skip : int?,
+ ?reset_count : int?, ?max_outliers : int?, ?mode : int?, ?high : float?,
+ ?low : float?, ?mv_threshold : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `limit` (of type `float?`, which defaults to `null`): Threshold below which the pixel is considered black. (default: 0.0941176470588)
+- `round` (of type `int?`, which defaults to `null`): Value by which the width/height should be divisible. (default: 16)
+- `reset` (of type `int?`, which defaults to `null`): Recalculate the crop area after this many frames. (default: 0)
+- `skip` (of type `int?`, which defaults to `null`): Number of initial frames to skip. (default: 2)
+- `reset_count` (of type `int?`, which defaults to `null`): Recalculate the crop area after this many frames. (default: 0)
+- `max_outliers` (of type `int?`, which defaults to `null`): Threshold count of outliers. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (black), 1 (mvedges))
+- `high` (of type `float?`, which defaults to `null`): Set high threshold for edge detection. (default: 0.0980392156863)
+- `low` (of type `float?`, which defaults to `null`): Set low threshold for edge detection. (default: 0.0588235294118)
+- `mv_threshold` (of type `int?`, which defaults to `null`): motion vector threshold when estimating video window size. (default: 8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.cropdetect.create`
+
+Ffmpeg filter: Auto-detect crop size.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?limit : float?, ?round : int?, ?reset : int?, ?skip : int?,
+ ?reset_count : int?, ?max_outliers : int?, ?mode : int?, ?high : float?,
+ ?low : float?, ?mv_threshold : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `limit` (of type `float?`, which defaults to `null`): Threshold below which the pixel is considered black. (default: 0.0941176470588)
+- `round` (of type `int?`, which defaults to `null`): Value by which the width/height should be divisible. (default: 16)
+- `reset` (of type `int?`, which defaults to `null`): Recalculate the crop area after this many frames. (default: 0)
+- `skip` (of type `int?`, which defaults to `null`): Number of initial frames to skip. (default: 2)
+- `reset_count` (of type `int?`, which defaults to `null`): Recalculate the crop area after this many frames. (default: 0)
+- `max_outliers` (of type `int?`, which defaults to `null`): Threshold count of outliers. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (black), 1 (mvedges))
+- `high` (of type `float?`, which defaults to `null`): Set high threshold for edge detection. (default: 0.0980392156863)
+- `low` (of type `float?`, which defaults to `null`): Set low threshold for edge detection. (default: 0.0588235294118)
+- `mv_threshold` (of type `int?`, which defaults to `null`): motion vector threshold when estimating video window size. (default: 8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.crossfeed`
+
+Ffmpeg filter: Apply headphone crossfeed filter.
+
+Type:
+
+```
+(?strength : float?, ?range : float?, ?slope : float?, ?level_in : float?,
+ ?level_out : float?, ?block_size : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set crossfeed strength. (default: 0.2)
+- `range` (of type `float?`, which defaults to `null`): set soundstage wideness. (default: 0.5)
+- `slope` (of type `float?`, which defaults to `null`): set curve slope. (default: 0.5)
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 0.9)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `block_size` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.crossfeed.create`
+
+Ffmpeg filter: Apply headphone crossfeed filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?strength : float?, ?range : float?, ?slope : float?, ?level_in : float?,
+ ?level_out : float?, ?block_size : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set crossfeed strength. (default: 0.2)
+- `range` (of type `float?`, which defaults to `null`): set soundstage wideness. (default: 0.5)
+- `slope` (of type `float?`, which defaults to `null`): set curve slope. (default: 0.5)
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 0.9)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `block_size` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.crystalizer`
+
+Ffmpeg filter: Simple audio noise sharpening filter.
+
+Type:
+
+```
+(?i : float?, ?c : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 2.)
+- `c` (of type `bool?`, which defaults to `null`): enable clipping. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.crystalizer.create`
+
+Ffmpeg filter: Simple audio noise sharpening filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?i : float?, ?c : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 2.)
+- `c` (of type `bool?`, which defaults to `null`): enable clipping. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.cue`
+
+Ffmpeg filter: Delay filtering to match a cue.
+
+Type:
+
+```
+(?cue : int?, ?preroll : int?, ?buffer : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cue` (of type `int?`, which defaults to `null`): cue unix timestamp in microseconds. (default: 0)
+- `preroll` (of type `int?`, which defaults to `null`): preroll duration in seconds. (default: 0)
+- `buffer` (of type `int?`, which defaults to `null`): buffer duration in seconds. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.cue.create`
+
+Ffmpeg filter: Delay filtering to match a cue.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cue : int?, ?preroll : int?, ?buffer : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cue` (of type `int?`, which defaults to `null`): cue unix timestamp in microseconds. (default: 0)
+- `preroll` (of type `int?`, which defaults to `null`): preroll duration in seconds. (default: 0)
+- `buffer` (of type `int?`, which defaults to `null`): buffer duration in seconds. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.curves`
+
+Ffmpeg filter: Adjust components curves.
+
+Type:
+
+```
+(?preset : int?, ?master : string?, ?m : string?, ?red : string?,
+ ?r : string?, ?green : string?, ?g : string?, ?blue : string?, ?b : string?,
+ ?all : string?, ?psfile : string?, ?plot : string?, ?interp : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `preset` (of type `int?`, which defaults to `null`): select a color curves preset. (default: 0, possible values: 0 (none), 1 (color_negative), 2 (cross_process), 3 (darker), 4 (increase_contrast), 5 (lighter), 6 (linear_contrast), 7 (medium_contrast), 8 (negative), 9 (strong_contrast), 10 (vintage))
+- `master` (of type `string?`, which defaults to `null`): set master points coordinates
+- `m` (of type `string?`, which defaults to `null`): set master points coordinates
+- `red` (of type `string?`, which defaults to `null`): set red points coordinates
+- `r` (of type `string?`, which defaults to `null`): set red points coordinates
+- `green` (of type `string?`, which defaults to `null`): set green points coordinates
+- `g` (of type `string?`, which defaults to `null`): set green points coordinates
+- `blue` (of type `string?`, which defaults to `null`): set blue points coordinates
+- `b` (of type `string?`, which defaults to `null`): set blue points coordinates
+- `all` (of type `string?`, which defaults to `null`): set points coordinates for all components
+- `psfile` (of type `string?`, which defaults to `null`): set Photoshop curves file name
+- `plot` (of type `string?`, which defaults to `null`): save Gnuplot script of the curves in specified file
+- `interp` (of type `int?`, which defaults to `null`): specify the kind of interpolation. (default: 0, possible values: 0 (natural), 1 (pchip))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.curves.create`
+
+Ffmpeg filter: Adjust components curves.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?preset : int?, ?master : string?, ?m : string?, ?red : string?,
+ ?r : string?, ?green : string?, ?g : string?, ?blue : string?, ?b : string?,
+ ?all : string?, ?psfile : string?, ?plot : string?, ?interp : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `preset` (of type `int?`, which defaults to `null`): select a color curves preset. (default: 0, possible values: 0 (none), 1 (color_negative), 2 (cross_process), 3 (darker), 4 (increase_contrast), 5 (lighter), 6 (linear_contrast), 7 (medium_contrast), 8 (negative), 9 (strong_contrast), 10 (vintage))
+- `master` (of type `string?`, which defaults to `null`): set master points coordinates
+- `m` (of type `string?`, which defaults to `null`): set master points coordinates
+- `red` (of type `string?`, which defaults to `null`): set red points coordinates
+- `r` (of type `string?`, which defaults to `null`): set red points coordinates
+- `green` (of type `string?`, which defaults to `null`): set green points coordinates
+- `g` (of type `string?`, which defaults to `null`): set green points coordinates
+- `blue` (of type `string?`, which defaults to `null`): set blue points coordinates
+- `b` (of type `string?`, which defaults to `null`): set blue points coordinates
+- `all` (of type `string?`, which defaults to `null`): set points coordinates for all components
+- `psfile` (of type `string?`, which defaults to `null`): set Photoshop curves file name
+- `plot` (of type `string?`, which defaults to `null`): save Gnuplot script of the curves in specified file
+- `interp` (of type `int?`, which defaults to `null`): specify the kind of interpolation. (default: 0, possible values: 0 (natural), 1 (pchip))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.datascope`
+
+Ffmpeg filter: Video data analysis.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?x : int?, ?y : int?, ?mode : int?,
+ ?axis : bool?, ?opacity : float?, ?format : int?, ?components : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set output size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set output size. (default: hd720)
+- `x` (of type `int?`, which defaults to `null`): set x offset. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): set y offset. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set scope mode. (default: 0, possible values: 0 (mono), 1 (color), 2 (color2))
+- `axis` (of type `bool?`, which defaults to `null`): draw column/row numbers. (default: false)
+- `opacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.75)
+- `format` (of type `int?`, which defaults to `null`): set display number format. (default: 0, possible values: 0 (hex), 1 (dec))
+- `components` (of type `int?`, which defaults to `null`): set components to display. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.datascope.create`
+
+Ffmpeg filter: Video data analysis.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?x : int?, ?y : int?, ?mode : int?,
+ ?axis : bool?, ?opacity : float?, ?format : int?, ?components : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set output size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set output size. (default: hd720)
+- `x` (of type `int?`, which defaults to `null`): set x offset. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): set y offset. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set scope mode. (default: 0, possible values: 0 (mono), 1 (color), 2 (color2))
+- `axis` (of type `bool?`, which defaults to `null`): draw column/row numbers. (default: false)
+- `opacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.75)
+- `format` (of type `int?`, which defaults to `null`): set display number format. (default: 0, possible values: 0 (hex), 1 (dec))
+- `components` (of type `int?`, which defaults to `null`): set components to display. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dblur`
+
+Ffmpeg filter: Apply Directional Blur filter.
+
+Type:
+
+```
+(?angle : float?, ?radius : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `angle` (of type `float?`, which defaults to `null`): set angle. (default: 45.)
+- `radius` (of type `float?`, which defaults to `null`): set radius. (default: 5.)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dblur.create`
+
+Ffmpeg filter: Apply Directional Blur filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?angle : float?, ?radius : float?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `angle` (of type `float?`, which defaults to `null`): set angle. (default: 45.)
+- `radius` (of type `float?`, which defaults to `null`): set radius. (default: 5.)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dcshift`
+
+Ffmpeg filter: Apply a DC shift to the audio.
+
+Type:
+
+```
+(?shift : float?, ?limitergain : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `shift` (of type `float?`, which defaults to `null`): set DC shift. (default: 0.)
+- `limitergain` (of type `float?`, which defaults to `null`): set limiter gain. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.dcshift.create`
+
+Ffmpeg filter: Apply a DC shift to the audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?shift : float?, ?limitergain : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `shift` (of type `float?`, which defaults to `null`): set DC shift. (default: 0.)
+- `limitergain` (of type `float?`, which defaults to `null`): set limiter gain. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dctdnoiz`
+
+Ffmpeg filter: Denoise frames using 2D DCT.
+
+Type:
+
+```
+(?sigma : float?, ?s : float?, ?overlap : int?, ?expr : string?,
+ ?e : string?, ?n : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set noise sigma constant. (default: 0.)
+- `s` (of type `float?`, which defaults to `null`): set noise sigma constant. (default: 0.)
+- `overlap` (of type `int?`, which defaults to `null`): set number of block overlapping pixels. (default: -1)
+- `expr` (of type `string?`, which defaults to `null`): set coefficient factor expression
+- `e` (of type `string?`, which defaults to `null`): set coefficient factor expression
+- `n` (of type `int?`, which defaults to `null`): set the block size, expressed in bits. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dctdnoiz.create`
+
+Ffmpeg filter: Denoise frames using 2D DCT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigma : float?, ?s : float?, ?overlap : int?, ?expr : string?,
+ ?e : string?, ?n : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set noise sigma constant. (default: 0.)
+- `s` (of type `float?`, which defaults to `null`): set noise sigma constant. (default: 0.)
+- `overlap` (of type `int?`, which defaults to `null`): set number of block overlapping pixels. (default: -1)
+- `expr` (of type `string?`, which defaults to `null`): set coefficient factor expression
+- `e` (of type `string?`, which defaults to `null`): set coefficient factor expression
+- `n` (of type `int?`, which defaults to `null`): set the block size, expressed in bits. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deband`
+
+Ffmpeg filter: Debands video.
+
+Type:
+
+```
+(?1thr : float?, ?2thr : float?, ?3thr : float?, ?4thr : float?,
+ ?range : int?, ?r : int?, ?direction : float?, ?d : float?, ?blur : bool?,
+ ?b : bool?, ?coupling : bool?, ?c : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `1thr` (of type `float?`, which defaults to `null`): set 1st plane threshold. (default: 0.02)
+- `2thr` (of type `float?`, which defaults to `null`): set 2nd plane threshold. (default: 0.02)
+- `3thr` (of type `float?`, which defaults to `null`): set 3rd plane threshold. (default: 0.02)
+- `4thr` (of type `float?`, which defaults to `null`): set 4th plane threshold. (default: 0.02)
+- `range` (of type `int?`, which defaults to `null`): set range. (default: 16)
+- `r` (of type `int?`, which defaults to `null`): set range. (default: 16)
+- `direction` (of type `float?`, which defaults to `null`): set direction. (default: 6.28318530718)
+- `d` (of type `float?`, which defaults to `null`): set direction. (default: 6.28318530718)
+- `blur` (of type `bool?`, which defaults to `null`): set blur. (default: true)
+- `b` (of type `bool?`, which defaults to `null`): set blur. (default: true)
+- `coupling` (of type `bool?`, which defaults to `null`): set plane coupling. (default: false)
+- `c` (of type `bool?`, which defaults to `null`): set plane coupling. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deband.create`
+
+Ffmpeg filter: Debands video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?1thr : float?, ?2thr : float?, ?3thr : float?, ?4thr : float?,
+ ?range : int?, ?r : int?, ?direction : float?, ?d : float?, ?blur : bool?,
+ ?b : bool?, ?coupling : bool?, ?c : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `1thr` (of type `float?`, which defaults to `null`): set 1st plane threshold. (default: 0.02)
+- `2thr` (of type `float?`, which defaults to `null`): set 2nd plane threshold. (default: 0.02)
+- `3thr` (of type `float?`, which defaults to `null`): set 3rd plane threshold. (default: 0.02)
+- `4thr` (of type `float?`, which defaults to `null`): set 4th plane threshold. (default: 0.02)
+- `range` (of type `int?`, which defaults to `null`): set range. (default: 16)
+- `r` (of type `int?`, which defaults to `null`): set range. (default: 16)
+- `direction` (of type `float?`, which defaults to `null`): set direction. (default: 6.28318530718)
+- `d` (of type `float?`, which defaults to `null`): set direction. (default: 6.28318530718)
+- `blur` (of type `bool?`, which defaults to `null`): set blur. (default: true)
+- `b` (of type `bool?`, which defaults to `null`): set blur. (default: true)
+- `coupling` (of type `bool?`, which defaults to `null`): set plane coupling. (default: false)
+- `c` (of type `bool?`, which defaults to `null`): set plane coupling. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deblock`
+
+Ffmpeg filter: Deblock video.
+
+Type:
+
+```
+(?filter : int?, ?block : int?, ?alpha : float?, ?beta : float?,
+ ?gamma : float?, ?delta : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filter` (of type `int?`, which defaults to `null`): set type of filter. (default: 1, possible values: 0 (weak), 1 (strong))
+- `block` (of type `int?`, which defaults to `null`): set size of block. (default: 8)
+- `alpha` (of type `float?`, which defaults to `null`): set 1st detection threshold. (default: 0.098)
+- `beta` (of type `float?`, which defaults to `null`): set 2nd detection threshold. (default: 0.05)
+- `gamma` (of type `float?`, which defaults to `null`): set 3rd detection threshold. (default: 0.05)
+- `delta` (of type `float?`, which defaults to `null`): set 4th detection threshold. (default: 0.05)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deblock.create`
+
+Ffmpeg filter: Deblock video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filter : int?, ?block : int?, ?alpha : float?, ?beta : float?,
+ ?gamma : float?, ?delta : float?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `filter` (of type `int?`, which defaults to `null`): set type of filter. (default: 1, possible values: 0 (weak), 1 (strong))
+- `block` (of type `int?`, which defaults to `null`): set size of block. (default: 8)
+- `alpha` (of type `float?`, which defaults to `null`): set 1st detection threshold. (default: 0.098)
+- `beta` (of type `float?`, which defaults to `null`): set 2nd detection threshold. (default: 0.05)
+- `gamma` (of type `float?`, which defaults to `null`): set 3rd detection threshold. (default: 0.05)
+- `delta` (of type `float?`, which defaults to `null`): set 4th detection threshold. (default: 0.05)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.decimate`
+
+Ffmpeg filter: Decimate frames (post field matching filter). This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?cycle : int?, ?dupthresh : float?, ?scthresh : float?, ?blockx : int?,
+ ?blocky : int?, ?ppsrc : bool?, ?chroma : bool?, ?mixed : bool?,
+ ffmpeg.filter.graph, [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cycle` (of type `int?`, which defaults to `null`): set the number of frame from which one will be dropped. (default: 5)
+- `dupthresh` (of type `float?`, which defaults to `null`): set duplicate threshold. (default: 1.1)
+- `scthresh` (of type `float?`, which defaults to `null`): set scene change threshold. (default: 15.)
+- `blockx` (of type `int?`, which defaults to `null`): set the size of the x-axis blocks used during metric calculations. (default: 32)
+- `blocky` (of type `int?`, which defaults to `null`): set the size of the y-axis blocks used during metric calculations. (default: 32)
+- `ppsrc` (of type `bool?`, which defaults to `null`): mark main input as a pre-processed input and activate clean source input stream. (default: false)
+- `chroma` (of type `bool?`, which defaults to `null`): set whether or not chroma is considered in the metric calculations. (default: true)
+- `mixed` (of type `bool?`, which defaults to `null`): set whether or not the input only partially contains content to be decimated. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.decimate.create`
+
+Ffmpeg filter: Decimate frames (post field matching filter). This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cycle : int?, ?dupthresh : float?, ?scthresh : float?, ?blockx : int?,
+ ?blocky : int?, ?ppsrc : bool?, ?chroma : bool?, ?mixed : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cycle` (of type `int?`, which defaults to `null`): set the number of frame from which one will be dropped. (default: 5)
+- `dupthresh` (of type `float?`, which defaults to `null`): set duplicate threshold. (default: 1.1)
+- `scthresh` (of type `float?`, which defaults to `null`): set scene change threshold. (default: 15.)
+- `blockx` (of type `int?`, which defaults to `null`): set the size of the x-axis blocks used during metric calculations. (default: 32)
+- `blocky` (of type `int?`, which defaults to `null`): set the size of the y-axis blocks used during metric calculations. (default: 32)
+- `ppsrc` (of type `bool?`, which defaults to `null`): mark main input as a pre-processed input and activate clean source input stream. (default: false)
+- `chroma` (of type `bool?`, which defaults to `null`): set whether or not chroma is considered in the metric calculations. (default: true)
+- `mixed` (of type `bool?`, which defaults to `null`): set whether or not the input only partially contains content to be decimated. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deconvolve`
+
+Ffmpeg filter: Deconvolve first video stream with second video stream.
+
+Type:
+
+```
+(?planes : int?, ?impulse : int?, ?noise : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to deconvolve. (default: 7)
+- `impulse` (of type `int?`, which defaults to `null`): when to process impulses. (default: 1, possible values: 0 (first), 1 (all))
+- `noise` (of type `float?`, which defaults to `null`): set noise. (default: 1e-07)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deconvolve.create`
+
+Ffmpeg filter: Deconvolve first video stream with second video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?impulse : int?, ?noise : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to deconvolve. (default: 7)
+- `impulse` (of type `int?`, which defaults to `null`): when to process impulses. (default: 1, possible values: 0 (first), 1 (all))
+- `noise` (of type `float?`, which defaults to `null`): set noise. (default: 1e-07)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dedot`
+
+Ffmpeg filter: Reduce cross-luminance and cross-color.
+
+Type:
+
+```
+(?m : int?, ?lt : float?, ?tl : float?, ?tc : float?, ?ct : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `m` (of type `int?`, which defaults to `null`): set filtering mode. (default: 3, possible values: 1 (dotcrawl), 2 (rainbows))
+- `lt` (of type `float?`, which defaults to `null`): set spatial luma threshold. (default: 0.079)
+- `tl` (of type `float?`, which defaults to `null`): set tolerance for temporal luma. (default: 0.079)
+- `tc` (of type `float?`, which defaults to `null`): set tolerance for chroma temporal variation. (default: 0.058)
+- `ct` (of type `float?`, which defaults to `null`): set temporal chroma threshold. (default: 0.019)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dedot.create`
+
+Ffmpeg filter: Reduce cross-luminance and cross-color.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?m : int?, ?lt : float?, ?tl : float?, ?tc : float?, ?ct : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `m` (of type `int?`, which defaults to `null`): set filtering mode. (default: 3, possible values: 1 (dotcrawl), 2 (rainbows))
+- `lt` (of type `float?`, which defaults to `null`): set spatial luma threshold. (default: 0.079)
+- `tl` (of type `float?`, which defaults to `null`): set tolerance for temporal luma. (default: 0.079)
+- `tc` (of type `float?`, which defaults to `null`): set tolerance for chroma temporal variation. (default: 0.058)
+- `ct` (of type `float?`, which defaults to `null`): set temporal chroma threshold. (default: 0.019)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deesser`
+
+Ffmpeg filter: Apply de-essing to the audio.
+
+Type:
+
+```
+(?i : float?, ?m : float?, ?f : float?, ?s : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 0.)
+- `m` (of type `float?`, which defaults to `null`): set max deessing. (default: 0.5)
+- `f` (of type `float?`, which defaults to `null`): set frequency. (default: 0.5)
+- `s` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (i), 1 (o), 2 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.deesser.create`
+
+Ffmpeg filter: Apply de-essing to the audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?i : float?, ?m : float?, ?f : float?, ?s : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 0.)
+- `m` (of type `float?`, which defaults to `null`): set max deessing. (default: 0.5)
+- `f` (of type `float?`, which defaults to `null`): set frequency. (default: 0.5)
+- `s` (of type `int?`, which defaults to `null`): set output mode. (default: 1, possible values: 0 (i), 1 (o), 2 (e))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deflate`
+
+Ffmpeg filter: Apply deflate effect.
+
+Type:
+
+```
+(?threshold0 : int?, ?threshold1 : int?, ?threshold2 : int?,
+ ?threshold3 : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deflate.create`
+
+Ffmpeg filter: Apply deflate effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold0 : int?, ?threshold1 : int?, ?threshold2 : int?,
+ ?threshold3 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deflicker`
+
+Ffmpeg filter: Remove temporal frame luminance variations.
+
+Type:
+
+```
+(?size : int?, ?s : int?, ?mode : int?, ?m : int?, ?bypass : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 5)
+- `s` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 5)
+- `mode` (of type `int?`, which defaults to `null`): set how to smooth luminance. (default: 0, possible values: 0 (am), 1 (gm), 2 (hm), 3 (qm), 4 (cm), 5 (pm), 6 (median))
+- `m` (of type `int?`, which defaults to `null`): set how to smooth luminance. (default: 0, possible values: 0 (am), 1 (gm), 2 (hm), 3 (qm), 4 (cm), 5 (pm), 6 (median))
+- `bypass` (of type `bool?`, which defaults to `null`): leave frames unchanged. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deflicker.create`
+
+Ffmpeg filter: Remove temporal frame luminance variations.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : int?, ?s : int?, ?mode : int?, ?m : int?, ?bypass : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 5)
+- `s` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 5)
+- `mode` (of type `int?`, which defaults to `null`): set how to smooth luminance. (default: 0, possible values: 0 (am), 1 (gm), 2 (hm), 3 (qm), 4 (cm), 5 (pm), 6 (median))
+- `m` (of type `int?`, which defaults to `null`): set how to smooth luminance. (default: 0, possible values: 0 (am), 1 (gm), 2 (hm), 3 (qm), 4 (cm), 5 (pm), 6 (median))
+- `bypass` (of type `bool?`, which defaults to `null`): leave frames unchanged. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deinterlace_vaapi`
+
+Ffmpeg filter: Deinterlacing of VAAPI surfaces
+
+Type:
+
+```
+(?mode : int?, ?rate : int?, ?auto : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): Deinterlacing mode. (default: 0, possible values: 0 (default), 1 (bob), 2 (weave), 3 (motion_adaptive), 4 (motion_compensated))
+- `rate` (of type `int?`, which defaults to `null`): Generate output at frame rate or field rate. (default: 1, possible values: 1 (frame), 2 (field))
+- `auto` (of type `int?`, which defaults to `null`): Only deinterlace fields, passing frames through unchanged. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deinterlace_vaapi.create`
+
+Ffmpeg filter: Deinterlacing of VAAPI surfaces. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?rate : int?, ?auto : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): Deinterlacing mode. (default: 0, possible values: 0 (default), 1 (bob), 2 (weave), 3 (motion_adaptive), 4 (motion_compensated))
+- `rate` (of type `int?`, which defaults to `null`): Generate output at frame rate or field rate. (default: 1, possible values: 1 (frame), 2 (field))
+- `auto` (of type `int?`, which defaults to `null`): Only deinterlace fields, passing frames through unchanged. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dejudder`
+
+Ffmpeg filter: Remove judder produced by pullup.
+
+Type:
+
+```
+(?cycle : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cycle` (of type `int?`, which defaults to `null`): set the length of the cycle to use for dejuddering. (default: 4)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dejudder.create`
+
+Ffmpeg filter: Remove judder produced by pullup.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cycle : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cycle` (of type `int?`, which defaults to `null`): set the length of the cycle to use for dejuddering. (default: 4)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.delogo`
+
+Ffmpeg filter: Remove logo from input video.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?w : string?, ?h : string?, ?show : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set logo x position. (default: -1)
+- `y` (of type `string?`, which defaults to `null`): set logo y position. (default: -1)
+- `w` (of type `string?`, which defaults to `null`): set logo width. (default: -1)
+- `h` (of type `string?`, which defaults to `null`): set logo height. (default: -1)
+- `show` (of type `bool?`, which defaults to `null`): show delogo area. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.delogo.create`
+
+Ffmpeg filter: Remove logo from input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?w : string?, ?h : string?, ?show : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set logo x position. (default: -1)
+- `y` (of type `string?`, which defaults to `null`): set logo y position. (default: -1)
+- `w` (of type `string?`, which defaults to `null`): set logo width. (default: -1)
+- `h` (of type `string?`, which defaults to `null`): set logo height. (default: -1)
+- `show` (of type `bool?`, which defaults to `null`): show delogo area. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.denoise_vaapi`
+
+Ffmpeg filter: VAAPI VPP for de-noise
+
+Type:
+
+```
+(?denoise : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `denoise` (of type `int?`, which defaults to `null`): denoise level. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.denoise_vaapi.create`
+
+Ffmpeg filter: VAAPI VPP for de-noise. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?denoise : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `denoise` (of type `int?`, which defaults to `null`): denoise level. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.derain`
+
+Ffmpeg filter: Apply derain filter to the input.
+
+Type:
+
+```
+(?filter_type : int?, ?dnn_backend : int?, ?model : string?,
+ ?input : string?, ?output : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filter_type` (of type `int?`, which defaults to `null`): filter type(derain/dehaze). (default: 0, possible values: 0 (derain), 1 (dehaze))
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 1)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model. (default: x)
+- `output` (of type `string?`, which defaults to `null`): output name of the model. (default: y)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.derain.create`
+
+Ffmpeg filter: Apply derain filter to the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filter_type : int?, ?dnn_backend : int?, ?model : string?,
+ ?input : string?, ?output : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filter_type` (of type `int?`, which defaults to `null`): filter type(derain/dehaze). (default: 0, possible values: 0 (derain), 1 (dehaze))
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 1)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model. (default: x)
+- `output` (of type `string?`, which defaults to `null`): output name of the model. (default: y)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deshake`
+
+Ffmpeg filter: Stabilize shaky video.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ?w : int?, ?h : int?, ?rx : int?, ?ry : int?,
+ ?edge : int?, ?blocksize : int?, ?contrast : int?, ?search : int?,
+ ?filename : string?, ?opencl : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): set x for the rectangular search area. (default: -1)
+- `y` (of type `int?`, which defaults to `null`): set y for the rectangular search area. (default: -1)
+- `w` (of type `int?`, which defaults to `null`): set width for the rectangular search area. (default: -1)
+- `h` (of type `int?`, which defaults to `null`): set height for the rectangular search area. (default: -1)
+- `rx` (of type `int?`, which defaults to `null`): set x for the rectangular search area. (default: 16)
+- `ry` (of type `int?`, which defaults to `null`): set y for the rectangular search area. (default: 16)
+- `edge` (of type `int?`, which defaults to `null`): set edge mode. (default: 3, possible values: 0 (blank), 1 (original), 2 (clamp), 3 (mirror))
+- `blocksize` (of type `int?`, which defaults to `null`): set motion search blocksize. (default: 8)
+- `contrast` (of type `int?`, which defaults to `null`): set contrast threshold for blocks. (default: 125)
+- `search` (of type `int?`, which defaults to `null`): set search strategy. (default: 0, possible values: 0 (exhaustive), 1 (less))
+- `filename` (of type `string?`, which defaults to `null`): set motion search detailed log file name
+- `opencl` (of type `bool?`, which defaults to `null`): ignored. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deshake.create`
+
+Ffmpeg filter: Stabilize shaky video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ?w : int?, ?h : int?, ?rx : int?, ?ry : int?,
+ ?edge : int?, ?blocksize : int?, ?contrast : int?, ?search : int?,
+ ?filename : string?, ?opencl : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): set x for the rectangular search area. (default: -1)
+- `y` (of type `int?`, which defaults to `null`): set y for the rectangular search area. (default: -1)
+- `w` (of type `int?`, which defaults to `null`): set width for the rectangular search area. (default: -1)
+- `h` (of type `int?`, which defaults to `null`): set height for the rectangular search area. (default: -1)
+- `rx` (of type `int?`, which defaults to `null`): set x for the rectangular search area. (default: 16)
+- `ry` (of type `int?`, which defaults to `null`): set y for the rectangular search area. (default: 16)
+- `edge` (of type `int?`, which defaults to `null`): set edge mode. (default: 3, possible values: 0 (blank), 1 (original), 2 (clamp), 3 (mirror))
+- `blocksize` (of type `int?`, which defaults to `null`): set motion search blocksize. (default: 8)
+- `contrast` (of type `int?`, which defaults to `null`): set contrast threshold for blocks. (default: 125)
+- `search` (of type `int?`, which defaults to `null`): set search strategy. (default: 0, possible values: 0 (exhaustive), 1 (less))
+- `filename` (of type `string?`, which defaults to `null`): set motion search detailed log file name
+- `opencl` (of type `bool?`, which defaults to `null`): ignored. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.deshake_opencl`
+
+Ffmpeg filter: Feature-point based video stabilization filter
+
+Type:
+
+```
+(?tripod : bool?, ?debug : bool?, ?adaptive_crop : bool?,
+ ?refine_features : bool?, ?smooth_strength : float?,
+ ?smooth_window_multiplier : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `tripod` (of type `bool?`, which defaults to `null`): simulates a tripod by preventing any camera movement whatsoever from the original frame. (default: false)
+- `debug` (of type `bool?`, which defaults to `null`): turn on additional debugging information. (default: false)
+- `adaptive_crop` (of type `bool?`, which defaults to `null`): attempt to subtly crop borders to reduce mirrored content. (default: true)
+- `refine_features` (of type `bool?`, which defaults to `null`): refine feature point locations at a sub-pixel level. (default: true)
+- `smooth_strength` (of type `float?`, which defaults to `null`): smoothing strength (0 attempts to adaptively determine optimal strength). (default: 0.)
+- `smooth_window_multiplier` (of type `float?`, which defaults to `null`): multiplier for number of frames to buffer for motion data. (default: 2.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.deshake_opencl.create`
+
+Ffmpeg filter: Feature-point based video stabilization filter. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?tripod : bool?, ?debug : bool?, ?adaptive_crop : bool?,
+ ?refine_features : bool?, ?smooth_strength : float?,
+ ?smooth_window_multiplier : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `tripod` (of type `bool?`, which defaults to `null`): simulates a tripod by preventing any camera movement whatsoever from the original frame. (default: false)
+- `debug` (of type `bool?`, which defaults to `null`): turn on additional debugging information. (default: false)
+- `adaptive_crop` (of type `bool?`, which defaults to `null`): attempt to subtly crop borders to reduce mirrored content. (default: true)
+- `refine_features` (of type `bool?`, which defaults to `null`): refine feature point locations at a sub-pixel level. (default: true)
+- `smooth_strength` (of type `float?`, which defaults to `null`): smoothing strength (0 attempts to adaptively determine optimal strength). (default: 0.)
+- `smooth_window_multiplier` (of type `float?`, which defaults to `null`): multiplier for number of frames to buffer for motion data. (default: 2.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.despill`
+
+Ffmpeg filter: Despill video.
+
+Type:
+
+```
+(?type : int?, ?mix : float?, ?expand : float?, ?red : float?,
+ ?green : float?, ?blue : float?, ?brightness : float?, ?alpha : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set the screen type. (default: 0, possible values: 0 (green), 1 (blue))
+- `mix` (of type `float?`, which defaults to `null`): set the spillmap mix. (default: 0.5)
+- `expand` (of type `float?`, which defaults to `null`): set the spillmap expand. (default: 0.)
+- `red` (of type `float?`, which defaults to `null`): set red scale. (default: 0.)
+- `green` (of type `float?`, which defaults to `null`): set green scale. (default: -1.)
+- `blue` (of type `float?`, which defaults to `null`): set blue scale. (default: 0.)
+- `brightness` (of type `float?`, which defaults to `null`): set brightness. (default: 0.)
+- `alpha` (of type `bool?`, which defaults to `null`): change alpha component. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.despill.create`
+
+Ffmpeg filter: Despill video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?type : int?, ?mix : float?, ?expand : float?, ?red : float?,
+ ?green : float?, ?blue : float?, ?brightness : float?, ?alpha : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set the screen type. (default: 0, possible values: 0 (green), 1 (blue))
+- `mix` (of type `float?`, which defaults to `null`): set the spillmap mix. (default: 0.5)
+- `expand` (of type `float?`, which defaults to `null`): set the spillmap expand. (default: 0.)
+- `red` (of type `float?`, which defaults to `null`): set red scale. (default: 0.)
+- `green` (of type `float?`, which defaults to `null`): set green scale. (default: -1.)
+- `blue` (of type `float?`, which defaults to `null`): set blue scale. (default: 0.)
+- `brightness` (of type `float?`, which defaults to `null`): set brightness. (default: 0.)
+- `alpha` (of type `bool?`, which defaults to `null`): change alpha component. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.detelecine`
+
+Ffmpeg filter: Apply an inverse telecine pattern.
+
+Type:
+
+```
+(?first_field : int?, ?pattern : string?, ?start_frame : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): select first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `pattern` (of type `string?`, which defaults to `null`): pattern that describe for how many fields a frame is to be displayed. (default: 23)
+- `start_frame` (of type `int?`, which defaults to `null`): position of first frame with respect to the pattern if stream is cut. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.detelecine.create`
+
+Ffmpeg filter: Apply an inverse telecine pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?first_field : int?, ?pattern : string?, ?start_frame : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): select first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `pattern` (of type `string?`, which defaults to `null`): pattern that describe for how many fields a frame is to be displayed. (default: 23)
+- `start_frame` (of type `int?`, which defaults to `null`): position of first frame with respect to the pattern if stream is cut. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dialoguenhance`
+
+Ffmpeg filter: Audio Dialogue Enhancement.
+
+Type:
+
+```
+(?original : float?, ?enhance : float?, ?voice : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `original` (of type `float?`, which defaults to `null`): set original center factor. (default: 1.)
+- `enhance` (of type `float?`, which defaults to `null`): set dialogue enhance factor. (default: 1.)
+- `voice` (of type `float?`, which defaults to `null`): set voice detection factor. (default: 2.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.dialoguenhance.create`
+
+Ffmpeg filter: Audio Dialogue Enhancement.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?original : float?, ?enhance : float?, ?voice : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `original` (of type `float?`, which defaults to `null`): set original center factor. (default: 1.)
+- `enhance` (of type `float?`, which defaults to `null`): set dialogue enhance factor. (default: 1.)
+- `voice` (of type `float?`, which defaults to `null`): set voice detection factor. (default: 2.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dilation`
+
+Ffmpeg filter: Apply dilation effect.
+
+Type:
+
+```
+(?coordinates : int?, ?threshold0 : int?, ?threshold1 : int?,
+ ?threshold2 : int?, ?threshold3 : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dilation.create`
+
+Ffmpeg filter: Apply dilation effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?coordinates : int?, ?threshold0 : int?, ?threshold1 : int?,
+ ?threshold2 : int?, ?threshold3 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dilation_opencl`
+
+Ffmpeg filter: Apply dilation effect
+
+Type:
+
+```
+(?threshold0 : float?, ?threshold1 : float?, ?threshold2 : float?,
+ ?threshold3 : float?, ?coordinates : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold0` (of type `float?`, which defaults to `null`): set threshold for 1st plane. (default: 65535.)
+- `threshold1` (of type `float?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535.)
+- `threshold2` (of type `float?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535.)
+- `threshold3` (of type `float?`, which defaults to `null`): set threshold for 4th plane. (default: 65535.)
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dilation_opencl.create`
+
+Ffmpeg filter: Apply dilation effect. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold0 : float?, ?threshold1 : float?, ?threshold2 : float?,
+ ?threshold3 : float?, ?coordinates : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold0` (of type `float?`, which defaults to `null`): set threshold for 1st plane. (default: 65535.)
+- `threshold1` (of type `float?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535.)
+- `threshold2` (of type `float?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535.)
+- `threshold3` (of type `float?`, which defaults to `null`): set threshold for 4th plane. (default: 65535.)
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.displace`
+
+Ffmpeg filter: Displace pixels.
+
+Type:
+
+```
+(?edge : int?, ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `edge` (of type `int?`, which defaults to `null`): set edge mode. (default: 1, possible values: 0 (blank), 1 (smear), 2 (wrap), 3 (mirror))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.displace.create`
+
+Ffmpeg filter: Displace pixels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?edge : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `edge` (of type `int?`, which defaults to `null`): set edge mode. (default: 1, possible values: 0 (blank), 1 (smear), 2 (wrap), 3 (mirror))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dnn_classify`
+
+Ffmpeg filter: Apply DNN classify filter to the input.
+
+Type:
+
+```
+(?dnn_backend : int?, ?model : string?, ?input : string?, ?output : string?,
+ ?backend_configs : string?, ?options : string?, ?async : bool?,
+ ?confidence : float?, ?labels : string?, ?target : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 2)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model
+- `output` (of type `string?`, which defaults to `null`): output name of the model
+- `backend_configs` (of type `string?`, which defaults to `null`): backend configs
+- `options` (of type `string?`, which defaults to `null`): backend configs (deprecated, use backend_configs)
+- `async` (of type `bool?`, which defaults to `null`): use DNN async inference (ignored, use backend_configs='async=1'). (default: true)
+- `confidence` (of type `float?`, which defaults to `null`): threshold of confidence. (default: 0.5)
+- `labels` (of type `string?`, which defaults to `null`): path to labels file
+- `target` (of type `string?`, which defaults to `null`): which one to be classified
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dnn_classify.create`
+
+Ffmpeg filter: Apply DNN classify filter to the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dnn_backend : int?, ?model : string?, ?input : string?, ?output : string?,
+ ?backend_configs : string?, ?options : string?, ?async : bool?,
+ ?confidence : float?, ?labels : string?, ?target : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 2)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model
+- `output` (of type `string?`, which defaults to `null`): output name of the model
+- `backend_configs` (of type `string?`, which defaults to `null`): backend configs
+- `options` (of type `string?`, which defaults to `null`): backend configs (deprecated, use backend_configs)
+- `async` (of type `bool?`, which defaults to `null`): use DNN async inference (ignored, use backend_configs='async=1'). (default: true)
+- `confidence` (of type `float?`, which defaults to `null`): threshold of confidence. (default: 0.5)
+- `labels` (of type `string?`, which defaults to `null`): path to labels file
+- `target` (of type `string?`, which defaults to `null`): which one to be classified
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dnn_detect`
+
+Ffmpeg filter: Apply DNN detect filter to the input.
+
+Type:
+
+```
+(?dnn_backend : int?, ?model : string?, ?input : string?, ?output : string?,
+ ?backend_configs : string?, ?options : string?, ?async : bool?,
+ ?confidence : float?, ?labels : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 2)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model
+- `output` (of type `string?`, which defaults to `null`): output name of the model
+- `backend_configs` (of type `string?`, which defaults to `null`): backend configs
+- `options` (of type `string?`, which defaults to `null`): backend configs (deprecated, use backend_configs)
+- `async` (of type `bool?`, which defaults to `null`): use DNN async inference (ignored, use backend_configs='async=1'). (default: true)
+- `confidence` (of type `float?`, which defaults to `null`): threshold of confidence. (default: 0.5)
+- `labels` (of type `string?`, which defaults to `null`): path to labels file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dnn_detect.create`
+
+Ffmpeg filter: Apply DNN detect filter to the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dnn_backend : int?, ?model : string?, ?input : string?, ?output : string?,
+ ?backend_configs : string?, ?options : string?, ?async : bool?,
+ ?confidence : float?, ?labels : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 2)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model
+- `output` (of type `string?`, which defaults to `null`): output name of the model
+- `backend_configs` (of type `string?`, which defaults to `null`): backend configs
+- `options` (of type `string?`, which defaults to `null`): backend configs (deprecated, use backend_configs)
+- `async` (of type `bool?`, which defaults to `null`): use DNN async inference (ignored, use backend_configs='async=1'). (default: true)
+- `confidence` (of type `float?`, which defaults to `null`): threshold of confidence. (default: 0.5)
+- `labels` (of type `string?`, which defaults to `null`): path to labels file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dnn_processing`
+
+Ffmpeg filter: Apply DNN processing filter to the input.
+
+Type:
+
+```
+(?dnn_backend : int?, ?model : string?, ?input : string?, ?output : string?,
+ ?backend_configs : string?, ?options : string?, ?async : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 1)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model
+- `output` (of type `string?`, which defaults to `null`): output name of the model
+- `backend_configs` (of type `string?`, which defaults to `null`): backend configs
+- `options` (of type `string?`, which defaults to `null`): backend configs (deprecated, use backend_configs)
+- `async` (of type `bool?`, which defaults to `null`): use DNN async inference (ignored, use backend_configs='async=1'). (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.dnn_processing.create`
+
+Ffmpeg filter: Apply DNN processing filter to the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dnn_backend : int?, ?model : string?, ?input : string?, ?output : string?,
+ ?backend_configs : string?, ?options : string?, ?async : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend. (default: 1)
+- `model` (of type `string?`, which defaults to `null`): path to model file
+- `input` (of type `string?`, which defaults to `null`): input name of the model
+- `output` (of type `string?`, which defaults to `null`): output name of the model
+- `backend_configs` (of type `string?`, which defaults to `null`): backend configs
+- `options` (of type `string?`, which defaults to `null`): backend configs (deprecated, use backend_configs)
+- `async` (of type `bool?`, which defaults to `null`): use DNN async inference (ignored, use backend_configs='async=1'). (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.doubleweave`
+
+Ffmpeg filter: Weave input video fields into double number of frames.
+
+Type:
+
+```
+(?first_field : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): set first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.doubleweave.create`
+
+Ffmpeg filter: Weave input video fields into double number of frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?first_field : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): set first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.drawbox`
+
+Ffmpeg filter: Draw a colored box on the input video.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?width : string?, ?w : string?,
+ ?height : string?, ?h : string?, ?color : string?, ?c : string?,
+ ?thickness : string?, ?t : string?, ?replace : bool?, ?box_source : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set horizontal position of the left box edge. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set vertical position of the top box edge. (default: 0)
+- `width` (of type `string?`, which defaults to `null`): set width of the box. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): set width of the box. (default: 0)
+- `height` (of type `string?`, which defaults to `null`): set height of the box. (default: 0)
+- `h` (of type `string?`, which defaults to `null`): set height of the box. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set color of the box. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color of the box. (default: black)
+- `thickness` (of type `string?`, which defaults to `null`): set the box thickness. (default: 3)
+- `t` (of type `string?`, which defaults to `null`): set the box thickness. (default: 3)
+- `replace` (of type `bool?`, which defaults to `null`): replace color & alpha. (default: false)
+- `box_source` (of type `string?`, which defaults to `null`): use datas from bounding box in side data
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.drawbox.create`
+
+Ffmpeg filter: Draw a colored box on the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?width : string?, ?w : string?,
+ ?height : string?, ?h : string?, ?color : string?, ?c : string?,
+ ?thickness : string?, ?t : string?, ?replace : bool?, ?box_source : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set horizontal position of the left box edge. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set vertical position of the top box edge. (default: 0)
+- `width` (of type `string?`, which defaults to `null`): set width of the box. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): set width of the box. (default: 0)
+- `height` (of type `string?`, which defaults to `null`): set height of the box. (default: 0)
+- `h` (of type `string?`, which defaults to `null`): set height of the box. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set color of the box. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color of the box. (default: black)
+- `thickness` (of type `string?`, which defaults to `null`): set the box thickness. (default: 3)
+- `t` (of type `string?`, which defaults to `null`): set the box thickness. (default: 3)
+- `replace` (of type `bool?`, which defaults to `null`): replace color & alpha. (default: false)
+- `box_source` (of type `string?`, which defaults to `null`): use datas from bounding box in side data
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.drawgraph`
+
+Ffmpeg filter: Draw a graph using input video metadata.
+
+Type:
+
+```
+(?m1 : string?, ?fg1 : string?, ?m2 : string?, ?fg2 : string?, ?m3 : string?,
+ ?fg3 : string?, ?m4 : string?, ?fg4 : string?, ?bg : string?, ?min : float?,
+ ?max : float?, ?mode : int?, ?slide : int?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `m1` (of type `string?`, which defaults to `null`): set 1st metadata key. (default: )
+- `fg1` (of type `string?`, which defaults to `null`): set 1st foreground color expression. (default: 0xffff0000)
+- `m2` (of type `string?`, which defaults to `null`): set 2nd metadata key. (default: )
+- `fg2` (of type `string?`, which defaults to `null`): set 2nd foreground color expression. (default: 0xff00ff00)
+- `m3` (of type `string?`, which defaults to `null`): set 3rd metadata key. (default: )
+- `fg3` (of type `string?`, which defaults to `null`): set 3rd foreground color expression. (default: 0xffff00ff)
+- `m4` (of type `string?`, which defaults to `null`): set 4th metadata key. (default: )
+- `fg4` (of type `string?`, which defaults to `null`): set 4th foreground color expression. (default: 0xffffff00)
+- `bg` (of type `string?`, which defaults to `null`): set background color. (default: white)
+- `min` (of type `float?`, which defaults to `null`): set minimal value. (default: -1.)
+- `max` (of type `float?`, which defaults to `null`): set maximal value. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set graph mode. (default: 2, possible values: 0 (bar), 1 (dot), 2 (line))
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 0, possible values: 0 (frame), 1 (replace), 2 (scroll), 3 (rscroll), 4 (picture))
+- `size` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `s` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.drawgraph.create`
+
+Ffmpeg filter: Draw a graph using input video metadata.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?m1 : string?, ?fg1 : string?, ?m2 : string?, ?fg2 : string?, ?m3 : string?,
+ ?fg3 : string?, ?m4 : string?, ?fg4 : string?, ?bg : string?, ?min : float?,
+ ?max : float?, ?mode : int?, ?slide : int?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `m1` (of type `string?`, which defaults to `null`): set 1st metadata key. (default: )
+- `fg1` (of type `string?`, which defaults to `null`): set 1st foreground color expression. (default: 0xffff0000)
+- `m2` (of type `string?`, which defaults to `null`): set 2nd metadata key. (default: )
+- `fg2` (of type `string?`, which defaults to `null`): set 2nd foreground color expression. (default: 0xff00ff00)
+- `m3` (of type `string?`, which defaults to `null`): set 3rd metadata key. (default: )
+- `fg3` (of type `string?`, which defaults to `null`): set 3rd foreground color expression. (default: 0xffff00ff)
+- `m4` (of type `string?`, which defaults to `null`): set 4th metadata key. (default: )
+- `fg4` (of type `string?`, which defaults to `null`): set 4th foreground color expression. (default: 0xffffff00)
+- `bg` (of type `string?`, which defaults to `null`): set background color. (default: white)
+- `min` (of type `float?`, which defaults to `null`): set minimal value. (default: -1.)
+- `max` (of type `float?`, which defaults to `null`): set maximal value. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set graph mode. (default: 2, possible values: 0 (bar), 1 (dot), 2 (line))
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 0, possible values: 0 (frame), 1 (replace), 2 (scroll), 3 (rscroll), 4 (picture))
+- `size` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `s` (of type `string?`, which defaults to `null`): set graph size. (default: 900x256)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.drawgrid`
+
+Ffmpeg filter: Draw a colored grid on the input video.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?width : string?, ?w : string?,
+ ?height : string?, ?h : string?, ?color : string?, ?c : string?,
+ ?thickness : string?, ?t : string?, ?replace : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set horizontal offset. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set vertical offset. (default: 0)
+- `width` (of type `string?`, which defaults to `null`): set width of grid cell. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): set width of grid cell. (default: 0)
+- `height` (of type `string?`, which defaults to `null`): set height of grid cell. (default: 0)
+- `h` (of type `string?`, which defaults to `null`): set height of grid cell. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set color of the grid. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color of the grid. (default: black)
+- `thickness` (of type `string?`, which defaults to `null`): set grid line thickness. (default: 1)
+- `t` (of type `string?`, which defaults to `null`): set grid line thickness. (default: 1)
+- `replace` (of type `bool?`, which defaults to `null`): replace color & alpha. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.drawgrid.create`
+
+Ffmpeg filter: Draw a colored grid on the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?width : string?, ?w : string?,
+ ?height : string?, ?h : string?, ?color : string?, ?c : string?,
+ ?thickness : string?, ?t : string?, ?replace : bool?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set horizontal offset. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set vertical offset. (default: 0)
+- `width` (of type `string?`, which defaults to `null`): set width of grid cell. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): set width of grid cell. (default: 0)
+- `height` (of type `string?`, which defaults to `null`): set height of grid cell. (default: 0)
+- `h` (of type `string?`, which defaults to `null`): set height of grid cell. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set color of the grid. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color of the grid. (default: black)
+- `thickness` (of type `string?`, which defaults to `null`): set grid line thickness. (default: 1)
+- `t` (of type `string?`, which defaults to `null`): set grid line thickness. (default: 1)
+- `replace` (of type `bool?`, which defaults to `null`): replace color & alpha. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.drawtext`
+
+Ffmpeg filter: Draw text on top of video frames using libfreetype library.
+
+Type:
+
+```
+(?fontfile : string?, ?text : string?, ?textfile : string?,
+ ?fontcolor : string?, ?fontcolor_expr : string?, ?boxcolor : string?,
+ ?bordercolor : string?, ?shadowcolor : string?, ?box : bool?,
+ ?boxborderw : string?, ?line_spacing : int?, ?fontsize : string?,
+ ?text_align : int?, ?x : string?, ?y : string?, ?boxw : int?, ?boxh : int?,
+ ?shadowx : int?, ?shadowy : int?, ?borderw : int?, ?tabsize : int?,
+ ?basetime : int?, ?font : string?, ?expansion : int?, ?y_align : int?,
+ ?timecode : string?, ?tc24hmax : bool?, ?timecode_rate : string?,
+ ?r : string?, ?rate : string?, ?reload : int?, ?alpha : string?,
+ ?fix_bounds : bool?, ?start_number : int?, ?text_source : string?,
+ ?text_shaping : bool?, ?ft_load_flags : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `fontfile` (of type `string?`, which defaults to `null`): set font file
+- `text` (of type `string?`, which defaults to `null`): set text
+- `textfile` (of type `string?`, which defaults to `null`): set text file
+- `fontcolor` (of type `string?`, which defaults to `null`): set foreground color. (default: black)
+- `fontcolor_expr` (of type `string?`, which defaults to `null`): set foreground color expression. (default: )
+- `boxcolor` (of type `string?`, which defaults to `null`): set box color. (default: white)
+- `bordercolor` (of type `string?`, which defaults to `null`): set border color. (default: black)
+- `shadowcolor` (of type `string?`, which defaults to `null`): set shadow color. (default: black)
+- `box` (of type `bool?`, which defaults to `null`): set box. (default: false)
+- `boxborderw` (of type `string?`, which defaults to `null`): set box borders width. (default: 0)
+- `line_spacing` (of type `int?`, which defaults to `null`): set line spacing in pixels. (default: 0)
+- `fontsize` (of type `string?`, which defaults to `null`): set font size
+- `text_align` (of type `int?`, which defaults to `null`): set text alignment. (default: 0, possible values: 1 (left), 1 (L), 2 (right), 2 (R), 3 (center), 3 (C), 4 (top), 4 (T), 8 (bottom), 8 (B), 12 (middle), 12 (M))
+- `x` (of type `string?`, which defaults to `null`): set x expression. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set y expression. (default: 0)
+- `boxw` (of type `int?`, which defaults to `null`): set box width. (default: 0)
+- `boxh` (of type `int?`, which defaults to `null`): set box height. (default: 0)
+- `shadowx` (of type `int?`, which defaults to `null`): set shadow x offset. (default: 0)
+- `shadowy` (of type `int?`, which defaults to `null`): set shadow y offset. (default: 0)
+- `borderw` (of type `int?`, which defaults to `null`): set border width. (default: 0)
+- `tabsize` (of type `int?`, which defaults to `null`): set tab size. (default: 4)
+- `basetime` (of type `int?`, which defaults to `null`): set base time. (default: -9223372036854775808)
+- `font` (of type `string?`, which defaults to `null`): Font name. (default: Sans)
+- `expansion` (of type `int?`, which defaults to `null`): set the expansion mode. (default: 1, possible values: 0 (none), 1 (normal), 2 (strftime))
+- `y_align` (of type `int?`, which defaults to `null`): set the y alignment. (default: 0, possible values: 0 (text), 1 (baseline), 2 (font))
+- `timecode` (of type `string?`, which defaults to `null`): set initial timecode
+- `tc24hmax` (of type `bool?`, which defaults to `null`): set 24 hours max (timecode only). (default: false)
+- `timecode_rate` (of type `string?`, which defaults to `null`): set rate (timecode only). (default: 0/1)
+- `r` (of type `string?`, which defaults to `null`): set rate (timecode only). (default: 0/1)
+- `rate` (of type `string?`, which defaults to `null`): set rate (timecode only). (default: 0/1)
+- `reload` (of type `int?`, which defaults to `null`): reload text file at specified frame interval. (default: 0)
+- `alpha` (of type `string?`, which defaults to `null`): apply alpha while rendering. (default: 1)
+- `fix_bounds` (of type `bool?`, which defaults to `null`): check and fix text coords to avoid clipping. (default: false)
+- `start_number` (of type `int?`, which defaults to `null`): start frame number for n/frame_num variable. (default: 0)
+- `text_source` (of type `string?`, which defaults to `null`): the source of text
+- `text_shaping` (of type `bool?`, which defaults to `null`): attempt to shape text before drawing. (default: true)
+- `ft_load_flags` (of type `int?`, which defaults to `null`): set font loading flags for libfreetype. (default: 0, possible values: 0 (default), 1 (no_scale), 2 (no_hinting), 4 (render), 8 (no_bitmap), 16 (vertical_layout), 32 (force_autohint), 64 (crop_bitmap), 128 (pedantic), 512 (ignore_global_advance_width), 1024 (no_recurse), 2048 (ignore_transform), 4096 (monochrome), 8192 (linear_design), 32768 (no_autohint))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.drawtext.create`
+
+Ffmpeg filter: Draw text on top of video frames using libfreetype library.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?fontfile : string?, ?text : string?, ?textfile : string?,
+ ?fontcolor : string?, ?fontcolor_expr : string?, ?boxcolor : string?,
+ ?bordercolor : string?, ?shadowcolor : string?, ?box : bool?,
+ ?boxborderw : string?, ?line_spacing : int?, ?fontsize : string?,
+ ?text_align : int?, ?x : string?, ?y : string?, ?boxw : int?, ?boxh : int?,
+ ?shadowx : int?, ?shadowy : int?, ?borderw : int?, ?tabsize : int?,
+ ?basetime : int?, ?font : string?, ?expansion : int?, ?y_align : int?,
+ ?timecode : string?, ?tc24hmax : bool?, ?timecode_rate : string?,
+ ?r : string?, ?rate : string?, ?reload : int?, ?alpha : string?,
+ ?fix_bounds : bool?, ?start_number : int?, ?text_source : string?,
+ ?text_shaping : bool?, ?ft_load_flags : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `fontfile` (of type `string?`, which defaults to `null`): set font file
+- `text` (of type `string?`, which defaults to `null`): set text
+- `textfile` (of type `string?`, which defaults to `null`): set text file
+- `fontcolor` (of type `string?`, which defaults to `null`): set foreground color. (default: black)
+- `fontcolor_expr` (of type `string?`, which defaults to `null`): set foreground color expression. (default: )
+- `boxcolor` (of type `string?`, which defaults to `null`): set box color. (default: white)
+- `bordercolor` (of type `string?`, which defaults to `null`): set border color. (default: black)
+- `shadowcolor` (of type `string?`, which defaults to `null`): set shadow color. (default: black)
+- `box` (of type `bool?`, which defaults to `null`): set box. (default: false)
+- `boxborderw` (of type `string?`, which defaults to `null`): set box borders width. (default: 0)
+- `line_spacing` (of type `int?`, which defaults to `null`): set line spacing in pixels. (default: 0)
+- `fontsize` (of type `string?`, which defaults to `null`): set font size
+- `text_align` (of type `int?`, which defaults to `null`): set text alignment. (default: 0, possible values: 1 (left), 1 (L), 2 (right), 2 (R), 3 (center), 3 (C), 4 (top), 4 (T), 8 (bottom), 8 (B), 12 (middle), 12 (M))
+- `x` (of type `string?`, which defaults to `null`): set x expression. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set y expression. (default: 0)
+- `boxw` (of type `int?`, which defaults to `null`): set box width. (default: 0)
+- `boxh` (of type `int?`, which defaults to `null`): set box height. (default: 0)
+- `shadowx` (of type `int?`, which defaults to `null`): set shadow x offset. (default: 0)
+- `shadowy` (of type `int?`, which defaults to `null`): set shadow y offset. (default: 0)
+- `borderw` (of type `int?`, which defaults to `null`): set border width. (default: 0)
+- `tabsize` (of type `int?`, which defaults to `null`): set tab size. (default: 4)
+- `basetime` (of type `int?`, which defaults to `null`): set base time. (default: -9223372036854775808)
+- `font` (of type `string?`, which defaults to `null`): Font name. (default: Sans)
+- `expansion` (of type `int?`, which defaults to `null`): set the expansion mode. (default: 1, possible values: 0 (none), 1 (normal), 2 (strftime))
+- `y_align` (of type `int?`, which defaults to `null`): set the y alignment. (default: 0, possible values: 0 (text), 1 (baseline), 2 (font))
+- `timecode` (of type `string?`, which defaults to `null`): set initial timecode
+- `tc24hmax` (of type `bool?`, which defaults to `null`): set 24 hours max (timecode only). (default: false)
+- `timecode_rate` (of type `string?`, which defaults to `null`): set rate (timecode only). (default: 0/1)
+- `r` (of type `string?`, which defaults to `null`): set rate (timecode only). (default: 0/1)
+- `rate` (of type `string?`, which defaults to `null`): set rate (timecode only). (default: 0/1)
+- `reload` (of type `int?`, which defaults to `null`): reload text file at specified frame interval. (default: 0)
+- `alpha` (of type `string?`, which defaults to `null`): apply alpha while rendering. (default: 1)
+- `fix_bounds` (of type `bool?`, which defaults to `null`): check and fix text coords to avoid clipping. (default: false)
+- `start_number` (of type `int?`, which defaults to `null`): start frame number for n/frame_num variable. (default: 0)
+- `text_source` (of type `string?`, which defaults to `null`): the source of text
+- `text_shaping` (of type `bool?`, which defaults to `null`): attempt to shape text before drawing. (default: true)
+- `ft_load_flags` (of type `int?`, which defaults to `null`): set font loading flags for libfreetype. (default: 0, possible values: 0 (default), 1 (no_scale), 2 (no_hinting), 4 (render), 8 (no_bitmap), 16 (vertical_layout), 32 (force_autohint), 64 (crop_bitmap), 128 (pedantic), 512 (ignore_global_advance_width), 1024 (no_recurse), 2048 (ignore_transform), 4096 (monochrome), 8192 (linear_design), 32768 (no_autohint))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.drmeter`
+
+Ffmpeg filter: Measure audio dynamic range.
+
+Type:
+
+```
+(?length : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `length` (of type `float?`, which defaults to `null`): set the window length. (default: 3.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.drmeter.create`
+
+Ffmpeg filter: Measure audio dynamic range.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?length : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `length` (of type `float?`, which defaults to `null`): set the window length. (default: 3.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.dynaudnorm`
+
+Ffmpeg filter: Dynamic Audio Normalizer.
+
+Type:
+
+```
+(?framelen : int?, ?f : int?, ?gausssize : int?, ?g : int?, ?peak : float?,
+ ?p : float?, ?maxgain : float?, ?m : float?, ?targetrms : float?,
+ ?r : float?, ?coupling : bool?, ?n : bool?, ?correctdc : bool?, ?c : bool?,
+ ?altboundary : bool?, ?b : bool?, ?compress : float?, ?s : float?,
+ ?threshold : float?, ?t : float?, ?channels : string?, ?h : string?,
+ ?overlap : float?, ?o : float?, ?curve : string?, ?v : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `framelen` (of type `int?`, which defaults to `null`): set the frame length in msec. (default: 500)
+- `f` (of type `int?`, which defaults to `null`): set the frame length in msec. (default: 500)
+- `gausssize` (of type `int?`, which defaults to `null`): set the filter size. (default: 31)
+- `g` (of type `int?`, which defaults to `null`): set the filter size. (default: 31)
+- `peak` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `p` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `maxgain` (of type `float?`, which defaults to `null`): set the max amplification. (default: 10.)
+- `m` (of type `float?`, which defaults to `null`): set the max amplification. (default: 10.)
+- `targetrms` (of type `float?`, which defaults to `null`): set the target RMS. (default: 0.)
+- `r` (of type `float?`, which defaults to `null`): set the target RMS. (default: 0.)
+- `coupling` (of type `bool?`, which defaults to `null`): set channel coupling. (default: true)
+- `n` (of type `bool?`, which defaults to `null`): set channel coupling. (default: true)
+- `correctdc` (of type `bool?`, which defaults to `null`): set DC correction. (default: false)
+- `c` (of type `bool?`, which defaults to `null`): set DC correction. (default: false)
+- `altboundary` (of type `bool?`, which defaults to `null`): set alternative boundary mode. (default: false)
+- `b` (of type `bool?`, which defaults to `null`): set alternative boundary mode. (default: false)
+- `compress` (of type `float?`, which defaults to `null`): set the compress factor. (default: 0.)
+- `s` (of type `float?`, which defaults to `null`): set the compress factor. (default: 0.)
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `t` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `h` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `overlap` (of type `float?`, which defaults to `null`): set the frame overlap. (default: 0.)
+- `o` (of type `float?`, which defaults to `null`): set the frame overlap. (default: 0.)
+- `curve` (of type `string?`, which defaults to `null`): set the custom peak mapping curve
+- `v` (of type `string?`, which defaults to `null`): set the custom peak mapping curve
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.dynaudnorm.create`
+
+Ffmpeg filter: Dynamic Audio Normalizer.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?framelen : int?, ?f : int?, ?gausssize : int?, ?g : int?, ?peak : float?,
+ ?p : float?, ?maxgain : float?, ?m : float?, ?targetrms : float?,
+ ?r : float?, ?coupling : bool?, ?n : bool?, ?correctdc : bool?, ?c : bool?,
+ ?altboundary : bool?, ?b : bool?, ?compress : float?, ?s : float?,
+ ?threshold : float?, ?t : float?, ?channels : string?, ?h : string?,
+ ?overlap : float?, ?o : float?, ?curve : string?, ?v : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `framelen` (of type `int?`, which defaults to `null`): set the frame length in msec. (default: 500)
+- `f` (of type `int?`, which defaults to `null`): set the frame length in msec. (default: 500)
+- `gausssize` (of type `int?`, which defaults to `null`): set the filter size. (default: 31)
+- `g` (of type `int?`, which defaults to `null`): set the filter size. (default: 31)
+- `peak` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `p` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `maxgain` (of type `float?`, which defaults to `null`): set the max amplification. (default: 10.)
+- `m` (of type `float?`, which defaults to `null`): set the max amplification. (default: 10.)
+- `targetrms` (of type `float?`, which defaults to `null`): set the target RMS. (default: 0.)
+- `r` (of type `float?`, which defaults to `null`): set the target RMS. (default: 0.)
+- `coupling` (of type `bool?`, which defaults to `null`): set channel coupling. (default: true)
+- `n` (of type `bool?`, which defaults to `null`): set channel coupling. (default: true)
+- `correctdc` (of type `bool?`, which defaults to `null`): set DC correction. (default: false)
+- `c` (of type `bool?`, which defaults to `null`): set DC correction. (default: false)
+- `altboundary` (of type `bool?`, which defaults to `null`): set alternative boundary mode. (default: false)
+- `b` (of type `bool?`, which defaults to `null`): set alternative boundary mode. (default: false)
+- `compress` (of type `float?`, which defaults to `null`): set the compress factor. (default: 0.)
+- `s` (of type `float?`, which defaults to `null`): set the compress factor. (default: 0.)
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `t` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `h` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `overlap` (of type `float?`, which defaults to `null`): set the frame overlap. (default: 0.)
+- `o` (of type `float?`, which defaults to `null`): set the frame overlap. (default: 0.)
+- `curve` (of type `string?`, which defaults to `null`): set the custom peak mapping curve
+- `v` (of type `string?`, which defaults to `null`): set the custom peak mapping curve
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.earwax`
+
+Ffmpeg filter: Widen the stereo image.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.earwax.create`
+
+Ffmpeg filter: Widen the stereo image.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ebur128`
+
+Ffmpeg filter: EBU R128 scanner. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?video : bool?, ?size : string?, ?meter : int?, ?framelog : int?,
+ ?metadata : bool?, ?peak : int?, ?dualmono : bool?, ?panlaw : float?,
+ ?target : int?, ?gauge : int?, ?scale : int?, ?integrated : float?,
+ ?range : float?, ?lra_low : float?, ?lra_high : float?,
+ ?sample_peak : float?, ?true_peak : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `video` (of type `bool?`, which defaults to `null`): set video output. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 640x480)
+- `meter` (of type `int?`, which defaults to `null`): set scale meter (+9 to +18). (default: 9)
+- `framelog` (of type `int?`, which defaults to `null`): force frame logging level. (default: -1, possible values: -8 (quiet), 32 (info), 40 (verbose))
+- `metadata` (of type `bool?`, which defaults to `null`): inject metadata in the filtergraph. (default: false)
+- `peak` (of type `int?`, which defaults to `null`): set peak mode. (default: 0, possible values: 0 (none), 2 (sample), 4 (true))
+- `dualmono` (of type `bool?`, which defaults to `null`): treat mono input files as dual-mono. (default: false)
+- `panlaw` (of type `float?`, which defaults to `null`): set a specific pan law for dual-mono files. (default: -3.01029995664)
+- `target` (of type `int?`, which defaults to `null`): set a specific target level in LUFS (-23 to 0). (default: -23)
+- `gauge` (of type `int?`, which defaults to `null`): set gauge display type. (default: 0, possible values: 0 (momentary), 0 (m), 1 (shortterm), 1 (s))
+- `scale` (of type `int?`, which defaults to `null`): sets display method for the stats. (default: 0, possible values: 0 (absolute), 0 (LUFS), 1 (relative), 1 (LU))
+- `integrated` (of type `float?`, which defaults to `null`): integrated loudness (LUFS). (default: 0.)
+- `range` (of type `float?`, which defaults to `null`): loudness range (LU). (default: 0.)
+- `lra_low` (of type `float?`, which defaults to `null`): LRA low (LUFS). (default: 0.)
+- `lra_high` (of type `float?`, which defaults to `null`): LRA high (LUFS). (default: 0.)
+- `sample_peak` (of type `float?`, which defaults to `null`): sample peak (dBFS). (default: 0.)
+- `true_peak` (of type `float?`, which defaults to `null`): true peak (dBFS). (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.ebur128.create`
+
+Ffmpeg filter: EBU R128 scanner. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?video : bool?, ?size : string?, ?meter : int?, ?framelog : int?,
+ ?metadata : bool?, ?peak : int?, ?dualmono : bool?, ?panlaw : float?,
+ ?target : int?, ?gauge : int?, ?scale : int?, ?integrated : float?,
+ ?range : float?, ?lra_low : float?, ?lra_high : float?,
+ ?sample_peak : float?, ?true_peak : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `video` (of type `bool?`, which defaults to `null`): set video output. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 640x480)
+- `meter` (of type `int?`, which defaults to `null`): set scale meter (+9 to +18). (default: 9)
+- `framelog` (of type `int?`, which defaults to `null`): force frame logging level. (default: -1, possible values: -8 (quiet), 32 (info), 40 (verbose))
+- `metadata` (of type `bool?`, which defaults to `null`): inject metadata in the filtergraph. (default: false)
+- `peak` (of type `int?`, which defaults to `null`): set peak mode. (default: 0, possible values: 0 (none), 2 (sample), 4 (true))
+- `dualmono` (of type `bool?`, which defaults to `null`): treat mono input files as dual-mono. (default: false)
+- `panlaw` (of type `float?`, which defaults to `null`): set a specific pan law for dual-mono files. (default: -3.01029995664)
+- `target` (of type `int?`, which defaults to `null`): set a specific target level in LUFS (-23 to 0). (default: -23)
+- `gauge` (of type `int?`, which defaults to `null`): set gauge display type. (default: 0, possible values: 0 (momentary), 0 (m), 1 (shortterm), 1 (s))
+- `scale` (of type `int?`, which defaults to `null`): sets display method for the stats. (default: 0, possible values: 0 (absolute), 0 (LUFS), 1 (relative), 1 (LU))
+- `integrated` (of type `float?`, which defaults to `null`): integrated loudness (LUFS). (default: 0.)
+- `range` (of type `float?`, which defaults to `null`): loudness range (LU). (default: 0.)
+- `lra_low` (of type `float?`, which defaults to `null`): LRA low (LUFS). (default: 0.)
+- `lra_high` (of type `float?`, which defaults to `null`): LRA high (LUFS). (default: 0.)
+- `sample_peak` (of type `float?`, which defaults to `null`): sample peak (dBFS). (default: 0.)
+- `true_peak` (of type `float?`, which defaults to `null`): true peak (dBFS). (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.edgedetect`
+
+Ffmpeg filter: Detect and draw edge.
+
+Type:
+
+```
+(?high : float?, ?low : float?, ?mode : int?, ?planes : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `high` (of type `float?`, which defaults to `null`): set high threshold. (default: 0.196078431373)
+- `low` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.078431372549)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (wires), 1 (colormix), 2 (canny))
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7, possible values: 1 (y), 2 (u), 4 (v), 4 (r), 1 (g), 2 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.edgedetect.create`
+
+Ffmpeg filter: Detect and draw edge.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?high : float?, ?low : float?, ?mode : int?, ?planes : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `high` (of type `float?`, which defaults to `null`): set high threshold. (default: 0.196078431373)
+- `low` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.078431372549)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (wires), 1 (colormix), 2 (canny))
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7, possible values: 1 (y), 2 (u), 4 (v), 4 (r), 1 (g), 2 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.elbg`
+
+Ffmpeg filter: Apply posterize effect, using the ELBG algorithm.
+
+Type:
+
+```
+(?codebook_length : int?, ?l : int?, ?nb_steps : int?, ?n : int?,
+ ?seed : int?, ?s : int?, ?pal8 : bool?, ?use_alpha : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `codebook_length` (of type `int?`, which defaults to `null`): set codebook length. (default: 256)
+- `l` (of type `int?`, which defaults to `null`): set codebook length. (default: 256)
+- `nb_steps` (of type `int?`, which defaults to `null`): set max number of steps used to compute the mapping. (default: 1)
+- `n` (of type `int?`, which defaults to `null`): set max number of steps used to compute the mapping. (default: 1)
+- `seed` (of type `int?`, which defaults to `null`): set the random seed. (default: -1)
+- `s` (of type `int?`, which defaults to `null`): set the random seed. (default: -1)
+- `pal8` (of type `bool?`, which defaults to `null`): set the pal8 output. (default: false)
+- `use_alpha` (of type `bool?`, which defaults to `null`): use alpha channel for mapping. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.elbg.create`
+
+Ffmpeg filter: Apply posterize effect, using the ELBG algorithm.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?codebook_length : int?, ?l : int?, ?nb_steps : int?, ?n : int?,
+ ?seed : int?, ?s : int?, ?pal8 : bool?, ?use_alpha : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `codebook_length` (of type `int?`, which defaults to `null`): set codebook length. (default: 256)
+- `l` (of type `int?`, which defaults to `null`): set codebook length. (default: 256)
+- `nb_steps` (of type `int?`, which defaults to `null`): set max number of steps used to compute the mapping. (default: 1)
+- `n` (of type `int?`, which defaults to `null`): set max number of steps used to compute the mapping. (default: 1)
+- `seed` (of type `int?`, which defaults to `null`): set the random seed. (default: -1)
+- `s` (of type `int?`, which defaults to `null`): set the random seed. (default: -1)
+- `pal8` (of type `bool?`, which defaults to `null`): set the pal8 output. (default: false)
+- `use_alpha` (of type `bool?`, which defaults to `null`): use alpha channel for mapping. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.entropy`
+
+Ffmpeg filter: Measure video frames entropy.
+
+Type:
+
+```
+(?mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set kind of histogram entropy measurement. (default: 0, possible values: 0 (normal), 1 (diff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.entropy.create`
+
+Ffmpeg filter: Measure video frames entropy.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set kind of histogram entropy measurement. (default: 0, possible values: 0 (normal), 1 (diff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.epx`
+
+Ffmpeg filter: Scale the input using EPX algorithm.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set scale factor. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.epx.create`
+
+Ffmpeg filter: Scale the input using EPX algorithm.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set scale factor. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.eq`
+
+Ffmpeg filter: Adjust brightness, contrast, gamma, and saturation.
+
+Type:
+
+```
+(?contrast : string?, ?brightness : string?, ?saturation : string?,
+ ?gamma : string?, ?gamma_r : string?, ?gamma_g : string?,
+ ?gamma_b : string?, ?gamma_weight : string?, ?eval : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `contrast` (of type `string?`, which defaults to `null`): set the contrast adjustment, negative values give a negative image. (default: 1.0)
+- `brightness` (of type `string?`, which defaults to `null`): set the brightness adjustment. (default: 0.0)
+- `saturation` (of type `string?`, which defaults to `null`): set the saturation adjustment. (default: 1.0)
+- `gamma` (of type `string?`, which defaults to `null`): set the initial gamma value. (default: 1.0)
+- `gamma_r` (of type `string?`, which defaults to `null`): gamma value for red. (default: 1.0)
+- `gamma_g` (of type `string?`, which defaults to `null`): gamma value for green. (default: 1.0)
+- `gamma_b` (of type `string?`, which defaults to `null`): gamma value for blue. (default: 1.0)
+- `gamma_weight` (of type `string?`, which defaults to `null`): set the gamma weight which reduces the effect of gamma on bright areas. (default: 1.0)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.eq.create`
+
+Ffmpeg filter: Adjust brightness, contrast, gamma, and saturation.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?contrast : string?, ?brightness : string?, ?saturation : string?,
+ ?gamma : string?, ?gamma_r : string?, ?gamma_g : string?,
+ ?gamma_b : string?, ?gamma_weight : string?, ?eval : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `contrast` (of type `string?`, which defaults to `null`): set the contrast adjustment, negative values give a negative image. (default: 1.0)
+- `brightness` (of type `string?`, which defaults to `null`): set the brightness adjustment. (default: 0.0)
+- `saturation` (of type `string?`, which defaults to `null`): set the saturation adjustment. (default: 1.0)
+- `gamma` (of type `string?`, which defaults to `null`): set the initial gamma value. (default: 1.0)
+- `gamma_r` (of type `string?`, which defaults to `null`): gamma value for red. (default: 1.0)
+- `gamma_g` (of type `string?`, which defaults to `null`): gamma value for green. (default: 1.0)
+- `gamma_b` (of type `string?`, which defaults to `null`): gamma value for blue. (default: 1.0)
+- `gamma_weight` (of type `string?`, which defaults to `null`): set the gamma weight which reduces the effect of gamma on bright areas. (default: 1.0)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.equalizer`
+
+Ffmpeg filter: Apply two-pole peaking equalization (EQ) filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?mix : float?,
+ ?m : float?, ?channels : string?, ?c : string?, ?normalize : bool?,
+ ?n : bool?, ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 0.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 0.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 1.)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 1.)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.equalizer.create`
+
+Ffmpeg filter: Apply two-pole peaking equalization (EQ) filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?mix : float?,
+ ?m : float?, ?channels : string?, ?c : string?, ?normalize : bool?,
+ ?n : bool?, ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 0.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 0.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 1.)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 1.)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.erosion`
+
+Ffmpeg filter: Apply erosion effect.
+
+Type:
+
+```
+(?coordinates : int?, ?threshold0 : int?, ?threshold1 : int?,
+ ?threshold2 : int?, ?threshold3 : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.erosion.create`
+
+Ffmpeg filter: Apply erosion effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?coordinates : int?, ?threshold0 : int?, ?threshold1 : int?,
+ ?threshold2 : int?, ?threshold3 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.erosion_opencl`
+
+Ffmpeg filter: Apply erosion effect
+
+Type:
+
+```
+(?threshold0 : float?, ?threshold1 : float?, ?threshold2 : float?,
+ ?threshold3 : float?, ?coordinates : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold0` (of type `float?`, which defaults to `null`): set threshold for 1st plane. (default: 65535.)
+- `threshold1` (of type `float?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535.)
+- `threshold2` (of type `float?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535.)
+- `threshold3` (of type `float?`, which defaults to `null`): set threshold for 4th plane. (default: 65535.)
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.erosion_opencl.create`
+
+Ffmpeg filter: Apply erosion effect. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold0 : float?, ?threshold1 : float?, ?threshold2 : float?,
+ ?threshold3 : float?, ?coordinates : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold0` (of type `float?`, which defaults to `null`): set threshold for 1st plane. (default: 65535.)
+- `threshold1` (of type `float?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535.)
+- `threshold2` (of type `float?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535.)
+- `threshold3` (of type `float?`, which defaults to `null`): set threshold for 4th plane. (default: 65535.)
+- `coordinates` (of type `int?`, which defaults to `null`): set coordinates. (default: 255)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.estdif`
+
+Ffmpeg filter: Apply Edge Slope Tracing deinterlace.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ?rslope : int?, ?redge : int?,
+ ?ecost : int?, ?mcost : int?, ?dcost : int?, ?interp : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the mode. (default: 1, possible values: 0 (frame), 1 (field))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `rslope` (of type `int?`, which defaults to `null`): specify the search radius for edge slope tracing. (default: 1)
+- `redge` (of type `int?`, which defaults to `null`): specify the search radius for best edge matching. (default: 2)
+- `ecost` (of type `int?`, which defaults to `null`): specify the edge cost for edge matching. (default: 2)
+- `mcost` (of type `int?`, which defaults to `null`): specify the middle cost for edge matching. (default: 1)
+- `dcost` (of type `int?`, which defaults to `null`): specify the distance cost for edge matching. (default: 1)
+- `interp` (of type `int?`, which defaults to `null`): specify the type of interpolation. (default: 1, possible values: 0 (2p), 1 (4p), 2 (6p))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.estdif.create`
+
+Ffmpeg filter: Apply Edge Slope Tracing deinterlace.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ?rslope : int?, ?redge : int?,
+ ?ecost : int?, ?mcost : int?, ?dcost : int?, ?interp : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the mode. (default: 1, possible values: 0 (frame), 1 (field))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `rslope` (of type `int?`, which defaults to `null`): specify the search radius for edge slope tracing. (default: 1)
+- `redge` (of type `int?`, which defaults to `null`): specify the search radius for best edge matching. (default: 2)
+- `ecost` (of type `int?`, which defaults to `null`): specify the edge cost for edge matching. (default: 2)
+- `mcost` (of type `int?`, which defaults to `null`): specify the middle cost for edge matching. (default: 1)
+- `dcost` (of type `int?`, which defaults to `null`): specify the distance cost for edge matching. (default: 1)
+- `interp` (of type `int?`, which defaults to `null`): specify the type of interpolation. (default: 1, possible values: 0 (2p), 1 (4p), 2 (6p))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.exposure`
+
+Ffmpeg filter: Adjust exposure of the video stream.
+
+Type:
+
+```
+(?exposure : float?, ?black : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `exposure` (of type `float?`, which defaults to `null`): set the exposure correction. (default: 0.)
+- `black` (of type `float?`, which defaults to `null`): set the black level correction. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.exposure.create`
+
+Ffmpeg filter: Adjust exposure of the video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?exposure : float?, ?black : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `exposure` (of type `float?`, which defaults to `null`): set the exposure correction. (default: 0.)
+- `black` (of type `float?`, which defaults to `null`): set the black level correction. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.extractplanes`
+
+Ffmpeg filter: Extract planes as grayscale frames. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 1, possible values: 16 (y), 32 (u), 64 (v), 1 (r), 2 (g), 4 (b), 8 (a))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.extractplanes.create`
+
+Ffmpeg filter: Extract planes as grayscale frames. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 1, possible values: 16 (y), 32 (u), 64 (v), 1 (r), 2 (g), 4 (b), 8 (a))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.extrastereo`
+
+Ffmpeg filter: Increase difference between stereo audio channels.
+
+Type:
+
+```
+(?m : float?, ?c : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `m` (of type `float?`, which defaults to `null`): set the difference coefficient. (default: 2.5)
+- `c` (of type `bool?`, which defaults to `null`): enable clipping. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.extrastereo.create`
+
+Ffmpeg filter: Increase difference between stereo audio channels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?m : float?, ?c : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `m` (of type `float?`, which defaults to `null`): set the difference coefficient. (default: 2.5)
+- `c` (of type `bool?`, which defaults to `null`): enable clipping. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fade`
+
+Ffmpeg filter: Fade in/out input video.
+
+Type:
+
+```
+(?type : int?, ?t : int?, ?start_frame : int?, ?s : int?, ?nb_frames : int?,
+ ?n : int?, ?alpha : bool?, ?start_time : int?, ?st : int?, ?duration : int?,
+ ?d : int?, ?color : string?, ?c : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `t` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `start_frame` (of type `int?`, which defaults to `null`): Number of the first frame to which to apply the effect.. (default: 0)
+- `s` (of type `int?`, which defaults to `null`): Number of the first frame to which to apply the effect.. (default: 0)
+- `nb_frames` (of type `int?`, which defaults to `null`): Number of frames to which the effect should be applied.. (default: 25)
+- `n` (of type `int?`, which defaults to `null`): Number of frames to which the effect should be applied.. (default: 25)
+- `alpha` (of type `bool?`, which defaults to `null`): fade alpha if it is available on the input. (default: false)
+- `start_time` (of type `int?`, which defaults to `null`): Number of seconds of the beginning of the effect.. (default: 0)
+- `st` (of type `int?`, which defaults to `null`): Number of seconds of the beginning of the effect.. (default: 0)
+- `duration` (of type `int?`, which defaults to `null`): Duration of the effect in seconds.. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): Duration of the effect in seconds.. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fade.create`
+
+Ffmpeg filter: Fade in/out input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?type : int?, ?t : int?, ?start_frame : int?, ?s : int?, ?nb_frames : int?,
+ ?n : int?, ?alpha : bool?, ?start_time : int?, ?st : int?, ?duration : int?,
+ ?d : int?, ?color : string?, ?c : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `t` (of type `int?`, which defaults to `null`): set the fade direction. (default: 0, possible values: 0 (in), 1 (out))
+- `start_frame` (of type `int?`, which defaults to `null`): Number of the first frame to which to apply the effect.. (default: 0)
+- `s` (of type `int?`, which defaults to `null`): Number of the first frame to which to apply the effect.. (default: 0)
+- `nb_frames` (of type `int?`, which defaults to `null`): Number of frames to which the effect should be applied.. (default: 25)
+- `n` (of type `int?`, which defaults to `null`): Number of frames to which the effect should be applied.. (default: 25)
+- `alpha` (of type `bool?`, which defaults to `null`): fade alpha if it is available on the input. (default: false)
+- `start_time` (of type `int?`, which defaults to `null`): Number of seconds of the beginning of the effect.. (default: 0)
+- `st` (of type `int?`, which defaults to `null`): Number of seconds of the beginning of the effect.. (default: 0)
+- `duration` (of type `int?`, which defaults to `null`): Duration of the effect in seconds.. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): Duration of the effect in seconds.. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set color. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.feedback`
+
+Ffmpeg filter: Apply feedback video filter.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ?w : int?, ?h : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video * ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): set top left crop position. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): set top left crop position. (default: 0)
+- `w` (of type `int?`, which defaults to `null`): set crop size. (default: 0)
+- `h` (of type `int?`, which defaults to `null`): set crop size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.feedback.create`
+
+Ffmpeg filter: Apply feedback video filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ?w : int?, ?h : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): set top left crop position. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): set top left crop position. (default: 0)
+- `w` (of type `int?`, which defaults to `null`): set crop size. (default: 0)
+- `h` (of type `int?`, which defaults to `null`): set crop size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video * ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fftdnoiz`
+
+Ffmpeg filter: Denoise frames using 3D FFT.
+
+Type:
+
+```
+(?sigma : float?, ?amount : float?, ?block : int?, ?overlap : float?,
+ ?method : int?, ?prev : int?, ?next : int?, ?planes : int?, ?window : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set denoise strength. (default: 1.)
+- `amount` (of type `float?`, which defaults to `null`): set amount of denoising. (default: 1.)
+- `block` (of type `int?`, which defaults to `null`): set block size. (default: 32)
+- `overlap` (of type `float?`, which defaults to `null`): set block overlap. (default: 0.5)
+- `method` (of type `int?`, which defaults to `null`): set method of denoising. (default: 0, possible values: 0 (wiener), 1 (hard))
+- `prev` (of type `int?`, which defaults to `null`): set number of previous frames for temporal denoising. (default: 0)
+- `next` (of type `int?`, which defaults to `null`): set number of next frames for temporal denoising. (default: 0)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7)
+- `window` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fftdnoiz.create`
+
+Ffmpeg filter: Denoise frames using 3D FFT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigma : float?, ?amount : float?, ?block : int?, ?overlap : float?,
+ ?method : int?, ?prev : int?, ?next : int?, ?planes : int?, ?window : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set denoise strength. (default: 1.)
+- `amount` (of type `float?`, which defaults to `null`): set amount of denoising. (default: 1.)
+- `block` (of type `int?`, which defaults to `null`): set block size. (default: 32)
+- `overlap` (of type `float?`, which defaults to `null`): set block overlap. (default: 0.5)
+- `method` (of type `int?`, which defaults to `null`): set method of denoising. (default: 0, possible values: 0 (wiener), 1 (hard))
+- `prev` (of type `int?`, which defaults to `null`): set number of previous frames for temporal denoising. (default: 0)
+- `next` (of type `int?`, which defaults to `null`): set number of next frames for temporal denoising. (default: 0)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7)
+- `window` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fftfilt`
+
+Ffmpeg filter: Apply arbitrary expressions to pixels in frequency domain.
+
+Type:
+
+```
+(?dc_Y : int?, ?dc_U : int?, ?dc_V : int?, ?weight_Y : string?,
+ ?weight_U : string?, ?weight_V : string?, ?eval : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dc_Y` (of type `int?`, which defaults to `null`): adjust gain in Y plane. (default: 0)
+- `dc_U` (of type `int?`, which defaults to `null`): adjust gain in U plane. (default: 0)
+- `dc_V` (of type `int?`, which defaults to `null`): adjust gain in V plane. (default: 0)
+- `weight_Y` (of type `string?`, which defaults to `null`): set luminance expression in Y plane. (default: 1)
+- `weight_U` (of type `string?`, which defaults to `null`): set chrominance expression in U plane
+- `weight_V` (of type `string?`, which defaults to `null`): set chrominance expression in V plane
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fftfilt.create`
+
+Ffmpeg filter: Apply arbitrary expressions to pixels in frequency domain.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dc_Y : int?, ?dc_U : int?, ?dc_V : int?, ?weight_Y : string?,
+ ?weight_U : string?, ?weight_V : string?, ?eval : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `dc_Y` (of type `int?`, which defaults to `null`): adjust gain in Y plane. (default: 0)
+- `dc_U` (of type `int?`, which defaults to `null`): adjust gain in U plane. (default: 0)
+- `dc_V` (of type `int?`, which defaults to `null`): adjust gain in V plane. (default: 0)
+- `weight_Y` (of type `string?`, which defaults to `null`): set luminance expression in Y plane. (default: 1)
+- `weight_U` (of type `string?`, which defaults to `null`): set chrominance expression in U plane
+- `weight_V` (of type `string?`, which defaults to `null`): set chrominance expression in V plane
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.field`
+
+Ffmpeg filter: Extract a field from the input video.
+
+Type:
+
+```
+(?type : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set field type (top or bottom). (default: 0, possible values: 0 (top), 1 (bottom))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.field.create`
+
+Ffmpeg filter: Extract a field from the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `type` (of type `int?`, which defaults to `null`): set field type (top or bottom). (default: 0, possible values: 0 (top), 1 (bottom))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fieldhint`
+
+Ffmpeg filter: Field matching using hints.
+
+Type:
+
+```
+(?hint : string?, ?mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `hint` (of type `string?`, which defaults to `null`): set hint file
+- `mode` (of type `int?`, which defaults to `null`): set hint mode. (default: 0, possible values: 0 (absolute), 1 (relative), 2 (pattern))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fieldhint.create`
+
+Ffmpeg filter: Field matching using hints.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?hint : string?, ?mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `hint` (of type `string?`, which defaults to `null`): set hint file
+- `mode` (of type `int?`, which defaults to `null`): set hint mode. (default: 0, possible values: 0 (absolute), 1 (relative), 2 (pattern))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fieldmatch`
+
+Ffmpeg filter: Field matching for inverse telecine. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?order : int?, ?mode : int?, ?ppsrc : bool?, ?field : int?,
+ ?mchroma : bool?, ?y0 : int?, ?y1 : int?, ?scthresh : float?,
+ ?combmatch : int?, ?combdbg : int?, ?cthresh : int?, ?chroma : bool?,
+ ?blockx : int?, ?blocky : int?, ?combpel : int?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): specify the assumed field order. (default: -1, possible values: -1 (auto), 0 (bff), 1 (tff))
+- `mode` (of type `int?`, which defaults to `null`): set the matching mode or strategy to use. (default: 1, possible values: 0 (pc), 1 (pc_n), 2 (pc_u), 3 (pc_n_ub), 4 (pcn), 5 (pcn_ub))
+- `ppsrc` (of type `bool?`, which defaults to `null`): mark main input as a pre-processed input and activate clean source input stream. (default: false)
+- `field` (of type `int?`, which defaults to `null`): set the field to match from. (default: -1, possible values: -1 (auto), 0 (bottom), 1 (top))
+- `mchroma` (of type `bool?`, which defaults to `null`): set whether or not chroma is included during the match comparisons. (default: true)
+- `y0` (of type `int?`, which defaults to `null`): define an exclusion band which excludes the lines between y0 and y1 from the field matching decision. (default: 0)
+- `y1` (of type `int?`, which defaults to `null`): define an exclusion band which excludes the lines between y0 and y1 from the field matching decision. (default: 0)
+- `scthresh` (of type `float?`, which defaults to `null`): set scene change detection threshold. (default: 12.)
+- `combmatch` (of type `int?`, which defaults to `null`): set combmatching mode. (default: 1, possible values: 0 (none), 1 (sc), 2 (full))
+- `combdbg` (of type `int?`, which defaults to `null`): enable comb debug. (default: 0, possible values: 0 (none), 1 (pcn), 2 (pcnub))
+- `cthresh` (of type `int?`, which defaults to `null`): set the area combing threshold used for combed frame detection. (default: 9)
+- `chroma` (of type `bool?`, which defaults to `null`): set whether or not chroma is considered in the combed frame decision. (default: false)
+- `blockx` (of type `int?`, which defaults to `null`): set the x-axis size of the window used during combed frame detection. (default: 16)
+- `blocky` (of type `int?`, which defaults to `null`): set the y-axis size of the window used during combed frame detection. (default: 16)
+- `combpel` (of type `int?`, which defaults to `null`): set the number of combed pixels inside any of the blocky by blockx size blocks on the frame for the frame to be detected as combed. (default: 80)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.fieldmatch.create`
+
+Ffmpeg filter: Field matching for inverse telecine. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?order : int?, ?mode : int?, ?ppsrc : bool?, ?field : int?,
+ ?mchroma : bool?, ?y0 : int?, ?y1 : int?, ?scthresh : float?,
+ ?combmatch : int?, ?combdbg : int?, ?cthresh : int?, ?chroma : bool?,
+ ?blockx : int?, ?blocky : int?, ?combpel : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): specify the assumed field order. (default: -1, possible values: -1 (auto), 0 (bff), 1 (tff))
+- `mode` (of type `int?`, which defaults to `null`): set the matching mode or strategy to use. (default: 1, possible values: 0 (pc), 1 (pc_n), 2 (pc_u), 3 (pc_n_ub), 4 (pcn), 5 (pcn_ub))
+- `ppsrc` (of type `bool?`, which defaults to `null`): mark main input as a pre-processed input and activate clean source input stream. (default: false)
+- `field` (of type `int?`, which defaults to `null`): set the field to match from. (default: -1, possible values: -1 (auto), 0 (bottom), 1 (top))
+- `mchroma` (of type `bool?`, which defaults to `null`): set whether or not chroma is included during the match comparisons. (default: true)
+- `y0` (of type `int?`, which defaults to `null`): define an exclusion band which excludes the lines between y0 and y1 from the field matching decision. (default: 0)
+- `y1` (of type `int?`, which defaults to `null`): define an exclusion band which excludes the lines between y0 and y1 from the field matching decision. (default: 0)
+- `scthresh` (of type `float?`, which defaults to `null`): set scene change detection threshold. (default: 12.)
+- `combmatch` (of type `int?`, which defaults to `null`): set combmatching mode. (default: 1, possible values: 0 (none), 1 (sc), 2 (full))
+- `combdbg` (of type `int?`, which defaults to `null`): enable comb debug. (default: 0, possible values: 0 (none), 1 (pcn), 2 (pcnub))
+- `cthresh` (of type `int?`, which defaults to `null`): set the area combing threshold used for combed frame detection. (default: 9)
+- `chroma` (of type `bool?`, which defaults to `null`): set whether or not chroma is considered in the combed frame decision. (default: false)
+- `blockx` (of type `int?`, which defaults to `null`): set the x-axis size of the window used during combed frame detection. (default: 16)
+- `blocky` (of type `int?`, which defaults to `null`): set the y-axis size of the window used during combed frame detection. (default: 16)
+- `combpel` (of type `int?`, which defaults to `null`): set the number of combed pixels inside any of the blocky by blockx size blocks on the frame for the frame to be detected as combed. (default: 80)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fieldorder`
+
+Ffmpeg filter: Set the field order.
+
+Type:
+
+```
+(?order : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): output field order. (default: 1, possible values: 0 (bff), 1 (tff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fieldorder.create`
+
+Ffmpeg filter: Set the field order.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?order : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `order` (of type `int?`, which defaults to `null`): output field order. (default: 1, possible values: 0 (bff), 1 (tff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fifo`
+
+Ffmpeg filter: Buffer input images and send them when they are requested.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fifo.create`
+
+Ffmpeg filter: Buffer input images and send them when they are requested.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fillborders`
+
+Ffmpeg filter: Fill borders of the input video.
+
+Type:
+
+```
+(?left : int?, ?right : int?, ?top : int?, ?bottom : int?, ?mode : int?,
+ ?color : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `left` (of type `int?`, which defaults to `null`): set the left fill border. (default: 0)
+- `right` (of type `int?`, which defaults to `null`): set the right fill border. (default: 0)
+- `top` (of type `int?`, which defaults to `null`): set the top fill border. (default: 0)
+- `bottom` (of type `int?`, which defaults to `null`): set the bottom fill border. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set the fill borders mode. (default: 0, possible values: 0 (smear), 1 (mirror), 2 (fixed), 3 (reflect), 4 (wrap), 5 (fade), 6 (margins))
+- `color` (of type `string?`, which defaults to `null`): set the color for the fixed/fade mode. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fillborders.create`
+
+Ffmpeg filter: Fill borders of the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?left : int?, ?right : int?, ?top : int?, ?bottom : int?, ?mode : int?,
+ ?color : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `left` (of type `int?`, which defaults to `null`): set the left fill border. (default: 0)
+- `right` (of type `int?`, which defaults to `null`): set the right fill border. (default: 0)
+- `top` (of type `int?`, which defaults to `null`): set the top fill border. (default: 0)
+- `bottom` (of type `int?`, which defaults to `null`): set the bottom fill border. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set the fill borders mode. (default: 0, possible values: 0 (smear), 1 (mirror), 2 (fixed), 3 (reflect), 4 (wrap), 5 (fade), 6 (margins))
+- `color` (of type `string?`, which defaults to `null`): set the color for the fixed/fade mode. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.find_rect`
+
+Ffmpeg filter: Find a user specified object.
+
+Type:
+
+```
+(?object : string?, ?threshold : float?, ?mipmaps : int?, ?xmin : int?,
+ ?ymin : int?, ?xmax : int?, ?ymax : int?, ?discard : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `object` (of type `string?`, which defaults to `null`): object bitmap filename
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.5)
+- `mipmaps` (of type `int?`, which defaults to `null`): set mipmaps. (default: 3)
+- `xmin` (of type `int?`, which defaults to `null`): Default: 0
+- `ymin` (of type `int?`, which defaults to `null`): Default: 0
+- `xmax` (of type `int?`, which defaults to `null`): Default: 0
+- `ymax` (of type `int?`, which defaults to `null`): Default: 0
+- `discard` (of type `bool?`, which defaults to `null`): Default: false
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.find_rect.create`
+
+Ffmpeg filter: Find a user specified object.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?object : string?, ?threshold : float?, ?mipmaps : int?, ?xmin : int?,
+ ?ymin : int?, ?xmax : int?, ?ymax : int?, ?discard : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `object` (of type `string?`, which defaults to `null`): object bitmap filename
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.5)
+- `mipmaps` (of type `int?`, which defaults to `null`): set mipmaps. (default: 3)
+- `xmin` (of type `int?`, which defaults to `null`): Default: 0
+- `ymin` (of type `int?`, which defaults to `null`): Default: 0
+- `xmax` (of type `int?`, which defaults to `null`): Default: 0
+- `ymax` (of type `int?`, which defaults to `null`): Default: 0
+- `discard` (of type `bool?`, which defaults to `null`): Default: false
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.firequalizer`
+
+Ffmpeg filter: Finite Impulse Response Equalizer.
+
+Type:
+
+```
+(?gain : string?, ?gain_entry : string?, ?delay : float?, ?accuracy : float?,
+ ?wfunc : int?, ?fixed : bool?, ?multi : bool?, ?zero_phase : bool?,
+ ?scale : int?, ?dumpfile : string?, ?dumpscale : int?, ?fft2 : bool?,
+ ?min_phase : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `gain` (of type `string?`, which defaults to `null`): set gain curve. (default: gain_interpolate(f))
+- `gain_entry` (of type `string?`, which defaults to `null`): set gain entry
+- `delay` (of type `float?`, which defaults to `null`): set delay. (default: 0.01)
+- `accuracy` (of type `float?`, which defaults to `null`): set accuracy. (default: 5.)
+- `wfunc` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rectangular), 1 (hann), 2 (hamming), 3 (blackman), 4 (nuttall3), 5 (mnuttall3), 6 (nuttall), 7 (bnuttall), 8 (bharris), 9 (tukey))
+- `fixed` (of type `bool?`, which defaults to `null`): set fixed frame samples. (default: false)
+- `multi` (of type `bool?`, which defaults to `null`): set multi channels mode. (default: false)
+- `zero_phase` (of type `bool?`, which defaults to `null`): set zero phase mode. (default: false)
+- `scale` (of type `int?`, which defaults to `null`): set gain scale. (default: 1, possible values: 0 (linlin), 1 (linlog), 2 (loglin), 3 (loglog))
+- `dumpfile` (of type `string?`, which defaults to `null`): set dump file
+- `dumpscale` (of type `int?`, which defaults to `null`): set dump scale. (default: 1, possible values: 0 (linlin), 1 (linlog), 2 (loglin), 3 (loglog))
+- `fft2` (of type `bool?`, which defaults to `null`): set 2-channels fft. (default: false)
+- `min_phase` (of type `bool?`, which defaults to `null`): set minimum phase mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.firequalizer.create`
+
+Ffmpeg filter: Finite Impulse Response Equalizer.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?gain : string?, ?gain_entry : string?, ?delay : float?, ?accuracy : float?,
+ ?wfunc : int?, ?fixed : bool?, ?multi : bool?, ?zero_phase : bool?,
+ ?scale : int?, ?dumpfile : string?, ?dumpscale : int?, ?fft2 : bool?,
+ ?min_phase : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `gain` (of type `string?`, which defaults to `null`): set gain curve. (default: gain_interpolate(f))
+- `gain_entry` (of type `string?`, which defaults to `null`): set gain entry
+- `delay` (of type `float?`, which defaults to `null`): set delay. (default: 0.01)
+- `accuracy` (of type `float?`, which defaults to `null`): set accuracy. (default: 5.)
+- `wfunc` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rectangular), 1 (hann), 2 (hamming), 3 (blackman), 4 (nuttall3), 5 (mnuttall3), 6 (nuttall), 7 (bnuttall), 8 (bharris), 9 (tukey))
+- `fixed` (of type `bool?`, which defaults to `null`): set fixed frame samples. (default: false)
+- `multi` (of type `bool?`, which defaults to `null`): set multi channels mode. (default: false)
+- `zero_phase` (of type `bool?`, which defaults to `null`): set zero phase mode. (default: false)
+- `scale` (of type `int?`, which defaults to `null`): set gain scale. (default: 1, possible values: 0 (linlin), 1 (linlog), 2 (loglin), 3 (loglog))
+- `dumpfile` (of type `string?`, which defaults to `null`): set dump file
+- `dumpscale` (of type `int?`, which defaults to `null`): set dump scale. (default: 1, possible values: 0 (linlin), 1 (linlog), 2 (loglin), 3 (loglog))
+- `fft2` (of type `bool?`, which defaults to `null`): set 2-channels fft. (default: false)
+- `min_phase` (of type `bool?`, which defaults to `null`): set minimum phase mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.flanger`
+
+Ffmpeg filter: Apply a flanging effect to the audio.
+
+Type:
+
+```
+(?delay : float?, ?depth : float?, ?regen : float?, ?width : float?,
+ ?speed : float?, ?shape : int?, ?phase : float?, ?interp : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `delay` (of type `float?`, which defaults to `null`): base delay in milliseconds. (default: 0.)
+- `depth` (of type `float?`, which defaults to `null`): added swept delay in milliseconds. (default: 2.)
+- `regen` (of type `float?`, which defaults to `null`): percentage regeneration (delayed signal feedback). (default: 0.)
+- `width` (of type `float?`, which defaults to `null`): percentage of delayed signal mixed with original. (default: 71.)
+- `speed` (of type `float?`, which defaults to `null`): sweeps per second (Hz). (default: 0.5)
+- `shape` (of type `int?`, which defaults to `null`): swept wave shape. (default: 0, possible values: 1 (triangular), 1 (t), 0 (sinusoidal), 0 (s))
+- `phase` (of type `float?`, which defaults to `null`): swept wave percentage phase-shift for multi-channel. (default: 25.)
+- `interp` (of type `int?`, which defaults to `null`): delay-line interpolation. (default: 0, possible values: 0 (linear), 1 (quadratic))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.flanger.create`
+
+Ffmpeg filter: Apply a flanging effect to the audio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?delay : float?, ?depth : float?, ?regen : float?, ?width : float?,
+ ?speed : float?, ?shape : int?, ?phase : float?, ?interp : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `delay` (of type `float?`, which defaults to `null`): base delay in milliseconds. (default: 0.)
+- `depth` (of type `float?`, which defaults to `null`): added swept delay in milliseconds. (default: 2.)
+- `regen` (of type `float?`, which defaults to `null`): percentage regeneration (delayed signal feedback). (default: 0.)
+- `width` (of type `float?`, which defaults to `null`): percentage of delayed signal mixed with original. (default: 71.)
+- `speed` (of type `float?`, which defaults to `null`): sweeps per second (Hz). (default: 0.5)
+- `shape` (of type `int?`, which defaults to `null`): swept wave shape. (default: 0, possible values: 1 (triangular), 1 (t), 0 (sinusoidal), 0 (s))
+- `phase` (of type `float?`, which defaults to `null`): swept wave percentage phase-shift for multi-channel. (default: 25.)
+- `interp` (of type `int?`, which defaults to `null`): delay-line interpolation. (default: 0, possible values: 0 (linear), 1 (quadratic))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.flite`
+
+Ffmpeg filter: Synthesize voice from text using libflite.
+
+Type:
+
+```
+(?list_voices : bool?, ?nb_samples : int?, ?n : int?, ?text : string?,
+ ?textfile : string?, ?v : string?, ?voice : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `list_voices` (of type `bool?`, which defaults to `null`): list voices and exit. (default: false)
+- `nb_samples` (of type `int?`, which defaults to `null`): set number of samples per frame. (default: 512)
+- `n` (of type `int?`, which defaults to `null`): set number of samples per frame. (default: 512)
+- `text` (of type `string?`, which defaults to `null`): set text to speak
+- `textfile` (of type `string?`, which defaults to `null`): set filename of the text to speak
+- `v` (of type `string?`, which defaults to `null`): set voice. (default: kal)
+- `voice` (of type `string?`, which defaults to `null`): set voice. (default: kal)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.flite.create`
+
+Ffmpeg filter: Synthesize voice from text using libflite.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?list_voices : bool?, ?nb_samples : int?, ?n : int?, ?text : string?,
+ ?textfile : string?, ?v : string?, ?voice : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `list_voices` (of type `bool?`, which defaults to `null`): list voices and exit. (default: false)
+- `nb_samples` (of type `int?`, which defaults to `null`): set number of samples per frame. (default: 512)
+- `n` (of type `int?`, which defaults to `null`): set number of samples per frame. (default: 512)
+- `text` (of type `string?`, which defaults to `null`): set text to speak
+- `textfile` (of type `string?`, which defaults to `null`): set filename of the text to speak
+- `v` (of type `string?`, which defaults to `null`): set voice. (default: kal)
+- `voice` (of type `string?`, which defaults to `null`): set voice. (default: kal)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.floodfill`
+
+Ffmpeg filter: Fill area with same color with another color.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ?s0 : int?, ?s1 : int?, ?s2 : int?, ?s3 : int?,
+ ?d0 : int?, ?d1 : int?, ?d2 : int?, ?d3 : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): set pixel x coordinate. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): set pixel y coordinate. (default: 0)
+- `s0` (of type `int?`, which defaults to `null`): set source #0 component value. (default: 0)
+- `s1` (of type `int?`, which defaults to `null`): set source #1 component value. (default: 0)
+- `s2` (of type `int?`, which defaults to `null`): set source #2 component value. (default: 0)
+- `s3` (of type `int?`, which defaults to `null`): set source #3 component value. (default: 0)
+- `d0` (of type `int?`, which defaults to `null`): set destination #0 component value. (default: 0)
+- `d1` (of type `int?`, which defaults to `null`): set destination #1 component value. (default: 0)
+- `d2` (of type `int?`, which defaults to `null`): set destination #2 component value. (default: 0)
+- `d3` (of type `int?`, which defaults to `null`): set destination #3 component value. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.floodfill.create`
+
+Ffmpeg filter: Fill area with same color with another color.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ?s0 : int?, ?s1 : int?, ?s2 : int?, ?s3 : int?,
+ ?d0 : int?, ?d1 : int?, ?d2 : int?, ?d3 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): set pixel x coordinate. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): set pixel y coordinate. (default: 0)
+- `s0` (of type `int?`, which defaults to `null`): set source #0 component value. (default: 0)
+- `s1` (of type `int?`, which defaults to `null`): set source #1 component value. (default: 0)
+- `s2` (of type `int?`, which defaults to `null`): set source #2 component value. (default: 0)
+- `s3` (of type `int?`, which defaults to `null`): set source #3 component value. (default: 0)
+- `d0` (of type `int?`, which defaults to `null`): set destination #0 component value. (default: 0)
+- `d1` (of type `int?`, which defaults to `null`): set destination #1 component value. (default: 0)
+- `d2` (of type `int?`, which defaults to `null`): set destination #2 component value. (default: 0)
+- `d3` (of type `int?`, which defaults to `null`): set destination #3 component value. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.format`
+
+Ffmpeg filter: Convert the input video to one of the specified pixel formats.
+
+Type:
+
+```
+(?pix_fmts : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `pix_fmts` (of type `string?`, which defaults to `null`): A '|'-separated list of pixel formats
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.format.create`
+
+Ffmpeg filter: Convert the input video to one of the specified pixel formats.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?pix_fmts : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `pix_fmts` (of type `string?`, which defaults to `null`): A '|'-separated list of pixel formats
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fps`
+
+Ffmpeg filter: Force constant framerate.
+
+Type:
+
+```
+(?fps : string?, ?start_time : float?, ?round : int?, ?eof_action : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `fps` (of type `string?`, which defaults to `null`): A string describing desired output framerate. (default: 25)
+- `start_time` (of type `float?`, which defaults to `null`): Assume the first PTS should be this value.. (default: 1.79769313486e+308)
+- `round` (of type `int?`, which defaults to `null`): set rounding method for timestamps. (default: 5, possible values: 0 (zero), 1 (inf), 2 (down), 3 (up), 5 (near))
+- `eof_action` (of type `int?`, which defaults to `null`): action performed for last frame. (default: 0, possible values: 0 (round), 1 (pass))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fps.create`
+
+Ffmpeg filter: Force constant framerate.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?fps : string?, ?start_time : float?, ?round : int?, ?eof_action : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `fps` (of type `string?`, which defaults to `null`): A string describing desired output framerate. (default: 25)
+- `start_time` (of type `float?`, which defaults to `null`): Assume the first PTS should be this value.. (default: 1.79769313486e+308)
+- `round` (of type `int?`, which defaults to `null`): set rounding method for timestamps. (default: 5, possible values: 0 (zero), 1 (inf), 2 (down), 3 (up), 5 (near))
+- `eof_action` (of type `int?`, which defaults to `null`): action performed for last frame. (default: 0, possible values: 0 (round), 1 (pass))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.framepack`
+
+Ffmpeg filter: Generate a frame packed stereoscopic video.
+
+Type:
+
+```
+(?format : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `format` (of type `int?`, which defaults to `null`): Frame pack output format. (default: 1, possible values: 1 (sbs), 2 (tab), 3 (frameseq), 6 (lines), 7 (columns))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.framepack.create`
+
+Ffmpeg filter: Generate a frame packed stereoscopic video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?format : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `format` (of type `int?`, which defaults to `null`): Frame pack output format. (default: 1, possible values: 1 (sbs), 2 (tab), 3 (frameseq), 6 (lines), 7 (columns))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.framerate`
+
+Ffmpeg filter: Upsamples or downsamples progressive source between specified frame rates.
+
+Type:
+
+```
+(?fps : string?, ?interp_start : int?, ?interp_end : int?, ?scene : float?,
+ ?flags : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `fps` (of type `string?`, which defaults to `null`): required output frames per second rate. (default: 50)
+- `interp_start` (of type `int?`, which defaults to `null`): point to start linear interpolation. (default: 15)
+- `interp_end` (of type `int?`, which defaults to `null`): point to end linear interpolation. (default: 240)
+- `scene` (of type `float?`, which defaults to `null`): scene change level. (default: 8.2)
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 1 (scene_change_detect), 1 (scd))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.framerate.create`
+
+Ffmpeg filter: Upsamples or downsamples progressive source between specified frame rates.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?fps : string?, ?interp_start : int?, ?interp_end : int?, ?scene : float?,
+ ?flags : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `fps` (of type `string?`, which defaults to `null`): required output frames per second rate. (default: 50)
+- `interp_start` (of type `int?`, which defaults to `null`): point to start linear interpolation. (default: 15)
+- `interp_end` (of type `int?`, which defaults to `null`): point to end linear interpolation. (default: 240)
+- `scene` (of type `float?`, which defaults to `null`): scene change level. (default: 8.2)
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 1 (scene_change_detect), 1 (scd))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.framestep`
+
+Ffmpeg filter: Select one frame every N frames.
+
+Type:
+
+```
+(?step : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `step` (of type `int?`, which defaults to `null`): set frame step. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.framestep.create`
+
+Ffmpeg filter: Select one frame every N frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?step : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `step` (of type `int?`, which defaults to `null`): set frame step. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.freezedetect`
+
+Ffmpeg filter: Detects frozen video input.
+
+Type:
+
+```
+(?n : float?, ?noise : float?, ?d : int?, ?duration : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `n` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `noise` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `d` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `duration` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.freezedetect.create`
+
+Ffmpeg filter: Detects frozen video input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : float?, ?noise : float?, ?d : int?, ?duration : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `noise` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `d` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `duration` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.freezeframes`
+
+Ffmpeg filter: Freeze video frames.
+
+Type:
+
+```
+(?first : int?, ?last : int?, ?replace : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `first` (of type `int?`, which defaults to `null`): set first frame to freeze. (default: 0)
+- `last` (of type `int?`, which defaults to `null`): set last frame to freeze. (default: 0)
+- `replace` (of type `int?`, which defaults to `null`): set frame to replace. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.freezeframes.create`
+
+Ffmpeg filter: Freeze video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?first : int?, ?last : int?, ?replace : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `first` (of type `int?`, which defaults to `null`): set first frame to freeze. (default: 0)
+- `last` (of type `int?`, which defaults to `null`): set last frame to freeze. (default: 0)
+- `replace` (of type `int?`, which defaults to `null`): set frame to replace. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.frei0r`
+
+Ffmpeg filter: Apply a frei0r effect.
+
+Type:
+
+```
+(?filter_name : string?, ?filter_params : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filter_name` (of type `string?`, which defaults to `null`)
+- `filter_params` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.frei0r.create`
+
+Ffmpeg filter: Apply a frei0r effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filter_name : string?, ?filter_params : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `filter_name` (of type `string?`, which defaults to `null`)
+- `filter_params` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.frei0r_src`
+
+Ffmpeg filter: Generate a frei0r source.
+
+Type:
+
+```
+(?size : string?, ?framerate : string?, ?filter_name : string?,
+ ?filter_params : string?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): Dimensions of the generated video.. (default: 320x240)
+- `framerate` (of type `string?`, which defaults to `null`): Default: 25
+- `filter_name` (of type `string?`, which defaults to `null`)
+- `filter_params` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.frei0r_src.create`
+
+Ffmpeg filter: Generate a frei0r source.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?framerate : string?, ?filter_name : string?,
+ ?filter_params : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): Dimensions of the generated video.. (default: 320x240)
+- `framerate` (of type `string?`, which defaults to `null`): Default: 25
+- `filter_name` (of type `string?`, which defaults to `null`)
+- `filter_params` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.fspp`
+
+Ffmpeg filter: Apply Fast Simple Post-processing filter.
+
+Type:
+
+```
+(?quality : int?, ?qp : int?, ?strength : int?, ?use_bframe_qp : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `quality` (of type `int?`, which defaults to `null`): set quality. (default: 4)
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `strength` (of type `int?`, which defaults to `null`): set filter strength. (default: 0)
+- `use_bframe_qp` (of type `bool?`, which defaults to `null`): use B-frames' QP. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.fspp.create`
+
+Ffmpeg filter: Apply Fast Simple Post-processing filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?quality : int?, ?qp : int?, ?strength : int?, ?use_bframe_qp : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `quality` (of type `int?`, which defaults to `null`): set quality. (default: 4)
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `strength` (of type `int?`, which defaults to `null`): set filter strength. (default: 0)
+- `use_bframe_qp` (of type `bool?`, which defaults to `null`): use B-frames' QP. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.gblur`
+
+Ffmpeg filter: Apply Gaussian Blur filter.
+
+Type:
+
+```
+(?sigma : float?, ?steps : int?, ?planes : int?, ?sigmaV : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set sigma. (default: 0.5)
+- `steps` (of type `int?`, which defaults to `null`): set number of steps. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `sigmaV` (of type `float?`, which defaults to `null`): set vertical sigma. (default: -1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.gblur.create`
+
+Ffmpeg filter: Apply Gaussian Blur filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sigma : float?, ?steps : int?, ?planes : int?, ?sigmaV : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sigma` (of type `float?`, which defaults to `null`): set sigma. (default: 0.5)
+- `steps` (of type `int?`, which defaults to `null`): set number of steps. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `sigmaV` (of type `float?`, which defaults to `null`): set vertical sigma. (default: -1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.geq`
+
+Ffmpeg filter: Apply generic equation to each pixel.
+
+Type:
+
+```
+(?lum_expr : string?, ?lum : string?, ?cb_expr : string?, ?cb : string?,
+ ?cr_expr : string?, ?cr : string?, ?alpha_expr : string?, ?a : string?,
+ ?red_expr : string?, ?r : string?, ?green_expr : string?, ?g : string?,
+ ?blue_expr : string?, ?b : string?, ?interpolation : int?, ?i : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `lum_expr` (of type `string?`, which defaults to `null`): set luminance expression
+- `lum` (of type `string?`, which defaults to `null`): set luminance expression
+- `cb_expr` (of type `string?`, which defaults to `null`): set chroma blue expression
+- `cb` (of type `string?`, which defaults to `null`): set chroma blue expression
+- `cr_expr` (of type `string?`, which defaults to `null`): set chroma red expression
+- `cr` (of type `string?`, which defaults to `null`): set chroma red expression
+- `alpha_expr` (of type `string?`, which defaults to `null`): set alpha expression
+- `a` (of type `string?`, which defaults to `null`): set alpha expression
+- `red_expr` (of type `string?`, which defaults to `null`): set red expression
+- `r` (of type `string?`, which defaults to `null`): set red expression
+- `green_expr` (of type `string?`, which defaults to `null`): set green expression
+- `g` (of type `string?`, which defaults to `null`): set green expression
+- `blue_expr` (of type `string?`, which defaults to `null`): set blue expression
+- `b` (of type `string?`, which defaults to `null`): set blue expression
+- `interpolation` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (nearest), 0 (n), 1 (bilinear), 1 (b))
+- `i` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (nearest), 0 (n), 1 (bilinear), 1 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.geq.create`
+
+Ffmpeg filter: Apply generic equation to each pixel.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?lum_expr : string?, ?lum : string?, ?cb_expr : string?, ?cb : string?,
+ ?cr_expr : string?, ?cr : string?, ?alpha_expr : string?, ?a : string?,
+ ?red_expr : string?, ?r : string?, ?green_expr : string?, ?g : string?,
+ ?blue_expr : string?, ?b : string?, ?interpolation : int?, ?i : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `lum_expr` (of type `string?`, which defaults to `null`): set luminance expression
+- `lum` (of type `string?`, which defaults to `null`): set luminance expression
+- `cb_expr` (of type `string?`, which defaults to `null`): set chroma blue expression
+- `cb` (of type `string?`, which defaults to `null`): set chroma blue expression
+- `cr_expr` (of type `string?`, which defaults to `null`): set chroma red expression
+- `cr` (of type `string?`, which defaults to `null`): set chroma red expression
+- `alpha_expr` (of type `string?`, which defaults to `null`): set alpha expression
+- `a` (of type `string?`, which defaults to `null`): set alpha expression
+- `red_expr` (of type `string?`, which defaults to `null`): set red expression
+- `r` (of type `string?`, which defaults to `null`): set red expression
+- `green_expr` (of type `string?`, which defaults to `null`): set green expression
+- `g` (of type `string?`, which defaults to `null`): set green expression
+- `blue_expr` (of type `string?`, which defaults to `null`): set blue expression
+- `b` (of type `string?`, which defaults to `null`): set blue expression
+- `interpolation` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (nearest), 0 (n), 1 (bilinear), 1 (b))
+- `i` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (nearest), 0 (n), 1 (bilinear), 1 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.gradfun`
+
+Ffmpeg filter: Debands video quickly using gradients.
+
+Type:
+
+```
+(?strength : float?, ?radius : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): The maximum amount by which the filter will change any one pixel.. (default: 1.2)
+- `radius` (of type `int?`, which defaults to `null`): The neighborhood to fit the gradient to.. (default: 16)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.gradfun.create`
+
+Ffmpeg filter: Debands video quickly using gradients.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?strength : float?, ?radius : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): The maximum amount by which the filter will change any one pixel.. (default: 1.2)
+- `radius` (of type `int?`, which defaults to `null`): The neighborhood to fit the gradient to.. (default: 16)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.gradients`
+
+Ffmpeg filter: Draw a gradients.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?c0 : string?,
+ ?c1 : string?, ?c2 : string?, ?c3 : string?, ?c4 : string?, ?c5 : string?,
+ ?c6 : string?, ?c7 : string?, ?x0 : int?, ?y0 : int?, ?x1 : int?,
+ ?y1 : int?, ?nb_colors : int?, ?n : int?, ?seed : int?, ?duration : int?,
+ ?d : int?, ?speed : float?, ?type : int?, ?t : int?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `rate` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `c0` (of type `string?`, which defaults to `null`): set 1st color. (default: random)
+- `c1` (of type `string?`, which defaults to `null`): set 2nd color. (default: random)
+- `c2` (of type `string?`, which defaults to `null`): set 3rd color. (default: random)
+- `c3` (of type `string?`, which defaults to `null`): set 4th color. (default: random)
+- `c4` (of type `string?`, which defaults to `null`): set 5th color. (default: random)
+- `c5` (of type `string?`, which defaults to `null`): set 6th color. (default: random)
+- `c6` (of type `string?`, which defaults to `null`): set 7th color. (default: random)
+- `c7` (of type `string?`, which defaults to `null`): set 8th color. (default: random)
+- `x0` (of type `int?`, which defaults to `null`): set gradient line source x0. (default: -1)
+- `y0` (of type `int?`, which defaults to `null`): set gradient line source y0. (default: -1)
+- `x1` (of type `int?`, which defaults to `null`): set gradient line destination x1. (default: -1)
+- `y1` (of type `int?`, which defaults to `null`): set gradient line destination y1. (default: -1)
+- `nb_colors` (of type `int?`, which defaults to `null`): set the number of colors. (default: 2)
+- `n` (of type `int?`, which defaults to `null`): set the number of colors. (default: 2)
+- `seed` (of type `int?`, which defaults to `null`): set the seed. (default: -1)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `speed` (of type `float?`, which defaults to `null`): set gradients rotation speed. (default: 0.01)
+- `type` (of type `int?`, which defaults to `null`): set gradient type. (default: 0, possible values: 0 (linear), 1 (radial), 2 (circular), 3 (spiral))
+- `t` (of type `int?`, which defaults to `null`): set gradient type. (default: 0, possible values: 0 (linear), 1 (radial), 2 (circular), 3 (spiral))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.gradients.create`
+
+Ffmpeg filter: Draw a gradients.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?c0 : string?,
+ ?c1 : string?, ?c2 : string?, ?c3 : string?, ?c4 : string?, ?c5 : string?,
+ ?c6 : string?, ?c7 : string?, ?x0 : int?, ?y0 : int?, ?x1 : int?,
+ ?y1 : int?, ?nb_colors : int?, ?n : int?, ?seed : int?, ?duration : int?,
+ ?d : int?, ?speed : float?, ?type : int?, ?t : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `rate` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `c0` (of type `string?`, which defaults to `null`): set 1st color. (default: random)
+- `c1` (of type `string?`, which defaults to `null`): set 2nd color. (default: random)
+- `c2` (of type `string?`, which defaults to `null`): set 3rd color. (default: random)
+- `c3` (of type `string?`, which defaults to `null`): set 4th color. (default: random)
+- `c4` (of type `string?`, which defaults to `null`): set 5th color. (default: random)
+- `c5` (of type `string?`, which defaults to `null`): set 6th color. (default: random)
+- `c6` (of type `string?`, which defaults to `null`): set 7th color. (default: random)
+- `c7` (of type `string?`, which defaults to `null`): set 8th color. (default: random)
+- `x0` (of type `int?`, which defaults to `null`): set gradient line source x0. (default: -1)
+- `y0` (of type `int?`, which defaults to `null`): set gradient line source y0. (default: -1)
+- `x1` (of type `int?`, which defaults to `null`): set gradient line destination x1. (default: -1)
+- `y1` (of type `int?`, which defaults to `null`): set gradient line destination y1. (default: -1)
+- `nb_colors` (of type `int?`, which defaults to `null`): set the number of colors. (default: 2)
+- `n` (of type `int?`, which defaults to `null`): set the number of colors. (default: 2)
+- `seed` (of type `int?`, which defaults to `null`): set the seed. (default: -1)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `speed` (of type `float?`, which defaults to `null`): set gradients rotation speed. (default: 0.01)
+- `type` (of type `int?`, which defaults to `null`): set gradient type. (default: 0, possible values: 0 (linear), 1 (radial), 2 (circular), 3 (spiral))
+- `t` (of type `int?`, which defaults to `null`): set gradient type. (default: 0, possible values: 0 (linear), 1 (radial), 2 (circular), 3 (spiral))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.graphmonitor`
+
+Ffmpeg filter: Show various filtergraph stats.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?opacity : float?, ?o : float?, ?mode : int?,
+ ?m : int?, ?flags : int?, ?f : int?, ?rate : string?, ?r : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `opacity` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `o` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `f` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.graphmonitor.create`
+
+Ffmpeg filter: Show various filtergraph stats.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?opacity : float?, ?o : float?, ?mode : int?,
+ ?m : int?, ?flags : int?, ?f : int?, ?rate : string?, ?r : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `s` (of type `string?`, which defaults to `null`): set monitor size. (default: hd720)
+- `opacity` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `o` (of type `float?`, which defaults to `null`): set video opacity. (default: 0.9)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (full), 1 (compact), 2 (nozero), 4 (noeof), 8 (nodisabled))
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `f` (of type `int?`, which defaults to `null`): set flags. (default: 1, possible values: 0 (none), 2147483647 (all), 1 (queue), 4 (frame_count_in), 2 (frame_count_out), 16384 (frame_count_delta), 8 (pts), 4096 (pts_delta), 16 (time), 8192 (time_delta), 32 (timebase), 64 (format), 128 (size), 256 (rate), 512 (eof), 2048 (sample_count_in), 1024 (sample_count_out), 32768 (sample_count_delta), 65536 (disabled))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.grayworld`
+
+Ffmpeg filter: Adjust white balance using LAB gray world algorithm
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.grayworld.create`
+
+Ffmpeg filter: Adjust white balance using LAB gray world algorithm. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.greyedge`
+
+Ffmpeg filter: Estimates scene illumination by grey edge assumption.
+
+Type:
+
+```
+(?difford : int?, ?minknorm : int?, ?sigma : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `difford` (of type `int?`, which defaults to `null`): set differentiation order. (default: 1)
+- `minknorm` (of type `int?`, which defaults to `null`): set Minkowski norm. (default: 1)
+- `sigma` (of type `float?`, which defaults to `null`): set sigma. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.greyedge.create`
+
+Ffmpeg filter: Estimates scene illumination by grey edge assumption.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?difford : int?, ?minknorm : int?, ?sigma : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `difford` (of type `int?`, which defaults to `null`): set differentiation order. (default: 1)
+- `minknorm` (of type `int?`, which defaults to `null`): set Minkowski norm. (default: 1)
+- `sigma` (of type `float?`, which defaults to `null`): set sigma. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.guided`
+
+Ffmpeg filter: Apply Guided filter. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?radius : int?, ?eps : float?, ?mode : int?, ?sub : int?, ?guidance : int?,
+ ?planes : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set the box radius. (default: 3)
+- `eps` (of type `float?`, which defaults to `null`): set the regularization parameter (with square). (default: 0.01)
+- `mode` (of type `int?`, which defaults to `null`): set filtering mode (0: basic mode; 1: fast mode). (default: 0, possible values: 0 (basic), 1 (fast))
+- `sub` (of type `int?`, which defaults to `null`): subsampling ratio for fast mode. (default: 4)
+- `guidance` (of type `int?`, which defaults to `null`): set guidance mode (0: off mode; 1: on mode). (default: 0, possible values: 0 (off), 1 (on))
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.guided.create`
+
+Ffmpeg filter: Apply Guided filter. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?radius : int?, ?eps : float?, ?mode : int?, ?sub : int?, ?guidance : int?,
+ ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set the box radius. (default: 3)
+- `eps` (of type `float?`, which defaults to `null`): set the regularization parameter (with square). (default: 0.01)
+- `mode` (of type `int?`, which defaults to `null`): set filtering mode (0: basic mode; 1: fast mode). (default: 0, possible values: 0 (basic), 1 (fast))
+- `sub` (of type `int?`, which defaults to `null`): subsampling ratio for fast mode. (default: 4)
+- `guidance` (of type `int?`, which defaults to `null`): set guidance mode (0: off mode; 1: on mode). (default: 0, possible values: 0 (off), 1 (on))
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.haas`
+
+Ffmpeg filter: Apply Haas Stereo Enhancer.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?side_gain : float?,
+ ?middle_source : int?, ?middle_phase : bool?, ?left_delay : float?,
+ ?left_balance : float?, ?left_gain : float?, ?left_phase : bool?,
+ ?right_delay : float?, ?right_balance : float?, ?right_gain : float?,
+ ?right_phase : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `side_gain` (of type `float?`, which defaults to `null`): set side gain. (default: 1.)
+- `middle_source` (of type `int?`, which defaults to `null`): set middle source. (default: 2, possible values: 0 (left), 1 (right), 2 (mid), 3 (side))
+- `middle_phase` (of type `bool?`, which defaults to `null`): set middle phase. (default: false)
+- `left_delay` (of type `float?`, which defaults to `null`): set left delay. (default: 2.05)
+- `left_balance` (of type `float?`, which defaults to `null`): set left balance. (default: -1.)
+- `left_gain` (of type `float?`, which defaults to `null`): set left gain. (default: 1.)
+- `left_phase` (of type `bool?`, which defaults to `null`): set left phase. (default: false)
+- `right_delay` (of type `float?`, which defaults to `null`): set right delay. (default: 2.12)
+- `right_balance` (of type `float?`, which defaults to `null`): set right balance. (default: 1.)
+- `right_gain` (of type `float?`, which defaults to `null`): set right gain. (default: 1.)
+- `right_phase` (of type `bool?`, which defaults to `null`): set right phase. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.haas.create`
+
+Ffmpeg filter: Apply Haas Stereo Enhancer.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?side_gain : float?,
+ ?middle_source : int?, ?middle_phase : bool?, ?left_delay : float?,
+ ?left_balance : float?, ?left_gain : float?, ?left_phase : bool?,
+ ?right_delay : float?, ?right_balance : float?, ?right_gain : float?,
+ ?right_phase : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `side_gain` (of type `float?`, which defaults to `null`): set side gain. (default: 1.)
+- `middle_source` (of type `int?`, which defaults to `null`): set middle source. (default: 2, possible values: 0 (left), 1 (right), 2 (mid), 3 (side))
+- `middle_phase` (of type `bool?`, which defaults to `null`): set middle phase. (default: false)
+- `left_delay` (of type `float?`, which defaults to `null`): set left delay. (default: 2.05)
+- `left_balance` (of type `float?`, which defaults to `null`): set left balance. (default: -1.)
+- `left_gain` (of type `float?`, which defaults to `null`): set left gain. (default: 1.)
+- `left_phase` (of type `bool?`, which defaults to `null`): set left phase. (default: false)
+- `right_delay` (of type `float?`, which defaults to `null`): set right delay. (default: 2.12)
+- `right_balance` (of type `float?`, which defaults to `null`): set right balance. (default: 1.)
+- `right_gain` (of type `float?`, which defaults to `null`): set right gain. (default: 1.)
+- `right_phase` (of type `bool?`, which defaults to `null`): set right phase. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.haldclut`
+
+Ffmpeg filter: Adjust colors using a Hald CLUT.
+
+Type:
+
+```
+(?clut : int?, ?interp : int?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `clut` (of type `int?`, which defaults to `null`): when to process CLUT. (default: 1, possible values: 0 (first), 1 (all))
+- `interp` (of type `int?`, which defaults to `null`): select interpolation mode. (default: 2, possible values: 0 (nearest), 1 (trilinear), 2 (tetrahedral), 3 (pyramid), 4 (prism))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.haldclut.create`
+
+Ffmpeg filter: Adjust colors using a Hald CLUT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?clut : int?, ?interp : int?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `clut` (of type `int?`, which defaults to `null`): when to process CLUT. (default: 1, possible values: 0 (first), 1 (all))
+- `interp` (of type `int?`, which defaults to `null`): select interpolation mode. (default: 2, possible values: 0 (nearest), 1 (trilinear), 2 (tetrahedral), 3 (pyramid), 4 (prism))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.haldclutsrc`
+
+Ffmpeg filter: Provide an identity Hald CLUT.
+
+Type:
+
+```
+(?level : int?, ?rate : string?, ?r : string?, ?duration : int?, ?d : int?,
+ ?sar : string?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `level` (of type `int?`, which defaults to `null`): set level. (default: 6)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.haldclutsrc.create`
+
+Ffmpeg filter: Provide an identity Hald CLUT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level : int?, ?rate : string?, ?r : string?, ?duration : int?, ?d : int?,
+ ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level` (of type `int?`, which defaults to `null`): set level. (default: 6)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hdcd`
+
+Ffmpeg filter: Apply High Definition Compatible Digital (HDCD) decoding.
+
+Type:
+
+```
+(?disable_autoconvert : bool?, ?process_stereo : bool?, ?cdt_ms : int?,
+ ?force_pe : bool?, ?analyze_mode : int?, ?bits_per_sample : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `disable_autoconvert` (of type `bool?`, which defaults to `null`): Disable any format conversion or resampling in the filter graph.. (default: true)
+- `process_stereo` (of type `bool?`, which defaults to `null`): Process stereo channels together. Only apply target_gain when both channels match.. (default: true)
+- `cdt_ms` (of type `int?`, which defaults to `null`): Code detect timer period in ms.. (default: 2000)
+- `force_pe` (of type `bool?`, which defaults to `null`): Always extend peaks above -3dBFS even when PE is not signaled.. (default: false)
+- `analyze_mode` (of type `int?`, which defaults to `null`): Replace audio with solid tone and signal some processing aspect in the amplitude.. (default: 0, possible values: 0 (off), 1 (lle), 2 (pe), 3 (cdt), 4 (tgm))
+- `bits_per_sample` (of type `int?`, which defaults to `null`): Valid bits per sample (location of the true LSB).. (default: 16, possible values: 16 (16), 20 (20), 24 (24))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.hdcd.create`
+
+Ffmpeg filter: Apply High Definition Compatible Digital (HDCD) decoding.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?disable_autoconvert : bool?, ?process_stereo : bool?, ?cdt_ms : int?,
+ ?force_pe : bool?, ?analyze_mode : int?, ?bits_per_sample : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `disable_autoconvert` (of type `bool?`, which defaults to `null`): Disable any format conversion or resampling in the filter graph.. (default: true)
+- `process_stereo` (of type `bool?`, which defaults to `null`): Process stereo channels together. Only apply target_gain when both channels match.. (default: true)
+- `cdt_ms` (of type `int?`, which defaults to `null`): Code detect timer period in ms.. (default: 2000)
+- `force_pe` (of type `bool?`, which defaults to `null`): Always extend peaks above -3dBFS even when PE is not signaled.. (default: false)
+- `analyze_mode` (of type `int?`, which defaults to `null`): Replace audio with solid tone and signal some processing aspect in the amplitude.. (default: 0, possible values: 0 (off), 1 (lle), 2 (pe), 3 (cdt), 4 (tgm))
+- `bits_per_sample` (of type `int?`, which defaults to `null`): Valid bits per sample (location of the true LSB).. (default: 16, possible values: 16 (16), 20 (20), 24 (24))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.headphone`
+
+Ffmpeg filter: Apply headphone binaural spatialization with HRTFs in additional streams. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?map : string?, ?gain : float?, ?lfe : float?, ?type : int?, ?size : int?,
+ ?hrir : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `map` (of type `string?`, which defaults to `null`): set channels convolution mappings
+- `gain` (of type `float?`, which defaults to `null`): set gain in dB. (default: 0.)
+- `lfe` (of type `float?`, which defaults to `null`): set lfe gain in dB. (default: 0.)
+- `type` (of type `int?`, which defaults to `null`): set processing. (default: 1, possible values: 0 (time), 1 (freq))
+- `size` (of type `int?`, which defaults to `null`): set frame size. (default: 1024)
+- `hrir` (of type `int?`, which defaults to `null`): set hrir format. (default: 0, possible values: 0 (stereo), 1 (multich))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.headphone.create`
+
+Ffmpeg filter: Apply headphone binaural spatialization with HRTFs in additional streams. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?map : string?, ?gain : float?, ?lfe : float?, ?type : int?, ?size : int?,
+ ?hrir : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `map` (of type `string?`, which defaults to `null`): set channels convolution mappings
+- `gain` (of type `float?`, which defaults to `null`): set gain in dB. (default: 0.)
+- `lfe` (of type `float?`, which defaults to `null`): set lfe gain in dB. (default: 0.)
+- `type` (of type `int?`, which defaults to `null`): set processing. (default: 1, possible values: 0 (time), 1 (freq))
+- `size` (of type `int?`, which defaults to `null`): set frame size. (default: 1024)
+- `hrir` (of type `int?`, which defaults to `null`): set hrir format. (default: 0, possible values: 0 (stereo), 1 (multich))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hflip`
+
+Ffmpeg filter: Horizontally flip the input video.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hflip.create`
+
+Ffmpeg filter: Horizontally flip the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.highpass`
+
+Ffmpeg filter: Apply a high-pass filter with 3dB point frequency.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?poles : int?, ?p : int?, ?mix : float?,
+ ?m : float?, ?channels : string?, ?c : string?, ?normalize : bool?,
+ ?n : bool?, ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.highpass.create`
+
+Ffmpeg filter: Apply a high-pass filter with 3dB point frequency.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?poles : int?, ?p : int?, ?mix : float?,
+ ?m : float?, ?channels : string?, ?c : string?, ?normalize : bool?,
+ ?n : bool?, ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.highshelf`
+
+Ffmpeg filter: Apply a high shelf filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.highshelf.create`
+
+Ffmpeg filter: Apply a high shelf filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hilbert`
+
+Ffmpeg filter: Generate a Hilbert transform FIR coefficients.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ?taps : int?, ?t : int?, ?nb_samples : int?,
+ ?n : int?, ?win_func : int?, ?w : int?, ffmpeg.filter.graph) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `taps` (of type `int?`, which defaults to `null`): set number of taps. (default: 22051)
+- `t` (of type `int?`, which defaults to `null`): set number of taps. (default: 22051)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `w` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.hilbert.create`
+
+Ffmpeg filter: Generate a Hilbert transform FIR coefficients.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ?taps : int?, ?t : int?, ?nb_samples : int?,
+ ?n : int?, ?win_func : int?, ?w : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `taps` (of type `int?`, which defaults to `null`): set number of taps. (default: 22051)
+- `t` (of type `int?`, which defaults to `null`): set number of taps. (default: 22051)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `w` (of type `int?`, which defaults to `null`): set window function. (default: 3, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser), 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.histeq`
+
+Ffmpeg filter: Apply global color histogram equalization.
+
+Type:
+
+```
+(?strength : float?, ?intensity : float?, ?antibanding : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set the strength. (default: 0.2)
+- `intensity` (of type `float?`, which defaults to `null`): set the intensity. (default: 0.21)
+- `antibanding` (of type `int?`, which defaults to `null`): set the antibanding level. (default: 0, possible values: 0 (none), 1 (weak), 2 (strong))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.histeq.create`
+
+Ffmpeg filter: Apply global color histogram equalization.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?strength : float?, ?intensity : float?, ?antibanding : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `strength` (of type `float?`, which defaults to `null`): set the strength. (default: 0.2)
+- `intensity` (of type `float?`, which defaults to `null`): set the intensity. (default: 0.21)
+- `antibanding` (of type `int?`, which defaults to `null`): set the antibanding level. (default: 0, possible values: 0 (none), 1 (weak), 2 (strong))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.histogram`
+
+Ffmpeg filter: Compute and draw a histogram.
+
+Type:
+
+```
+(?level_height : int?, ?scale_height : int?, ?display_mode : int?, ?d : int?,
+ ?levels_mode : int?, ?m : int?, ?components : int?, ?c : int?,
+ ?fgopacity : float?, ?f : float?, ?bgopacity : float?, ?b : float?,
+ ?colors_mode : int?, ?l : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `level_height` (of type `int?`, which defaults to `null`): set level height. (default: 200)
+- `scale_height` (of type `int?`, which defaults to `null`): set scale height. (default: 12)
+- `display_mode` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `d` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `levels_mode` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `m` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `components` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `c` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `fgopacity` (of type `float?`, which defaults to `null`): set foreground opacity. (default: 0.7)
+- `f` (of type `float?`, which defaults to `null`): set foreground opacity. (default: 0.7)
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.5)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.5)
+- `colors_mode` (of type `int?`, which defaults to `null`): set colors mode. (default: 0, possible values: 0 (whiteonblack), 1 (blackonwhite), 2 (whiteongray), 3 (blackongray), 4 (coloronblack), 5 (coloronwhite), 6 (colorongray), 7 (blackoncolor), 8 (whiteoncolor), 9 (grayoncolor))
+- `l` (of type `int?`, which defaults to `null`): set colors mode. (default: 0, possible values: 0 (whiteonblack), 1 (blackonwhite), 2 (whiteongray), 3 (blackongray), 4 (coloronblack), 5 (coloronwhite), 6 (colorongray), 7 (blackoncolor), 8 (whiteoncolor), 9 (grayoncolor))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.histogram.create`
+
+Ffmpeg filter: Compute and draw a histogram.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_height : int?, ?scale_height : int?, ?display_mode : int?, ?d : int?,
+ ?levels_mode : int?, ?m : int?, ?components : int?, ?c : int?,
+ ?fgopacity : float?, ?f : float?, ?bgopacity : float?, ?b : float?,
+ ?colors_mode : int?, ?l : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_height` (of type `int?`, which defaults to `null`): set level height. (default: 200)
+- `scale_height` (of type `int?`, which defaults to `null`): set scale height. (default: 12)
+- `display_mode` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `d` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `levels_mode` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `m` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `components` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `c` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `fgopacity` (of type `float?`, which defaults to `null`): set foreground opacity. (default: 0.7)
+- `f` (of type `float?`, which defaults to `null`): set foreground opacity. (default: 0.7)
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.5)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.5)
+- `colors_mode` (of type `int?`, which defaults to `null`): set colors mode. (default: 0, possible values: 0 (whiteonblack), 1 (blackonwhite), 2 (whiteongray), 3 (blackongray), 4 (coloronblack), 5 (coloronwhite), 6 (colorongray), 7 (blackoncolor), 8 (whiteoncolor), 9 (grayoncolor))
+- `l` (of type `int?`, which defaults to `null`): set colors mode. (default: 0, possible values: 0 (whiteonblack), 1 (blackonwhite), 2 (whiteongray), 3 (blackongray), 4 (coloronblack), 5 (coloronwhite), 6 (colorongray), 7 (blackoncolor), 8 (whiteoncolor), 9 (grayoncolor))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hqdn3d`
+
+Ffmpeg filter: Apply a High Quality 3D Denoiser.
+
+Type:
+
+```
+(?luma_spatial : float?, ?chroma_spatial : float?, ?luma_tmp : float?,
+ ?chroma_tmp : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_spatial` (of type `float?`, which defaults to `null`): spatial luma strength. (default: 0.)
+- `chroma_spatial` (of type `float?`, which defaults to `null`): spatial chroma strength. (default: 0.)
+- `luma_tmp` (of type `float?`, which defaults to `null`): temporal luma strength. (default: 0.)
+- `chroma_tmp` (of type `float?`, which defaults to `null`): temporal chroma strength. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hqdn3d.create`
+
+Ffmpeg filter: Apply a High Quality 3D Denoiser.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_spatial : float?, ?chroma_spatial : float?, ?luma_tmp : float?,
+ ?chroma_tmp : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_spatial` (of type `float?`, which defaults to `null`): spatial luma strength. (default: 0.)
+- `chroma_spatial` (of type `float?`, which defaults to `null`): spatial chroma strength. (default: 0.)
+- `luma_tmp` (of type `float?`, which defaults to `null`): temporal luma strength. (default: 0.)
+- `chroma_tmp` (of type `float?`, which defaults to `null`): temporal chroma strength. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hqx`
+
+Ffmpeg filter: Scale the input by 2, 3 or 4 using the hq*x magnification algorithm.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set scale factor. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hqx.create`
+
+Ffmpeg filter: Scale the input by 2, 3 or 4 using the hq*x magnification algorithm.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set scale factor. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hstack`
+
+Ffmpeg filter: Stack video inputs horizontally. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.hstack.create`
+
+Ffmpeg filter: Stack video inputs horizontally. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hstack_vaapi`
+
+Ffmpeg filter: "VA-API" hstack This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ?height : int?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): Force termination when the shortest input terminates. (default: false)
+- `height` (of type `int?`, which defaults to `null`): Set output height (0 to use the height of input 0). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.hstack_vaapi.create`
+
+Ffmpeg filter: "VA-API" hstack This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ?height : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): Force termination when the shortest input terminates. (default: false)
+- `height` (of type `int?`, which defaults to `null`): Set output height (0 to use the height of input 0). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hsvhold`
+
+Ffmpeg filter: Turns a certain HSV range into gray.
+
+Type:
+
+```
+(?hue : float?, ?sat : float?, ?val : float?, ?similarity : float?,
+ ?blend : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue value. (default: 0.)
+- `sat` (of type `float?`, which defaults to `null`): set the saturation value. (default: 0.)
+- `val` (of type `float?`, which defaults to `null`): set the value value. (default: 0.)
+- `similarity` (of type `float?`, which defaults to `null`): set the hsvhold similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the hsvhold blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hsvhold.create`
+
+Ffmpeg filter: Turns a certain HSV range into gray.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?hue : float?, ?sat : float?, ?val : float?, ?similarity : float?,
+ ?blend : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue value. (default: 0.)
+- `sat` (of type `float?`, which defaults to `null`): set the saturation value. (default: 0.)
+- `val` (of type `float?`, which defaults to `null`): set the value value. (default: 0.)
+- `similarity` (of type `float?`, which defaults to `null`): set the hsvhold similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the hsvhold blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hsvkey`
+
+Ffmpeg filter: Turns a certain HSV range into transparency. Operates on YUV colors.
+
+Type:
+
+```
+(?hue : float?, ?sat : float?, ?val : float?, ?similarity : float?,
+ ?blend : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue value. (default: 0.)
+- `sat` (of type `float?`, which defaults to `null`): set the saturation value. (default: 0.)
+- `val` (of type `float?`, which defaults to `null`): set the value value. (default: 0.)
+- `similarity` (of type `float?`, which defaults to `null`): set the hsvkey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the hsvkey blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hsvkey.create`
+
+Ffmpeg filter: Turns a certain HSV range into transparency. Operates on YUV colors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?hue : float?, ?sat : float?, ?val : float?, ?similarity : float?,
+ ?blend : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue value. (default: 0.)
+- `sat` (of type `float?`, which defaults to `null`): set the saturation value. (default: 0.)
+- `val` (of type `float?`, which defaults to `null`): set the value value. (default: 0.)
+- `similarity` (of type `float?`, which defaults to `null`): set the hsvkey similarity value. (default: 0.01)
+- `blend` (of type `float?`, which defaults to `null`): set the hsvkey blend value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hue`
+
+Ffmpeg filter: Adjust the hue and saturation of the input video.
+
+Type:
+
+```
+(?h : string?, ?s : string?, ?H : string?, ?b : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `h` (of type `string?`, which defaults to `null`): set the hue angle degrees expression
+- `s` (of type `string?`, which defaults to `null`): set the saturation expression. (default: 1)
+- `H` (of type `string?`, which defaults to `null`): set the hue angle radians expression
+- `b` (of type `string?`, which defaults to `null`): set the brightness expression. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hue.create`
+
+Ffmpeg filter: Adjust the hue and saturation of the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?h : string?, ?s : string?, ?H : string?, ?b : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `h` (of type `string?`, which defaults to `null`): set the hue angle degrees expression
+- `s` (of type `string?`, which defaults to `null`): set the saturation expression. (default: 1)
+- `H` (of type `string?`, which defaults to `null`): set the hue angle radians expression
+- `b` (of type `string?`, which defaults to `null`): set the brightness expression. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.huesaturation`
+
+Ffmpeg filter: Apply hue-saturation-intensity adjustments.
+
+Type:
+
+```
+(?hue : float?, ?saturation : float?, ?intensity : float?, ?colors : int?,
+ ?strength : float?, ?rw : float?, ?gw : float?, ?bw : float?,
+ ?lightness : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue shift. (default: 0.)
+- `saturation` (of type `float?`, which defaults to `null`): set the saturation shift. (default: 0.)
+- `intensity` (of type `float?`, which defaults to `null`): set the intensity shift. (default: 0.)
+- `colors` (of type `int?`, which defaults to `null`): set colors range. (default: 63, possible values: 1 (r), 2 (y), 4 (g), 8 (c), 16 (b), 32 (m), 63 (a))
+- `strength` (of type `float?`, which defaults to `null`): set the filtering strength. (default: 1.)
+- `rw` (of type `float?`, which defaults to `null`): set the red weight. (default: 0.333)
+- `gw` (of type `float?`, which defaults to `null`): set the green weight. (default: 0.334)
+- `bw` (of type `float?`, which defaults to `null`): set the blue weight. (default: 0.333)
+- `lightness` (of type `bool?`, which defaults to `null`): set the preserve lightness. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.huesaturation.create`
+
+Ffmpeg filter: Apply hue-saturation-intensity adjustments.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?hue : float?, ?saturation : float?, ?intensity : float?, ?colors : int?,
+ ?strength : float?, ?rw : float?, ?gw : float?, ?bw : float?,
+ ?lightness : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `hue` (of type `float?`, which defaults to `null`): set the hue shift. (default: 0.)
+- `saturation` (of type `float?`, which defaults to `null`): set the saturation shift. (default: 0.)
+- `intensity` (of type `float?`, which defaults to `null`): set the intensity shift. (default: 0.)
+- `colors` (of type `int?`, which defaults to `null`): set colors range. (default: 63, possible values: 1 (r), 2 (y), 4 (g), 8 (c), 16 (b), 32 (m), 63 (a))
+- `strength` (of type `float?`, which defaults to `null`): set the filtering strength. (default: 1.)
+- `rw` (of type `float?`, which defaults to `null`): set the red weight. (default: 0.333)
+- `gw` (of type `float?`, which defaults to `null`): set the green weight. (default: 0.334)
+- `bw` (of type `float?`, which defaults to `null`): set the blue weight. (default: 0.333)
+- `lightness` (of type `bool?`, which defaults to `null`): set the preserve lightness. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hwdownload`
+
+Ffmpeg filter: Download a hardware frame to a normal frame
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hwdownload.create`
+
+Ffmpeg filter: Download a hardware frame to a normal frame. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hwmap`
+
+Ffmpeg filter: Map hardware frames
+
+Type:
+
+```
+(?mode : int?, ?derive_device : string?, ?reverse : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): Frame mapping mode. (default: 3, possible values: 1 (read), 2 (write), 4 (overwrite), 8 (direct))
+- `derive_device` (of type `string?`, which defaults to `null`): Derive a new device of this type
+- `reverse` (of type `int?`, which defaults to `null`): Map in reverse (create and allocate in the sink). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hwmap.create`
+
+Ffmpeg filter: Map hardware frames. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?derive_device : string?, ?reverse : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): Frame mapping mode. (default: 3, possible values: 1 (read), 2 (write), 4 (overwrite), 8 (direct))
+- `derive_device` (of type `string?`, which defaults to `null`): Derive a new device of this type
+- `reverse` (of type `int?`, which defaults to `null`): Map in reverse (create and allocate in the sink). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hwupload`
+
+Ffmpeg filter: Upload a normal frame to a hardware frame
+
+Type:
+
+```
+(?derive_device : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `derive_device` (of type `string?`, which defaults to `null`): Derive a new device of this type
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hwupload.create`
+
+Ffmpeg filter: Upload a normal frame to a hardware frame. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?derive_device : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `derive_device` (of type `string?`, which defaults to `null`): Derive a new device of this type
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hwupload_cuda`
+
+Ffmpeg filter: Upload a system memory frame to a CUDA device.
+
+Type:
+
+```
+(?device : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `device` (of type `int?`, which defaults to `null`): Number of the device to use. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hwupload_cuda.create`
+
+Ffmpeg filter: Upload a system memory frame to a CUDA device.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?device : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `device` (of type `int?`, which defaults to `null`): Number of the device to use. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.hysteresis`
+
+Ffmpeg filter: Grow first stream into second stream by connecting components.
+
+Type:
+
+```
+(?planes : int?, ?threshold : int?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `threshold` (of type `int?`, which defaults to `null`): set threshold. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.hysteresis.create`
+
+Ffmpeg filter: Grow first stream into second stream by connecting components.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?threshold : int?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `threshold` (of type `int?`, which defaults to `null`): set threshold. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.identity`
+
+Ffmpeg filter: Calculate the Identity between two video streams.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.identity.create`
+
+Ffmpeg filter: Calculate the Identity between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.idet`
+
+Ffmpeg filter: Interlace detect Filter.
+
+Type:
+
+```
+(?intl_thres : float?, ?prog_thres : float?, ?rep_thres : float?,
+ ?half_life : float?, ?analyze_interlaced_flag : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `intl_thres` (of type `float?`, which defaults to `null`): set interlacing threshold. (default: 1.04)
+- `prog_thres` (of type `float?`, which defaults to `null`): set progressive threshold. (default: 1.5)
+- `rep_thres` (of type `float?`, which defaults to `null`): set repeat threshold. (default: 3.)
+- `half_life` (of type `float?`, which defaults to `null`): half life of cumulative statistics. (default: 0.)
+- `analyze_interlaced_flag` (of type `int?`, which defaults to `null`): set number of frames to use to determine if the interlace flag is accurate. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.idet.create`
+
+Ffmpeg filter: Interlace detect Filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?intl_thres : float?, ?prog_thres : float?, ?rep_thres : float?,
+ ?half_life : float?, ?analyze_interlaced_flag : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `intl_thres` (of type `float?`, which defaults to `null`): set interlacing threshold. (default: 1.04)
+- `prog_thres` (of type `float?`, which defaults to `null`): set progressive threshold. (default: 1.5)
+- `rep_thres` (of type `float?`, which defaults to `null`): set repeat threshold. (default: 3.)
+- `half_life` (of type `float?`, which defaults to `null`): half life of cumulative statistics. (default: 0.)
+- `analyze_interlaced_flag` (of type `int?`, which defaults to `null`): set number of frames to use to determine if the interlace flag is accurate. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.il`
+
+Ffmpeg filter: Deinterleave or interleave fields.
+
+Type:
+
+```
+(?luma_mode : int?, ?l : int?, ?chroma_mode : int?, ?c : int?,
+ ?alpha_mode : int?, ?a : int?, ?luma_swap : bool?, ?ls : bool?,
+ ?chroma_swap : bool?, ?cs : bool?, ?alpha_swap : bool?, ?as : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_mode` (of type `int?`, which defaults to `null`): select luma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `l` (of type `int?`, which defaults to `null`): select luma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `chroma_mode` (of type `int?`, which defaults to `null`): select chroma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `c` (of type `int?`, which defaults to `null`): select chroma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `alpha_mode` (of type `int?`, which defaults to `null`): select alpha mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `a` (of type `int?`, which defaults to `null`): select alpha mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `luma_swap` (of type `bool?`, which defaults to `null`): swap luma fields. (default: false)
+- `ls` (of type `bool?`, which defaults to `null`): swap luma fields. (default: false)
+- `chroma_swap` (of type `bool?`, which defaults to `null`): swap chroma fields. (default: false)
+- `cs` (of type `bool?`, which defaults to `null`): swap chroma fields. (default: false)
+- `alpha_swap` (of type `bool?`, which defaults to `null`): swap alpha fields. (default: false)
+- `as` (of type `bool?`, which defaults to `null`): swap alpha fields. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.il.create`
+
+Ffmpeg filter: Deinterleave or interleave fields.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_mode : int?, ?l : int?, ?chroma_mode : int?, ?c : int?,
+ ?alpha_mode : int?, ?a : int?, ?luma_swap : bool?, ?ls : bool?,
+ ?chroma_swap : bool?, ?cs : bool?, ?alpha_swap : bool?, ?as : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_mode` (of type `int?`, which defaults to `null`): select luma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `l` (of type `int?`, which defaults to `null`): select luma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `chroma_mode` (of type `int?`, which defaults to `null`): select chroma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `c` (of type `int?`, which defaults to `null`): select chroma mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `alpha_mode` (of type `int?`, which defaults to `null`): select alpha mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `a` (of type `int?`, which defaults to `null`): select alpha mode. (default: 0, possible values: 0 (none), 1 (interleave), 1 (i), 2 (deinterleave), 2 (d))
+- `luma_swap` (of type `bool?`, which defaults to `null`): swap luma fields. (default: false)
+- `ls` (of type `bool?`, which defaults to `null`): swap luma fields. (default: false)
+- `chroma_swap` (of type `bool?`, which defaults to `null`): swap chroma fields. (default: false)
+- `cs` (of type `bool?`, which defaults to `null`): swap chroma fields. (default: false)
+- `alpha_swap` (of type `bool?`, which defaults to `null`): swap alpha fields. (default: false)
+- `as` (of type `bool?`, which defaults to `null`): swap alpha fields. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.inflate`
+
+Ffmpeg filter: Apply inflate effect.
+
+Type:
+
+```
+(?threshold0 : int?, ?threshold1 : int?, ?threshold2 : int?,
+ ?threshold3 : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.inflate.create`
+
+Ffmpeg filter: Apply inflate effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold0 : int?, ?threshold1 : int?, ?threshold2 : int?,
+ ?threshold3 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold0` (of type `int?`, which defaults to `null`): set threshold for 1st plane. (default: 65535)
+- `threshold1` (of type `int?`, which defaults to `null`): set threshold for 2nd plane. (default: 65535)
+- `threshold2` (of type `int?`, which defaults to `null`): set threshold for 3rd plane. (default: 65535)
+- `threshold3` (of type `int?`, which defaults to `null`): set threshold for 4th plane. (default: 65535)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.interlace`
+
+Ffmpeg filter: Convert progressive video into interlaced.
+
+Type:
+
+```
+(?scan : int?, ?lowpass : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `scan` (of type `int?`, which defaults to `null`): scanning mode. (default: 0, possible values: 0 (tff), 1 (bff))
+- `lowpass` (of type `int?`, which defaults to `null`): set vertical low-pass filter. (default: 1, possible values: 0 (off), 1 (linear), 2 (complex))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.interlace.create`
+
+Ffmpeg filter: Convert progressive video into interlaced.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?scan : int?, ?lowpass : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `scan` (of type `int?`, which defaults to `null`): scanning mode. (default: 0, possible values: 0 (tff), 1 (bff))
+- `lowpass` (of type `int?`, which defaults to `null`): set vertical low-pass filter. (default: 1, possible values: 0 (off), 1 (linear), 2 (complex))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.interleave`
+
+Ffmpeg filter: Temporally interleave video inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?nb_inputs : int?, ?n : int?, ?duration : int?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `nb_inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `n` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `duration` (of type `int?`, which defaults to `null`): how to determine the end-of-stream. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.interleave.create`
+
+Ffmpeg filter: Temporally interleave video inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?nb_inputs : int?, ?n : int?, ?duration : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `nb_inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `n` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `duration` (of type `int?`, which defaults to `null`): how to determine the end-of-stream. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.join`
+
+Ffmpeg filter: Join multiple audio streams into multi-channel output. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?channel_layout : string?, ?map : string?,
+ ffmpeg.filter.graph, [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Number of input streams.. (default: 2)
+- `channel_layout` (of type `string?`, which defaults to `null`): Channel layout of the output stream.. (default: stereo)
+- `map` (of type `string?`, which defaults to `null`): A comma-separated list of channels maps in the format 'input_stream.input_channel-output_channel.
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.join.create`
+
+Ffmpeg filter: Join multiple audio streams into multi-channel output. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?channel_layout : string?, ?map : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Number of input streams.. (default: 2)
+- `channel_layout` (of type `string?`, which defaults to `null`): Channel layout of the output stream.. (default: stereo)
+- `map` (of type `string?`, which defaults to `null`): A comma-separated list of channels maps in the format 'input_stream.input_channel-output_channel.
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.kerndeint`
+
+Ffmpeg filter: Apply kernel deinterlacing to the input.
+
+Type:
+
+```
+(?thresh : int?, ?map : bool?, ?order : bool?, ?sharp : bool?,
+ ?twoway : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `thresh` (of type `int?`, which defaults to `null`): set the threshold. (default: 10)
+- `map` (of type `bool?`, which defaults to `null`): set the map. (default: false)
+- `order` (of type `bool?`, which defaults to `null`): set the order. (default: false)
+- `sharp` (of type `bool?`, which defaults to `null`): set sharpening. (default: false)
+- `twoway` (of type `bool?`, which defaults to `null`): set twoway. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.kerndeint.create`
+
+Ffmpeg filter: Apply kernel deinterlacing to the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?thresh : int?, ?map : bool?, ?order : bool?, ?sharp : bool?,
+ ?twoway : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `thresh` (of type `int?`, which defaults to `null`): set the threshold. (default: 10)
+- `map` (of type `bool?`, which defaults to `null`): set the map. (default: false)
+- `order` (of type `bool?`, which defaults to `null`): set the order. (default: false)
+- `sharp` (of type `bool?`, which defaults to `null`): set sharpening. (default: false)
+- `twoway` (of type `bool?`, which defaults to `null`): set twoway. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.kirsch`
+
+Ffmpeg filter: Apply kirsch operator.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.kirsch.create`
+
+Ffmpeg filter: Apply kirsch operator.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ladspa`
+
+Ffmpeg filter: Apply LADSPA effect. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?file : string?, ?f : string?, ?plugin : string?, ?p : string?,
+ ?controls : string?, ?c : string?, ?sample_rate : int?, ?s : int?,
+ ?nb_samples : int?, ?n : int?, ?duration : int?, ?d : int?,
+ ?latency : bool?, ?l : bool?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `file` (of type `string?`, which defaults to `null`): set library name or full path
+- `f` (of type `string?`, which defaults to `null`): set library name or full path
+- `plugin` (of type `string?`, which defaults to `null`): set plugin name
+- `p` (of type `string?`, which defaults to `null`): set plugin name
+- `controls` (of type `string?`, which defaults to `null`): set plugin options
+- `c` (of type `string?`, which defaults to `null`): set plugin options
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `s` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `duration` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `latency` (of type `bool?`, which defaults to `null`): enable latency compensation. (default: false)
+- `l` (of type `bool?`, which defaults to `null`): enable latency compensation. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.ladspa.create`
+
+Ffmpeg filter: Apply LADSPA effect. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?file : string?, ?f : string?, ?plugin : string?, ?p : string?,
+ ?controls : string?, ?c : string?, ?sample_rate : int?, ?s : int?,
+ ?nb_samples : int?, ?n : int?, ?duration : int?, ?d : int?,
+ ?latency : bool?, ?l : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `file` (of type `string?`, which defaults to `null`): set library name or full path
+- `f` (of type `string?`, which defaults to `null`): set library name or full path
+- `plugin` (of type `string?`, which defaults to `null`): set plugin name
+- `p` (of type `string?`, which defaults to `null`): set plugin name
+- `controls` (of type `string?`, which defaults to `null`): set plugin options
+- `c` (of type `string?`, which defaults to `null`): set plugin options
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `s` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `duration` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `latency` (of type `bool?`, which defaults to `null`): enable latency compensation. (default: false)
+- `l` (of type `bool?`, which defaults to `null`): enable latency compensation. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lagfun`
+
+Ffmpeg filter: Slowly update darker pixels.
+
+Type:
+
+```
+(?decay : float?, ?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `decay` (of type `float?`, which defaults to `null`): set decay. (default: 0.95)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lagfun.create`
+
+Ffmpeg filter: Slowly update darker pixels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?decay : float?, ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `decay` (of type `float?`, which defaults to `null`): set decay. (default: 0.95)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.latency`
+
+Ffmpeg filter: Report video filtering latency.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.latency.create`
+
+Ffmpeg filter: Report video filtering latency.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lenscorrection`
+
+Ffmpeg filter: Rectify the image by correcting for lens distortion.
+
+Type:
+
+```
+(?cx : float?, ?cy : float?, ?k1 : float?, ?k2 : float?, ?i : int?,
+ ?fc : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cx` (of type `float?`, which defaults to `null`): set relative center x. (default: 0.5)
+- `cy` (of type `float?`, which defaults to `null`): set relative center y. (default: 0.5)
+- `k1` (of type `float?`, which defaults to `null`): set quadratic distortion factor. (default: 0.)
+- `k2` (of type `float?`, which defaults to `null`): set double quadratic distortion factor. (default: 0.)
+- `i` (of type `int?`, which defaults to `null`): set interpolation type. (default: 0, possible values: 0 (nearest), 1 (bilinear))
+- `fc` (of type `string?`, which defaults to `null`): set the color of the unmapped pixels. (default: black@0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lenscorrection.create`
+
+Ffmpeg filter: Rectify the image by correcting for lens distortion.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cx : float?, ?cy : float?, ?k1 : float?, ?k2 : float?, ?i : int?,
+ ?fc : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cx` (of type `float?`, which defaults to `null`): set relative center x. (default: 0.5)
+- `cy` (of type `float?`, which defaults to `null`): set relative center y. (default: 0.5)
+- `k1` (of type `float?`, which defaults to `null`): set quadratic distortion factor. (default: 0.)
+- `k2` (of type `float?`, which defaults to `null`): set double quadratic distortion factor. (default: 0.)
+- `i` (of type `int?`, which defaults to `null`): set interpolation type. (default: 0, possible values: 0 (nearest), 1 (bilinear))
+- `fc` (of type `string?`, which defaults to `null`): set the color of the unmapped pixels. (default: black@0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.libplacebo`
+
+Ffmpeg filter: Apply various GPU filters from libplacebo This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?w : string?, ?h : string?, ?fps : string?,
+ ?crop_x : string?, ?crop_y : string?, ?crop_w : string?, ?crop_h : string?,
+ ?pos_x : string?, ?pos_y : string?, ?pos_w : string?, ?pos_h : string?,
+ ?format : string?, ?force_original_aspect_ratio : int?,
+ ?force_divisible_by : int?, ?normalize_sar : bool?,
+ ?pad_crop_ratio : float?, ?fillcolor : string?, ?corner_rounding : float?,
+ ?extra_opts : string?, ?colorspace : int?, ?range : int?,
+ ?color_primaries : int?, ?color_trc : int?, ?upscaler : string?,
+ ?downscaler : string?, ?frame_mixer : string?, ?lut_entries : int?,
+ ?antiringing : float?, ?sigmoid : bool?, ?apply_filmgrain : bool?,
+ ?apply_dolbyvision : bool?, ?deband : bool?, ?deband_iterations : int?,
+ ?deband_threshold : float?, ?deband_radius : float?, ?deband_grain : float?,
+ ?brightness : float?, ?contrast : float?, ?saturation : float?,
+ ?hue : float?, ?gamma : float?, ?peak_detect : bool?,
+ ?smoothing_period : float?, ?minimum_peak : float?,
+ ?scene_threshold_low : float?, ?scene_threshold_high : float?,
+ ?percentile : float?, ?gamut_mode : int?, ?tonemapping : int?,
+ ?tonemapping_param : float?, ?inverse_tonemapping : bool?,
+ ?tonemapping_lut_size : int?, ?contrast_recovery : float?,
+ ?contrast_smoothness : float?, ?desaturation_strength : float?,
+ ?desaturation_exponent : float?, ?gamut_warning : bool?,
+ ?gamut_clipping : bool?, ?intent : int?, ?tonemapping_mode : int?,
+ ?tonemapping_crosstalk : float?, ?overshoot : float?, ?hybrid_mix : float?,
+ ?dithering : int?, ?dither_lut_size : int?, ?dither_temporal : bool?,
+ ?cones : int?, ?cone-strength : float?, ?custom_shader_path : string?,
+ ?custom_shader_bin : string?, ?skip_aa : bool?, ?polar_cutoff : float?,
+ ?disable_linear : bool?, ?disable_builtin : bool?, ?force_icc_lut : bool?,
+ ?force_dither : bool?, ?disable_fbos : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Number of inputs. (default: 1)
+- `w` (of type `string?`, which defaults to `null`): Output video frame width. (default: iw)
+- `h` (of type `string?`, which defaults to `null`): Output video frame height. (default: ih)
+- `fps` (of type `string?`, which defaults to `null`): Output video frame rate. (default: none)
+- `crop_x` (of type `string?`, which defaults to `null`): Input video crop x. (default: (iw-cw)/2)
+- `crop_y` (of type `string?`, which defaults to `null`): Input video crop y. (default: (ih-ch)/2)
+- `crop_w` (of type `string?`, which defaults to `null`): Input video crop w. (default: iw)
+- `crop_h` (of type `string?`, which defaults to `null`): Input video crop h. (default: ih)
+- `pos_x` (of type `string?`, which defaults to `null`): Output video placement x. (default: (ow-pw)/2)
+- `pos_y` (of type `string?`, which defaults to `null`): Output video placement y. (default: (oh-ph)/2)
+- `pos_w` (of type `string?`, which defaults to `null`): Output video placement w. (default: ow)
+- `pos_h` (of type `string?`, which defaults to `null`): Output video placement h. (default: oh)
+- `format` (of type `string?`, which defaults to `null`): Output video format
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `normalize_sar` (of type `bool?`, which defaults to `null`): force SAR normalization to 1:1 by adjusting pos_x/y/w/h. (default: false)
+- `pad_crop_ratio` (of type `float?`, which defaults to `null`): ratio between padding and cropping when normalizing SAR (0=pad, 1=crop). (default: 0.)
+- `fillcolor` (of type `string?`, which defaults to `null`): Background fill color. (default: black)
+- `corner_rounding` (of type `float?`, which defaults to `null`): Corner rounding radius. (default: 0.)
+- `extra_opts` (of type `string?`, which defaults to `null`): Pass extra libplacebo-specific options using a :-separated list of key=value pairs
+- `colorspace` (of type `int?`, which defaults to `null`): select colorspace. (default: -1, possible values: -1 (auto), 0 (gbr), 1 (bt709), 2 (unknown), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 14 (ictcp))
+- `range` (of type `int?`, which defaults to `null`): select color range. (default: -1, possible values: -1 (auto), 0 (unspecified), 0 (unknown), 1 (limited), 1 (tv), 1 (mpeg), 2 (full), 2 (pc), 2 (jpeg))
+- `color_primaries` (of type `int?`, which defaults to `null`): select color primaries. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `color_trc` (of type `int?`, which defaults to `null`): select color transfer. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (linear), 11 (iec61966-2-4), 12 (bt1361e), 13 (iec61966-2-1), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 18 (arib-std-b67))
+- `upscaler` (of type `string?`, which defaults to `null`): Upscaler function. (default: spline36)
+- `downscaler` (of type `string?`, which defaults to `null`): Downscaler function. (default: mitchell)
+- `frame_mixer` (of type `string?`, which defaults to `null`): Frame mixing function. (default: none)
+- `lut_entries` (of type `int?`, which defaults to `null`): Number of scaler LUT entries. (default: 0)
+- `antiringing` (of type `float?`, which defaults to `null`): Antiringing strength (for non-EWA filters). (default: 0.)
+- `sigmoid` (of type `bool?`, which defaults to `null`): Enable sigmoid upscaling. (default: true)
+- `apply_filmgrain` (of type `bool?`, which defaults to `null`): Apply film grain metadata. (default: true)
+- `apply_dolbyvision` (of type `bool?`, which defaults to `null`): Apply Dolby Vision metadata. (default: true)
+- `deband` (of type `bool?`, which defaults to `null`): Enable debanding. (default: false)
+- `deband_iterations` (of type `int?`, which defaults to `null`): Deband iterations. (default: 1)
+- `deband_threshold` (of type `float?`, which defaults to `null`): Deband threshold. (default: 4.)
+- `deband_radius` (of type `float?`, which defaults to `null`): Deband radius. (default: 16.)
+- `deband_grain` (of type `float?`, which defaults to `null`): Deband grain. (default: 6.)
+- `brightness` (of type `float?`, which defaults to `null`): Brightness boost. (default: 0.)
+- `contrast` (of type `float?`, which defaults to `null`): Contrast gain. (default: 1.)
+- `saturation` (of type `float?`, which defaults to `null`): Saturation gain. (default: 1.)
+- `hue` (of type `float?`, which defaults to `null`): Hue shift. (default: 0.)
+- `gamma` (of type `float?`, which defaults to `null`): Gamma adjustment. (default: 1.)
+- `peak_detect` (of type `bool?`, which defaults to `null`): Enable dynamic peak detection for HDR tone-mapping. (default: true)
+- `smoothing_period` (of type `float?`, which defaults to `null`): Peak detection smoothing period. (default: 100.)
+- `minimum_peak` (of type `float?`, which defaults to `null`): Peak detection minimum peak. (default: 1.)
+- `scene_threshold_low` (of type `float?`, which defaults to `null`): Scene change low threshold. (default: 5.5)
+- `scene_threshold_high` (of type `float?`, which defaults to `null`): Scene change high threshold. (default: 10.)
+- `percentile` (of type `float?`, which defaults to `null`): Peak detection percentile. (default: 99.995)
+- `gamut_mode` (of type `int?`, which defaults to `null`): Gamut-mapping mode. (default: 1, possible values: 0 (clip), 1 (perceptual), 2 (relative), 3 (saturation), 4 (absolute), 5 (desaturate), 6 (darken), 7 (warn), 8 (linear))
+- `tonemapping` (of type `int?`, which defaults to `null`): Tone-mapping algorithm. (default: 0, possible values: 0 (auto), 1 (clip), 2 (st2094-40), 3 (st2094-10), 4 (bt.2390), 5 (bt.2446a), 6 (spline), 7 (reinhard), 8 (mobius), 9 (hable), 10 (gamma), 11 (linear))
+- `tonemapping_param` (of type `float?`, which defaults to `null`): Tunable parameter for some tone-mapping functions. (default: 0.)
+- `inverse_tonemapping` (of type `bool?`, which defaults to `null`): Inverse tone mapping (range expansion). (default: false)
+- `tonemapping_lut_size` (of type `int?`, which defaults to `null`): Tone-mapping LUT size. (default: 256)
+- `contrast_recovery` (of type `float?`, which defaults to `null`): HDR contrast recovery strength. (default: 0.3)
+- `contrast_smoothness` (of type `float?`, which defaults to `null`): HDR contrast recovery smoothness. (default: 3.5)
+- `desaturation_strength` (of type `float?`, which defaults to `null`): Desaturation strength. (default: -1.)
+- `desaturation_exponent` (of type `float?`, which defaults to `null`): Desaturation exponent. (default: -1.)
+- `gamut_warning` (of type `bool?`, which defaults to `null`): Highlight out-of-gamut colors. (default: false)
+- `gamut_clipping` (of type `bool?`, which defaults to `null`): Enable desaturating colorimetric gamut clipping. (default: false)
+- `intent` (of type `int?`, which defaults to `null`): Rendering intent. (default: 0, possible values: 0 (perceptual), 1 (relative), 3 (absolute), 2 (saturation))
+- `tonemapping_mode` (of type `int?`, which defaults to `null`): Tone-mapping mode. (default: 0, possible values: 0 (auto), 1 (rgb), 2 (max), 3 (hybrid), 4 (luma))
+- `tonemapping_crosstalk` (of type `float?`, which defaults to `null`): Crosstalk factor for tone-mapping. (default: 0.04)
+- `overshoot` (of type `float?`, which defaults to `null`): Tone-mapping overshoot margin. (default: 0.05)
+- `hybrid_mix` (of type `float?`, which defaults to `null`): Tone-mapping hybrid LMS mixing coefficient. (default: 0.2)
+- `dithering` (of type `int?`, which defaults to `null`): Dither method to use. (default: 0, possible values: -1 (none), 0 (blue), 1 (ordered), 2 (ordered_fixed), 3 (white))
+- `dither_lut_size` (of type `int?`, which defaults to `null`): Dithering LUT size. (default: 6)
+- `dither_temporal` (of type `bool?`, which defaults to `null`): Enable temporal dithering. (default: false)
+- `cones` (of type `int?`, which defaults to `null`): Colorblindness adaptation model. (default: 0, possible values: 1 (l), 2 (m), 4 (s))
+- `cone-strength` (of type `float?`, which defaults to `null`): Colorblindness adaptation strength. (default: 0.)
+- `custom_shader_path` (of type `string?`, which defaults to `null`): Path to custom user shader (mpv .hook format)
+- `custom_shader_bin` (of type `string?`, which defaults to `null`): Custom user shader as binary (mpv .hook format)
+- `skip_aa` (of type `bool?`, which defaults to `null`): Skip anti-aliasing. (default: false)
+- `polar_cutoff` (of type `float?`, which defaults to `null`): Polar LUT cutoff. (default: 0.)
+- `disable_linear` (of type `bool?`, which defaults to `null`): Disable linear scaling. (default: false)
+- `disable_builtin` (of type `bool?`, which defaults to `null`): Disable built-in scalers. (default: false)
+- `force_icc_lut` (of type `bool?`, which defaults to `null`): Deprecated, does nothing. (default: false)
+- `force_dither` (of type `bool?`, which defaults to `null`): Force dithering. (default: false)
+- `disable_fbos` (of type `bool?`, which defaults to `null`): Force-disable FBOs. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.libplacebo.create`
+
+Ffmpeg filter: Apply various GPU filters from libplacebo This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?w : string?, ?h : string?, ?fps : string?,
+ ?crop_x : string?, ?crop_y : string?, ?crop_w : string?, ?crop_h : string?,
+ ?pos_x : string?, ?pos_y : string?, ?pos_w : string?, ?pos_h : string?,
+ ?format : string?, ?force_original_aspect_ratio : int?,
+ ?force_divisible_by : int?, ?normalize_sar : bool?,
+ ?pad_crop_ratio : float?, ?fillcolor : string?, ?corner_rounding : float?,
+ ?extra_opts : string?, ?colorspace : int?, ?range : int?,
+ ?color_primaries : int?, ?color_trc : int?, ?upscaler : string?,
+ ?downscaler : string?, ?frame_mixer : string?, ?lut_entries : int?,
+ ?antiringing : float?, ?sigmoid : bool?, ?apply_filmgrain : bool?,
+ ?apply_dolbyvision : bool?, ?deband : bool?, ?deband_iterations : int?,
+ ?deband_threshold : float?, ?deband_radius : float?, ?deband_grain : float?,
+ ?brightness : float?, ?contrast : float?, ?saturation : float?,
+ ?hue : float?, ?gamma : float?, ?peak_detect : bool?,
+ ?smoothing_period : float?, ?minimum_peak : float?,
+ ?scene_threshold_low : float?, ?scene_threshold_high : float?,
+ ?percentile : float?, ?gamut_mode : int?, ?tonemapping : int?,
+ ?tonemapping_param : float?, ?inverse_tonemapping : bool?,
+ ?tonemapping_lut_size : int?, ?contrast_recovery : float?,
+ ?contrast_smoothness : float?, ?desaturation_strength : float?,
+ ?desaturation_exponent : float?, ?gamut_warning : bool?,
+ ?gamut_clipping : bool?, ?intent : int?, ?tonemapping_mode : int?,
+ ?tonemapping_crosstalk : float?, ?overshoot : float?, ?hybrid_mix : float?,
+ ?dithering : int?, ?dither_lut_size : int?, ?dither_temporal : bool?,
+ ?cones : int?, ?cone-strength : float?, ?custom_shader_path : string?,
+ ?custom_shader_bin : string?, ?skip_aa : bool?, ?polar_cutoff : float?,
+ ?disable_linear : bool?, ?disable_builtin : bool?, ?force_icc_lut : bool?,
+ ?force_dither : bool?, ?disable_fbos : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Number of inputs. (default: 1)
+- `w` (of type `string?`, which defaults to `null`): Output video frame width. (default: iw)
+- `h` (of type `string?`, which defaults to `null`): Output video frame height. (default: ih)
+- `fps` (of type `string?`, which defaults to `null`): Output video frame rate. (default: none)
+- `crop_x` (of type `string?`, which defaults to `null`): Input video crop x. (default: (iw-cw)/2)
+- `crop_y` (of type `string?`, which defaults to `null`): Input video crop y. (default: (ih-ch)/2)
+- `crop_w` (of type `string?`, which defaults to `null`): Input video crop w. (default: iw)
+- `crop_h` (of type `string?`, which defaults to `null`): Input video crop h. (default: ih)
+- `pos_x` (of type `string?`, which defaults to `null`): Output video placement x. (default: (ow-pw)/2)
+- `pos_y` (of type `string?`, which defaults to `null`): Output video placement y. (default: (oh-ph)/2)
+- `pos_w` (of type `string?`, which defaults to `null`): Output video placement w. (default: ow)
+- `pos_h` (of type `string?`, which defaults to `null`): Output video placement h. (default: oh)
+- `format` (of type `string?`, which defaults to `null`): Output video format
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `normalize_sar` (of type `bool?`, which defaults to `null`): force SAR normalization to 1:1 by adjusting pos_x/y/w/h. (default: false)
+- `pad_crop_ratio` (of type `float?`, which defaults to `null`): ratio between padding and cropping when normalizing SAR (0=pad, 1=crop). (default: 0.)
+- `fillcolor` (of type `string?`, which defaults to `null`): Background fill color. (default: black)
+- `corner_rounding` (of type `float?`, which defaults to `null`): Corner rounding radius. (default: 0.)
+- `extra_opts` (of type `string?`, which defaults to `null`): Pass extra libplacebo-specific options using a :-separated list of key=value pairs
+- `colorspace` (of type `int?`, which defaults to `null`): select colorspace. (default: -1, possible values: -1 (auto), 0 (gbr), 1 (bt709), 2 (unknown), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 14 (ictcp))
+- `range` (of type `int?`, which defaults to `null`): select color range. (default: -1, possible values: -1 (auto), 0 (unspecified), 0 (unknown), 1 (limited), 1 (tv), 1 (mpeg), 2 (full), 2 (pc), 2 (jpeg))
+- `color_primaries` (of type `int?`, which defaults to `null`): select color primaries. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `color_trc` (of type `int?`, which defaults to `null`): select color transfer. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (linear), 11 (iec61966-2-4), 12 (bt1361e), 13 (iec61966-2-1), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 18 (arib-std-b67))
+- `upscaler` (of type `string?`, which defaults to `null`): Upscaler function. (default: spline36)
+- `downscaler` (of type `string?`, which defaults to `null`): Downscaler function. (default: mitchell)
+- `frame_mixer` (of type `string?`, which defaults to `null`): Frame mixing function. (default: none)
+- `lut_entries` (of type `int?`, which defaults to `null`): Number of scaler LUT entries. (default: 0)
+- `antiringing` (of type `float?`, which defaults to `null`): Antiringing strength (for non-EWA filters). (default: 0.)
+- `sigmoid` (of type `bool?`, which defaults to `null`): Enable sigmoid upscaling. (default: true)
+- `apply_filmgrain` (of type `bool?`, which defaults to `null`): Apply film grain metadata. (default: true)
+- `apply_dolbyvision` (of type `bool?`, which defaults to `null`): Apply Dolby Vision metadata. (default: true)
+- `deband` (of type `bool?`, which defaults to `null`): Enable debanding. (default: false)
+- `deband_iterations` (of type `int?`, which defaults to `null`): Deband iterations. (default: 1)
+- `deband_threshold` (of type `float?`, which defaults to `null`): Deband threshold. (default: 4.)
+- `deband_radius` (of type `float?`, which defaults to `null`): Deband radius. (default: 16.)
+- `deband_grain` (of type `float?`, which defaults to `null`): Deband grain. (default: 6.)
+- `brightness` (of type `float?`, which defaults to `null`): Brightness boost. (default: 0.)
+- `contrast` (of type `float?`, which defaults to `null`): Contrast gain. (default: 1.)
+- `saturation` (of type `float?`, which defaults to `null`): Saturation gain. (default: 1.)
+- `hue` (of type `float?`, which defaults to `null`): Hue shift. (default: 0.)
+- `gamma` (of type `float?`, which defaults to `null`): Gamma adjustment. (default: 1.)
+- `peak_detect` (of type `bool?`, which defaults to `null`): Enable dynamic peak detection for HDR tone-mapping. (default: true)
+- `smoothing_period` (of type `float?`, which defaults to `null`): Peak detection smoothing period. (default: 100.)
+- `minimum_peak` (of type `float?`, which defaults to `null`): Peak detection minimum peak. (default: 1.)
+- `scene_threshold_low` (of type `float?`, which defaults to `null`): Scene change low threshold. (default: 5.5)
+- `scene_threshold_high` (of type `float?`, which defaults to `null`): Scene change high threshold. (default: 10.)
+- `percentile` (of type `float?`, which defaults to `null`): Peak detection percentile. (default: 99.995)
+- `gamut_mode` (of type `int?`, which defaults to `null`): Gamut-mapping mode. (default: 1, possible values: 0 (clip), 1 (perceptual), 2 (relative), 3 (saturation), 4 (absolute), 5 (desaturate), 6 (darken), 7 (warn), 8 (linear))
+- `tonemapping` (of type `int?`, which defaults to `null`): Tone-mapping algorithm. (default: 0, possible values: 0 (auto), 1 (clip), 2 (st2094-40), 3 (st2094-10), 4 (bt.2390), 5 (bt.2446a), 6 (spline), 7 (reinhard), 8 (mobius), 9 (hable), 10 (gamma), 11 (linear))
+- `tonemapping_param` (of type `float?`, which defaults to `null`): Tunable parameter for some tone-mapping functions. (default: 0.)
+- `inverse_tonemapping` (of type `bool?`, which defaults to `null`): Inverse tone mapping (range expansion). (default: false)
+- `tonemapping_lut_size` (of type `int?`, which defaults to `null`): Tone-mapping LUT size. (default: 256)
+- `contrast_recovery` (of type `float?`, which defaults to `null`): HDR contrast recovery strength. (default: 0.3)
+- `contrast_smoothness` (of type `float?`, which defaults to `null`): HDR contrast recovery smoothness. (default: 3.5)
+- `desaturation_strength` (of type `float?`, which defaults to `null`): Desaturation strength. (default: -1.)
+- `desaturation_exponent` (of type `float?`, which defaults to `null`): Desaturation exponent. (default: -1.)
+- `gamut_warning` (of type `bool?`, which defaults to `null`): Highlight out-of-gamut colors. (default: false)
+- `gamut_clipping` (of type `bool?`, which defaults to `null`): Enable desaturating colorimetric gamut clipping. (default: false)
+- `intent` (of type `int?`, which defaults to `null`): Rendering intent. (default: 0, possible values: 0 (perceptual), 1 (relative), 3 (absolute), 2 (saturation))
+- `tonemapping_mode` (of type `int?`, which defaults to `null`): Tone-mapping mode. (default: 0, possible values: 0 (auto), 1 (rgb), 2 (max), 3 (hybrid), 4 (luma))
+- `tonemapping_crosstalk` (of type `float?`, which defaults to `null`): Crosstalk factor for tone-mapping. (default: 0.04)
+- `overshoot` (of type `float?`, which defaults to `null`): Tone-mapping overshoot margin. (default: 0.05)
+- `hybrid_mix` (of type `float?`, which defaults to `null`): Tone-mapping hybrid LMS mixing coefficient. (default: 0.2)
+- `dithering` (of type `int?`, which defaults to `null`): Dither method to use. (default: 0, possible values: -1 (none), 0 (blue), 1 (ordered), 2 (ordered_fixed), 3 (white))
+- `dither_lut_size` (of type `int?`, which defaults to `null`): Dithering LUT size. (default: 6)
+- `dither_temporal` (of type `bool?`, which defaults to `null`): Enable temporal dithering. (default: false)
+- `cones` (of type `int?`, which defaults to `null`): Colorblindness adaptation model. (default: 0, possible values: 1 (l), 2 (m), 4 (s))
+- `cone-strength` (of type `float?`, which defaults to `null`): Colorblindness adaptation strength. (default: 0.)
+- `custom_shader_path` (of type `string?`, which defaults to `null`): Path to custom user shader (mpv .hook format)
+- `custom_shader_bin` (of type `string?`, which defaults to `null`): Custom user shader as binary (mpv .hook format)
+- `skip_aa` (of type `bool?`, which defaults to `null`): Skip anti-aliasing. (default: false)
+- `polar_cutoff` (of type `float?`, which defaults to `null`): Polar LUT cutoff. (default: 0.)
+- `disable_linear` (of type `bool?`, which defaults to `null`): Disable linear scaling. (default: false)
+- `disable_builtin` (of type `bool?`, which defaults to `null`): Disable built-in scalers. (default: false)
+- `force_icc_lut` (of type `bool?`, which defaults to `null`): Deprecated, does nothing. (default: false)
+- `force_dither` (of type `bool?`, which defaults to `null`): Force dithering. (default: false)
+- `disable_fbos` (of type `bool?`, which defaults to `null`): Force-disable FBOs. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.libvmaf`
+
+Ffmpeg filter: Calculate the VMAF between two video streams.
+
+Type:
+
+```
+(?log_path : string?, ?log_fmt : string?, ?pool : string?, ?n_threads : int?,
+ ?n_subsample : int?, ?model : string?, ?feature : string?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `log_path` (of type `string?`, which defaults to `null`): Set the file path to be used to write log.
+- `log_fmt` (of type `string?`, which defaults to `null`): Set the format of the log (csv, json, xml, or sub).. (default: xml)
+- `pool` (of type `string?`, which defaults to `null`): Set the pool method to be used for computing vmaf.
+- `n_threads` (of type `int?`, which defaults to `null`): Set number of threads to be used when computing vmaf.. (default: 0)
+- `n_subsample` (of type `int?`, which defaults to `null`): Set interval for frame subsampling used when computing vmaf.. (default: 1)
+- `model` (of type `string?`, which defaults to `null`): Set the model to be used for computing vmaf.. (default: version=vmaf_v0.6.1)
+- `feature` (of type `string?`, which defaults to `null`): Set the feature to be used for computing vmaf.
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.libvmaf.create`
+
+Ffmpeg filter: Calculate the VMAF between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?log_path : string?, ?log_fmt : string?, ?pool : string?, ?n_threads : int?,
+ ?n_subsample : int?, ?model : string?, ?feature : string?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `log_path` (of type `string?`, which defaults to `null`): Set the file path to be used to write log.
+- `log_fmt` (of type `string?`, which defaults to `null`): Set the format of the log (csv, json, xml, or sub).. (default: xml)
+- `pool` (of type `string?`, which defaults to `null`): Set the pool method to be used for computing vmaf.
+- `n_threads` (of type `int?`, which defaults to `null`): Set number of threads to be used when computing vmaf.. (default: 0)
+- `n_subsample` (of type `int?`, which defaults to `null`): Set interval for frame subsampling used when computing vmaf.. (default: 1)
+- `model` (of type `string?`, which defaults to `null`): Set the model to be used for computing vmaf.. (default: version=vmaf_v0.6.1)
+- `feature` (of type `string?`, which defaults to `null`): Set the feature to be used for computing vmaf.
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.life`
+
+Ffmpeg filter: Create life.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ?rule : string?, ?random_fill_ratio : float?,
+ ?ratio : float?, ?random_seed : int?, ?seed : int?, ?stitch : bool?,
+ ?mold : int?, ?life_color : string?, ?death_color : string?,
+ ?mold_color : string?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set source file
+- `f` (of type `string?`, which defaults to `null`): set source file
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `rule` (of type `string?`, which defaults to `null`): set rule. (default: B3/S23)
+- `random_fill_ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `random_seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `stitch` (of type `bool?`, which defaults to `null`): stitch boundaries. (default: true)
+- `mold` (of type `int?`, which defaults to `null`): set mold speed for dead cells. (default: 0)
+- `life_color` (of type `string?`, which defaults to `null`): set life color. (default: white)
+- `death_color` (of type `string?`, which defaults to `null`): set death color. (default: black)
+- `mold_color` (of type `string?`, which defaults to `null`): set mold color. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.life.create`
+
+Ffmpeg filter: Create life.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?size : string?, ?s : string?,
+ ?rate : string?, ?r : string?, ?rule : string?, ?random_fill_ratio : float?,
+ ?ratio : float?, ?random_seed : int?, ?seed : int?, ?stitch : bool?,
+ ?mold : int?, ?life_color : string?, ?death_color : string?,
+ ?mold_color : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set source file
+- `f` (of type `string?`, which defaults to `null`): set source file
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `rule` (of type `string?`, which defaults to `null`): set rule. (default: B3/S23)
+- `random_fill_ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `ratio` (of type `float?`, which defaults to `null`): set fill ratio for filling initial grid randomly. (default: 0.61803398875)
+- `random_seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `seed` (of type `int?`, which defaults to `null`): set the seed for filling the initial grid randomly. (default: -1)
+- `stitch` (of type `bool?`, which defaults to `null`): stitch boundaries. (default: true)
+- `mold` (of type `int?`, which defaults to `null`): set mold speed for dead cells. (default: 0)
+- `life_color` (of type `string?`, which defaults to `null`): set life color. (default: white)
+- `death_color` (of type `string?`, which defaults to `null`): set death color. (default: black)
+- `mold_color` (of type `string?`, which defaults to `null`): set mold color. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.limitdiff`
+
+Ffmpeg filter: Apply filtering with limiting difference. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?threshold : float?, ?elasticity : float?, ?reference : bool?,
+ ?planes : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold. (default: 0.00392156885937)
+- `elasticity` (of type `float?`, which defaults to `null`): set the elasticity. (default: 2.)
+- `reference` (of type `bool?`, which defaults to `null`): enable reference stream. (default: false)
+- `planes` (of type `int?`, which defaults to `null`): set the planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.limitdiff.create`
+
+Ffmpeg filter: Apply filtering with limiting difference. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : float?, ?elasticity : float?, ?reference : bool?,
+ ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold. (default: 0.00392156885937)
+- `elasticity` (of type `float?`, which defaults to `null`): set the elasticity. (default: 2.)
+- `reference` (of type `bool?`, which defaults to `null`): enable reference stream. (default: false)
+- `planes` (of type `int?`, which defaults to `null`): set the planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.limiter`
+
+Ffmpeg filter: Limit pixels components to the specified range.
+
+Type:
+
+```
+(?min : int?, ?max : int?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `min` (of type `int?`, which defaults to `null`): set min value. (default: 0)
+- `max` (of type `int?`, which defaults to `null`): set max value. (default: 65535)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.limiter.create`
+
+Ffmpeg filter: Limit pixels components to the specified range.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?min : int?, ?max : int?, ?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `min` (of type `int?`, which defaults to `null`): set min value. (default: 0)
+- `max` (of type `int?`, which defaults to `null`): set max value. (default: 65535)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.loop`
+
+Ffmpeg filter: Loop video frames.
+
+Type:
+
+```
+(?loop : int?, ?size : int?, ?start : int?, ?time : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `loop` (of type `int?`, which defaults to `null`): number of loops. (default: 0)
+- `size` (of type `int?`, which defaults to `null`): max number of frames to loop. (default: 0)
+- `start` (of type `int?`, which defaults to `null`): set the loop start frame. (default: 0)
+- `time` (of type `int?`, which defaults to `null`): set the loop start time. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.loop.create`
+
+Ffmpeg filter: Loop video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?loop : int?, ?size : int?, ?start : int?, ?time : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `loop` (of type `int?`, which defaults to `null`): number of loops. (default: 0)
+- `size` (of type `int?`, which defaults to `null`): max number of frames to loop. (default: 0)
+- `start` (of type `int?`, which defaults to `null`): set the loop start frame. (default: 0)
+- `time` (of type `int?`, which defaults to `null`): set the loop start time. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.loudnorm`
+
+Ffmpeg filter: EBU R128 loudness normalization
+
+Type:
+
+```
+(?I : float?, ?i : float?, ?LRA : float?, ?lra : float?, ?TP : float?,
+ ?tp : float?, ?measured_I : float?, ?measured_i : float?,
+ ?measured_LRA : float?, ?measured_lra : float?, ?measured_TP : float?,
+ ?measured_tp : float?, ?measured_thresh : float?, ?offset : float?,
+ ?linear : bool?, ?dual_mono : bool?, ?print_format : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `I` (of type `float?`, which defaults to `null`): set integrated loudness target. (default: -24.)
+- `i` (of type `float?`, which defaults to `null`): set integrated loudness target. (default: -24.)
+- `LRA` (of type `float?`, which defaults to `null`): set loudness range target. (default: 7.)
+- `lra` (of type `float?`, which defaults to `null`): set loudness range target. (default: 7.)
+- `TP` (of type `float?`, which defaults to `null`): set maximum true peak. (default: -2.)
+- `tp` (of type `float?`, which defaults to `null`): set maximum true peak. (default: -2.)
+- `measured_I` (of type `float?`, which defaults to `null`): measured IL of input file. (default: 0.)
+- `measured_i` (of type `float?`, which defaults to `null`): measured IL of input file. (default: 0.)
+- `measured_LRA` (of type `float?`, which defaults to `null`): measured LRA of input file. (default: 0.)
+- `measured_lra` (of type `float?`, which defaults to `null`): measured LRA of input file. (default: 0.)
+- `measured_TP` (of type `float?`, which defaults to `null`): measured true peak of input file. (default: 99.)
+- `measured_tp` (of type `float?`, which defaults to `null`): measured true peak of input file. (default: 99.)
+- `measured_thresh` (of type `float?`, which defaults to `null`): measured threshold of input file. (default: -70.)
+- `offset` (of type `float?`, which defaults to `null`): set offset gain. (default: 0.)
+- `linear` (of type `bool?`, which defaults to `null`): normalize linearly if possible. (default: true)
+- `dual_mono` (of type `bool?`, which defaults to `null`): treat mono input as dual-mono. (default: false)
+- `print_format` (of type `int?`, which defaults to `null`): set print format for stats. (default: 0, possible values: 0 (none), 1 (json), 2 (summary))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.loudnorm.create`
+
+Ffmpeg filter: EBU R128 loudness normalization. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?I : float?, ?i : float?, ?LRA : float?, ?lra : float?, ?TP : float?,
+ ?tp : float?, ?measured_I : float?, ?measured_i : float?,
+ ?measured_LRA : float?, ?measured_lra : float?, ?measured_TP : float?,
+ ?measured_tp : float?, ?measured_thresh : float?, ?offset : float?,
+ ?linear : bool?, ?dual_mono : bool?, ?print_format : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `I` (of type `float?`, which defaults to `null`): set integrated loudness target. (default: -24.)
+- `i` (of type `float?`, which defaults to `null`): set integrated loudness target. (default: -24.)
+- `LRA` (of type `float?`, which defaults to `null`): set loudness range target. (default: 7.)
+- `lra` (of type `float?`, which defaults to `null`): set loudness range target. (default: 7.)
+- `TP` (of type `float?`, which defaults to `null`): set maximum true peak. (default: -2.)
+- `tp` (of type `float?`, which defaults to `null`): set maximum true peak. (default: -2.)
+- `measured_I` (of type `float?`, which defaults to `null`): measured IL of input file. (default: 0.)
+- `measured_i` (of type `float?`, which defaults to `null`): measured IL of input file. (default: 0.)
+- `measured_LRA` (of type `float?`, which defaults to `null`): measured LRA of input file. (default: 0.)
+- `measured_lra` (of type `float?`, which defaults to `null`): measured LRA of input file. (default: 0.)
+- `measured_TP` (of type `float?`, which defaults to `null`): measured true peak of input file. (default: 99.)
+- `measured_tp` (of type `float?`, which defaults to `null`): measured true peak of input file. (default: 99.)
+- `measured_thresh` (of type `float?`, which defaults to `null`): measured threshold of input file. (default: -70.)
+- `offset` (of type `float?`, which defaults to `null`): set offset gain. (default: 0.)
+- `linear` (of type `bool?`, which defaults to `null`): normalize linearly if possible. (default: true)
+- `dual_mono` (of type `bool?`, which defaults to `null`): treat mono input as dual-mono. (default: false)
+- `print_format` (of type `int?`, which defaults to `null`): set print format for stats. (default: 0, possible values: 0 (none), 1 (json), 2 (summary))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lowpass`
+
+Ffmpeg filter: Apply a low-pass filter with 3dB point frequency.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?poles : int?, ?p : int?, ?mix : float?,
+ ?m : float?, ?channels : string?, ?c : string?, ?normalize : bool?,
+ ?n : bool?, ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set frequency. (default: 500.)
+- `f` (of type `float?`, which defaults to `null`): set frequency. (default: 500.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.lowpass.create`
+
+Ffmpeg filter: Apply a low-pass filter with 3dB point frequency.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?poles : int?, ?p : int?, ?mix : float?,
+ ?m : float?, ?channels : string?, ?c : string?, ?normalize : bool?,
+ ?n : bool?, ?transform : int?, ?a : int?, ?precision : int?, ?r : int?,
+ ?blocksize : int?, ?b : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set frequency. (default: 500.)
+- `f` (of type `float?`, which defaults to `null`): set frequency. (default: 500.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.707)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lowshelf`
+
+Ffmpeg filter: Apply a low shelf filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.lowshelf.create`
+
+Ffmpeg filter: Apply a low shelf filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 100.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lumakey`
+
+Ffmpeg filter: Turns a certain luma into transparency.
+
+Type:
+
+```
+(?threshold : float?, ?tolerance : float?, ?softness : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `tolerance` (of type `float?`, which defaults to `null`): set the tolerance value. (default: 0.01)
+- `softness` (of type `float?`, which defaults to `null`): set the softness value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lumakey.create`
+
+Ffmpeg filter: Turns a certain luma into transparency.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : float?, ?tolerance : float?, ?softness : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `tolerance` (of type `float?`, which defaults to `null`): set the tolerance value. (default: 0.01)
+- `softness` (of type `float?`, which defaults to `null`): set the softness value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lut`
+
+Ffmpeg filter: Compute and apply a lookup table to the RGB/YUV input video.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?y : string?,
+ ?u : string?, ?v : string?, ?r : string?, ?g : string?, ?b : string?,
+ ?a : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: clipval)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: clipval)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: clipval)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: clipval)
+- `y` (of type `string?`, which defaults to `null`): set Y expression. (default: clipval)
+- `u` (of type `string?`, which defaults to `null`): set U expression. (default: clipval)
+- `v` (of type `string?`, which defaults to `null`): set V expression. (default: clipval)
+- `r` (of type `string?`, which defaults to `null`): set R expression. (default: clipval)
+- `g` (of type `string?`, which defaults to `null`): set G expression. (default: clipval)
+- `b` (of type `string?`, which defaults to `null`): set B expression. (default: clipval)
+- `a` (of type `string?`, which defaults to `null`): set A expression. (default: clipval)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lut.create`
+
+Ffmpeg filter: Compute and apply a lookup table to the RGB/YUV input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?y : string?,
+ ?u : string?, ?v : string?, ?r : string?, ?g : string?, ?b : string?,
+ ?a : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: clipval)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: clipval)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: clipval)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: clipval)
+- `y` (of type `string?`, which defaults to `null`): set Y expression. (default: clipval)
+- `u` (of type `string?`, which defaults to `null`): set U expression. (default: clipval)
+- `v` (of type `string?`, which defaults to `null`): set V expression. (default: clipval)
+- `r` (of type `string?`, which defaults to `null`): set R expression. (default: clipval)
+- `g` (of type `string?`, which defaults to `null`): set G expression. (default: clipval)
+- `b` (of type `string?`, which defaults to `null`): set B expression. (default: clipval)
+- `a` (of type `string?`, which defaults to `null`): set A expression. (default: clipval)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lut1d`
+
+Ffmpeg filter: Adjust colors using a 1D LUT.
+
+Type:
+
+```
+(?file : string?, ?interp : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `file` (of type `string?`, which defaults to `null`): set 1D LUT file name
+- `interp` (of type `int?`, which defaults to `null`): select interpolation mode. (default: 1, possible values: 0 (nearest), 1 (linear), 3 (cosine), 2 (cubic), 4 (spline))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lut1d.create`
+
+Ffmpeg filter: Adjust colors using a 1D LUT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?file : string?, ?interp : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `file` (of type `string?`, which defaults to `null`): set 1D LUT file name
+- `interp` (of type `int?`, which defaults to `null`): select interpolation mode. (default: 1, possible values: 0 (nearest), 1 (linear), 3 (cosine), 2 (cubic), 4 (spline))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lut2`
+
+Ffmpeg filter: Compute and apply a lookup table from two video inputs.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?d : int?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: x)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: x)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: x)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: x)
+- `d` (of type `int?`, which defaults to `null`): set output depth. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lut2.create`
+
+Ffmpeg filter: Compute and apply a lookup table from two video inputs.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?d : int?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: x)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: x)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: x)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: x)
+- `d` (of type `int?`, which defaults to `null`): set output depth. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lut3d`
+
+Ffmpeg filter: Adjust colors using a 3D LUT.
+
+Type:
+
+```
+(?file : string?, ?clut : int?, ?interp : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `file` (of type `string?`, which defaults to `null`): set 3D LUT file name
+- `clut` (of type `int?`, which defaults to `null`): when to process CLUT. (default: 1, possible values: 0 (first), 1 (all))
+- `interp` (of type `int?`, which defaults to `null`): select interpolation mode. (default: 2, possible values: 0 (nearest), 1 (trilinear), 2 (tetrahedral), 3 (pyramid), 4 (prism))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lut3d.create`
+
+Ffmpeg filter: Adjust colors using a 3D LUT.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?file : string?, ?clut : int?, ?interp : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `file` (of type `string?`, which defaults to `null`): set 3D LUT file name
+- `clut` (of type `int?`, which defaults to `null`): when to process CLUT. (default: 1, possible values: 0 (first), 1 (all))
+- `interp` (of type `int?`, which defaults to `null`): select interpolation mode. (default: 2, possible values: 0 (nearest), 1 (trilinear), 2 (tetrahedral), 3 (pyramid), 4 (prism))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lutrgb`
+
+Ffmpeg filter: Compute and apply a lookup table to the RGB input video.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?y : string?,
+ ?u : string?, ?v : string?, ?r : string?, ?g : string?, ?b : string?,
+ ?a : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: clipval)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: clipval)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: clipval)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: clipval)
+- `y` (of type `string?`, which defaults to `null`): set Y expression. (default: clipval)
+- `u` (of type `string?`, which defaults to `null`): set U expression. (default: clipval)
+- `v` (of type `string?`, which defaults to `null`): set V expression. (default: clipval)
+- `r` (of type `string?`, which defaults to `null`): set R expression. (default: clipval)
+- `g` (of type `string?`, which defaults to `null`): set G expression. (default: clipval)
+- `b` (of type `string?`, which defaults to `null`): set B expression. (default: clipval)
+- `a` (of type `string?`, which defaults to `null`): set A expression. (default: clipval)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lutrgb.create`
+
+Ffmpeg filter: Compute and apply a lookup table to the RGB input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?y : string?,
+ ?u : string?, ?v : string?, ?r : string?, ?g : string?, ?b : string?,
+ ?a : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: clipval)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: clipval)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: clipval)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: clipval)
+- `y` (of type `string?`, which defaults to `null`): set Y expression. (default: clipval)
+- `u` (of type `string?`, which defaults to `null`): set U expression. (default: clipval)
+- `v` (of type `string?`, which defaults to `null`): set V expression. (default: clipval)
+- `r` (of type `string?`, which defaults to `null`): set R expression. (default: clipval)
+- `g` (of type `string?`, which defaults to `null`): set G expression. (default: clipval)
+- `b` (of type `string?`, which defaults to `null`): set B expression. (default: clipval)
+- `a` (of type `string?`, which defaults to `null`): set A expression. (default: clipval)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lutyuv`
+
+Ffmpeg filter: Compute and apply a lookup table to the YUV input video.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?y : string?,
+ ?u : string?, ?v : string?, ?r : string?, ?g : string?, ?b : string?,
+ ?a : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: clipval)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: clipval)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: clipval)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: clipval)
+- `y` (of type `string?`, which defaults to `null`): set Y expression. (default: clipval)
+- `u` (of type `string?`, which defaults to `null`): set U expression. (default: clipval)
+- `v` (of type `string?`, which defaults to `null`): set V expression. (default: clipval)
+- `r` (of type `string?`, which defaults to `null`): set R expression. (default: clipval)
+- `g` (of type `string?`, which defaults to `null`): set G expression. (default: clipval)
+- `b` (of type `string?`, which defaults to `null`): set B expression. (default: clipval)
+- `a` (of type `string?`, which defaults to `null`): set A expression. (default: clipval)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.lutyuv.create`
+
+Ffmpeg filter: Compute and apply a lookup table to the YUV input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?y : string?,
+ ?u : string?, ?v : string?, ?r : string?, ?g : string?, ?b : string?,
+ ?a : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: clipval)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: clipval)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: clipval)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: clipval)
+- `y` (of type `string?`, which defaults to `null`): set Y expression. (default: clipval)
+- `u` (of type `string?`, which defaults to `null`): set U expression. (default: clipval)
+- `v` (of type `string?`, which defaults to `null`): set V expression. (default: clipval)
+- `r` (of type `string?`, which defaults to `null`): set R expression. (default: clipval)
+- `g` (of type `string?`, which defaults to `null`): set G expression. (default: clipval)
+- `b` (of type `string?`, which defaults to `null`): set B expression. (default: clipval)
+- `a` (of type `string?`, which defaults to `null`): set A expression. (default: clipval)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.lv2`
+
+Ffmpeg filter: Apply LV2 effect. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?plugin : string?, ?p : string?, ?controls : string?, ?c : string?,
+ ?sample_rate : int?, ?s : int?, ?nb_samples : int?, ?n : int?,
+ ?duration : int?, ?d : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `plugin` (of type `string?`, which defaults to `null`): set plugin uri
+- `p` (of type `string?`, which defaults to `null`): set plugin uri
+- `controls` (of type `string?`, which defaults to `null`): set plugin options
+- `c` (of type `string?`, which defaults to `null`): set plugin options
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `s` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `duration` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.lv2.create`
+
+Ffmpeg filter: Apply LV2 effect. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?plugin : string?, ?p : string?, ?controls : string?, ?c : string?,
+ ?sample_rate : int?, ?s : int?, ?nb_samples : int?, ?n : int?,
+ ?duration : int?, ?d : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `plugin` (of type `string?`, which defaults to `null`): set plugin uri
+- `p` (of type `string?`, which defaults to `null`): set plugin uri
+- `controls` (of type `string?`, which defaults to `null`): set plugin options
+- `c` (of type `string?`, which defaults to `null`): set plugin options
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `s` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `duration` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set audio duration. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mandelbrot`
+
+Ffmpeg filter: Render a Mandelbrot fractal.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?maxiter : int?, ?start_x : float?, ?start_y : float?,
+ ?start_scale : float?, ?end_scale : float?, ?end_pts : float?,
+ ?bailout : float?, ?morphxf : float?, ?morphyf : float?, ?morphamp : float?,
+ ?outer : int?, ?inner : int?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `rate` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `maxiter` (of type `int?`, which defaults to `null`): set max iterations number. (default: 7189)
+- `start_x` (of type `float?`, which defaults to `null`): set the initial x position. (default: -0.743643887037)
+- `start_y` (of type `float?`, which defaults to `null`): set the initial y position. (default: -0.131825904205)
+- `start_scale` (of type `float?`, which defaults to `null`): set the initial scale value. (default: 3.)
+- `end_scale` (of type `float?`, which defaults to `null`): set the terminal scale value. (default: 0.3)
+- `end_pts` (of type `float?`, which defaults to `null`): set the terminal pts value. (default: 400.)
+- `bailout` (of type `float?`, which defaults to `null`): set the bailout value. (default: 10.)
+- `morphxf` (of type `float?`, which defaults to `null`): set morph x frequency. (default: 0.01)
+- `morphyf` (of type `float?`, which defaults to `null`): set morph y frequency. (default: 0.0123)
+- `morphamp` (of type `float?`, which defaults to `null`): set morph amplitude. (default: 0.)
+- `outer` (of type `int?`, which defaults to `null`): set outer coloring mode. (default: 1, possible values: 0 (iteration_count), 1 (normalized_iteration_count), 2 (white), 3 (outz))
+- `inner` (of type `int?`, which defaults to `null`): set inner coloring mode. (default: 3, possible values: 0 (black), 1 (period), 2 (convergence), 3 (mincol))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.mandelbrot.create`
+
+Ffmpeg filter: Render a Mandelbrot fractal.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?maxiter : int?, ?start_x : float?, ?start_y : float?,
+ ?start_scale : float?, ?end_scale : float?, ?end_pts : float?,
+ ?bailout : float?, ?morphxf : float?, ?morphyf : float?, ?morphamp : float?,
+ ?outer : int?, ?inner : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `rate` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `maxiter` (of type `int?`, which defaults to `null`): set max iterations number. (default: 7189)
+- `start_x` (of type `float?`, which defaults to `null`): set the initial x position. (default: -0.743643887037)
+- `start_y` (of type `float?`, which defaults to `null`): set the initial y position. (default: -0.131825904205)
+- `start_scale` (of type `float?`, which defaults to `null`): set the initial scale value. (default: 3.)
+- `end_scale` (of type `float?`, which defaults to `null`): set the terminal scale value. (default: 0.3)
+- `end_pts` (of type `float?`, which defaults to `null`): set the terminal pts value. (default: 400.)
+- `bailout` (of type `float?`, which defaults to `null`): set the bailout value. (default: 10.)
+- `morphxf` (of type `float?`, which defaults to `null`): set morph x frequency. (default: 0.01)
+- `morphyf` (of type `float?`, which defaults to `null`): set morph y frequency. (default: 0.0123)
+- `morphamp` (of type `float?`, which defaults to `null`): set morph amplitude. (default: 0.)
+- `outer` (of type `int?`, which defaults to `null`): set outer coloring mode. (default: 1, possible values: 0 (iteration_count), 1 (normalized_iteration_count), 2 (white), 3 (outz))
+- `inner` (of type `int?`, which defaults to `null`): set inner coloring mode. (default: 3, possible values: 0 (black), 1 (period), 2 (convergence), 3 (mincol))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.maskedclamp`
+
+Ffmpeg filter: Clamp first stream with second stream and third stream.
+
+Type:
+
+```
+(?undershoot : int?, ?overshoot : int?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `undershoot` (of type `int?`, which defaults to `null`): set undershoot. (default: 0)
+- `overshoot` (of type `int?`, which defaults to `null`): set overshoot. (default: 0)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.maskedclamp.create`
+
+Ffmpeg filter: Clamp first stream with second stream and third stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?undershoot : int?, ?overshoot : int?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `undershoot` (of type `int?`, which defaults to `null`): set undershoot. (default: 0)
+- `overshoot` (of type `int?`, which defaults to `null`): set overshoot. (default: 0)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.maskedmax`
+
+Ffmpeg filter: Apply filtering with maximum difference of two streams.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.maskedmax.create`
+
+Ffmpeg filter: Apply filtering with maximum difference of two streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.maskedmerge`
+
+Ffmpeg filter: Merge first stream with second stream using third stream as mask.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.maskedmerge.create`
+
+Ffmpeg filter: Merge first stream with second stream using third stream as mask.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.maskedmin`
+
+Ffmpeg filter: Apply filtering with minimum difference of two streams.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.maskedmin.create`
+
+Ffmpeg filter: Apply filtering with minimum difference of two streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.maskedthreshold`
+
+Ffmpeg filter: Pick pixels comparing absolute difference of two streams with threshold.
+
+Type:
+
+```
+(?threshold : int?, ?planes : int?, ?mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold` (of type `int?`, which defaults to `null`): set threshold. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (abs), 1 (diff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.maskedthreshold.create`
+
+Ffmpeg filter: Pick pixels comparing absolute difference of two streams with threshold.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : int?, ?planes : int?, ?mode : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `threshold` (of type `int?`, which defaults to `null`): set threshold. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (abs), 1 (diff))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.maskfun`
+
+Ffmpeg filter: Create Mask.
+
+Type:
+
+```
+(?low : int?, ?high : int?, ?planes : int?, ?fill : int?, ?sum : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `low` (of type `int?`, which defaults to `null`): set low threshold. (default: 10)
+- `high` (of type `int?`, which defaults to `null`): set high threshold. (default: 10)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `fill` (of type `int?`, which defaults to `null`): set fill value. (default: 0)
+- `sum` (of type `int?`, which defaults to `null`): set sum value. (default: 10)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.maskfun.create`
+
+Ffmpeg filter: Create Mask.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?low : int?, ?high : int?, ?planes : int?, ?fill : int?, ?sum : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `low` (of type `int?`, which defaults to `null`): set low threshold. (default: 10)
+- `high` (of type `int?`, which defaults to `null`): set high threshold. (default: 10)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `fill` (of type `int?`, which defaults to `null`): set fill value. (default: 0)
+- `sum` (of type `int?`, which defaults to `null`): set sum value. (default: 10)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mcdeint`
+
+Ffmpeg filter: Apply motion compensating deinterlacing.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?qp : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (fast), 1 (medium), 2 (slow), 3 (extra_slow))
+- `parity` (of type `int?`, which defaults to `null`): set the assumed picture field parity. (default: 1, possible values: 0 (tff), 1 (bff))
+- `qp` (of type `int?`, which defaults to `null`): set qp. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.mcdeint.create`
+
+Ffmpeg filter: Apply motion compensating deinterlacing.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?qp : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (fast), 1 (medium), 2 (slow), 3 (extra_slow))
+- `parity` (of type `int?`, which defaults to `null`): set the assumed picture field parity. (default: 1, possible values: 0 (tff), 1 (bff))
+- `qp` (of type `int?`, which defaults to `null`): set qp. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mcompand`
+
+Ffmpeg filter: Multiband Compress or expand audio dynamic range.
+
+Type:
+
+```
+(?args : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `args` (of type `string?`, which defaults to `null`): set parameters for each band. (default: 0.005,0.1 6 -47/-40,-34/-34,-17/-33 100 | 0.003,0.05 6 -47/-40,-34/-34,-17/-33 400 | 0.000625,0.0125 6 -47/-40,-34/-34,-15/-33 1600 | 0.0001,0.025 6 -47/-40,-34/-34,-31/-31,-0/-30 6400 | 0,0.025 6 -38/-31,-28/-28,-0/-25 22000)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.mcompand.create`
+
+Ffmpeg filter: Multiband Compress or expand audio dynamic range.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?args : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `args` (of type `string?`, which defaults to `null`): set parameters for each band. (default: 0.005,0.1 6 -47/-40,-34/-34,-17/-33 100 | 0.003,0.05 6 -47/-40,-34/-34,-17/-33 400 | 0.000625,0.0125 6 -47/-40,-34/-34,-15/-33 1600 | 0.0001,0.025 6 -47/-40,-34/-34,-31/-31,-0/-30 6400 | 0,0.025 6 -38/-31,-28/-28,-0/-25 22000)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.median`
+
+Ffmpeg filter: Apply Median filter.
+
+Type:
+
+```
+(?radius : int?, ?planes : int?, ?radiusV : int?, ?percentile : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set median radius. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `radiusV` (of type `int?`, which defaults to `null`): set median vertical radius. (default: 0)
+- `percentile` (of type `float?`, which defaults to `null`): set median percentile. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.median.create`
+
+Ffmpeg filter: Apply Median filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?radius : int?, ?planes : int?, ?radiusV : int?, ?percentile : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set median radius. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `radiusV` (of type `int?`, which defaults to `null`): set median vertical radius. (default: 0)
+- `percentile` (of type `float?`, which defaults to `null`): set median percentile. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mergeplanes`
+
+Ffmpeg filter: Merge planes. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?mapping : int?, ?format : string?, ?map0s : int?, ?map0p : int?,
+ ?map1s : int?, ?map1p : int?, ?map2s : int?, ?map2p : int?, ?map3s : int?,
+ ?map3p : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mapping` (of type `int?`, which defaults to `null`): set input to output plane mapping. (default: -1)
+- `format` (of type `string?`, which defaults to `null`): set output pixel format. (default: yuva444p)
+- `map0s` (of type `int?`, which defaults to `null`): set 1st input to output stream mapping. (default: 0)
+- `map0p` (of type `int?`, which defaults to `null`): set 1st input to output plane mapping. (default: 0)
+- `map1s` (of type `int?`, which defaults to `null`): set 2nd input to output stream mapping. (default: 0)
+- `map1p` (of type `int?`, which defaults to `null`): set 2nd input to output plane mapping. (default: 0)
+- `map2s` (of type `int?`, which defaults to `null`): set 3rd input to output stream mapping. (default: 0)
+- `map2p` (of type `int?`, which defaults to `null`): set 3rd input to output plane mapping. (default: 0)
+- `map3s` (of type `int?`, which defaults to `null`): set 4th input to output stream mapping. (default: 0)
+- `map3p` (of type `int?`, which defaults to `null`): set 4th input to output plane mapping. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.mergeplanes.create`
+
+Ffmpeg filter: Merge planes. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mapping : int?, ?format : string?, ?map0s : int?, ?map0p : int?,
+ ?map1s : int?, ?map1p : int?, ?map2s : int?, ?map2p : int?, ?map3s : int?,
+ ?map3p : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mapping` (of type `int?`, which defaults to `null`): set input to output plane mapping. (default: -1)
+- `format` (of type `string?`, which defaults to `null`): set output pixel format. (default: yuva444p)
+- `map0s` (of type `int?`, which defaults to `null`): set 1st input to output stream mapping. (default: 0)
+- `map0p` (of type `int?`, which defaults to `null`): set 1st input to output plane mapping. (default: 0)
+- `map1s` (of type `int?`, which defaults to `null`): set 2nd input to output stream mapping. (default: 0)
+- `map1p` (of type `int?`, which defaults to `null`): set 2nd input to output plane mapping. (default: 0)
+- `map2s` (of type `int?`, which defaults to `null`): set 3rd input to output stream mapping. (default: 0)
+- `map2p` (of type `int?`, which defaults to `null`): set 3rd input to output plane mapping. (default: 0)
+- `map3s` (of type `int?`, which defaults to `null`): set 4th input to output stream mapping. (default: 0)
+- `map3p` (of type `int?`, which defaults to `null`): set 4th input to output plane mapping. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mestimate`
+
+Ffmpeg filter: Generate motion vectors.
+
+Type:
+
+```
+(?method : int?, ?mb_size : int?, ?search_param : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `method` (of type `int?`, which defaults to `null`): motion estimation method. (default: 1, possible values: 1 (esa), 2 (tss), 3 (tdls), 4 (ntss), 5 (fss), 6 (ds), 7 (hexbs), 8 (epzs), 9 (umh))
+- `mb_size` (of type `int?`, which defaults to `null`): macroblock size. (default: 16)
+- `search_param` (of type `int?`, which defaults to `null`): search parameter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.mestimate.create`
+
+Ffmpeg filter: Generate motion vectors.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?method : int?, ?mb_size : int?, ?search_param : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `method` (of type `int?`, which defaults to `null`): motion estimation method. (default: 1, possible values: 1 (esa), 2 (tss), 3 (tdls), 4 (ntss), 5 (fss), 6 (ds), 7 (hexbs), 8 (epzs), 9 (umh))
+- `mb_size` (of type `int?`, which defaults to `null`): macroblock size. (default: 16)
+- `search_param` (of type `int?`, which defaults to `null`): search parameter. (default: 7)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.metadata`
+
+Ffmpeg filter: Manipulate video frame metadata.
+
+Type:
+
+```
+(?mode : int?, ?key : string?, ?value : string?, ?function : int?,
+ ?expr : string?, ?file : string?, ?direct : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (add), 2 (modify), 3 (delete), 4 (print))
+- `key` (of type `string?`, which defaults to `null`): set metadata key
+- `value` (of type `string?`, which defaults to `null`): set metadata value
+- `function` (of type `int?`, which defaults to `null`): function for comparing values. (default: 0, possible values: 0 (same_str), 1 (starts_with), 2 (less), 3 (equal), 4 (greater), 5 (expr), 6 (ends_with))
+- `expr` (of type `string?`, which defaults to `null`): set expression for expr function
+- `file` (of type `string?`, which defaults to `null`): set file where to print metadata information
+- `direct` (of type `bool?`, which defaults to `null`): reduce buffering when printing to user-set file or pipe. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.metadata.create`
+
+Ffmpeg filter: Manipulate video frame metadata.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?key : string?, ?value : string?, ?function : int?,
+ ?expr : string?, ?file : string?, ?direct : bool?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (add), 2 (modify), 3 (delete), 4 (print))
+- `key` (of type `string?`, which defaults to `null`): set metadata key
+- `value` (of type `string?`, which defaults to `null`): set metadata value
+- `function` (of type `int?`, which defaults to `null`): function for comparing values. (default: 0, possible values: 0 (same_str), 1 (starts_with), 2 (less), 3 (equal), 4 (greater), 5 (expr), 6 (ends_with))
+- `expr` (of type `string?`, which defaults to `null`): set expression for expr function
+- `file` (of type `string?`, which defaults to `null`): set file where to print metadata information
+- `direct` (of type `bool?`, which defaults to `null`): reduce buffering when printing to user-set file or pipe. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.midequalizer`
+
+Ffmpeg filter: Apply Midway Equalization.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.midequalizer.create`
+
+Ffmpeg filter: Apply Midway Equalization.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.minterpolate`
+
+Ffmpeg filter: Frame rate conversion using Motion Interpolation.
+
+Type:
+
+```
+(?fps : string?, ?mi_mode : int?, ?mc_mode : int?, ?me_mode : int?,
+ ?me : int?, ?mb_size : int?, ?search_param : int?, ?vsbmc : int?,
+ ?scd : int?, ?scd_threshold : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `fps` (of type `string?`, which defaults to `null`): output's frame rate. (default: 60)
+- `mi_mode` (of type `int?`, which defaults to `null`): motion interpolation mode. (default: 2, possible values: 0 (dup), 1 (blend), 2 (mci))
+- `mc_mode` (of type `int?`, which defaults to `null`): motion compensation mode. (default: 0, possible values: 0 (obmc), 1 (aobmc))
+- `me_mode` (of type `int?`, which defaults to `null`): motion estimation mode. (default: 1, possible values: 0 (bidir), 1 (bilat))
+- `me` (of type `int?`, which defaults to `null`): motion estimation method. (default: 8, possible values: 1 (esa), 2 (tss), 3 (tdls), 4 (ntss), 5 (fss), 6 (ds), 7 (hexbs), 8 (epzs), 9 (umh))
+- `mb_size` (of type `int?`, which defaults to `null`): macroblock size. (default: 16)
+- `search_param` (of type `int?`, which defaults to `null`): search parameter. (default: 32)
+- `vsbmc` (of type `int?`, which defaults to `null`): variable-size block motion compensation. (default: 0)
+- `scd` (of type `int?`, which defaults to `null`): scene change detection method. (default: 1, possible values: 0 (none), 1 (fdiff))
+- `scd_threshold` (of type `float?`, which defaults to `null`): scene change threshold. (default: 10.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.minterpolate.create`
+
+Ffmpeg filter: Frame rate conversion using Motion Interpolation.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?fps : string?, ?mi_mode : int?, ?mc_mode : int?, ?me_mode : int?,
+ ?me : int?, ?mb_size : int?, ?search_param : int?, ?vsbmc : int?,
+ ?scd : int?, ?scd_threshold : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `fps` (of type `string?`, which defaults to `null`): output's frame rate. (default: 60)
+- `mi_mode` (of type `int?`, which defaults to `null`): motion interpolation mode. (default: 2, possible values: 0 (dup), 1 (blend), 2 (mci))
+- `mc_mode` (of type `int?`, which defaults to `null`): motion compensation mode. (default: 0, possible values: 0 (obmc), 1 (aobmc))
+- `me_mode` (of type `int?`, which defaults to `null`): motion estimation mode. (default: 1, possible values: 0 (bidir), 1 (bilat))
+- `me` (of type `int?`, which defaults to `null`): motion estimation method. (default: 8, possible values: 1 (esa), 2 (tss), 3 (tdls), 4 (ntss), 5 (fss), 6 (ds), 7 (hexbs), 8 (epzs), 9 (umh))
+- `mb_size` (of type `int?`, which defaults to `null`): macroblock size. (default: 16)
+- `search_param` (of type `int?`, which defaults to `null`): search parameter. (default: 32)
+- `vsbmc` (of type `int?`, which defaults to `null`): variable-size block motion compensation. (default: 0)
+- `scd` (of type `int?`, which defaults to `null`): scene change detection method. (default: 1, possible values: 0 (none), 1 (fdiff))
+- `scd_threshold` (of type `float?`, which defaults to `null`): scene change threshold. (default: 10.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mix`
+
+Ffmpeg filter: Mix video inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?weights : string?, ?scale : float?, ?planes : int?,
+ ?duration : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `weights` (of type `string?`, which defaults to `null`): set weight for each input. (default: 1 1)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 0.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `duration` (of type `int?`, which defaults to `null`): how to determine end of stream. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.mix.create`
+
+Ffmpeg filter: Mix video inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?weights : string?, ?scale : float?, ?planes : int?,
+ ?duration : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `weights` (of type `string?`, which defaults to `null`): set weight for each input. (default: 1 1)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 0.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `duration` (of type `int?`, which defaults to `null`): how to determine end of stream. (default: 0, possible values: 0 (longest), 1 (shortest), 2 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.monochrome`
+
+Ffmpeg filter: Convert video to gray using custom color filter.
+
+Type:
+
+```
+(?cb : float?, ?cr : float?, ?size : float?, ?high : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `cb` (of type `float?`, which defaults to `null`): set the chroma blue spot. (default: 0.)
+- `cr` (of type `float?`, which defaults to `null`): set the chroma red spot. (default: 0.)
+- `size` (of type `float?`, which defaults to `null`): set the color filter size. (default: 1.)
+- `high` (of type `float?`, which defaults to `null`): set the highlights strength. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.monochrome.create`
+
+Ffmpeg filter: Convert video to gray using custom color filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cb : float?, ?cr : float?, ?size : float?, ?high : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cb` (of type `float?`, which defaults to `null`): set the chroma blue spot. (default: 0.)
+- `cr` (of type `float?`, which defaults to `null`): set the chroma red spot. (default: 0.)
+- `size` (of type `float?`, which defaults to `null`): set the color filter size. (default: 1.)
+- `high` (of type `float?`, which defaults to `null`): set the highlights strength. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.morpho`
+
+Ffmpeg filter: Apply Morphological filter.
+
+Type:
+
+```
+(?mode : int?, ?planes : int?, ?structure : int?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set morphological transform. (default: 0, possible values: 0 (erode), 1 (dilate), 2 (open), 3 (close), 4 (gradient), 5 (tophat), 6 (blackhat))
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7)
+- `structure` (of type `int?`, which defaults to `null`): when to process structures. (default: 1, possible values: 0 (first), 1 (all))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.morpho.create`
+
+Ffmpeg filter: Apply Morphological filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?planes : int?, ?structure : int?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set morphological transform. (default: 0, possible values: 0 (erode), 1 (dilate), 2 (open), 3 (close), 4 (gradient), 5 (tophat), 6 (blackhat))
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 7)
+- `structure` (of type `int?`, which defaults to `null`): when to process structures. (default: 1, possible values: 0 (first), 1 (all))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.movie`
+
+Ffmpeg filter: Read from a movie source. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?filename : string?, ?format_name : string?, ?f : string?,
+ ?stream_index : int?, ?si : int?, ?seek_point : float?, ?sp : float?,
+ ?streams : string?, ?s : string?, ?loop : int?, ?discontinuity : int?,
+ ?dec_threads : int?, ?format_opts : string?, ffmpeg.filter.graph) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`)
+- `format_name` (of type `string?`, which defaults to `null`): set format name
+- `f` (of type `string?`, which defaults to `null`): set format name
+- `stream_index` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `si` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `seek_point` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `sp` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `streams` (of type `string?`, which defaults to `null`): set streams
+- `s` (of type `string?`, which defaults to `null`): set streams
+- `loop` (of type `int?`, which defaults to `null`): set loop count. (default: 1)
+- `discontinuity` (of type `int?`, which defaults to `null`): set discontinuity threshold. (default: 0)
+- `dec_threads` (of type `int?`, which defaults to `null`): set the number of threads for decoding. (default: 0)
+- `format_opts` (of type `string?`, which defaults to `null`): set format options for the opened file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.movie.create`
+
+Ffmpeg filter: Read from a movie source. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?format_name : string?, ?f : string?,
+ ?stream_index : int?, ?si : int?, ?seek_point : float?, ?sp : float?,
+ ?streams : string?, ?s : string?, ?loop : int?, ?discontinuity : int?,
+ ?dec_threads : int?, ?format_opts : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`)
+- `format_name` (of type `string?`, which defaults to `null`): set format name
+- `f` (of type `string?`, which defaults to `null`): set format name
+- `stream_index` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `si` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `seek_point` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `sp` (of type `float?`, which defaults to `null`): set seekpoint (seconds). (default: 0.)
+- `streams` (of type `string?`, which defaults to `null`): set streams
+- `s` (of type `string?`, which defaults to `null`): set streams
+- `loop` (of type `int?`, which defaults to `null`): set loop count. (default: 1)
+- `discontinuity` (of type `int?`, which defaults to `null`): set discontinuity threshold. (default: 0)
+- `dec_threads` (of type `int?`, which defaults to `null`): set the number of threads for decoding. (default: 0)
+- `format_opts` (of type `string?`, which defaults to `null`): set format options for the opened file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mpdecimate`
+
+Ffmpeg filter: Remove near-duplicate frames.
+
+Type:
+
+```
+(?max : int?, ?keep : int?, ?hi : int?, ?lo : int?, ?frac : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `max` (of type `int?`, which defaults to `null`): set the maximum number of consecutive dropped frames (positive), or the minimum interval between dropped frames (negative). (default: 0)
+- `keep` (of type `int?`, which defaults to `null`): set the number of similar consecutive frames to be kept before starting to drop similar frames. (default: 0)
+- `hi` (of type `int?`, which defaults to `null`): set high dropping threshold. (default: 768)
+- `lo` (of type `int?`, which defaults to `null`): set low dropping threshold. (default: 320)
+- `frac` (of type `float?`, which defaults to `null`): set fraction dropping threshold. (default: 0.33)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.mpdecimate.create`
+
+Ffmpeg filter: Remove near-duplicate frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?max : int?, ?keep : int?, ?hi : int?, ?lo : int?, ?frac : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `max` (of type `int?`, which defaults to `null`): set the maximum number of consecutive dropped frames (positive), or the minimum interval between dropped frames (negative). (default: 0)
+- `keep` (of type `int?`, which defaults to `null`): set the number of similar consecutive frames to be kept before starting to drop similar frames. (default: 0)
+- `hi` (of type `int?`, which defaults to `null`): set high dropping threshold. (default: 768)
+- `lo` (of type `int?`, which defaults to `null`): set low dropping threshold. (default: 320)
+- `frac` (of type `float?`, which defaults to `null`): set fraction dropping threshold. (default: 0.33)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.mptestsrc`
+
+Ffmpeg filter: Generate various test pattern.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?test : int?,
+ ?t : int?, ?max_frames : int?, ?m : int?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `test` (of type `int?`, which defaults to `null`): set test to perform. (default: 10, possible values: 0 (dc_luma), 1 (dc_chroma), 2 (freq_luma), 3 (freq_chroma), 4 (amp_luma), 5 (amp_chroma), 6 (cbp), 7 (mv), 8 (ring1), 9 (ring2), 10 (all))
+- `t` (of type `int?`, which defaults to `null`): set test to perform. (default: 10, possible values: 0 (dc_luma), 1 (dc_chroma), 2 (freq_luma), 3 (freq_chroma), 4 (amp_luma), 5 (amp_chroma), 6 (cbp), 7 (mv), 8 (ring1), 9 (ring2), 10 (all))
+- `max_frames` (of type `int?`, which defaults to `null`): Set the maximum number of frames generated for each test. (default: 30)
+- `m` (of type `int?`, which defaults to `null`): Set the maximum number of frames generated for each test. (default: 30)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.mptestsrc.create`
+
+Ffmpeg filter: Generate various test pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?duration : int?, ?d : int?, ?test : int?,
+ ?t : int?, ?max_frames : int?, ?m : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `test` (of type `int?`, which defaults to `null`): set test to perform. (default: 10, possible values: 0 (dc_luma), 1 (dc_chroma), 2 (freq_luma), 3 (freq_chroma), 4 (amp_luma), 5 (amp_chroma), 6 (cbp), 7 (mv), 8 (ring1), 9 (ring2), 10 (all))
+- `t` (of type `int?`, which defaults to `null`): set test to perform. (default: 10, possible values: 0 (dc_luma), 1 (dc_chroma), 2 (freq_luma), 3 (freq_chroma), 4 (amp_luma), 5 (amp_chroma), 6 (cbp), 7 (mv), 8 (ring1), 9 (ring2), 10 (all))
+- `max_frames` (of type `int?`, which defaults to `null`): Set the maximum number of frames generated for each test. (default: 30)
+- `m` (of type `int?`, which defaults to `null`): Set the maximum number of frames generated for each test. (default: 30)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.msad`
+
+Ffmpeg filter: Calculate the MSAD between two video streams.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.msad.create`
+
+Ffmpeg filter: Calculate the MSAD between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.multiply`
+
+Ffmpeg filter: Multiply first video stream with second video stream.
+
+Type:
+
+```
+(?scale : float?, ?offset : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `offset` (of type `float?`, which defaults to `null`): set offset. (default: 0.5)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.multiply.create`
+
+Ffmpeg filter: Multiply first video stream with second video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?scale : float?, ?offset : float?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `offset` (of type `float?`, which defaults to `null`): set offset. (default: 0.5)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.negate`
+
+Ffmpeg filter: Negate input video.
+
+Type:
+
+```
+(?components : int?, ?negate_alpha : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `components` (of type `int?`, which defaults to `null`): set components to negate. (default: 119, possible values: 16 (y), 32 (u), 64 (v), 1 (r), 2 (g), 4 (b), 8 (a))
+- `negate_alpha` (of type `bool?`, which defaults to `null`): Default: false
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.negate.create`
+
+Ffmpeg filter: Negate input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?components : int?, ?negate_alpha : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `components` (of type `int?`, which defaults to `null`): set components to negate. (default: 119, possible values: 16 (y), 32 (u), 64 (v), 1 (r), 2 (g), 4 (b), 8 (a))
+- `negate_alpha` (of type `bool?`, which defaults to `null`): Default: false
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.nlmeans`
+
+Ffmpeg filter: Non-local means denoiser.
+
+Type:
+
+```
+(?s : float?, ?p : int?, ?pc : int?, ?r : int?, ?rc : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `s` (of type `float?`, which defaults to `null`): denoising strength. (default: 1.)
+- `p` (of type `int?`, which defaults to `null`): patch size. (default: 7)
+- `pc` (of type `int?`, which defaults to `null`): patch size for chroma planes. (default: 0)
+- `r` (of type `int?`, which defaults to `null`): research window. (default: 15)
+- `rc` (of type `int?`, which defaults to `null`): research window for chroma planes. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.nlmeans.create`
+
+Ffmpeg filter: Non-local means denoiser.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?s : float?, ?p : int?, ?pc : int?, ?r : int?, ?rc : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `s` (of type `float?`, which defaults to `null`): denoising strength. (default: 1.)
+- `p` (of type `int?`, which defaults to `null`): patch size. (default: 7)
+- `pc` (of type `int?`, which defaults to `null`): patch size for chroma planes. (default: 0)
+- `r` (of type `int?`, which defaults to `null`): research window. (default: 15)
+- `rc` (of type `int?`, which defaults to `null`): research window for chroma planes. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.nlmeans_opencl`
+
+Ffmpeg filter: Non-local means denoiser through OpenCL
+
+Type:
+
+```
+(?s : float?, ?p : int?, ?pc : int?, ?r : int?, ?rc : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `s` (of type `float?`, which defaults to `null`): denoising strength. (default: 1.)
+- `p` (of type `int?`, which defaults to `null`): patch size. (default: 7)
+- `pc` (of type `int?`, which defaults to `null`): patch size for chroma planes. (default: 0)
+- `r` (of type `int?`, which defaults to `null`): research window. (default: 15)
+- `rc` (of type `int?`, which defaults to `null`): research window for chroma planes. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.nlmeans_opencl.create`
+
+Ffmpeg filter: Non-local means denoiser through OpenCL. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?s : float?, ?p : int?, ?pc : int?, ?r : int?, ?rc : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `s` (of type `float?`, which defaults to `null`): denoising strength. (default: 1.)
+- `p` (of type `int?`, which defaults to `null`): patch size. (default: 7)
+- `pc` (of type `int?`, which defaults to `null`): patch size for chroma planes. (default: 0)
+- `r` (of type `int?`, which defaults to `null`): research window. (default: 15)
+- `rc` (of type `int?`, which defaults to `null`): research window for chroma planes. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.nnedi`
+
+Ffmpeg filter: Apply neural network edge directed interpolation intra-only deinterlacer.
+
+Type:
+
+```
+(?weights : string?, ?deint : int?, ?field : int?, ?planes : int?,
+ ?nsize : int?, ?nns : int?, ?qual : int?, ?etype : int?, ?pscrn : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `weights` (of type `string?`, which defaults to `null`): set weights file. (default: nnedi3_weights.bin)
+- `deint` (of type `int?`, which defaults to `null`): set which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `field` (of type `int?`, which defaults to `null`): set mode of operation. (default: -1, possible values: -2 (af), -1 (a), 0 (t), 1 (b), 2 (tf), 3 (bf))
+- `planes` (of type `int?`, which defaults to `null`): set which planes to process. (default: 7)
+- `nsize` (of type `int?`, which defaults to `null`): set size of local neighborhood around each pixel, used by the predictor neural network. (default: 6, possible values: 0 (s8x6), 1 (s16x6), 2 (s32x6), 3 (s48x6), 4 (s8x4), 5 (s16x4), 6 (s32x4))
+- `nns` (of type `int?`, which defaults to `null`): set number of neurons in predictor neural network. (default: 1, possible values: 0 (n16), 1 (n32), 2 (n64), 3 (n128), 4 (n256))
+- `qual` (of type `int?`, which defaults to `null`): set quality. (default: 1, possible values: 1 (fast), 2 (slow))
+- `etype` (of type `int?`, which defaults to `null`): set which set of weights to use in the predictor. (default: 0, possible values: 0 (a), 0 (abs), 1 (s), 1 (mse))
+- `pscrn` (of type `int?`, which defaults to `null`): set prescreening. (default: 2, possible values: 0 (none), 1 (original), 2 (new), 3 (new2), 4 (new3))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.nnedi.create`
+
+Ffmpeg filter: Apply neural network edge directed interpolation intra-only deinterlacer.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?weights : string?, ?deint : int?, ?field : int?, ?planes : int?,
+ ?nsize : int?, ?nns : int?, ?qual : int?, ?etype : int?, ?pscrn : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `weights` (of type `string?`, which defaults to `null`): set weights file. (default: nnedi3_weights.bin)
+- `deint` (of type `int?`, which defaults to `null`): set which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `field` (of type `int?`, which defaults to `null`): set mode of operation. (default: -1, possible values: -2 (af), -1 (a), 0 (t), 1 (b), 2 (tf), 3 (bf))
+- `planes` (of type `int?`, which defaults to `null`): set which planes to process. (default: 7)
+- `nsize` (of type `int?`, which defaults to `null`): set size of local neighborhood around each pixel, used by the predictor neural network. (default: 6, possible values: 0 (s8x6), 1 (s16x6), 2 (s32x6), 3 (s48x6), 4 (s8x4), 5 (s16x4), 6 (s32x4))
+- `nns` (of type `int?`, which defaults to `null`): set number of neurons in predictor neural network. (default: 1, possible values: 0 (n16), 1 (n32), 2 (n64), 3 (n128), 4 (n256))
+- `qual` (of type `int?`, which defaults to `null`): set quality. (default: 1, possible values: 1 (fast), 2 (slow))
+- `etype` (of type `int?`, which defaults to `null`): set which set of weights to use in the predictor. (default: 0, possible values: 0 (a), 0 (abs), 1 (s), 1 (mse))
+- `pscrn` (of type `int?`, which defaults to `null`): set prescreening. (default: 2, possible values: 0 (none), 1 (original), 2 (new), 3 (new2), 4 (new3))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.noformat`
+
+Ffmpeg filter: Force libavfilter not to use any of the specified pixel formats for the input to the next filter.
+
+Type:
+
+```
+(?pix_fmts : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `pix_fmts` (of type `string?`, which defaults to `null`): A '|'-separated list of pixel formats
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.noformat.create`
+
+Ffmpeg filter: Force libavfilter not to use any of the specified pixel formats for the input to the next filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?pix_fmts : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `pix_fmts` (of type `string?`, which defaults to `null`): A '|'-separated list of pixel formats
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.noise`
+
+Ffmpeg filter: Add noise.
+
+Type:
+
+```
+(?all_seed : int?, ?all_strength : int?, ?alls : int?, ?all_flags : int?,
+ ?allf : int?, ?c0_seed : int?, ?c0_strength : int?, ?c0s : int?,
+ ?c0_flags : int?, ?c0f : int?, ?c1_seed : int?, ?c1_strength : int?,
+ ?c1s : int?, ?c1_flags : int?, ?c1f : int?, ?c2_seed : int?,
+ ?c2_strength : int?, ?c2s : int?, ?c2_flags : int?, ?c2f : int?,
+ ?c3_seed : int?, ?c3_strength : int?, ?c3s : int?, ?c3_flags : int?,
+ ?c3f : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `all_seed` (of type `int?`, which defaults to `null`): set component #0 noise seed. (default: -1)
+- `all_strength` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `alls` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `all_flags` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `allf` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c0_seed` (of type `int?`, which defaults to `null`): set component #0 noise seed. (default: -1)
+- `c0_strength` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `c0s` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `c0_flags` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c0f` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c1_seed` (of type `int?`, which defaults to `null`): set component #1 noise seed. (default: -1)
+- `c1_strength` (of type `int?`, which defaults to `null`): set component #1 strength. (default: 0)
+- `c1s` (of type `int?`, which defaults to `null`): set component #1 strength. (default: 0)
+- `c1_flags` (of type `int?`, which defaults to `null`): set component #1 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c1f` (of type `int?`, which defaults to `null`): set component #1 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c2_seed` (of type `int?`, which defaults to `null`): set component #2 noise seed. (default: -1)
+- `c2_strength` (of type `int?`, which defaults to `null`): set component #2 strength. (default: 0)
+- `c2s` (of type `int?`, which defaults to `null`): set component #2 strength. (default: 0)
+- `c2_flags` (of type `int?`, which defaults to `null`): set component #2 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c2f` (of type `int?`, which defaults to `null`): set component #2 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c3_seed` (of type `int?`, which defaults to `null`): set component #3 noise seed. (default: -1)
+- `c3_strength` (of type `int?`, which defaults to `null`): set component #3 strength. (default: 0)
+- `c3s` (of type `int?`, which defaults to `null`): set component #3 strength. (default: 0)
+- `c3_flags` (of type `int?`, which defaults to `null`): set component #3 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c3f` (of type `int?`, which defaults to `null`): set component #3 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.noise.create`
+
+Ffmpeg filter: Add noise.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?all_seed : int?, ?all_strength : int?, ?alls : int?, ?all_flags : int?,
+ ?allf : int?, ?c0_seed : int?, ?c0_strength : int?, ?c0s : int?,
+ ?c0_flags : int?, ?c0f : int?, ?c1_seed : int?, ?c1_strength : int?,
+ ?c1s : int?, ?c1_flags : int?, ?c1f : int?, ?c2_seed : int?,
+ ?c2_strength : int?, ?c2s : int?, ?c2_flags : int?, ?c2f : int?,
+ ?c3_seed : int?, ?c3_strength : int?, ?c3s : int?, ?c3_flags : int?,
+ ?c3f : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `all_seed` (of type `int?`, which defaults to `null`): set component #0 noise seed. (default: -1)
+- `all_strength` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `alls` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `all_flags` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `allf` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c0_seed` (of type `int?`, which defaults to `null`): set component #0 noise seed. (default: -1)
+- `c0_strength` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `c0s` (of type `int?`, which defaults to `null`): set component #0 strength. (default: 0)
+- `c0_flags` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c0f` (of type `int?`, which defaults to `null`): set component #0 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c1_seed` (of type `int?`, which defaults to `null`): set component #1 noise seed. (default: -1)
+- `c1_strength` (of type `int?`, which defaults to `null`): set component #1 strength. (default: 0)
+- `c1s` (of type `int?`, which defaults to `null`): set component #1 strength. (default: 0)
+- `c1_flags` (of type `int?`, which defaults to `null`): set component #1 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c1f` (of type `int?`, which defaults to `null`): set component #1 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c2_seed` (of type `int?`, which defaults to `null`): set component #2 noise seed. (default: -1)
+- `c2_strength` (of type `int?`, which defaults to `null`): set component #2 strength. (default: 0)
+- `c2s` (of type `int?`, which defaults to `null`): set component #2 strength. (default: 0)
+- `c2_flags` (of type `int?`, which defaults to `null`): set component #2 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c2f` (of type `int?`, which defaults to `null`): set component #2 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c3_seed` (of type `int?`, which defaults to `null`): set component #3 noise seed. (default: -1)
+- `c3_strength` (of type `int?`, which defaults to `null`): set component #3 strength. (default: 0)
+- `c3s` (of type `int?`, which defaults to `null`): set component #3 strength. (default: 0)
+- `c3_flags` (of type `int?`, which defaults to `null`): set component #3 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `c3f` (of type `int?`, which defaults to `null`): set component #3 flags. (default: 0, possible values: 8 (a), 16 (p), 2 (t), 1 (u))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.normalize`
+
+Ffmpeg filter: Normalize RGB video.
+
+Type:
+
+```
+(?blackpt : string?, ?whitept : string?, ?smoothing : int?,
+ ?independence : float?, ?strength : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `blackpt` (of type `string?`, which defaults to `null`): output color to which darkest input color is mapped. (default: black)
+- `whitept` (of type `string?`, which defaults to `null`): output color to which brightest input color is mapped. (default: white)
+- `smoothing` (of type `int?`, which defaults to `null`): amount of temporal smoothing of the input range, to reduce flicker. (default: 0)
+- `independence` (of type `float?`, which defaults to `null`): proportion of independent to linked channel normalization. (default: 1.)
+- `strength` (of type `float?`, which defaults to `null`): strength of filter, from no effect to full normalization. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.normalize.create`
+
+Ffmpeg filter: Normalize RGB video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?blackpt : string?, ?whitept : string?, ?smoothing : int?,
+ ?independence : float?, ?strength : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `blackpt` (of type `string?`, which defaults to `null`): output color to which darkest input color is mapped. (default: black)
+- `whitept` (of type `string?`, which defaults to `null`): output color to which brightest input color is mapped. (default: white)
+- `smoothing` (of type `int?`, which defaults to `null`): amount of temporal smoothing of the input range, to reduce flicker. (default: 0)
+- `independence` (of type `float?`, which defaults to `null`): proportion of independent to linked channel normalization. (default: 1.)
+- `strength` (of type `float?`, which defaults to `null`): strength of filter, from no effect to full normalization. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.null`
+
+Ffmpeg filter: Pass the source unchanged to the output.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.null.create`
+
+Ffmpeg filter: Pass the source unchanged to the output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.nullsink`
+
+Ffmpeg filter: Do absolutely nothing with the input video.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.nullsink.create`
+
+Ffmpeg filter: Do absolutely nothing with the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `unit`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.nullsrc`
+
+Ffmpeg filter: Null video source, return unprocessed video frames.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.nullsrc.create`
+
+Ffmpeg filter: Null video source, return unprocessed video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ocr`
+
+Ffmpeg filter: Optical Character Recognition.
+
+Type:
+
+```
+(?datapath : string?, ?language : string?, ?whitelist : string?,
+ ?blacklist : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `datapath` (of type `string?`, which defaults to `null`): set datapath
+- `language` (of type `string?`, which defaults to `null`): set language. (default: eng)
+- `whitelist` (of type `string?`, which defaults to `null`): set character whitelist. (default: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:;,-+_!?"'[]{}()<>|/\=*&%$#@!~ )
+- `blacklist` (of type `string?`, which defaults to `null`): set character blacklist. (default: )
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.ocr.create`
+
+Ffmpeg filter: Optical Character Recognition.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?datapath : string?, ?language : string?, ?whitelist : string?,
+ ?blacklist : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `datapath` (of type `string?`, which defaults to `null`): set datapath
+- `language` (of type `string?`, which defaults to `null`): set language. (default: eng)
+- `whitelist` (of type `string?`, which defaults to `null`): set character whitelist. (default: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:;,-+_!?"'[]{}()<>|/\=*&%$#@!~ )
+- `blacklist` (of type `string?`, which defaults to `null`): set character blacklist. (default: )
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.openclsrc`
+
+Ffmpeg filter: Generate video using an OpenCL program
+
+Type:
+
+```
+(?source : string?, ?kernel : string?, ?size : string?, ?s : string?,
+ ?format : string?, ?rate : string?, ?r : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `source` (of type `string?`, which defaults to `null`): OpenCL program source file
+- `kernel` (of type `string?`, which defaults to `null`): Kernel name in program
+- `size` (of type `string?`, which defaults to `null`): Video size
+- `s` (of type `string?`, which defaults to `null`): Video size
+- `format` (of type `string?`, which defaults to `null`): Video format
+- `rate` (of type `string?`, which defaults to `null`): Video frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): Video frame rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.openclsrc.create`
+
+Ffmpeg filter: Generate video using an OpenCL program. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?source : string?, ?kernel : string?, ?size : string?, ?s : string?,
+ ?format : string?, ?rate : string?, ?r : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `source` (of type `string?`, which defaults to `null`): OpenCL program source file
+- `kernel` (of type `string?`, which defaults to `null`): Kernel name in program
+- `size` (of type `string?`, which defaults to `null`): Video size
+- `s` (of type `string?`, which defaults to `null`): Video size
+- `format` (of type `string?`, which defaults to `null`): Video format
+- `rate` (of type `string?`, which defaults to `null`): Video frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): Video frame rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.oscilloscope`
+
+Ffmpeg filter: 2D Video Oscilloscope.
+
+Type:
+
+```
+(?x : float?, ?y : float?, ?s : float?, ?t : float?, ?o : float?,
+ ?tx : float?, ?ty : float?, ?tw : float?, ?th : float?, ?c : int?,
+ ?g : bool?, ?st : bool?, ?sc : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `float?`, which defaults to `null`): set scope x position. (default: 0.5)
+- `y` (of type `float?`, which defaults to `null`): set scope y position. (default: 0.5)
+- `s` (of type `float?`, which defaults to `null`): set scope size. (default: 0.8)
+- `t` (of type `float?`, which defaults to `null`): set scope tilt. (default: 0.5)
+- `o` (of type `float?`, which defaults to `null`): set trace opacity. (default: 0.8)
+- `tx` (of type `float?`, which defaults to `null`): set trace x position. (default: 0.5)
+- `ty` (of type `float?`, which defaults to `null`): set trace y position. (default: 0.9)
+- `tw` (of type `float?`, which defaults to `null`): set trace width. (default: 0.8)
+- `th` (of type `float?`, which defaults to `null`): set trace height. (default: 0.3)
+- `c` (of type `int?`, which defaults to `null`): set components to trace. (default: 7)
+- `g` (of type `bool?`, which defaults to `null`): draw trace grid. (default: true)
+- `st` (of type `bool?`, which defaults to `null`): draw statistics. (default: true)
+- `sc` (of type `bool?`, which defaults to `null`): draw scope. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.oscilloscope.create`
+
+Ffmpeg filter: 2D Video Oscilloscope.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : float?, ?y : float?, ?s : float?, ?t : float?, ?o : float?,
+ ?tx : float?, ?ty : float?, ?tw : float?, ?th : float?, ?c : int?,
+ ?g : bool?, ?st : bool?, ?sc : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `float?`, which defaults to `null`): set scope x position. (default: 0.5)
+- `y` (of type `float?`, which defaults to `null`): set scope y position. (default: 0.5)
+- `s` (of type `float?`, which defaults to `null`): set scope size. (default: 0.8)
+- `t` (of type `float?`, which defaults to `null`): set scope tilt. (default: 0.5)
+- `o` (of type `float?`, which defaults to `null`): set trace opacity. (default: 0.8)
+- `tx` (of type `float?`, which defaults to `null`): set trace x position. (default: 0.5)
+- `ty` (of type `float?`, which defaults to `null`): set trace y position. (default: 0.9)
+- `tw` (of type `float?`, which defaults to `null`): set trace width. (default: 0.8)
+- `th` (of type `float?`, which defaults to `null`): set trace height. (default: 0.3)
+- `c` (of type `int?`, which defaults to `null`): set components to trace. (default: 7)
+- `g` (of type `bool?`, which defaults to `null`): draw trace grid. (default: true)
+- `st` (of type `bool?`, which defaults to `null`): draw statistics. (default: true)
+- `sc` (of type `bool?`, which defaults to `null`): draw scope. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.overlay`
+
+Ffmpeg filter: Overlay a video source on top of the input.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?eof_action : int?, ?eval : int?,
+ ?shortest : bool?, ?format : int?, ?repeatlast : bool?, ?alpha : int?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set the x expression. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y expression. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 1, possible values: 0 (init), 1 (frame))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `format` (of type `int?`, which defaults to `null`): set output format. (default: 0, possible values: 0 (yuv420), 1 (yuv420p10), 2 (yuv422), 3 (yuv422p10), 4 (yuv444), 5 (yuv444p10), 6 (rgb), 7 (gbrp), 8 (auto))
+- `repeatlast` (of type `bool?`, which defaults to `null`): repeat overlay of the last overlay frame. (default: true)
+- `alpha` (of type `int?`, which defaults to `null`): alpha format. (default: 0, possible values: 0 (straight), 1 (premultiplied))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.overlay.create`
+
+Ffmpeg filter: Overlay a video source on top of the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?eof_action : int?, ?eval : int?,
+ ?shortest : bool?, ?format : int?, ?repeatlast : bool?, ?alpha : int?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set the x expression. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y expression. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 1, possible values: 0 (init), 1 (frame))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `format` (of type `int?`, which defaults to `null`): set output format. (default: 0, possible values: 0 (yuv420), 1 (yuv420p10), 2 (yuv422), 3 (yuv422p10), 4 (yuv444), 5 (yuv444p10), 6 (rgb), 7 (gbrp), 8 (auto))
+- `repeatlast` (of type `bool?`, which defaults to `null`): repeat overlay of the last overlay frame. (default: true)
+- `alpha` (of type `int?`, which defaults to `null`): alpha format. (default: 0, possible values: 0 (straight), 1 (premultiplied))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.overlay_cuda`
+
+Ffmpeg filter: Overlay one video on top of another using CUDA
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?eof_action : int?, ?eval : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set the x expression of overlay. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y expression of overlay. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 1, possible values: 0 (init), 1 (frame))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): repeat overlay of the last overlay frame. (default: true)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.overlay_cuda.create`
+
+Ffmpeg filter: Overlay one video on top of another using CUDA. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?eof_action : int?, ?eval : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): set the x expression of overlay. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y expression of overlay. (default: 0)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 1, possible values: 0 (init), 1 (frame))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): repeat overlay of the last overlay frame. (default: true)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.overlay_opencl`
+
+Ffmpeg filter: Overlay one video on top of another
+
+Type:
+
+```
+(?x : int?, ?y : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): Overlay x position. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): Overlay y position. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.overlay_opencl.create`
+
+Ffmpeg filter: Overlay one video on top of another. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : int?, ?y : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `int?`, which defaults to `null`): Overlay x position. (default: 0)
+- `y` (of type `int?`, which defaults to `null`): Overlay y position. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.overlay_vaapi`
+
+Ffmpeg filter: Overlay one video on top of another
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?w : string?, ?h : string?, ?alpha : float?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): Overlay x position. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): Overlay y position. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): Overlay width. (default: overlay_iw)
+- `h` (of type `string?`, which defaults to `null`): Overlay height. (default: overlay_ih*w/overlay_iw)
+- `alpha` (of type `float?`, which defaults to `null`): Overlay global alpha. (default: 1.)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): repeat overlay of the last overlay frame. (default: true)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.overlay_vaapi.create`
+
+Ffmpeg filter: Overlay one video on top of another. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : string?, ?y : string?, ?w : string?, ?h : string?, ?alpha : float?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `string?`, which defaults to `null`): Overlay x position. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): Overlay y position. (default: 0)
+- `w` (of type `string?`, which defaults to `null`): Overlay width. (default: overlay_iw)
+- `h` (of type `string?`, which defaults to `null`): Overlay height. (default: overlay_ih*w/overlay_iw)
+- `alpha` (of type `float?`, which defaults to `null`): Overlay global alpha. (default: 1.)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): repeat overlay of the last overlay frame. (default: true)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass), 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.owdenoise`
+
+Ffmpeg filter: Denoise using wavelets.
+
+Type:
+
+```
+(?depth : int?, ?luma_strength : float?, ?ls : float?,
+ ?chroma_strength : float?, ?cs : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `depth` (of type `int?`, which defaults to `null`): set depth. (default: 8)
+- `luma_strength` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `ls` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `chroma_strength` (of type `float?`, which defaults to `null`): set chroma strength. (default: 1.)
+- `cs` (of type `float?`, which defaults to `null`): set chroma strength. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.owdenoise.create`
+
+Ffmpeg filter: Denoise using wavelets.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?depth : int?, ?luma_strength : float?, ?ls : float?,
+ ?chroma_strength : float?, ?cs : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `depth` (of type `int?`, which defaults to `null`): set depth. (default: 8)
+- `luma_strength` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `ls` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `chroma_strength` (of type `float?`, which defaults to `null`): set chroma strength. (default: 1.)
+- `cs` (of type `float?`, which defaults to `null`): set chroma strength. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pad`
+
+Ffmpeg filter: Pad the input video.
+
+Type:
+
+```
+(?width : string?, ?w : string?, ?height : string?, ?h : string?,
+ ?x : string?, ?y : string?, ?color : string?, ?eval : int?,
+ ?aspect : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `width` (of type `string?`, which defaults to `null`): set the pad area width expression. (default: iw)
+- `w` (of type `string?`, which defaults to `null`): set the pad area width expression. (default: iw)
+- `height` (of type `string?`, which defaults to `null`): set the pad area height expression. (default: ih)
+- `h` (of type `string?`, which defaults to `null`): set the pad area height expression. (default: ih)
+- `x` (of type `string?`, which defaults to `null`): set the x offset expression for the input image position. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y offset expression for the input image position. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the padded area border. (default: black)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `aspect` (of type `string?`, which defaults to `null`): pad to fit an aspect instead of a resolution. (default: 0/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pad.create`
+
+Ffmpeg filter: Pad the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?width : string?, ?w : string?, ?height : string?, ?h : string?,
+ ?x : string?, ?y : string?, ?color : string?, ?eval : int?,
+ ?aspect : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `width` (of type `string?`, which defaults to `null`): set the pad area width expression. (default: iw)
+- `w` (of type `string?`, which defaults to `null`): set the pad area width expression. (default: iw)
+- `height` (of type `string?`, which defaults to `null`): set the pad area height expression. (default: ih)
+- `h` (of type `string?`, which defaults to `null`): set the pad area height expression. (default: ih)
+- `x` (of type `string?`, which defaults to `null`): set the x offset expression for the input image position. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y offset expression for the input image position. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the padded area border. (default: black)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `aspect` (of type `string?`, which defaults to `null`): pad to fit an aspect instead of a resolution. (default: 0/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pad_opencl`
+
+Ffmpeg filter: Pad the input video.
+
+Type:
+
+```
+(?width : string?, ?w : string?, ?height : string?, ?h : string?,
+ ?x : string?, ?y : string?, ?color : string?, ?aspect : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `width` (of type `string?`, which defaults to `null`): set the pad area width. (default: iw)
+- `w` (of type `string?`, which defaults to `null`): set the pad area width. (default: iw)
+- `height` (of type `string?`, which defaults to `null`): set the pad area height. (default: ih)
+- `h` (of type `string?`, which defaults to `null`): set the pad area height. (default: ih)
+- `x` (of type `string?`, which defaults to `null`): set the x offset for the input image position. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y offset for the input image position. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the padded area border. (default: black)
+- `aspect` (of type `string?`, which defaults to `null`): pad to fit an aspect instead of a resolution. (default: 0/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pad_opencl.create`
+
+Ffmpeg filter: Pad the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?width : string?, ?w : string?, ?height : string?, ?h : string?,
+ ?x : string?, ?y : string?, ?color : string?, ?aspect : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `width` (of type `string?`, which defaults to `null`): set the pad area width. (default: iw)
+- `w` (of type `string?`, which defaults to `null`): set the pad area width. (default: iw)
+- `height` (of type `string?`, which defaults to `null`): set the pad area height. (default: ih)
+- `h` (of type `string?`, which defaults to `null`): set the pad area height. (default: ih)
+- `x` (of type `string?`, which defaults to `null`): set the x offset for the input image position. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y offset for the input image position. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the padded area border. (default: black)
+- `aspect` (of type `string?`, which defaults to `null`): pad to fit an aspect instead of a resolution. (default: 0/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pal100bars`
+
+Ffmpeg filter: Generate PAL 100% color bars.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.pal100bars.create`
+
+Ffmpeg filter: Generate PAL 100% color bars.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pal75bars`
+
+Ffmpeg filter: Generate PAL 75% color bars.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.pal75bars.create`
+
+Ffmpeg filter: Generate PAL 75% color bars.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.palettegen`
+
+Ffmpeg filter: Find the optimal palette for a given stream.
+
+Type:
+
+```
+(?max_colors : int?, ?reserve_transparent : bool?,
+ ?transparency_color : string?, ?stats_mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `max_colors` (of type `int?`, which defaults to `null`): set the maximum number of colors to use in the palette. (default: 256)
+- `reserve_transparent` (of type `bool?`, which defaults to `null`): reserve a palette entry for transparency. (default: true)
+- `transparency_color` (of type `string?`, which defaults to `null`): set a background color for transparency. (default: lime)
+- `stats_mode` (of type `int?`, which defaults to `null`): set statistics mode. (default: 0, possible values: 0 (full), 1 (diff), 2 (single))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.palettegen.create`
+
+Ffmpeg filter: Find the optimal palette for a given stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?max_colors : int?, ?reserve_transparent : bool?,
+ ?transparency_color : string?, ?stats_mode : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `max_colors` (of type `int?`, which defaults to `null`): set the maximum number of colors to use in the palette. (default: 256)
+- `reserve_transparent` (of type `bool?`, which defaults to `null`): reserve a palette entry for transparency. (default: true)
+- `transparency_color` (of type `string?`, which defaults to `null`): set a background color for transparency. (default: lime)
+- `stats_mode` (of type `int?`, which defaults to `null`): set statistics mode. (default: 0, possible values: 0 (full), 1 (diff), 2 (single))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.paletteuse`
+
+Ffmpeg filter: Use a palette to downsample an input video stream.
+
+Type:
+
+```
+(?dither : int?, ?bayer_scale : int?, ?diff_mode : int?, ?new : bool?,
+ ?alpha_threshold : int?, ?debug_kdtree : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dither` (of type `int?`, which defaults to `null`): select dithering mode. (default: 5, possible values: 1 (bayer), 2 (heckbert), 3 (floyd_steinberg), 4 (sierra2), 5 (sierra2_4a), 6 (sierra3), 7 (burkes), 8 (atkinson))
+- `bayer_scale` (of type `int?`, which defaults to `null`): set scale for bayer dithering. (default: 2)
+- `diff_mode` (of type `int?`, which defaults to `null`): set frame difference mode. (default: 0, possible values: 1 (rectangle))
+- `new` (of type `bool?`, which defaults to `null`): take new palette for each output frame. (default: false)
+- `alpha_threshold` (of type `int?`, which defaults to `null`): set the alpha threshold for transparency. (default: 128)
+- `debug_kdtree` (of type `string?`, which defaults to `null`): save Graphviz graph of the kdtree in specified file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.paletteuse.create`
+
+Ffmpeg filter: Use a palette to downsample an input video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dither : int?, ?bayer_scale : int?, ?diff_mode : int?, ?new : bool?,
+ ?alpha_threshold : int?, ?debug_kdtree : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `dither` (of type `int?`, which defaults to `null`): select dithering mode. (default: 5, possible values: 1 (bayer), 2 (heckbert), 3 (floyd_steinberg), 4 (sierra2), 5 (sierra2_4a), 6 (sierra3), 7 (burkes), 8 (atkinson))
+- `bayer_scale` (of type `int?`, which defaults to `null`): set scale for bayer dithering. (default: 2)
+- `diff_mode` (of type `int?`, which defaults to `null`): set frame difference mode. (default: 0, possible values: 1 (rectangle))
+- `new` (of type `bool?`, which defaults to `null`): take new palette for each output frame. (default: false)
+- `alpha_threshold` (of type `int?`, which defaults to `null`): set the alpha threshold for transparency. (default: 128)
+- `debug_kdtree` (of type `string?`, which defaults to `null`): save Graphviz graph of the kdtree in specified file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pan`
+
+Ffmpeg filter: Remix channels with coefficients (panning).
+
+Type:
+
+```
+(?args : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `args` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.pan.create`
+
+Ffmpeg filter: Remix channels with coefficients (panning).. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?args : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `args` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.perms`
+
+Ffmpeg filter: Set permissions for the output video frame.
+
+Type:
+
+```
+(?mode : int?, ?seed : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select permissions mode. (default: 0, possible values: 0 (none), 1 (ro), 2 (rw), 3 (toggle), 4 (random))
+- `seed` (of type `int?`, which defaults to `null`): set the seed for the random mode. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.perms.create`
+
+Ffmpeg filter: Set permissions for the output video frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?seed : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select permissions mode. (default: 0, possible values: 0 (none), 1 (ro), 2 (rw), 3 (toggle), 4 (random))
+- `seed` (of type `int?`, which defaults to `null`): set the seed for the random mode. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.perspective`
+
+Ffmpeg filter: Correct the perspective of video.
+
+Type:
+
+```
+(?x0 : string?, ?y0 : string?, ?x1 : string?, ?y1 : string?, ?x2 : string?,
+ ?y2 : string?, ?x3 : string?, ?y3 : string?, ?interpolation : int?,
+ ?sense : int?, ?eval : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x0` (of type `string?`, which defaults to `null`): set top left x coordinate. (default: 0)
+- `y0` (of type `string?`, which defaults to `null`): set top left y coordinate. (default: 0)
+- `x1` (of type `string?`, which defaults to `null`): set top right x coordinate. (default: W)
+- `y1` (of type `string?`, which defaults to `null`): set top right y coordinate. (default: 0)
+- `x2` (of type `string?`, which defaults to `null`): set bottom left x coordinate. (default: 0)
+- `y2` (of type `string?`, which defaults to `null`): set bottom left y coordinate. (default: H)
+- `x3` (of type `string?`, which defaults to `null`): set bottom right x coordinate. (default: W)
+- `y3` (of type `string?`, which defaults to `null`): set bottom right y coordinate. (default: H)
+- `interpolation` (of type `int?`, which defaults to `null`): set interpolation. (default: 0, possible values: 0 (linear), 1 (cubic))
+- `sense` (of type `int?`, which defaults to `null`): specify the sense of the coordinates. (default: 0, possible values: 0 (source), 1 (destination))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.perspective.create`
+
+Ffmpeg filter: Correct the perspective of video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x0 : string?, ?y0 : string?, ?x1 : string?, ?y1 : string?, ?x2 : string?,
+ ?y2 : string?, ?x3 : string?, ?y3 : string?, ?interpolation : int?,
+ ?sense : int?, ?eval : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x0` (of type `string?`, which defaults to `null`): set top left x coordinate. (default: 0)
+- `y0` (of type `string?`, which defaults to `null`): set top left y coordinate. (default: 0)
+- `x1` (of type `string?`, which defaults to `null`): set top right x coordinate. (default: W)
+- `y1` (of type `string?`, which defaults to `null`): set top right y coordinate. (default: 0)
+- `x2` (of type `string?`, which defaults to `null`): set bottom left x coordinate. (default: 0)
+- `y2` (of type `string?`, which defaults to `null`): set bottom left y coordinate. (default: H)
+- `x3` (of type `string?`, which defaults to `null`): set bottom right x coordinate. (default: W)
+- `y3` (of type `string?`, which defaults to `null`): set bottom right y coordinate. (default: H)
+- `interpolation` (of type `int?`, which defaults to `null`): set interpolation. (default: 0, possible values: 0 (linear), 1 (cubic))
+- `sense` (of type `int?`, which defaults to `null`): specify the sense of the coordinates. (default: 0, possible values: 0 (source), 1 (destination))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.phase`
+
+Ffmpeg filter: Phase shift fields.
+
+Type:
+
+```
+(?mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set phase mode. (default: 8, possible values: 0 (p), 1 (t), 2 (b), 3 (T), 4 (B), 5 (u), 6 (U), 7 (a), 8 (A))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.phase.create`
+
+Ffmpeg filter: Phase shift fields.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set phase mode. (default: 8, possible values: 0 (p), 1 (t), 2 (b), 3 (T), 4 (B), 5 (u), 6 (U), 7 (a), 8 (A))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.photosensitivity`
+
+Ffmpeg filter: Filter out photosensitive epilepsy seizure-inducing flashes.
+
+Type:
+
+```
+(?frames : int?, ?f : int?, ?threshold : float?, ?t : float?, ?skip : int?,
+ ?bypass : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `frames` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 30)
+- `f` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 30)
+- `threshold` (of type `float?`, which defaults to `null`): set detection threshold factor (lower is stricter). (default: 1.)
+- `t` (of type `float?`, which defaults to `null`): set detection threshold factor (lower is stricter). (default: 1.)
+- `skip` (of type `int?`, which defaults to `null`): set pixels to skip when sampling frames. (default: 1)
+- `bypass` (of type `bool?`, which defaults to `null`): leave frames unchanged. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.photosensitivity.create`
+
+Ffmpeg filter: Filter out photosensitive epilepsy seizure-inducing flashes.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frames : int?, ?f : int?, ?threshold : float?, ?t : float?, ?skip : int?,
+ ?bypass : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frames` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 30)
+- `f` (of type `int?`, which defaults to `null`): set how many frames to use. (default: 30)
+- `threshold` (of type `float?`, which defaults to `null`): set detection threshold factor (lower is stricter). (default: 1.)
+- `t` (of type `float?`, which defaults to `null`): set detection threshold factor (lower is stricter). (default: 1.)
+- `skip` (of type `int?`, which defaults to `null`): set pixels to skip when sampling frames. (default: 1)
+- `bypass` (of type `bool?`, which defaults to `null`): leave frames unchanged. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pixdesctest`
+
+Ffmpeg filter: Test pixel format definitions.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pixdesctest.create`
+
+Ffmpeg filter: Test pixel format definitions.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pixelize`
+
+Ffmpeg filter: Pixelize video.
+
+Type:
+
+```
+(?width : int?, ?w : int?, ?height : int?, ?h : int?, ?mode : int?,
+ ?m : int?, ?planes : int?, ?p : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `width` (of type `int?`, which defaults to `null`): set block width. (default: 16)
+- `w` (of type `int?`, which defaults to `null`): set block width. (default: 16)
+- `height` (of type `int?`, which defaults to `null`): set block height. (default: 16)
+- `h` (of type `int?`, which defaults to `null`): set block height. (default: 16)
+- `mode` (of type `int?`, which defaults to `null`): set the pixelize mode. (default: 0, possible values: 0 (avg), 1 (min), 2 (max))
+- `m` (of type `int?`, which defaults to `null`): set the pixelize mode. (default: 0, possible values: 0 (avg), 1 (min), 2 (max))
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `p` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pixelize.create`
+
+Ffmpeg filter: Pixelize video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?width : int?, ?w : int?, ?height : int?, ?h : int?, ?mode : int?,
+ ?m : int?, ?planes : int?, ?p : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `width` (of type `int?`, which defaults to `null`): set block width. (default: 16)
+- `w` (of type `int?`, which defaults to `null`): set block width. (default: 16)
+- `height` (of type `int?`, which defaults to `null`): set block height. (default: 16)
+- `h` (of type `int?`, which defaults to `null`): set block height. (default: 16)
+- `mode` (of type `int?`, which defaults to `null`): set the pixelize mode. (default: 0, possible values: 0 (avg), 1 (min), 2 (max))
+- `m` (of type `int?`, which defaults to `null`): set the pixelize mode. (default: 0, possible values: 0 (avg), 1 (min), 2 (max))
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `p` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pixscope`
+
+Ffmpeg filter: Pixel data analysis.
+
+Type:
+
+```
+(?x : float?, ?y : float?, ?w : int?, ?h : int?, ?o : float?, ?wx : float?,
+ ?wy : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `x` (of type `float?`, which defaults to `null`): set scope x offset. (default: 0.5)
+- `y` (of type `float?`, which defaults to `null`): set scope y offset. (default: 0.5)
+- `w` (of type `int?`, which defaults to `null`): set scope width. (default: 7)
+- `h` (of type `int?`, which defaults to `null`): set scope height. (default: 7)
+- `o` (of type `float?`, which defaults to `null`): set window opacity. (default: 0.5)
+- `wx` (of type `float?`, which defaults to `null`): set window x offset. (default: -1.)
+- `wy` (of type `float?`, which defaults to `null`): set window y offset. (default: -1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pixscope.create`
+
+Ffmpeg filter: Pixel data analysis.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?x : float?, ?y : float?, ?w : int?, ?h : int?, ?o : float?, ?wx : float?,
+ ?wy : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `x` (of type `float?`, which defaults to `null`): set scope x offset. (default: 0.5)
+- `y` (of type `float?`, which defaults to `null`): set scope y offset. (default: 0.5)
+- `w` (of type `int?`, which defaults to `null`): set scope width. (default: 7)
+- `h` (of type `int?`, which defaults to `null`): set scope height. (default: 7)
+- `o` (of type `float?`, which defaults to `null`): set window opacity. (default: 0.5)
+- `wx` (of type `float?`, which defaults to `null`): set window x offset. (default: -1.)
+- `wy` (of type `float?`, which defaults to `null`): set window y offset. (default: -1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pp`
+
+Ffmpeg filter: Filter video using libpostproc.
+
+Type:
+
+```
+(?subfilters : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `subfilters` (of type `string?`, which defaults to `null`): set postprocess subfilters. (default: de)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pp.create`
+
+Ffmpeg filter: Filter video using libpostproc.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?subfilters : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `subfilters` (of type `string?`, which defaults to `null`): set postprocess subfilters. (default: de)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pp7`
+
+Ffmpeg filter: Apply Postprocessing 7 filter.
+
+Type:
+
+```
+(?qp : int?, ?mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set thresholding mode. (default: 2, possible values: 0 (hard), 1 (soft), 2 (medium))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pp7.create`
+
+Ffmpeg filter: Apply Postprocessing 7 filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?qp : int?, ?mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set thresholding mode. (default: 2, possible values: 0 (hard), 1 (soft), 2 (medium))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.premultiply`
+
+Ffmpeg filter: PreMultiply first stream with first plane of second stream. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?planes : int?, ?inplace : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `inplace` (of type `bool?`, which defaults to `null`): enable inplace mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.premultiply.create`
+
+Ffmpeg filter: PreMultiply first stream with first plane of second stream. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?inplace : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `inplace` (of type `bool?`, which defaults to `null`): enable inplace mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.prewitt`
+
+Ffmpeg filter: Apply prewitt operator.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.prewitt.create`
+
+Ffmpeg filter: Apply prewitt operator.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.prewitt_opencl`
+
+Ffmpeg filter: Apply prewitt operator
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.prewitt_opencl.create`
+
+Ffmpeg filter: Apply prewitt operator. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.procamp_vaapi`
+
+Ffmpeg filter: ProcAmp (color balance) adjustments for hue, saturation, brightness, contrast
+
+Type:
+
+```
+(?b : float?, ?brightness : float?, ?s : float?, ?saturatio : float?,
+ ?c : float?, ?contrast : float?, ?h : float?, ?hue : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `b` (of type `float?`, which defaults to `null`): Output video brightness. (default: 0.)
+- `brightness` (of type `float?`, which defaults to `null`): Output video brightness. (default: 0.)
+- `s` (of type `float?`, which defaults to `null`): Output video saturation. (default: 1.)
+- `saturatio` (of type `float?`, which defaults to `null`): Output video saturation. (default: 1.)
+- `c` (of type `float?`, which defaults to `null`): Output video contrast. (default: 1.)
+- `contrast` (of type `float?`, which defaults to `null`): Output video contrast. (default: 1.)
+- `h` (of type `float?`, which defaults to `null`): Output video hue. (default: 0.)
+- `hue` (of type `float?`, which defaults to `null`): Output video hue. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.procamp_vaapi.create`
+
+Ffmpeg filter: ProcAmp (color balance) adjustments for hue, saturation, brightness, contrast. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?b : float?, ?brightness : float?, ?s : float?, ?saturatio : float?,
+ ?c : float?, ?contrast : float?, ?h : float?, ?hue : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `b` (of type `float?`, which defaults to `null`): Output video brightness. (default: 0.)
+- `brightness` (of type `float?`, which defaults to `null`): Output video brightness. (default: 0.)
+- `s` (of type `float?`, which defaults to `null`): Output video saturation. (default: 1.)
+- `saturatio` (of type `float?`, which defaults to `null`): Output video saturation. (default: 1.)
+- `c` (of type `float?`, which defaults to `null`): Output video contrast. (default: 1.)
+- `contrast` (of type `float?`, which defaults to `null`): Output video contrast. (default: 1.)
+- `h` (of type `float?`, which defaults to `null`): Output video hue. (default: 0.)
+- `hue` (of type `float?`, which defaults to `null`): Output video hue. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.program_opencl`
+
+Ffmpeg filter: Filter video using an OpenCL program This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?source : string?, ?kernel : string?, ?inputs : int?, ?size : string?,
+ ?s : string?, ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `source` (of type `string?`, which defaults to `null`): OpenCL program source file
+- `kernel` (of type `string?`, which defaults to `null`): Kernel name in program
+- `inputs` (of type `int?`, which defaults to `null`): Number of inputs. (default: 1)
+- `size` (of type `string?`, which defaults to `null`): Video size
+- `s` (of type `string?`, which defaults to `null`): Video size
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.program_opencl.create`
+
+Ffmpeg filter: Filter video using an OpenCL program This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?source : string?, ?kernel : string?, ?inputs : int?, ?size : string?,
+ ?s : string?, ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `source` (of type `string?`, which defaults to `null`): OpenCL program source file
+- `kernel` (of type `string?`, which defaults to `null`): Kernel name in program
+- `inputs` (of type `int?`, which defaults to `null`): Number of inputs. (default: 1)
+- `size` (of type `string?`, which defaults to `null`): Video size
+- `s` (of type `string?`, which defaults to `null`): Video size
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pseudocolor`
+
+Ffmpeg filter: Make pseudocolored video frames.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?index : int?,
+ ?i : int?, ?preset : int?, ?p : int?, ?opacity : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: val)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: val)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: val)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: val)
+- `index` (of type `int?`, which defaults to `null`): set component as base. (default: 0)
+- `i` (of type `int?`, which defaults to `null`): set component as base. (default: 0)
+- `preset` (of type `int?`, which defaults to `null`): set preset. (default: -1, possible values: -1 (none), 0 (magma), 1 (inferno), 2 (plasma), 3 (viridis), 4 (turbo), 5 (cividis), 6 (range1), 7 (range2), 8 (shadows), 9 (highlights), 10 (solar), 11 (nominal), 12 (preferred), 13 (total), 14 (spectral), 15 (cool), 16 (heat), 17 (fiery), 18 (blues), 19 (green), 20 (helix))
+- `p` (of type `int?`, which defaults to `null`): set preset. (default: -1, possible values: -1 (none), 0 (magma), 1 (inferno), 2 (plasma), 3 (viridis), 4 (turbo), 5 (cividis), 6 (range1), 7 (range2), 8 (shadows), 9 (highlights), 10 (solar), 11 (nominal), 12 (preferred), 13 (total), 14 (spectral), 15 (cool), 16 (heat), 17 (fiery), 18 (blues), 19 (green), 20 (helix))
+- `opacity` (of type `float?`, which defaults to `null`): set pseudocolor opacity. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pseudocolor.create`
+
+Ffmpeg filter: Make pseudocolored video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?, ?index : int?,
+ ?i : int?, ?preset : int?, ?p : int?, ?opacity : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: val)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: val)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: val)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: val)
+- `index` (of type `int?`, which defaults to `null`): set component as base. (default: 0)
+- `i` (of type `int?`, which defaults to `null`): set component as base. (default: 0)
+- `preset` (of type `int?`, which defaults to `null`): set preset. (default: -1, possible values: -1 (none), 0 (magma), 1 (inferno), 2 (plasma), 3 (viridis), 4 (turbo), 5 (cividis), 6 (range1), 7 (range2), 8 (shadows), 9 (highlights), 10 (solar), 11 (nominal), 12 (preferred), 13 (total), 14 (spectral), 15 (cool), 16 (heat), 17 (fiery), 18 (blues), 19 (green), 20 (helix))
+- `p` (of type `int?`, which defaults to `null`): set preset. (default: -1, possible values: -1 (none), 0 (magma), 1 (inferno), 2 (plasma), 3 (viridis), 4 (turbo), 5 (cividis), 6 (range1), 7 (range2), 8 (shadows), 9 (highlights), 10 (solar), 11 (nominal), 12 (preferred), 13 (total), 14 (spectral), 15 (cool), 16 (heat), 17 (fiery), 18 (blues), 19 (green), 20 (helix))
+- `opacity` (of type `float?`, which defaults to `null`): set pseudocolor opacity. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.psnr`
+
+Ffmpeg filter: Calculate the PSNR between two video streams.
+
+Type:
+
+```
+(?stats_file : string?, ?f : string?, ?stats_version : int?,
+ ?output_max : bool?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `f` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `stats_version` (of type `int?`, which defaults to `null`): Set the format version for the stats file.. (default: 1)
+- `output_max` (of type `bool?`, which defaults to `null`): Add raw stats (max values) to the output log.. (default: false)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.psnr.create`
+
+Ffmpeg filter: Calculate the PSNR between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?stats_file : string?, ?f : string?, ?stats_version : int?,
+ ?output_max : bool?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `f` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `stats_version` (of type `int?`, which defaults to `null`): Set the format version for the stats file.. (default: 1)
+- `output_max` (of type `bool?`, which defaults to `null`): Add raw stats (max values) to the output log.. (default: false)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.pullup`
+
+Ffmpeg filter: Pullup from field sequence to frames.
+
+Type:
+
+```
+(?jl : int?, ?jr : int?, ?jt : int?, ?jb : int?, ?sb : bool?, ?mp : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `jl` (of type `int?`, which defaults to `null`): set left junk size. (default: 1)
+- `jr` (of type `int?`, which defaults to `null`): set right junk size. (default: 1)
+- `jt` (of type `int?`, which defaults to `null`): set top junk size. (default: 4)
+- `jb` (of type `int?`, which defaults to `null`): set bottom junk size. (default: 4)
+- `sb` (of type `bool?`, which defaults to `null`): set strict breaks. (default: false)
+- `mp` (of type `int?`, which defaults to `null`): set metric plane. (default: 0, possible values: 0 (y), 1 (u), 2 (v))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.pullup.create`
+
+Ffmpeg filter: Pullup from field sequence to frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?jl : int?, ?jr : int?, ?jt : int?, ?jb : int?, ?sb : bool?, ?mp : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `jl` (of type `int?`, which defaults to `null`): set left junk size. (default: 1)
+- `jr` (of type `int?`, which defaults to `null`): set right junk size. (default: 1)
+- `jt` (of type `int?`, which defaults to `null`): set top junk size. (default: 4)
+- `jb` (of type `int?`, which defaults to `null`): set bottom junk size. (default: 4)
+- `sb` (of type `bool?`, which defaults to `null`): set strict breaks. (default: false)
+- `mp` (of type `int?`, which defaults to `null`): set metric plane. (default: 0, possible values: 0 (y), 1 (u), 2 (v))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.qp`
+
+Ffmpeg filter: Change video quantization parameters.
+
+Type:
+
+```
+(?qp : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `qp` (of type `string?`, which defaults to `null`): set qp expression
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.qp.create`
+
+Ffmpeg filter: Change video quantization parameters.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?qp : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `qp` (of type `string?`, which defaults to `null`): set qp expression
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.random`
+
+Ffmpeg filter: Return random frames.
+
+Type:
+
+```
+(?frames : int?, ?seed : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `frames` (of type `int?`, which defaults to `null`): set number of frames in cache. (default: 30)
+- `seed` (of type `int?`, which defaults to `null`): set the seed. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.random.create`
+
+Ffmpeg filter: Return random frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frames : int?, ?seed : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frames` (of type `int?`, which defaults to `null`): set number of frames in cache. (default: 30)
+- `seed` (of type `int?`, which defaults to `null`): set the seed. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.readeia608`
+
+Ffmpeg filter: Read EIA-608 Closed Caption codes from input video and write them to frame metadata.
+
+Type:
+
+```
+(?scan_min : int?, ?scan_max : int?, ?spw : float?, ?chp : bool?,
+ ?lp : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `scan_min` (of type `int?`, which defaults to `null`): set from which line to scan for codes. (default: 0)
+- `scan_max` (of type `int?`, which defaults to `null`): set to which line to scan for codes. (default: 29)
+- `spw` (of type `float?`, which defaults to `null`): set ratio of width reserved for sync code detection. (default: 0.27)
+- `chp` (of type `bool?`, which defaults to `null`): check and apply parity bit. (default: false)
+- `lp` (of type `bool?`, which defaults to `null`): lowpass line prior to processing. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.readeia608.create`
+
+Ffmpeg filter: Read EIA-608 Closed Caption codes from input video and write them to frame metadata.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?scan_min : int?, ?scan_max : int?, ?spw : float?, ?chp : bool?,
+ ?lp : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `scan_min` (of type `int?`, which defaults to `null`): set from which line to scan for codes. (default: 0)
+- `scan_max` (of type `int?`, which defaults to `null`): set to which line to scan for codes. (default: 29)
+- `spw` (of type `float?`, which defaults to `null`): set ratio of width reserved for sync code detection. (default: 0.27)
+- `chp` (of type `bool?`, which defaults to `null`): check and apply parity bit. (default: false)
+- `lp` (of type `bool?`, which defaults to `null`): lowpass line prior to processing. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.readvitc`
+
+Ffmpeg filter: Read vertical interval timecode and write it to frame metadata.
+
+Type:
+
+```
+(?scan_max : int?, ?thr_b : float?, ?thr_w : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `scan_max` (of type `int?`, which defaults to `null`): maximum line numbers to scan for VITC data. (default: 45)
+- `thr_b` (of type `float?`, which defaults to `null`): black color threshold. (default: 0.2)
+- `thr_w` (of type `float?`, which defaults to `null`): white color threshold. (default: 0.6)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.readvitc.create`
+
+Ffmpeg filter: Read vertical interval timecode and write it to frame metadata.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?scan_max : int?, ?thr_b : float?, ?thr_w : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `scan_max` (of type `int?`, which defaults to `null`): maximum line numbers to scan for VITC data. (default: 45)
+- `thr_b` (of type `float?`, which defaults to `null`): black color threshold. (default: 0.2)
+- `thr_w` (of type `float?`, which defaults to `null`): white color threshold. (default: 0.6)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.realtime`
+
+Ffmpeg filter: Slow down filtering to match realtime.
+
+Type:
+
+```
+(?limit : int?, ?speed : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `limit` (of type `int?`, which defaults to `null`): sleep time limit. (default: 2000000)
+- `speed` (of type `float?`, which defaults to `null`): speed factor. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.realtime.create`
+
+Ffmpeg filter: Slow down filtering to match realtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?limit : int?, ?speed : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `limit` (of type `int?`, which defaults to `null`): sleep time limit. (default: 2000000)
+- `speed` (of type `float?`, which defaults to `null`): speed factor. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.remap`
+
+Ffmpeg filter: Remap pixels.
+
+Type:
+
+```
+(?format : int?, ?fill : string?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `format` (of type `int?`, which defaults to `null`): set output format. (default: 0, possible values: 0 (color), 1 (gray))
+- `fill` (of type `string?`, which defaults to `null`): set the color of the unmapped pixels. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.remap.create`
+
+Ffmpeg filter: Remap pixels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?format : int?, ?fill : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `format` (of type `int?`, which defaults to `null`): set output format. (default: 0, possible values: 0 (color), 1 (gray))
+- `fill` (of type `string?`, which defaults to `null`): set the color of the unmapped pixels. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.remap_opencl`
+
+Ffmpeg filter: Remap pixels using OpenCL.
+
+Type:
+
+```
+(?interp : int?, ?fill : string?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `interp` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (near), 1 (linear))
+- `fill` (of type `string?`, which defaults to `null`): set the color of the unmapped pixels. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.remap_opencl.create`
+
+Ffmpeg filter: Remap pixels using OpenCL.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?interp : int?, ?fill : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `interp` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (near), 1 (linear))
+- `fill` (of type `string?`, which defaults to `null`): set the color of the unmapped pixels. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.removegrain`
+
+Ffmpeg filter: Remove grain.
+
+Type:
+
+```
+(?m0 : int?, ?m1 : int?, ?m2 : int?, ?m3 : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `m0` (of type `int?`, which defaults to `null`): set mode for 1st plane. (default: 0)
+- `m1` (of type `int?`, which defaults to `null`): set mode for 2nd plane. (default: 0)
+- `m2` (of type `int?`, which defaults to `null`): set mode for 3rd plane. (default: 0)
+- `m3` (of type `int?`, which defaults to `null`): set mode for 4th plane. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.removegrain.create`
+
+Ffmpeg filter: Remove grain.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?m0 : int?, ?m1 : int?, ?m2 : int?, ?m3 : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `m0` (of type `int?`, which defaults to `null`): set mode for 1st plane. (default: 0)
+- `m1` (of type `int?`, which defaults to `null`): set mode for 2nd plane. (default: 0)
+- `m2` (of type `int?`, which defaults to `null`): set mode for 3rd plane. (default: 0)
+- `m3` (of type `int?`, which defaults to `null`): set mode for 4th plane. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.removelogo`
+
+Ffmpeg filter: Remove a TV logo based on a mask image.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set bitmap filename
+- `f` (of type `string?`, which defaults to `null`): set bitmap filename
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.removelogo.create`
+
+Ffmpeg filter: Remove a TV logo based on a mask image.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set bitmap filename
+- `f` (of type `string?`, which defaults to `null`): set bitmap filename
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.repeatfields`
+
+Ffmpeg filter: Hard repeat fields based on MPEG repeat field flag.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.repeatfields.create`
+
+Ffmpeg filter: Hard repeat fields based on MPEG repeat field flag.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.replaygain`
+
+Ffmpeg filter: ReplayGain scanner.
+
+Type:
+
+```
+(?track_gain : float?, ?track_peak : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `track_gain` (of type `float?`, which defaults to `null`): track gain (dB). (default: 0.)
+- `track_peak` (of type `float?`, which defaults to `null`): track peak. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.replaygain.create`
+
+Ffmpeg filter: ReplayGain scanner.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?track_gain : float?, ?track_peak : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `track_gain` (of type `float?`, which defaults to `null`): track gain (dB). (default: 0.)
+- `track_peak` (of type `float?`, which defaults to `null`): track peak. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.reverse`
+
+Ffmpeg filter: Reverse a clip.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.reverse.create`
+
+Ffmpeg filter: Reverse a clip.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.rgbashift`
+
+Ffmpeg filter: Shift RGBA.
+
+Type:
+
+```
+(?rh : int?, ?rv : int?, ?gh : int?, ?gv : int?, ?bh : int?, ?bv : int?,
+ ?ah : int?, ?av : int?, ?edge : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rh` (of type `int?`, which defaults to `null`): shift red horizontally. (default: 0)
+- `rv` (of type `int?`, which defaults to `null`): shift red vertically. (default: 0)
+- `gh` (of type `int?`, which defaults to `null`): shift green horizontally. (default: 0)
+- `gv` (of type `int?`, which defaults to `null`): shift green vertically. (default: 0)
+- `bh` (of type `int?`, which defaults to `null`): shift blue horizontally. (default: 0)
+- `bv` (of type `int?`, which defaults to `null`): shift blue vertically. (default: 0)
+- `ah` (of type `int?`, which defaults to `null`): shift alpha horizontally. (default: 0)
+- `av` (of type `int?`, which defaults to `null`): shift alpha vertically. (default: 0)
+- `edge` (of type `int?`, which defaults to `null`): set edge operation. (default: 0, possible values: 0 (smear), 1 (wrap))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.rgbashift.create`
+
+Ffmpeg filter: Shift RGBA.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rh : int?, ?rv : int?, ?gh : int?, ?gv : int?, ?bh : int?, ?bv : int?,
+ ?ah : int?, ?av : int?, ?edge : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rh` (of type `int?`, which defaults to `null`): shift red horizontally. (default: 0)
+- `rv` (of type `int?`, which defaults to `null`): shift red vertically. (default: 0)
+- `gh` (of type `int?`, which defaults to `null`): shift green horizontally. (default: 0)
+- `gv` (of type `int?`, which defaults to `null`): shift green vertically. (default: 0)
+- `bh` (of type `int?`, which defaults to `null`): shift blue horizontally. (default: 0)
+- `bv` (of type `int?`, which defaults to `null`): shift blue vertically. (default: 0)
+- `ah` (of type `int?`, which defaults to `null`): shift alpha horizontally. (default: 0)
+- `av` (of type `int?`, which defaults to `null`): shift alpha vertically. (default: 0)
+- `edge` (of type `int?`, which defaults to `null`): set edge operation. (default: 0, possible values: 0 (smear), 1 (wrap))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.rgbtestsrc`
+
+Ffmpeg filter: Generate RGB test pattern.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?complement : bool?,
+ ?co : bool?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `complement` (of type `bool?`, which defaults to `null`): set complement colors. (default: false)
+- `co` (of type `bool?`, which defaults to `null`): set complement colors. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.rgbtestsrc.create`
+
+Ffmpeg filter: Generate RGB test pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?complement : bool?,
+ ?co : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `complement` (of type `bool?`, which defaults to `null`): set complement colors. (default: false)
+- `co` (of type `bool?`, which defaults to `null`): set complement colors. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.roberts`
+
+Ffmpeg filter: Apply roberts cross operator.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.roberts.create`
+
+Ffmpeg filter: Apply roberts cross operator.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.roberts_opencl`
+
+Ffmpeg filter: Apply roberts operator
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.roberts_opencl.create`
+
+Ffmpeg filter: Apply roberts operator. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.rotate`
+
+Ffmpeg filter: Rotate the input image.
+
+Type:
+
+```
+(?angle : string?, ?a : string?, ?out_w : string?, ?ow : string?,
+ ?out_h : string?, ?oh : string?, ?fillcolor : string?, ?c : string?,
+ ?bilinear : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `angle` (of type `string?`, which defaults to `null`): set angle (in radians). (default: 0)
+- `a` (of type `string?`, which defaults to `null`): set angle (in radians). (default: 0)
+- `out_w` (of type `string?`, which defaults to `null`): set output width expression. (default: iw)
+- `ow` (of type `string?`, which defaults to `null`): set output width expression. (default: iw)
+- `out_h` (of type `string?`, which defaults to `null`): set output height expression. (default: ih)
+- `oh` (of type `string?`, which defaults to `null`): set output height expression. (default: ih)
+- `fillcolor` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `bilinear` (of type `bool?`, which defaults to `null`): use bilinear interpolation. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.rotate.create`
+
+Ffmpeg filter: Rotate the input image.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?angle : string?, ?a : string?, ?out_w : string?, ?ow : string?,
+ ?out_h : string?, ?oh : string?, ?fillcolor : string?, ?c : string?,
+ ?bilinear : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `angle` (of type `string?`, which defaults to `null`): set angle (in radians). (default: 0)
+- `a` (of type `string?`, which defaults to `null`): set angle (in radians). (default: 0)
+- `out_w` (of type `string?`, which defaults to `null`): set output width expression. (default: iw)
+- `ow` (of type `string?`, which defaults to `null`): set output width expression. (default: iw)
+- `out_h` (of type `string?`, which defaults to `null`): set output height expression. (default: ih)
+- `oh` (of type `string?`, which defaults to `null`): set output height expression. (default: ih)
+- `fillcolor` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `bilinear` (of type `bool?`, which defaults to `null`): use bilinear interpolation. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.rubberband`
+
+Ffmpeg filter: Apply time-stretching and pitch-shifting.
+
+Type:
+
+```
+(?tempo : float?, ?pitch : float?, ?transients : int?, ?detector : int?,
+ ?phase : int?, ?window : int?, ?smoothing : int?, ?formant : int?,
+ ?pitchq : int?, ?channels : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `tempo` (of type `float?`, which defaults to `null`): set tempo scale factor. (default: 1.)
+- `pitch` (of type `float?`, which defaults to `null`): set pitch scale factor. (default: 1.)
+- `transients` (of type `int?`, which defaults to `null`): set transients. (default: 0, possible values: 0 (crisp), 256 (mixed), 512 (smooth))
+- `detector` (of type `int?`, which defaults to `null`): set detector. (default: 0, possible values: 0 (compound), 1024 (percussive), 2048 (soft))
+- `phase` (of type `int?`, which defaults to `null`): set phase. (default: 0, possible values: 0 (laminar), 8192 (independent))
+- `window` (of type `int?`, which defaults to `null`): set window. (default: 0, possible values: 0 (standard), 1048576 (short), 2097152 (long))
+- `smoothing` (of type `int?`, which defaults to `null`): set smoothing. (default: 0, possible values: 0 (off), 8388608 (on))
+- `formant` (of type `int?`, which defaults to `null`): set formant. (default: 0, possible values: 0 (shifted), 16777216 (preserved))
+- `pitchq` (of type `int?`, which defaults to `null`): set pitch quality. (default: 0, possible values: 33554432 (quality), 0 (speed), 67108864 (consistency))
+- `channels` (of type `int?`, which defaults to `null`): set channels. (default: 0, possible values: 0 (apart), 268435456 (together))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.rubberband.create`
+
+Ffmpeg filter: Apply time-stretching and pitch-shifting.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?tempo : float?, ?pitch : float?, ?transients : int?, ?detector : int?,
+ ?phase : int?, ?window : int?, ?smoothing : int?, ?formant : int?,
+ ?pitchq : int?, ?channels : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `tempo` (of type `float?`, which defaults to `null`): set tempo scale factor. (default: 1.)
+- `pitch` (of type `float?`, which defaults to `null`): set pitch scale factor. (default: 1.)
+- `transients` (of type `int?`, which defaults to `null`): set transients. (default: 0, possible values: 0 (crisp), 256 (mixed), 512 (smooth))
+- `detector` (of type `int?`, which defaults to `null`): set detector. (default: 0, possible values: 0 (compound), 1024 (percussive), 2048 (soft))
+- `phase` (of type `int?`, which defaults to `null`): set phase. (default: 0, possible values: 0 (laminar), 8192 (independent))
+- `window` (of type `int?`, which defaults to `null`): set window. (default: 0, possible values: 0 (standard), 1048576 (short), 2097152 (long))
+- `smoothing` (of type `int?`, which defaults to `null`): set smoothing. (default: 0, possible values: 0 (off), 8388608 (on))
+- `formant` (of type `int?`, which defaults to `null`): set formant. (default: 0, possible values: 0 (shifted), 16777216 (preserved))
+- `pitchq` (of type `int?`, which defaults to `null`): set pitch quality. (default: 0, possible values: 33554432 (quality), 0 (speed), 67108864 (consistency))
+- `channels` (of type `int?`, which defaults to `null`): set channels. (default: 0, possible values: 0 (apart), 268435456 (together))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sab`
+
+Ffmpeg filter: Apply shape adaptive blur.
+
+Type:
+
+```
+(?luma_radius : float?, ?lr : float?, ?luma_pre_filter_radius : float?,
+ ?lpfr : float?, ?luma_strength : float?, ?ls : float?,
+ ?chroma_radius : float?, ?cr : float?, ?chroma_pre_filter_radius : float?,
+ ?cpfr : float?, ?chroma_strength : float?, ?cs : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_radius` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `lr` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `luma_pre_filter_radius` (of type `float?`, which defaults to `null`): set luma pre-filter radius. (default: 1.)
+- `lpfr` (of type `float?`, which defaults to `null`): set luma pre-filter radius. (default: 1.)
+- `luma_strength` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `ls` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `chroma_radius` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `cr` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `chroma_pre_filter_radius` (of type `float?`, which defaults to `null`): set chroma pre-filter radius. (default: -0.9)
+- `cpfr` (of type `float?`, which defaults to `null`): set chroma pre-filter radius. (default: -0.9)
+- `chroma_strength` (of type `float?`, which defaults to `null`): set chroma strength. (default: -0.9)
+- `cs` (of type `float?`, which defaults to `null`): set chroma strength. (default: -0.9)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sab.create`
+
+Ffmpeg filter: Apply shape adaptive blur.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_radius : float?, ?lr : float?, ?luma_pre_filter_radius : float?,
+ ?lpfr : float?, ?luma_strength : float?, ?ls : float?,
+ ?chroma_radius : float?, ?cr : float?, ?chroma_pre_filter_radius : float?,
+ ?cpfr : float?, ?chroma_strength : float?, ?cs : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_radius` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `lr` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `luma_pre_filter_radius` (of type `float?`, which defaults to `null`): set luma pre-filter radius. (default: 1.)
+- `lpfr` (of type `float?`, which defaults to `null`): set luma pre-filter radius. (default: 1.)
+- `luma_strength` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `ls` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `chroma_radius` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `cr` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `chroma_pre_filter_radius` (of type `float?`, which defaults to `null`): set chroma pre-filter radius. (default: -0.9)
+- `cpfr` (of type `float?`, which defaults to `null`): set chroma pre-filter radius. (default: -0.9)
+- `chroma_strength` (of type `float?`, which defaults to `null`): set chroma strength. (default: -0.9)
+- `cs` (of type `float?`, which defaults to `null`): set chroma strength. (default: -0.9)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scale`
+
+Ffmpeg filter: Scale the input video size and/or convert the image format.
+
+Type:
+
+```
+(?w : string?, ?width : string?, ?h : string?, ?height : string?,
+ ?flags : string?, ?interl : bool?, ?size : string?, ?s : string?,
+ ?in_color_matrix : string?, ?out_color_matrix : string?, ?in_range : int?,
+ ?out_range : int?, ?in_v_chr_pos : int?, ?in_h_chr_pos : int?,
+ ?out_v_chr_pos : int?, ?out_h_chr_pos : int?,
+ ?force_original_aspect_ratio : int?, ?force_divisible_by : int?,
+ ?param0 : float?, ?param1 : float?, ?eval : int?, ?sws_flags : int?,
+ ?srcw : int?, ?srch : int?, ?dstw : int?, ?dsth : int?,
+ ?src_format : string?, ?dst_format : string?, ?src_range : bool?,
+ ?dst_range : bool?, ?param0 : float?, ?param1 : float?,
+ ?src_v_chr_pos : int?, ?src_h_chr_pos : int?, ?dst_v_chr_pos : int?,
+ ?dst_h_chr_pos : int?, ?sws_dither : int?, ?gamma : bool?,
+ ?alphablend : int?, ?threads : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width
+- `width` (of type `string?`, which defaults to `null`): Output video width
+- `h` (of type `string?`, which defaults to `null`): Output video height
+- `height` (of type `string?`, which defaults to `null`): Output video height
+- `flags` (of type `string?`, which defaults to `null`): Flags to pass to libswscale. (default: )
+- `interl` (of type `bool?`, which defaults to `null`): set interlacing. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `in_color_matrix` (of type `string?`, which defaults to `null`): set input YCbCr type. (default: auto, possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `out_color_matrix` (of type `string?`, which defaults to `null`): set output YCbCr type. (possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `in_range` (of type `int?`, which defaults to `null`): set input color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `out_range` (of type `int?`, which defaults to `null`): set output color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `in_v_chr_pos` (of type `int?`, which defaults to `null`): input vertical chroma position in luma grid/256. (default: -513)
+- `in_h_chr_pos` (of type `int?`, which defaults to `null`): input horizontal chroma position in luma grid/256. (default: -513)
+- `out_v_chr_pos` (of type `int?`, which defaults to `null`): output vertical chroma position in luma grid/256. (default: -513)
+- `out_h_chr_pos` (of type `int?`, which defaults to `null`): output horizontal chroma position in luma grid/256. (default: -513)
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `param0` (of type `float?`, which defaults to `null`): Scaler param 0. (default: 1.79769313486e+308)
+- `param1` (of type `float?`, which defaults to `null`): Scaler param 1. (default: 1.79769313486e+308)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `sws_flags` (of type `int?`, which defaults to `null`): scaler flags. (default: 4, possible values: 1 (fast_bilinear), 2 (bilinear), 4 (bicubic), 8 (experimental), 16 (neighbor), 32 (area), 64 (bicublin), 128 (gauss), 256 (sinc), 512 (lanczos), 1024 (spline), 4096 (print_info), 262144 (accurate_rnd), 8192 (full_chroma_int), 16384 (full_chroma_inp), 524288 (bitexact), 8388608 (error_diffusion))
+- `srcw` (of type `int?`, which defaults to `null`): source width. (default: 16)
+- `srch` (of type `int?`, which defaults to `null`): source height. (default: 16)
+- `dstw` (of type `int?`, which defaults to `null`): destination width. (default: 16)
+- `dsth` (of type `int?`, which defaults to `null`): destination height. (default: 16)
+- `src_format` (of type `string?`, which defaults to `null`): source format. (default: yuv420p)
+- `dst_format` (of type `string?`, which defaults to `null`): destination format. (default: yuv420p)
+- `src_range` (of type `bool?`, which defaults to `null`): source is full range. (default: false)
+- `dst_range` (of type `bool?`, which defaults to `null`): destination is full range. (default: false)
+- `param0` (of type `float?`, which defaults to `null`): scaler param 0. (default: 123456.)
+- `param1` (of type `float?`, which defaults to `null`): scaler param 1. (default: 123456.)
+- `src_v_chr_pos` (of type `int?`, which defaults to `null`): source vertical chroma position in luma grid/256. (default: -513)
+- `src_h_chr_pos` (of type `int?`, which defaults to `null`): source horizontal chroma position in luma grid/256. (default: -513)
+- `dst_v_chr_pos` (of type `int?`, which defaults to `null`): destination vertical chroma position in luma grid/256. (default: -513)
+- `dst_h_chr_pos` (of type `int?`, which defaults to `null`): destination horizontal chroma position in luma grid/256. (default: -513)
+- `sws_dither` (of type `int?`, which defaults to `null`): set dithering algorithm. (default: 1, possible values: 1 (auto), 2 (bayer), 3 (ed), 4 (a_dither), 5 (x_dither))
+- `gamma` (of type `bool?`, which defaults to `null`): gamma correct scaling. (default: false)
+- `alphablend` (of type `int?`, which defaults to `null`): mode for alpha -> non alpha. (default: 0, possible values: 0 (none), 1 (uniform_color), 2 (checkerboard))
+- `threads` (of type `int?`, which defaults to `null`): number of threads. (default: 1, possible values: 0 (auto))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scale.create`
+
+Ffmpeg filter: Scale the input video size and/or convert the image format.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?w : string?, ?width : string?, ?h : string?, ?height : string?,
+ ?flags : string?, ?interl : bool?, ?size : string?, ?s : string?,
+ ?in_color_matrix : string?, ?out_color_matrix : string?, ?in_range : int?,
+ ?out_range : int?, ?in_v_chr_pos : int?, ?in_h_chr_pos : int?,
+ ?out_v_chr_pos : int?, ?out_h_chr_pos : int?,
+ ?force_original_aspect_ratio : int?, ?force_divisible_by : int?,
+ ?param0 : float?, ?param1 : float?, ?eval : int?, ?sws_flags : int?,
+ ?srcw : int?, ?srch : int?, ?dstw : int?, ?dsth : int?,
+ ?src_format : string?, ?dst_format : string?, ?src_range : bool?,
+ ?dst_range : bool?, ?param0 : float?, ?param1 : float?,
+ ?src_v_chr_pos : int?, ?src_h_chr_pos : int?, ?dst_v_chr_pos : int?,
+ ?dst_h_chr_pos : int?, ?sws_dither : int?, ?gamma : bool?,
+ ?alphablend : int?, ?threads : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width
+- `width` (of type `string?`, which defaults to `null`): Output video width
+- `h` (of type `string?`, which defaults to `null`): Output video height
+- `height` (of type `string?`, which defaults to `null`): Output video height
+- `flags` (of type `string?`, which defaults to `null`): Flags to pass to libswscale. (default: )
+- `interl` (of type `bool?`, which defaults to `null`): set interlacing. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `in_color_matrix` (of type `string?`, which defaults to `null`): set input YCbCr type. (default: auto, possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `out_color_matrix` (of type `string?`, which defaults to `null`): set output YCbCr type. (possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `in_range` (of type `int?`, which defaults to `null`): set input color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `out_range` (of type `int?`, which defaults to `null`): set output color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `in_v_chr_pos` (of type `int?`, which defaults to `null`): input vertical chroma position in luma grid/256. (default: -513)
+- `in_h_chr_pos` (of type `int?`, which defaults to `null`): input horizontal chroma position in luma grid/256. (default: -513)
+- `out_v_chr_pos` (of type `int?`, which defaults to `null`): output vertical chroma position in luma grid/256. (default: -513)
+- `out_h_chr_pos` (of type `int?`, which defaults to `null`): output horizontal chroma position in luma grid/256. (default: -513)
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `param0` (of type `float?`, which defaults to `null`): Scaler param 0. (default: 1.79769313486e+308)
+- `param1` (of type `float?`, which defaults to `null`): Scaler param 1. (default: 1.79769313486e+308)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `sws_flags` (of type `int?`, which defaults to `null`): scaler flags. (default: 4, possible values: 1 (fast_bilinear), 2 (bilinear), 4 (bicubic), 8 (experimental), 16 (neighbor), 32 (area), 64 (bicublin), 128 (gauss), 256 (sinc), 512 (lanczos), 1024 (spline), 4096 (print_info), 262144 (accurate_rnd), 8192 (full_chroma_int), 16384 (full_chroma_inp), 524288 (bitexact), 8388608 (error_diffusion))
+- `srcw` (of type `int?`, which defaults to `null`): source width. (default: 16)
+- `srch` (of type `int?`, which defaults to `null`): source height. (default: 16)
+- `dstw` (of type `int?`, which defaults to `null`): destination width. (default: 16)
+- `dsth` (of type `int?`, which defaults to `null`): destination height. (default: 16)
+- `src_format` (of type `string?`, which defaults to `null`): source format. (default: yuv420p)
+- `dst_format` (of type `string?`, which defaults to `null`): destination format. (default: yuv420p)
+- `src_range` (of type `bool?`, which defaults to `null`): source is full range. (default: false)
+- `dst_range` (of type `bool?`, which defaults to `null`): destination is full range. (default: false)
+- `param0` (of type `float?`, which defaults to `null`): scaler param 0. (default: 123456.)
+- `param1` (of type `float?`, which defaults to `null`): scaler param 1. (default: 123456.)
+- `src_v_chr_pos` (of type `int?`, which defaults to `null`): source vertical chroma position in luma grid/256. (default: -513)
+- `src_h_chr_pos` (of type `int?`, which defaults to `null`): source horizontal chroma position in luma grid/256. (default: -513)
+- `dst_v_chr_pos` (of type `int?`, which defaults to `null`): destination vertical chroma position in luma grid/256. (default: -513)
+- `dst_h_chr_pos` (of type `int?`, which defaults to `null`): destination horizontal chroma position in luma grid/256. (default: -513)
+- `sws_dither` (of type `int?`, which defaults to `null`): set dithering algorithm. (default: 1, possible values: 1 (auto), 2 (bayer), 3 (ed), 4 (a_dither), 5 (x_dither))
+- `gamma` (of type `bool?`, which defaults to `null`): gamma correct scaling. (default: false)
+- `alphablend` (of type `int?`, which defaults to `null`): mode for alpha -> non alpha. (default: 0, possible values: 0 (none), 1 (uniform_color), 2 (checkerboard))
+- `threads` (of type `int?`, which defaults to `null`): number of threads. (default: 1, possible values: 0 (auto))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scale2ref`
+
+Ffmpeg filter: Scale the input video size and/or convert the image format to the given reference.
+
+Type:
+
+```
+(?w : string?, ?width : string?, ?h : string?, ?height : string?,
+ ?flags : string?, ?interl : bool?, ?size : string?, ?s : string?,
+ ?in_color_matrix : string?, ?out_color_matrix : string?, ?in_range : int?,
+ ?out_range : int?, ?in_v_chr_pos : int?, ?in_h_chr_pos : int?,
+ ?out_v_chr_pos : int?, ?out_h_chr_pos : int?,
+ ?force_original_aspect_ratio : int?, ?force_divisible_by : int?,
+ ?param0 : float?, ?param1 : float?, ?eval : int?, ?sws_flags : int?,
+ ?srcw : int?, ?srch : int?, ?dstw : int?, ?dsth : int?,
+ ?src_format : string?, ?dst_format : string?, ?src_range : bool?,
+ ?dst_range : bool?, ?param0 : float?, ?param1 : float?,
+ ?src_v_chr_pos : int?, ?src_h_chr_pos : int?, ?dst_v_chr_pos : int?,
+ ?dst_h_chr_pos : int?, ?sws_dither : int?, ?gamma : bool?,
+ ?alphablend : int?, ?threads : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video * ffmpeg.filter.video
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width
+- `width` (of type `string?`, which defaults to `null`): Output video width
+- `h` (of type `string?`, which defaults to `null`): Output video height
+- `height` (of type `string?`, which defaults to `null`): Output video height
+- `flags` (of type `string?`, which defaults to `null`): Flags to pass to libswscale. (default: )
+- `interl` (of type `bool?`, which defaults to `null`): set interlacing. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `in_color_matrix` (of type `string?`, which defaults to `null`): set input YCbCr type. (default: auto, possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `out_color_matrix` (of type `string?`, which defaults to `null`): set output YCbCr type. (possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `in_range` (of type `int?`, which defaults to `null`): set input color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `out_range` (of type `int?`, which defaults to `null`): set output color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `in_v_chr_pos` (of type `int?`, which defaults to `null`): input vertical chroma position in luma grid/256. (default: -513)
+- `in_h_chr_pos` (of type `int?`, which defaults to `null`): input horizontal chroma position in luma grid/256. (default: -513)
+- `out_v_chr_pos` (of type `int?`, which defaults to `null`): output vertical chroma position in luma grid/256. (default: -513)
+- `out_h_chr_pos` (of type `int?`, which defaults to `null`): output horizontal chroma position in luma grid/256. (default: -513)
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `param0` (of type `float?`, which defaults to `null`): Scaler param 0. (default: 1.79769313486e+308)
+- `param1` (of type `float?`, which defaults to `null`): Scaler param 1. (default: 1.79769313486e+308)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `sws_flags` (of type `int?`, which defaults to `null`): scaler flags. (default: 4, possible values: 1 (fast_bilinear), 2 (bilinear), 4 (bicubic), 8 (experimental), 16 (neighbor), 32 (area), 64 (bicublin), 128 (gauss), 256 (sinc), 512 (lanczos), 1024 (spline), 4096 (print_info), 262144 (accurate_rnd), 8192 (full_chroma_int), 16384 (full_chroma_inp), 524288 (bitexact), 8388608 (error_diffusion))
+- `srcw` (of type `int?`, which defaults to `null`): source width. (default: 16)
+- `srch` (of type `int?`, which defaults to `null`): source height. (default: 16)
+- `dstw` (of type `int?`, which defaults to `null`): destination width. (default: 16)
+- `dsth` (of type `int?`, which defaults to `null`): destination height. (default: 16)
+- `src_format` (of type `string?`, which defaults to `null`): source format. (default: yuv420p)
+- `dst_format` (of type `string?`, which defaults to `null`): destination format. (default: yuv420p)
+- `src_range` (of type `bool?`, which defaults to `null`): source is full range. (default: false)
+- `dst_range` (of type `bool?`, which defaults to `null`): destination is full range. (default: false)
+- `param0` (of type `float?`, which defaults to `null`): scaler param 0. (default: 123456.)
+- `param1` (of type `float?`, which defaults to `null`): scaler param 1. (default: 123456.)
+- `src_v_chr_pos` (of type `int?`, which defaults to `null`): source vertical chroma position in luma grid/256. (default: -513)
+- `src_h_chr_pos` (of type `int?`, which defaults to `null`): source horizontal chroma position in luma grid/256. (default: -513)
+- `dst_v_chr_pos` (of type `int?`, which defaults to `null`): destination vertical chroma position in luma grid/256. (default: -513)
+- `dst_h_chr_pos` (of type `int?`, which defaults to `null`): destination horizontal chroma position in luma grid/256. (default: -513)
+- `sws_dither` (of type `int?`, which defaults to `null`): set dithering algorithm. (default: 1, possible values: 1 (auto), 2 (bayer), 3 (ed), 4 (a_dither), 5 (x_dither))
+- `gamma` (of type `bool?`, which defaults to `null`): gamma correct scaling. (default: false)
+- `alphablend` (of type `int?`, which defaults to `null`): mode for alpha -> non alpha. (default: 0, possible values: 0 (none), 1 (uniform_color), 2 (checkerboard))
+- `threads` (of type `int?`, which defaults to `null`): number of threads. (default: 1, possible values: 0 (auto))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scale2ref.create`
+
+Ffmpeg filter: Scale the input video size and/or convert the image format to the given reference.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?w : string?, ?width : string?, ?h : string?, ?height : string?,
+ ?flags : string?, ?interl : bool?, ?size : string?, ?s : string?,
+ ?in_color_matrix : string?, ?out_color_matrix : string?, ?in_range : int?,
+ ?out_range : int?, ?in_v_chr_pos : int?, ?in_h_chr_pos : int?,
+ ?out_v_chr_pos : int?, ?out_h_chr_pos : int?,
+ ?force_original_aspect_ratio : int?, ?force_divisible_by : int?,
+ ?param0 : float?, ?param1 : float?, ?eval : int?, ?sws_flags : int?,
+ ?srcw : int?, ?srch : int?, ?dstw : int?, ?dsth : int?,
+ ?src_format : string?, ?dst_format : string?, ?src_range : bool?,
+ ?dst_range : bool?, ?param0 : float?, ?param1 : float?,
+ ?src_v_chr_pos : int?, ?src_h_chr_pos : int?, ?dst_v_chr_pos : int?,
+ ?dst_h_chr_pos : int?, ?sws_dither : int?, ?gamma : bool?,
+ ?alphablend : int?, ?threads : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width
+- `width` (of type `string?`, which defaults to `null`): Output video width
+- `h` (of type `string?`, which defaults to `null`): Output video height
+- `height` (of type `string?`, which defaults to `null`): Output video height
+- `flags` (of type `string?`, which defaults to `null`): Flags to pass to libswscale. (default: )
+- `interl` (of type `bool?`, which defaults to `null`): set interlacing. (default: false)
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `in_color_matrix` (of type `string?`, which defaults to `null`): set input YCbCr type. (default: auto, possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `out_color_matrix` (of type `string?`, which defaults to `null`): set output YCbCr type. (possible values: auto (auto), bt601 (bt601), bt470 (bt470), smpte170m (smpte170m), bt709 (bt709), fcc (fcc), smpte240m (smpte240m), bt2020 (bt2020))
+- `in_range` (of type `int?`, which defaults to `null`): set input color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `out_range` (of type `int?`, which defaults to `null`): set output color range. (default: 0, possible values: 0 (auto), 0 (unknown), 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `in_v_chr_pos` (of type `int?`, which defaults to `null`): input vertical chroma position in luma grid/256. (default: -513)
+- `in_h_chr_pos` (of type `int?`, which defaults to `null`): input horizontal chroma position in luma grid/256. (default: -513)
+- `out_v_chr_pos` (of type `int?`, which defaults to `null`): output vertical chroma position in luma grid/256. (default: -513)
+- `out_h_chr_pos` (of type `int?`, which defaults to `null`): output horizontal chroma position in luma grid/256. (default: -513)
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `param0` (of type `float?`, which defaults to `null`): Scaler param 0. (default: 1.79769313486e+308)
+- `param1` (of type `float?`, which defaults to `null`): Scaler param 1. (default: 1.79769313486e+308)
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `sws_flags` (of type `int?`, which defaults to `null`): scaler flags. (default: 4, possible values: 1 (fast_bilinear), 2 (bilinear), 4 (bicubic), 8 (experimental), 16 (neighbor), 32 (area), 64 (bicublin), 128 (gauss), 256 (sinc), 512 (lanczos), 1024 (spline), 4096 (print_info), 262144 (accurate_rnd), 8192 (full_chroma_int), 16384 (full_chroma_inp), 524288 (bitexact), 8388608 (error_diffusion))
+- `srcw` (of type `int?`, which defaults to `null`): source width. (default: 16)
+- `srch` (of type `int?`, which defaults to `null`): source height. (default: 16)
+- `dstw` (of type `int?`, which defaults to `null`): destination width. (default: 16)
+- `dsth` (of type `int?`, which defaults to `null`): destination height. (default: 16)
+- `src_format` (of type `string?`, which defaults to `null`): source format. (default: yuv420p)
+- `dst_format` (of type `string?`, which defaults to `null`): destination format. (default: yuv420p)
+- `src_range` (of type `bool?`, which defaults to `null`): source is full range. (default: false)
+- `dst_range` (of type `bool?`, which defaults to `null`): destination is full range. (default: false)
+- `param0` (of type `float?`, which defaults to `null`): scaler param 0. (default: 123456.)
+- `param1` (of type `float?`, which defaults to `null`): scaler param 1. (default: 123456.)
+- `src_v_chr_pos` (of type `int?`, which defaults to `null`): source vertical chroma position in luma grid/256. (default: -513)
+- `src_h_chr_pos` (of type `int?`, which defaults to `null`): source horizontal chroma position in luma grid/256. (default: -513)
+- `dst_v_chr_pos` (of type `int?`, which defaults to `null`): destination vertical chroma position in luma grid/256. (default: -513)
+- `dst_h_chr_pos` (of type `int?`, which defaults to `null`): destination horizontal chroma position in luma grid/256. (default: -513)
+- `sws_dither` (of type `int?`, which defaults to `null`): set dithering algorithm. (default: 1, possible values: 1 (auto), 2 (bayer), 3 (ed), 4 (a_dither), 5 (x_dither))
+- `gamma` (of type `bool?`, which defaults to `null`): gamma correct scaling. (default: false)
+- `alphablend` (of type `int?`, which defaults to `null`): mode for alpha -> non alpha. (default: 0, possible values: 0 (none), 1 (uniform_color), 2 (checkerboard))
+- `threads` (of type `int?`, which defaults to `null`): number of threads. (default: 1, possible values: 0 (auto))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video * ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scale_cuda`
+
+Ffmpeg filter: GPU accelerated video resizer
+
+Type:
+
+```
+(?w : string?, ?h : string?, ?interp_algo : int?, ?format : string?,
+ ?passthrough : bool?, ?param : float?, ?force_original_aspect_ratio : int?,
+ ?force_divisible_by : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width. (default: iw)
+- `h` (of type `string?`, which defaults to `null`): Output video height. (default: ih)
+- `interp_algo` (of type `int?`, which defaults to `null`): Interpolation algorithm used for resizing. (default: 0, possible values: 1 (nearest), 2 (bilinear), 3 (bicubic), 4 (lanczos))
+- `format` (of type `string?`, which defaults to `null`): Output video pixel format
+- `passthrough` (of type `bool?`, which defaults to `null`): Do not process frames at all if parameters match. (default: true)
+- `param` (of type `float?`, which defaults to `null`): Algorithm-Specific parameter. (default: 999999.)
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scale_cuda.create`
+
+Ffmpeg filter: GPU accelerated video resizer. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?w : string?, ?h : string?, ?interp_algo : int?, ?format : string?,
+ ?passthrough : bool?, ?param : float?, ?force_original_aspect_ratio : int?,
+ ?force_divisible_by : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width. (default: iw)
+- `h` (of type `string?`, which defaults to `null`): Output video height. (default: ih)
+- `interp_algo` (of type `int?`, which defaults to `null`): Interpolation algorithm used for resizing. (default: 0, possible values: 1 (nearest), 2 (bilinear), 3 (bicubic), 4 (lanczos))
+- `format` (of type `string?`, which defaults to `null`): Output video pixel format
+- `passthrough` (of type `bool?`, which defaults to `null`): Do not process frames at all if parameters match. (default: true)
+- `param` (of type `float?`, which defaults to `null`): Algorithm-Specific parameter. (default: 999999.)
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scale_vaapi`
+
+Ffmpeg filter: Scale to/from VAAPI surfaces.
+
+Type:
+
+```
+(?w : string?, ?h : string?, ?format : string?, ?mode : int?,
+ ?out_color_matrix : string?, ?out_range : int?,
+ ?out_color_primaries : string?, ?out_color_transfer : string?,
+ ?out_chroma_location : string?, ?force_original_aspect_ratio : int?,
+ ?force_divisible_by : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width. (default: iw)
+- `h` (of type `string?`, which defaults to `null`): Output video height. (default: ih)
+- `format` (of type `string?`, which defaults to `null`): Output video format (software format of hardware frames)
+- `mode` (of type `int?`, which defaults to `null`): Scaling mode. (default: 512, possible values: 0 (default), 256 (fast), 512 (hq), 768 (nl_anamorphic))
+- `out_color_matrix` (of type `string?`, which defaults to `null`): Output colour matrix coefficient set
+- `out_range` (of type `int?`, which defaults to `null`): Output colour range. (default: 0, possible values: 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `out_color_primaries` (of type `string?`, which defaults to `null`): Output colour primaries
+- `out_color_transfer` (of type `string?`, which defaults to `null`): Output colour transfer characteristics
+- `out_chroma_location` (of type `string?`, which defaults to `null`): Output chroma sample location
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scale_vaapi.create`
+
+Ffmpeg filter: Scale to/from VAAPI surfaces.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?w : string?, ?h : string?, ?format : string?, ?mode : int?,
+ ?out_color_matrix : string?, ?out_range : int?,
+ ?out_color_primaries : string?, ?out_color_transfer : string?,
+ ?out_chroma_location : string?, ?force_original_aspect_ratio : int?,
+ ?force_divisible_by : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width. (default: iw)
+- `h` (of type `string?`, which defaults to `null`): Output video height. (default: ih)
+- `format` (of type `string?`, which defaults to `null`): Output video format (software format of hardware frames)
+- `mode` (of type `int?`, which defaults to `null`): Scaling mode. (default: 512, possible values: 0 (default), 256 (fast), 512 (hq), 768 (nl_anamorphic))
+- `out_color_matrix` (of type `string?`, which defaults to `null`): Output colour matrix coefficient set
+- `out_range` (of type `int?`, which defaults to `null`): Output colour range. (default: 0, possible values: 2 (full), 1 (limited), 2 (jpeg), 1 (mpeg), 1 (tv), 2 (pc))
+- `out_color_primaries` (of type `string?`, which defaults to `null`): Output colour primaries
+- `out_color_transfer` (of type `string?`, which defaults to `null`): Output colour transfer characteristics
+- `out_chroma_location` (of type `string?`, which defaults to `null`): Output chroma sample location
+- `force_original_aspect_ratio` (of type `int?`, which defaults to `null`): decrease or increase w/h if necessary to keep the original AR. (default: 0, possible values: 0 (disable), 1 (decrease), 2 (increase))
+- `force_divisible_by` (of type `int?`, which defaults to `null`): enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scdet`
+
+Ffmpeg filter: Detect video scene change
+
+Type:
+
+```
+(?threshold : float?, ?t : float?, ?sc_pass : bool?, ?s : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set scene change detect threshold. (default: 10.)
+- `t` (of type `float?`, which defaults to `null`): set scene change detect threshold. (default: 10.)
+- `sc_pass` (of type `bool?`, which defaults to `null`): Set the flag to pass scene change frames. (default: false)
+- `s` (of type `bool?`, which defaults to `null`): Set the flag to pass scene change frames. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scdet.create`
+
+Ffmpeg filter: Detect video scene change. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : float?, ?t : float?, ?sc_pass : bool?, ?s : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set scene change detect threshold. (default: 10.)
+- `t` (of type `float?`, which defaults to `null`): set scene change detect threshold. (default: 10.)
+- `sc_pass` (of type `bool?`, which defaults to `null`): Set the flag to pass scene change frames. (default: false)
+- `s` (of type `bool?`, which defaults to `null`): Set the flag to pass scene change frames. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scharr`
+
+Ffmpeg filter: Apply scharr operator.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scharr.create`
+
+Ffmpeg filter: Apply scharr operator.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.scroll`
+
+Ffmpeg filter: Scroll input video.
+
+Type:
+
+```
+(?horizontal : float?, ?h : float?, ?vertical : float?, ?v : float?,
+ ?hpos : float?, ?vpos : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `horizontal` (of type `float?`, which defaults to `null`): set the horizontal scrolling speed. (default: 0.)
+- `h` (of type `float?`, which defaults to `null`): set the horizontal scrolling speed. (default: 0.)
+- `vertical` (of type `float?`, which defaults to `null`): set the vertical scrolling speed. (default: 0.)
+- `v` (of type `float?`, which defaults to `null`): set the vertical scrolling speed. (default: 0.)
+- `hpos` (of type `float?`, which defaults to `null`): set initial horizontal position. (default: 0.)
+- `vpos` (of type `float?`, which defaults to `null`): set initial vertical position. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.scroll.create`
+
+Ffmpeg filter: Scroll input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?horizontal : float?, ?h : float?, ?vertical : float?, ?v : float?,
+ ?hpos : float?, ?vpos : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `horizontal` (of type `float?`, which defaults to `null`): set the horizontal scrolling speed. (default: 0.)
+- `h` (of type `float?`, which defaults to `null`): set the horizontal scrolling speed. (default: 0.)
+- `vertical` (of type `float?`, which defaults to `null`): set the vertical scrolling speed. (default: 0.)
+- `v` (of type `float?`, which defaults to `null`): set the vertical scrolling speed. (default: 0.)
+- `hpos` (of type `float?`, which defaults to `null`): set initial horizontal position. (default: 0.)
+- `vpos` (of type `float?`, which defaults to `null`): set initial vertical position. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.segment`
+
+Ffmpeg filter: Segment video stream. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?timestamps : string?, ?frames : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `timestamps` (of type `string?`, which defaults to `null`): timestamps of input at which to split input
+- `frames` (of type `string?`, which defaults to `null`): frames at which to split input
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.segment.create`
+
+Ffmpeg filter: Segment video stream. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?timestamps : string?, ?frames : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `timestamps` (of type `string?`, which defaults to `null`): timestamps of input at which to split input
+- `frames` (of type `string?`, which defaults to `null`): frames at which to split input
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.select`
+
+Ffmpeg filter: Select video frames to pass in output. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?expr : string?, ?e : string?, ?outputs : int?, ?n : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `e` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `outputs` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `n` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.select.create`
+
+Ffmpeg filter: Select video frames to pass in output. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?expr : string?, ?e : string?, ?outputs : int?, ?n : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `e` (of type `string?`, which defaults to `null`): set an expression to use for selecting frames. (default: 1)
+- `outputs` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `n` (of type `int?`, which defaults to `null`): set the number of outputs. (default: 1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.selectivecolor`
+
+Ffmpeg filter: Apply CMYK adjustments to specific color ranges.
+
+Type:
+
+```
+(?correction_method : int?, ?reds : string?, ?yellows : string?,
+ ?greens : string?, ?cyans : string?, ?blues : string?, ?magentas : string?,
+ ?whites : string?, ?neutrals : string?, ?blacks : string?,
+ ?psfile : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `correction_method` (of type `int?`, which defaults to `null`): select correction method. (default: 0, possible values: 0 (absolute), 1 (relative))
+- `reds` (of type `string?`, which defaults to `null`): adjust red regions
+- `yellows` (of type `string?`, which defaults to `null`): adjust yellow regions
+- `greens` (of type `string?`, which defaults to `null`): adjust green regions
+- `cyans` (of type `string?`, which defaults to `null`): adjust cyan regions
+- `blues` (of type `string?`, which defaults to `null`): adjust blue regions
+- `magentas` (of type `string?`, which defaults to `null`): adjust magenta regions
+- `whites` (of type `string?`, which defaults to `null`): adjust white regions
+- `neutrals` (of type `string?`, which defaults to `null`): adjust neutral regions
+- `blacks` (of type `string?`, which defaults to `null`): adjust black regions
+- `psfile` (of type `string?`, which defaults to `null`): set Photoshop selectivecolor file name
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.selectivecolor.create`
+
+Ffmpeg filter: Apply CMYK adjustments to specific color ranges.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?correction_method : int?, ?reds : string?, ?yellows : string?,
+ ?greens : string?, ?cyans : string?, ?blues : string?, ?magentas : string?,
+ ?whites : string?, ?neutrals : string?, ?blacks : string?,
+ ?psfile : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `correction_method` (of type `int?`, which defaults to `null`): select correction method. (default: 0, possible values: 0 (absolute), 1 (relative))
+- `reds` (of type `string?`, which defaults to `null`): adjust red regions
+- `yellows` (of type `string?`, which defaults to `null`): adjust yellow regions
+- `greens` (of type `string?`, which defaults to `null`): adjust green regions
+- `cyans` (of type `string?`, which defaults to `null`): adjust cyan regions
+- `blues` (of type `string?`, which defaults to `null`): adjust blue regions
+- `magentas` (of type `string?`, which defaults to `null`): adjust magenta regions
+- `whites` (of type `string?`, which defaults to `null`): adjust white regions
+- `neutrals` (of type `string?`, which defaults to `null`): adjust neutral regions
+- `blacks` (of type `string?`, which defaults to `null`): adjust black regions
+- `psfile` (of type `string?`, which defaults to `null`): set Photoshop selectivecolor file name
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sendcmd`
+
+Ffmpeg filter: Send commands to filters.
+
+Type:
+
+```
+(?commands : string?, ?c : string?, ?filename : string?, ?f : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `commands` (of type `string?`, which defaults to `null`): set commands
+- `c` (of type `string?`, which defaults to `null`): set commands
+- `filename` (of type `string?`, which defaults to `null`): set commands file
+- `f` (of type `string?`, which defaults to `null`): set commands file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sendcmd.create`
+
+Ffmpeg filter: Send commands to filters.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?commands : string?, ?c : string?, ?filename : string?, ?f : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `commands` (of type `string?`, which defaults to `null`): set commands
+- `c` (of type `string?`, which defaults to `null`): set commands
+- `filename` (of type `string?`, which defaults to `null`): set commands file
+- `f` (of type `string?`, which defaults to `null`): set commands file
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.separatefields`
+
+Ffmpeg filter: Split input video frames into fields.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.separatefields.create`
+
+Ffmpeg filter: Split input video frames into fields.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.setdar`
+
+Ffmpeg filter: Set the frame display aspect ratio.
+
+Type:
+
+```
+(?dar : string?, ?ratio : string?, ?r : string?, ?max : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dar` (of type `string?`, which defaults to `null`): set display aspect ratio. (default: 0)
+- `ratio` (of type `string?`, which defaults to `null`): set display aspect ratio. (default: 0)
+- `r` (of type `string?`, which defaults to `null`): set display aspect ratio. (default: 0)
+- `max` (of type `int?`, which defaults to `null`): set max value for nominator or denominator in the ratio. (default: 100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.setdar.create`
+
+Ffmpeg filter: Set the frame display aspect ratio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dar : string?, ?ratio : string?, ?r : string?, ?max : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dar` (of type `string?`, which defaults to `null`): set display aspect ratio. (default: 0)
+- `ratio` (of type `string?`, which defaults to `null`): set display aspect ratio. (default: 0)
+- `r` (of type `string?`, which defaults to `null`): set display aspect ratio. (default: 0)
+- `max` (of type `int?`, which defaults to `null`): set max value for nominator or denominator in the ratio. (default: 100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.setfield`
+
+Ffmpeg filter: Force field for the output video frame.
+
+Type:
+
+```
+(?mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select interlace mode. (default: -1, possible values: -1 (auto), 0 (bff), 1 (tff), 2 (prog))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.setfield.create`
+
+Ffmpeg filter: Force field for the output video frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select interlace mode. (default: -1, possible values: -1 (auto), 0 (bff), 1 (tff), 2 (prog))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.setparams`
+
+Ffmpeg filter: Force field, or color property for the output video frame.
+
+Type:
+
+```
+(?field_mode : int?, ?range : int?, ?color_primaries : int?,
+ ?color_trc : int?, ?colorspace : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `field_mode` (of type `int?`, which defaults to `null`): select interlace mode. (default: -1, possible values: -1 (auto), 0 (bff), 1 (tff), 2 (prog))
+- `range` (of type `int?`, which defaults to `null`): select color range. (default: -1, possible values: -1 (auto), 0 (unspecified), 0 (unknown), 1 (limited), 1 (tv), 1 (mpeg), 2 (full), 2 (pc), 2 (jpeg))
+- `color_primaries` (of type `int?`, which defaults to `null`): select color primaries. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `color_trc` (of type `int?`, which defaults to `null`): select color transfer. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (linear), 9 (log100), 10 (log316), 11 (iec61966-2-4), 12 (bt1361e), 13 (iec61966-2-1), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 17 (smpte428), 18 (arib-std-b67))
+- `colorspace` (of type `int?`, which defaults to `null`): select colorspace. (default: -1, possible values: -1 (auto), 0 (gbr), 1 (bt709), 2 (unknown), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 11 (smpte2085), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.setparams.create`
+
+Ffmpeg filter: Force field, or color property for the output video frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?field_mode : int?, ?range : int?, ?color_primaries : int?,
+ ?color_trc : int?, ?colorspace : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `field_mode` (of type `int?`, which defaults to `null`): select interlace mode. (default: -1, possible values: -1 (auto), 0 (bff), 1 (tff), 2 (prog))
+- `range` (of type `int?`, which defaults to `null`): select color range. (default: -1, possible values: -1 (auto), 0 (unspecified), 0 (unknown), 1 (limited), 1 (tv), 1 (mpeg), 2 (full), 2 (pc), 2 (jpeg))
+- `color_primaries` (of type `int?`, which defaults to `null`): select color primaries. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `color_trc` (of type `int?`, which defaults to `null`): select color transfer. (default: -1, possible values: -1 (auto), 1 (bt709), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (linear), 9 (log100), 10 (log316), 11 (iec61966-2-4), 12 (bt1361e), 13 (iec61966-2-1), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 17 (smpte428), 18 (arib-std-b67))
+- `colorspace` (of type `int?`, which defaults to `null`): select colorspace. (default: -1, possible values: -1 (auto), 0 (gbr), 1 (bt709), 2 (unknown), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 11 (smpte2085), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.setpts`
+
+Ffmpeg filter: Set PTS for the output video frame.
+
+Type:
+
+```
+(?expr : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): Expression determining the frame timestamp. (default: PTS)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.setpts.create`
+
+Ffmpeg filter: Set PTS for the output video frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?expr : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): Expression determining the frame timestamp. (default: PTS)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.setrange`
+
+Ffmpeg filter: Force color range for the output video frame.
+
+Type:
+
+```
+(?range : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `range` (of type `int?`, which defaults to `null`): select color range. (default: -1, possible values: -1 (auto), 0 (unspecified), 0 (unknown), 1 (limited), 1 (tv), 1 (mpeg), 2 (full), 2 (pc), 2 (jpeg))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.setrange.create`
+
+Ffmpeg filter: Force color range for the output video frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?range : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `range` (of type `int?`, which defaults to `null`): select color range. (default: -1, possible values: -1 (auto), 0 (unspecified), 0 (unknown), 1 (limited), 1 (tv), 1 (mpeg), 2 (full), 2 (pc), 2 (jpeg))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.setsar`
+
+Ffmpeg filter: Set the pixel sample aspect ratio.
+
+Type:
+
+```
+(?sar : string?, ?ratio : string?, ?r : string?, ?max : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sar` (of type `string?`, which defaults to `null`): set sample (pixel) aspect ratio. (default: 0)
+- `ratio` (of type `string?`, which defaults to `null`): set sample (pixel) aspect ratio. (default: 0)
+- `r` (of type `string?`, which defaults to `null`): set sample (pixel) aspect ratio. (default: 0)
+- `max` (of type `int?`, which defaults to `null`): set max value for nominator or denominator in the ratio. (default: 100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.setsar.create`
+
+Ffmpeg filter: Set the pixel sample aspect ratio.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sar : string?, ?ratio : string?, ?r : string?, ?max : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sar` (of type `string?`, which defaults to `null`): set sample (pixel) aspect ratio. (default: 0)
+- `ratio` (of type `string?`, which defaults to `null`): set sample (pixel) aspect ratio. (default: 0)
+- `r` (of type `string?`, which defaults to `null`): set sample (pixel) aspect ratio. (default: 0)
+- `max` (of type `int?`, which defaults to `null`): set max value for nominator or denominator in the ratio. (default: 100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.settb`
+
+Ffmpeg filter: Set timebase for the video output link.
+
+Type:
+
+```
+(?expr : string?, ?tb : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `tb` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.settb.create`
+
+Ffmpeg filter: Set timebase for the video output link.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?expr : string?, ?tb : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `expr` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `tb` (of type `string?`, which defaults to `null`): set expression determining the output timebase. (default: intb)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sharpness_vaapi`
+
+Ffmpeg filter: VAAPI VPP for sharpness
+
+Type:
+
+```
+(?sharpness : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `sharpness` (of type `int?`, which defaults to `null`): sharpness level. (default: 44)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sharpness_vaapi.create`
+
+Ffmpeg filter: VAAPI VPP for sharpness. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sharpness : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sharpness` (of type `int?`, which defaults to `null`): sharpness level. (default: 44)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.shear`
+
+Ffmpeg filter: Shear transform the input image.
+
+Type:
+
+```
+(?shx : float?, ?shy : float?, ?fillcolor : string?, ?c : string?,
+ ?interp : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `shx` (of type `float?`, which defaults to `null`): set x shear factor. (default: 0.)
+- `shy` (of type `float?`, which defaults to `null`): set y shear factor. (default: 0.)
+- `fillcolor` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `interp` (of type `int?`, which defaults to `null`): set interpolation. (default: 1, possible values: 0 (nearest), 1 (bilinear))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.shear.create`
+
+Ffmpeg filter: Shear transform the input image.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?shx : float?, ?shy : float?, ?fillcolor : string?, ?c : string?,
+ ?interp : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `shx` (of type `float?`, which defaults to `null`): set x shear factor. (default: 0.)
+- `shy` (of type `float?`, which defaults to `null`): set y shear factor. (default: 0.)
+- `fillcolor` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `c` (of type `string?`, which defaults to `null`): set background fill color. (default: black)
+- `interp` (of type `int?`, which defaults to `null`): set interpolation. (default: 1, possible values: 0 (nearest), 1 (bilinear))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showcqt`
+
+Ffmpeg filter: Convert input audio to a CQT (Constant/Clamped Q Transform) spectrum video output.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?fps : string?, ?rate : string?,
+ ?r : string?, ?bar_h : int?, ?axis_h : int?, ?sono_h : int?,
+ ?fullhd : bool?, ?sono_v : string?, ?volume : string?, ?bar_v : string?,
+ ?volume2 : string?, ?sono_g : float?, ?gamma : float?, ?bar_g : float?,
+ ?gamma2 : float?, ?bar_t : float?, ?timeclamp : float?, ?tc : float?,
+ ?attack : float?, ?basefreq : float?, ?endfreq : float?,
+ ?coeffclamp : float?, ?tlength : string?, ?count : int?, ?fcount : int?,
+ ?fontfile : string?, ?font : string?, ?fontcolor : string?,
+ ?axisfile : string?, ?axis : bool?, ?text : bool?, ?csp : int?,
+ ?cscheme : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 1920x1080)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 1920x1080)
+- `fps` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `bar_h` (of type `int?`, which defaults to `null`): set bargraph height. (default: -1)
+- `axis_h` (of type `int?`, which defaults to `null`): set axis height. (default: -1)
+- `sono_h` (of type `int?`, which defaults to `null`): set sonogram height. (default: -1)
+- `fullhd` (of type `bool?`, which defaults to `null`): set fullhd size. (default: true)
+- `sono_v` (of type `string?`, which defaults to `null`): set sonogram volume. (default: 16)
+- `volume` (of type `string?`, which defaults to `null`): set sonogram volume. (default: 16)
+- `bar_v` (of type `string?`, which defaults to `null`): set bargraph volume. (default: sono_v)
+- `volume2` (of type `string?`, which defaults to `null`): set bargraph volume. (default: sono_v)
+- `sono_g` (of type `float?`, which defaults to `null`): set sonogram gamma. (default: 3.)
+- `gamma` (of type `float?`, which defaults to `null`): set sonogram gamma. (default: 3.)
+- `bar_g` (of type `float?`, which defaults to `null`): set bargraph gamma. (default: 1.)
+- `gamma2` (of type `float?`, which defaults to `null`): set bargraph gamma. (default: 1.)
+- `bar_t` (of type `float?`, which defaults to `null`): set bar transparency. (default: 1.)
+- `timeclamp` (of type `float?`, which defaults to `null`): set timeclamp. (default: 0.17)
+- `tc` (of type `float?`, which defaults to `null`): set timeclamp. (default: 0.17)
+- `attack` (of type `float?`, which defaults to `null`): set attack time. (default: 0.)
+- `basefreq` (of type `float?`, which defaults to `null`): set base frequency. (default: 20.0152312641)
+- `endfreq` (of type `float?`, which defaults to `null`): set end frequency. (default: 20495.5968144)
+- `coeffclamp` (of type `float?`, which defaults to `null`): set coeffclamp. (default: 1.)
+- `tlength` (of type `string?`, which defaults to `null`): set tlength. (default: 384*tc/(384+tc*f))
+- `count` (of type `int?`, which defaults to `null`): set transform count. (default: 6)
+- `fcount` (of type `int?`, which defaults to `null`): set frequency count. (default: 0)
+- `fontfile` (of type `string?`, which defaults to `null`): set axis font file
+- `font` (of type `string?`, which defaults to `null`): set axis font
+- `fontcolor` (of type `string?`, which defaults to `null`): set font color. (default: st(0, (midi(f)-59.5)/12);st(1, if(between(ld(0),0,1), 0.5-0.5*cos(2*PI*ld(0)), 0));r(1-ld(1)) + b(ld(1)))
+- `axisfile` (of type `string?`, which defaults to `null`): set axis image
+- `axis` (of type `bool?`, which defaults to `null`): draw axis. (default: true)
+- `text` (of type `bool?`, which defaults to `null`): draw axis. (default: true)
+- `csp` (of type `int?`, which defaults to `null`): set color space. (default: 2, possible values: 2 (unspecified), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 9 (bt2020ncl))
+- `cscheme` (of type `string?`, which defaults to `null`): set color scheme. (default: 1|0.5|0|0|0.5|1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showcqt.create`
+
+Ffmpeg filter: Convert input audio to a CQT (Constant/Clamped Q Transform) spectrum video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?fps : string?, ?rate : string?,
+ ?r : string?, ?bar_h : int?, ?axis_h : int?, ?sono_h : int?,
+ ?fullhd : bool?, ?sono_v : string?, ?volume : string?, ?bar_v : string?,
+ ?volume2 : string?, ?sono_g : float?, ?gamma : float?, ?bar_g : float?,
+ ?gamma2 : float?, ?bar_t : float?, ?timeclamp : float?, ?tc : float?,
+ ?attack : float?, ?basefreq : float?, ?endfreq : float?,
+ ?coeffclamp : float?, ?tlength : string?, ?count : int?, ?fcount : int?,
+ ?fontfile : string?, ?font : string?, ?fontcolor : string?,
+ ?axisfile : string?, ?axis : bool?, ?text : bool?, ?csp : int?,
+ ?cscheme : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 1920x1080)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 1920x1080)
+- `fps` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `bar_h` (of type `int?`, which defaults to `null`): set bargraph height. (default: -1)
+- `axis_h` (of type `int?`, which defaults to `null`): set axis height. (default: -1)
+- `sono_h` (of type `int?`, which defaults to `null`): set sonogram height. (default: -1)
+- `fullhd` (of type `bool?`, which defaults to `null`): set fullhd size. (default: true)
+- `sono_v` (of type `string?`, which defaults to `null`): set sonogram volume. (default: 16)
+- `volume` (of type `string?`, which defaults to `null`): set sonogram volume. (default: 16)
+- `bar_v` (of type `string?`, which defaults to `null`): set bargraph volume. (default: sono_v)
+- `volume2` (of type `string?`, which defaults to `null`): set bargraph volume. (default: sono_v)
+- `sono_g` (of type `float?`, which defaults to `null`): set sonogram gamma. (default: 3.)
+- `gamma` (of type `float?`, which defaults to `null`): set sonogram gamma. (default: 3.)
+- `bar_g` (of type `float?`, which defaults to `null`): set bargraph gamma. (default: 1.)
+- `gamma2` (of type `float?`, which defaults to `null`): set bargraph gamma. (default: 1.)
+- `bar_t` (of type `float?`, which defaults to `null`): set bar transparency. (default: 1.)
+- `timeclamp` (of type `float?`, which defaults to `null`): set timeclamp. (default: 0.17)
+- `tc` (of type `float?`, which defaults to `null`): set timeclamp. (default: 0.17)
+- `attack` (of type `float?`, which defaults to `null`): set attack time. (default: 0.)
+- `basefreq` (of type `float?`, which defaults to `null`): set base frequency. (default: 20.0152312641)
+- `endfreq` (of type `float?`, which defaults to `null`): set end frequency. (default: 20495.5968144)
+- `coeffclamp` (of type `float?`, which defaults to `null`): set coeffclamp. (default: 1.)
+- `tlength` (of type `string?`, which defaults to `null`): set tlength. (default: 384*tc/(384+tc*f))
+- `count` (of type `int?`, which defaults to `null`): set transform count. (default: 6)
+- `fcount` (of type `int?`, which defaults to `null`): set frequency count. (default: 0)
+- `fontfile` (of type `string?`, which defaults to `null`): set axis font file
+- `font` (of type `string?`, which defaults to `null`): set axis font
+- `fontcolor` (of type `string?`, which defaults to `null`): set font color. (default: st(0, (midi(f)-59.5)/12);st(1, if(between(ld(0),0,1), 0.5-0.5*cos(2*PI*ld(0)), 0));r(1-ld(1)) + b(ld(1)))
+- `axisfile` (of type `string?`, which defaults to `null`): set axis image
+- `axis` (of type `bool?`, which defaults to `null`): draw axis. (default: true)
+- `text` (of type `bool?`, which defaults to `null`): draw axis. (default: true)
+- `csp` (of type `int?`, which defaults to `null`): set color space. (default: 2, possible values: 2 (unspecified), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 9 (bt2020ncl))
+- `cscheme` (of type `string?`, which defaults to `null`): set color scheme. (default: 1|0.5|0|0|0.5|1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showcwt`
+
+Ffmpeg filter: Convert input audio to a CWT (Continuous Wavelet Transform) spectrum video output.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?scale : int?,
+ ?iscale : int?, ?min : float?, ?max : float?, ?imin : float?,
+ ?imax : float?, ?logb : float?, ?deviation : float?, ?pps : int?,
+ ?mode : int?, ?slide : int?, ?direction : int?, ?bar : float?,
+ ?rotation : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `scale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (linear), 1 (log), 2 (bark), 3 (mel), 4 (erbs), 5 (sqrt), 6 (cbrt), 7 (qdrt))
+- `iscale` (of type `int?`, which defaults to `null`): set intensity scale. (default: 0, possible values: 1 (linear), 0 (log), 2 (sqrt), 3 (cbrt), 4 (qdrt))
+- `min` (of type `float?`, which defaults to `null`): set minimum frequency. (default: 20.)
+- `max` (of type `float?`, which defaults to `null`): set maximum frequency. (default: 20000.)
+- `imin` (of type `float?`, which defaults to `null`): set minimum intensity. (default: 0.)
+- `imax` (of type `float?`, which defaults to `null`): set maximum intensity. (default: 1.)
+- `logb` (of type `float?`, which defaults to `null`): set logarithmic basis. (default: 0.0001)
+- `deviation` (of type `float?`, which defaults to `null`): set frequency deviation. (default: 1.)
+- `pps` (of type `int?`, which defaults to `null`): set pixels per second. (default: 64)
+- `mode` (of type `int?`, which defaults to `null`): set output mode. (default: 0, possible values: 0 (magnitude), 1 (phase), 2 (magphase), 3 (channel), 4 (stereo))
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 0, possible values: 0 (replace), 1 (scroll), 2 (frame))
+- `direction` (of type `int?`, which defaults to `null`): set direction mode. (default: 0, possible values: 0 (lr), 1 (rl), 2 (ud), 3 (du))
+- `bar` (of type `float?`, which defaults to `null`): set bar ratio. (default: 0.)
+- `rotation` (of type `float?`, which defaults to `null`): set color rotation. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showcwt.create`
+
+Ffmpeg filter: Convert input audio to a CWT (Continuous Wavelet Transform) spectrum video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?scale : int?,
+ ?iscale : int?, ?min : float?, ?max : float?, ?imin : float?,
+ ?imax : float?, ?logb : float?, ?deviation : float?, ?pps : int?,
+ ?mode : int?, ?slide : int?, ?direction : int?, ?bar : float?,
+ ?rotation : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `scale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (linear), 1 (log), 2 (bark), 3 (mel), 4 (erbs), 5 (sqrt), 6 (cbrt), 7 (qdrt))
+- `iscale` (of type `int?`, which defaults to `null`): set intensity scale. (default: 0, possible values: 1 (linear), 0 (log), 2 (sqrt), 3 (cbrt), 4 (qdrt))
+- `min` (of type `float?`, which defaults to `null`): set minimum frequency. (default: 20.)
+- `max` (of type `float?`, which defaults to `null`): set maximum frequency. (default: 20000.)
+- `imin` (of type `float?`, which defaults to `null`): set minimum intensity. (default: 0.)
+- `imax` (of type `float?`, which defaults to `null`): set maximum intensity. (default: 1.)
+- `logb` (of type `float?`, which defaults to `null`): set logarithmic basis. (default: 0.0001)
+- `deviation` (of type `float?`, which defaults to `null`): set frequency deviation. (default: 1.)
+- `pps` (of type `int?`, which defaults to `null`): set pixels per second. (default: 64)
+- `mode` (of type `int?`, which defaults to `null`): set output mode. (default: 0, possible values: 0 (magnitude), 1 (phase), 2 (magphase), 3 (channel), 4 (stereo))
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 0, possible values: 0 (replace), 1 (scroll), 2 (frame))
+- `direction` (of type `int?`, which defaults to `null`): set direction mode. (default: 0, possible values: 0 (lr), 1 (rl), 2 (ud), 3 (du))
+- `bar` (of type `float?`, which defaults to `null`): set bar ratio. (default: 0.)
+- `rotation` (of type `float?`, which defaults to `null`): set color rotation. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showfreqs`
+
+Ffmpeg filter: Convert input audio to a frequencies video output.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?mode : int?,
+ ?ascale : int?, ?fscale : int?, ?win_size : int?, ?win_func : int?,
+ ?overlap : float?, ?averaging : int?, ?colors : string?, ?cmode : int?,
+ ?minamp : float?, ?data : int?, ?channels : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 1024x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 1024x512)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `mode` (of type `int?`, which defaults to `null`): set display mode. (default: 1, possible values: 0 (line), 1 (bar), 2 (dot))
+- `ascale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 3, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log))
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (lin), 1 (log), 2 (rlog))
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 2048)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 1.)
+- `averaging` (of type `int?`, which defaults to `null`): set time averaging. (default: 1)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `cmode` (of type `int?`, which defaults to `null`): set channel mode. (default: 0, possible values: 0 (combined), 1 (separate))
+- `minamp` (of type `float?`, which defaults to `null`): set minimum amplitude. (default: 1e-06)
+- `data` (of type `int?`, which defaults to `null`): set data mode. (default: 0, possible values: 0 (magnitude), 1 (phase), 2 (delay))
+- `channels` (of type `string?`, which defaults to `null`): set channels to draw. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showfreqs.create`
+
+Ffmpeg filter: Convert input audio to a frequencies video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?mode : int?,
+ ?ascale : int?, ?fscale : int?, ?win_size : int?, ?win_func : int?,
+ ?overlap : float?, ?averaging : int?, ?colors : string?, ?cmode : int?,
+ ?minamp : float?, ?data : int?, ?channels : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 1024x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 1024x512)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `mode` (of type `int?`, which defaults to `null`): set display mode. (default: 1, possible values: 0 (line), 1 (bar), 2 (dot))
+- `ascale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 3, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log))
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (lin), 1 (log), 2 (rlog))
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 2048)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 1.)
+- `averaging` (of type `int?`, which defaults to `null`): set time averaging. (default: 1)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `cmode` (of type `int?`, which defaults to `null`): set channel mode. (default: 0, possible values: 0 (combined), 1 (separate))
+- `minamp` (of type `float?`, which defaults to `null`): set minimum amplitude. (default: 1e-06)
+- `data` (of type `int?`, which defaults to `null`): set data mode. (default: 0, possible values: 0 (magnitude), 1 (phase), 2 (delay))
+- `channels` (of type `string?`, which defaults to `null`): set channels to draw. (default: all)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showinfo`
+
+Ffmpeg filter: Show textual information for each video frame.
+
+Type:
+
+```
+(?checksum : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `checksum` (of type `bool?`, which defaults to `null`): calculate checksums. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.showinfo.create`
+
+Ffmpeg filter: Show textual information for each video frame.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?checksum : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `checksum` (of type `bool?`, which defaults to `null`): calculate checksums. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showpalette`
+
+Ffmpeg filter: Display frame palette.
+
+Type:
+
+```
+(?s : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `s` (of type `int?`, which defaults to `null`): set pixel box size. (default: 30)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.showpalette.create`
+
+Ffmpeg filter: Display frame palette.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?s : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `s` (of type `int?`, which defaults to `null`): set pixel box size. (default: 30)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showspatial`
+
+Ffmpeg filter: Convert input audio to a spatial video output.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?win_size : int?, ?win_func : int?,
+ ?rate : string?, ?r : string?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 512x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 512x512)
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 4096)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showspatial.create`
+
+Ffmpeg filter: Convert input audio to a spatial video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?win_size : int?, ?win_func : int?,
+ ?rate : string?, ?r : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 512x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 512x512)
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 4096)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showspectrum`
+
+Ffmpeg filter: Convert input audio to a spectrum video output.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?slide : int?, ?mode : int?, ?color : int?,
+ ?scale : int?, ?fscale : int?, ?saturation : float?, ?win_func : int?,
+ ?orientation : int?, ?overlap : float?, ?gain : float?, ?data : int?,
+ ?rotation : float?, ?start : int?, ?stop : int?, ?fps : string?,
+ ?legend : bool?, ?drange : float?, ?limit : float?, ?opacity : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `slide` (of type `int?`, which defaults to `null`): set sliding mode. (default: 0, possible values: 0 (replace), 1 (scroll), 2 (fullframe), 3 (rscroll), 4 (lreplace))
+- `mode` (of type `int?`, which defaults to `null`): set channel display mode. (default: 0, possible values: 0 (combined), 1 (separate))
+- `color` (of type `int?`, which defaults to `null`): set channel coloring. (default: 0, possible values: 0 (channel), 1 (intensity), 2 (rainbow), 3 (moreland), 4 (nebulae), 5 (fire), 6 (fiery), 7 (fruit), 8 (cool), 9 (magma), 10 (green), 11 (viridis), 12 (plasma), 13 (cividis), 14 (terrain))
+- `scale` (of type `int?`, which defaults to `null`): set display scale. (default: 1, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log), 4 (4thrt), 5 (5thrt))
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (lin), 1 (log))
+- `saturation` (of type `float?`, which defaults to `null`): color saturation multiplier. (default: 1.)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `orientation` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (vertical), 1 (horizontal))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.)
+- `gain` (of type `float?`, which defaults to `null`): set scale gain. (default: 1.)
+- `data` (of type `int?`, which defaults to `null`): set data mode. (default: 0, possible values: 0 (magnitude), 1 (phase), 2 (uphase))
+- `rotation` (of type `float?`, which defaults to `null`): color rotation. (default: 0.)
+- `start` (of type `int?`, which defaults to `null`): start frequency. (default: 0)
+- `stop` (of type `int?`, which defaults to `null`): stop frequency. (default: 0)
+- `fps` (of type `string?`, which defaults to `null`): set video rate. (default: auto)
+- `legend` (of type `bool?`, which defaults to `null`): draw legend. (default: false)
+- `drange` (of type `float?`, which defaults to `null`): set dynamic range in dBFS. (default: 120.)
+- `limit` (of type `float?`, which defaults to `null`): set upper limit in dBFS. (default: 0.)
+- `opacity` (of type `float?`, which defaults to `null`): set opacity strength. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showspectrum.create`
+
+Ffmpeg filter: Convert input audio to a spectrum video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?slide : int?, ?mode : int?, ?color : int?,
+ ?scale : int?, ?fscale : int?, ?saturation : float?, ?win_func : int?,
+ ?orientation : int?, ?overlap : float?, ?gain : float?, ?data : int?,
+ ?rotation : float?, ?start : int?, ?stop : int?, ?fps : string?,
+ ?legend : bool?, ?drange : float?, ?limit : float?, ?opacity : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 640x512)
+- `slide` (of type `int?`, which defaults to `null`): set sliding mode. (default: 0, possible values: 0 (replace), 1 (scroll), 2 (fullframe), 3 (rscroll), 4 (lreplace))
+- `mode` (of type `int?`, which defaults to `null`): set channel display mode. (default: 0, possible values: 0 (combined), 1 (separate))
+- `color` (of type `int?`, which defaults to `null`): set channel coloring. (default: 0, possible values: 0 (channel), 1 (intensity), 2 (rainbow), 3 (moreland), 4 (nebulae), 5 (fire), 6 (fiery), 7 (fruit), 8 (cool), 9 (magma), 10 (green), 11 (viridis), 12 (plasma), 13 (cividis), 14 (terrain))
+- `scale` (of type `int?`, which defaults to `null`): set display scale. (default: 1, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log), 4 (4thrt), 5 (5thrt))
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (lin), 1 (log))
+- `saturation` (of type `float?`, which defaults to `null`): color saturation multiplier. (default: 1.)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `orientation` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (vertical), 1 (horizontal))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.)
+- `gain` (of type `float?`, which defaults to `null`): set scale gain. (default: 1.)
+- `data` (of type `int?`, which defaults to `null`): set data mode. (default: 0, possible values: 0 (magnitude), 1 (phase), 2 (uphase))
+- `rotation` (of type `float?`, which defaults to `null`): color rotation. (default: 0.)
+- `start` (of type `int?`, which defaults to `null`): start frequency. (default: 0)
+- `stop` (of type `int?`, which defaults to `null`): stop frequency. (default: 0)
+- `fps` (of type `string?`, which defaults to `null`): set video rate. (default: auto)
+- `legend` (of type `bool?`, which defaults to `null`): draw legend. (default: false)
+- `drange` (of type `float?`, which defaults to `null`): set dynamic range in dBFS. (default: 120.)
+- `limit` (of type `float?`, which defaults to `null`): set upper limit in dBFS. (default: 0.)
+- `opacity` (of type `float?`, which defaults to `null`): set opacity strength. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showspectrumpic`
+
+Ffmpeg filter: Convert input audio to a spectrum video output single picture.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?mode : int?, ?color : int?, ?scale : int?,
+ ?fscale : int?, ?saturation : float?, ?win_func : int?, ?orientation : int?,
+ ?gain : float?, ?legend : bool?, ?rotation : float?, ?start : int?,
+ ?stop : int?, ?drange : float?, ?limit : float?, ?opacity : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 4096x2048)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 4096x2048)
+- `mode` (of type `int?`, which defaults to `null`): set channel display mode. (default: 0, possible values: 0 (combined), 1 (separate))
+- `color` (of type `int?`, which defaults to `null`): set channel coloring. (default: 1, possible values: 0 (channel), 1 (intensity), 2 (rainbow), 3 (moreland), 4 (nebulae), 5 (fire), 6 (fiery), 7 (fruit), 8 (cool), 9 (magma), 10 (green), 11 (viridis), 12 (plasma), 13 (cividis), 14 (terrain))
+- `scale` (of type `int?`, which defaults to `null`): set display scale. (default: 3, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log), 4 (4thrt), 5 (5thrt))
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (lin), 1 (log))
+- `saturation` (of type `float?`, which defaults to `null`): color saturation multiplier. (default: 1.)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `orientation` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (vertical), 1 (horizontal))
+- `gain` (of type `float?`, which defaults to `null`): set scale gain. (default: 1.)
+- `legend` (of type `bool?`, which defaults to `null`): draw legend. (default: true)
+- `rotation` (of type `float?`, which defaults to `null`): color rotation. (default: 0.)
+- `start` (of type `int?`, which defaults to `null`): start frequency. (default: 0)
+- `stop` (of type `int?`, which defaults to `null`): stop frequency. (default: 0)
+- `drange` (of type `float?`, which defaults to `null`): set dynamic range in dBFS. (default: 120.)
+- `limit` (of type `float?`, which defaults to `null`): set upper limit in dBFS. (default: 0.)
+- `opacity` (of type `float?`, which defaults to `null`): set opacity strength. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showspectrumpic.create`
+
+Ffmpeg filter: Convert input audio to a spectrum video output single picture.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?mode : int?, ?color : int?, ?scale : int?,
+ ?fscale : int?, ?saturation : float?, ?win_func : int?, ?orientation : int?,
+ ?gain : float?, ?legend : bool?, ?rotation : float?, ?start : int?,
+ ?stop : int?, ?drange : float?, ?limit : float?, ?opacity : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 4096x2048)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 4096x2048)
+- `mode` (of type `int?`, which defaults to `null`): set channel display mode. (default: 0, possible values: 0 (combined), 1 (separate))
+- `color` (of type `int?`, which defaults to `null`): set channel coloring. (default: 1, possible values: 0 (channel), 1 (intensity), 2 (rainbow), 3 (moreland), 4 (nebulae), 5 (fire), 6 (fiery), 7 (fruit), 8 (cool), 9 (magma), 10 (green), 11 (viridis), 12 (plasma), 13 (cividis), 14 (terrain))
+- `scale` (of type `int?`, which defaults to `null`): set display scale. (default: 3, possible values: 0 (lin), 1 (sqrt), 2 (cbrt), 3 (log), 4 (4thrt), 5 (5thrt))
+- `fscale` (of type `int?`, which defaults to `null`): set frequency scale. (default: 0, possible values: 0 (lin), 1 (log))
+- `saturation` (of type `float?`, which defaults to `null`): color saturation multiplier. (default: 1.)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `orientation` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (vertical), 1 (horizontal))
+- `gain` (of type `float?`, which defaults to `null`): set scale gain. (default: 1.)
+- `legend` (of type `bool?`, which defaults to `null`): draw legend. (default: true)
+- `rotation` (of type `float?`, which defaults to `null`): color rotation. (default: 0.)
+- `start` (of type `int?`, which defaults to `null`): start frequency. (default: 0)
+- `stop` (of type `int?`, which defaults to `null`): stop frequency. (default: 0)
+- `drange` (of type `float?`, which defaults to `null`): set dynamic range in dBFS. (default: 120.)
+- `limit` (of type `float?`, which defaults to `null`): set upper limit in dBFS. (default: 0.)
+- `opacity` (of type `float?`, which defaults to `null`): set opacity strength. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showvolume`
+
+Ffmpeg filter: Convert input audio volume to video output.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?b : int?, ?w : int?, ?h : int?, ?f : float?,
+ ?c : string?, ?t : bool?, ?v : bool?, ?dm : float?, ?dmc : string?,
+ ?o : int?, ?s : int?, ?p : float?, ?m : int?, ?ds : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `b` (of type `int?`, which defaults to `null`): set border width. (default: 1)
+- `w` (of type `int?`, which defaults to `null`): set channel width. (default: 400)
+- `h` (of type `int?`, which defaults to `null`): set channel height. (default: 20)
+- `f` (of type `float?`, which defaults to `null`): set fade. (default: 0.95)
+- `c` (of type `string?`, which defaults to `null`): set volume color expression. (default: PEAK*255+floor((1-PEAK)*255)*256+0xff000000)
+- `t` (of type `bool?`, which defaults to `null`): display channel names. (default: true)
+- `v` (of type `bool?`, which defaults to `null`): display volume value. (default: true)
+- `dm` (of type `float?`, which defaults to `null`): duration for max value display. (default: 0.)
+- `dmc` (of type `string?`, which defaults to `null`): set color of the max value line. (default: orange)
+- `o` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (h), 1 (v))
+- `s` (of type `int?`, which defaults to `null`): set step size. (default: 0)
+- `p` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.)
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (p), 1 (r))
+- `ds` (of type `int?`, which defaults to `null`): set display scale. (default: 0, possible values: 0 (lin), 1 (log))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showvolume.create`
+
+Ffmpeg filter: Convert input audio volume to video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?rate : string?, ?r : string?, ?b : int?, ?w : int?, ?h : int?, ?f : float?,
+ ?c : string?, ?t : bool?, ?v : bool?, ?dm : float?, ?dmc : string?,
+ ?o : int?, ?s : int?, ?p : float?, ?m : int?, ?ds : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `b` (of type `int?`, which defaults to `null`): set border width. (default: 1)
+- `w` (of type `int?`, which defaults to `null`): set channel width. (default: 400)
+- `h` (of type `int?`, which defaults to `null`): set channel height. (default: 20)
+- `f` (of type `float?`, which defaults to `null`): set fade. (default: 0.95)
+- `c` (of type `string?`, which defaults to `null`): set volume color expression. (default: PEAK*255+floor((1-PEAK)*255)*256+0xff000000)
+- `t` (of type `bool?`, which defaults to `null`): display channel names. (default: true)
+- `v` (of type `bool?`, which defaults to `null`): display volume value. (default: true)
+- `dm` (of type `float?`, which defaults to `null`): duration for max value display. (default: 0.)
+- `dmc` (of type `string?`, which defaults to `null`): set color of the max value line. (default: orange)
+- `o` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (h), 1 (v))
+- `s` (of type `int?`, which defaults to `null`): set step size. (default: 0)
+- `p` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.)
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (p), 1 (r))
+- `ds` (of type `int?`, which defaults to `null`): set display scale. (default: 0, possible values: 0 (lin), 1 (log))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showwaves`
+
+Ffmpeg filter: Convert input audio to a video output.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?mode : int?, ?n : string?, ?rate : string?,
+ ?r : string?, ?split_channels : bool?, ?colors : string?, ?scale : int?,
+ ?draw : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `mode` (of type `int?`, which defaults to `null`): select display mode. (default: 0, possible values: 0 (point), 1 (line), 2 (p2p), 3 (cline))
+- `n` (of type `string?`, which defaults to `null`): set how many samples to show in the same point. (default: 0/1)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `split_channels` (of type `bool?`, which defaults to `null`): draw channels separately. (default: false)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `scale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 0, possible values: 0 (lin), 1 (log), 2 (sqrt), 3 (cbrt))
+- `draw` (of type `int?`, which defaults to `null`): set draw mode. (default: 0, possible values: 0 (scale), 1 (full))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showwaves.create`
+
+Ffmpeg filter: Convert input audio to a video output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?mode : int?, ?n : string?, ?rate : string?,
+ ?r : string?, ?split_channels : bool?, ?colors : string?, ?scale : int?,
+ ?draw : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `mode` (of type `int?`, which defaults to `null`): select display mode. (default: 0, possible values: 0 (point), 1 (line), 2 (p2p), 3 (cline))
+- `n` (of type `string?`, which defaults to `null`): set how many samples to show in the same point. (default: 0/1)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `split_channels` (of type `bool?`, which defaults to `null`): draw channels separately. (default: false)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `scale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 0, possible values: 0 (lin), 1 (log), 2 (sqrt), 3 (cbrt))
+- `draw` (of type `int?`, which defaults to `null`): set draw mode. (default: 0, possible values: 0 (scale), 1 (full))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.showwavespic`
+
+Ffmpeg filter: Convert input audio to a video output single picture.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?split_channels : bool?, ?colors : string?,
+ ?scale : int?, ?draw : int?, ?filter : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `split_channels` (of type `bool?`, which defaults to `null`): draw channels separately. (default: false)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `scale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 0, possible values: 0 (lin), 1 (log), 2 (sqrt), 3 (cbrt))
+- `draw` (of type `int?`, which defaults to `null`): set draw mode. (default: 0, possible values: 0 (scale), 1 (full))
+- `filter` (of type `int?`, which defaults to `null`): set filter mode. (default: 0, possible values: 0 (average), 1 (peak))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.showwavespic.create`
+
+Ffmpeg filter: Convert input audio to a video output single picture.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?split_channels : bool?, ?colors : string?,
+ ?scale : int?, ?draw : int?, ?filter : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 600x240)
+- `split_channels` (of type `bool?`, which defaults to `null`): draw channels separately. (default: false)
+- `colors` (of type `string?`, which defaults to `null`): set channels colors. (default: red|green|blue|yellow|orange|lime|pink|magenta|brown)
+- `scale` (of type `int?`, which defaults to `null`): set amplitude scale. (default: 0, possible values: 0 (lin), 1 (log), 2 (sqrt), 3 (cbrt))
+- `draw` (of type `int?`, which defaults to `null`): set draw mode. (default: 0, possible values: 0 (scale), 1 (full))
+- `filter` (of type `int?`, which defaults to `null`): set filter mode. (default: 0, possible values: 0 (average), 1 (peak))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.shuffleframes`
+
+Ffmpeg filter: Shuffle video frames.
+
+Type:
+
+```
+(?mapping : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mapping` (of type `string?`, which defaults to `null`): set destination indexes of input frames. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.shuffleframes.create`
+
+Ffmpeg filter: Shuffle video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mapping : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mapping` (of type `string?`, which defaults to `null`): set destination indexes of input frames. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.shufflepixels`
+
+Ffmpeg filter: Shuffle video pixels.
+
+Type:
+
+```
+(?direction : int?, ?d : int?, ?mode : int?, ?m : int?, ?width : int?,
+ ?w : int?, ?height : int?, ?h : int?, ?seed : int?, ?s : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `direction` (of type `int?`, which defaults to `null`): set shuffle direction. (default: 0, possible values: 0 (forward), 1 (inverse))
+- `d` (of type `int?`, which defaults to `null`): set shuffle direction. (default: 0, possible values: 0 (forward), 1 (inverse))
+- `mode` (of type `int?`, which defaults to `null`): set shuffle mode. (default: 0, possible values: 0 (horizontal), 1 (vertical), 2 (block))
+- `m` (of type `int?`, which defaults to `null`): set shuffle mode. (default: 0, possible values: 0 (horizontal), 1 (vertical), 2 (block))
+- `width` (of type `int?`, which defaults to `null`): set block width. (default: 10)
+- `w` (of type `int?`, which defaults to `null`): set block width. (default: 10)
+- `height` (of type `int?`, which defaults to `null`): set block height. (default: 10)
+- `h` (of type `int?`, which defaults to `null`): set block height. (default: 10)
+- `seed` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `s` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.shufflepixels.create`
+
+Ffmpeg filter: Shuffle video pixels.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?direction : int?, ?d : int?, ?mode : int?, ?m : int?, ?width : int?,
+ ?w : int?, ?height : int?, ?h : int?, ?seed : int?, ?s : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `direction` (of type `int?`, which defaults to `null`): set shuffle direction. (default: 0, possible values: 0 (forward), 1 (inverse))
+- `d` (of type `int?`, which defaults to `null`): set shuffle direction. (default: 0, possible values: 0 (forward), 1 (inverse))
+- `mode` (of type `int?`, which defaults to `null`): set shuffle mode. (default: 0, possible values: 0 (horizontal), 1 (vertical), 2 (block))
+- `m` (of type `int?`, which defaults to `null`): set shuffle mode. (default: 0, possible values: 0 (horizontal), 1 (vertical), 2 (block))
+- `width` (of type `int?`, which defaults to `null`): set block width. (default: 10)
+- `w` (of type `int?`, which defaults to `null`): set block width. (default: 10)
+- `height` (of type `int?`, which defaults to `null`): set block height. (default: 10)
+- `h` (of type `int?`, which defaults to `null`): set block height. (default: 10)
+- `seed` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `s` (of type `int?`, which defaults to `null`): set random seed. (default: -1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.shuffleplanes`
+
+Ffmpeg filter: Shuffle video planes.
+
+Type:
+
+```
+(?map0 : int?, ?map1 : int?, ?map2 : int?, ?map3 : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `map0` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the first output plane . (default: 0)
+- `map1` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the second output plane . (default: 1)
+- `map2` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the third output plane . (default: 2)
+- `map3` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the fourth output plane . (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.shuffleplanes.create`
+
+Ffmpeg filter: Shuffle video planes.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?map0 : int?, ?map1 : int?, ?map2 : int?, ?map3 : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `map0` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the first output plane . (default: 0)
+- `map1` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the second output plane . (default: 1)
+- `map2` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the third output plane . (default: 2)
+- `map3` (of type `int?`, which defaults to `null`): Index of the input plane to be used as the fourth output plane . (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sidechaincompress`
+
+Ffmpeg filter: Sidechain compressor.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?threshold : float?, ?ratio : float?,
+ ?attack : float?, ?release : float?, ?makeup : float?, ?knee : float?,
+ ?link : int?, ?detection : int?, ?level_sc : float?, ?mix : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set make up gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.82843)
+- `link` (of type `int?`, which defaults to `null`): set link type. (default: 0, possible values: 0 (average), 1 (maximum))
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.sidechaincompress.create`
+
+Ffmpeg filter: Sidechain compressor.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?threshold : float?, ?ratio : float?,
+ ?attack : float?, ?release : float?, ?makeup : float?, ?knee : float?,
+ ?link : int?, ?detection : int?, ?level_sc : float?, ?mix : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input gain. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set make up gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.82843)
+- `link` (of type `int?`, which defaults to `null`): set link type. (default: 0, possible values: 0 (average), 1 (maximum))
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sidechaingate`
+
+Ffmpeg filter: Audio sidechain gate.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?range : float?, ?threshold : float?,
+ ?ratio : float?, ?attack : float?, ?release : float?, ?makeup : float?,
+ ?knee : float?, ?detection : int?, ?link : int?, ?level_sc : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `range` (of type `float?`, which defaults to `null`): set max gain reduction. (default: 0.06125)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set makeup gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.828427125)
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `link` (of type `int?`, which defaults to `null`): set link. (default: 0, possible values: 0 (average), 1 (maximum))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.sidechaingate.create`
+
+Ffmpeg filter: Audio sidechain gate.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?mode : int?, ?range : float?, ?threshold : float?,
+ ?ratio : float?, ?attack : float?, ?release : float?, ?makeup : float?,
+ ?knee : float?, ?detection : int?, ?link : int?, ?level_sc : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 0, possible values: 0 (downward), 1 (upward))
+- `range` (of type `float?`, which defaults to `null`): set max gain reduction. (default: 0.06125)
+- `threshold` (of type `float?`, which defaults to `null`): set threshold. (default: 0.125)
+- `ratio` (of type `float?`, which defaults to `null`): set ratio. (default: 2.)
+- `attack` (of type `float?`, which defaults to `null`): set attack. (default: 20.)
+- `release` (of type `float?`, which defaults to `null`): set release. (default: 250.)
+- `makeup` (of type `float?`, which defaults to `null`): set makeup gain. (default: 1.)
+- `knee` (of type `float?`, which defaults to `null`): set knee. (default: 2.828427125)
+- `detection` (of type `int?`, which defaults to `null`): set detection. (default: 1, possible values: 0 (peak), 1 (rms))
+- `link` (of type `int?`, which defaults to `null`): set link. (default: 0, possible values: 0 (average), 1 (maximum))
+- `level_sc` (of type `float?`, which defaults to `null`): set sidechain gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio, ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sidedata`
+
+Ffmpeg filter: Manipulate video frame side data.
+
+Type:
+
+```
+(?mode : int?, ?type : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (delete))
+- `type` (of type `int?`, which defaults to `null`): set side data type. (default: -1, possible values: 0 (PANSCAN), 1 (A53_CC), 2 (STEREO3D), 3 (MATRIXENCODING), 4 (DOWNMIX_INFO), 5 (REPLAYGAIN), 6 (DISPLAYMATRIX), 7 (AFD), 8 (MOTION_VECTORS), 9 (SKIP_SAMPLES), 10 (AUDIO_SERVICE_TYPE), 11 (MASTERING_DISPLAY_METADATA), 12 (GOP_TIMECODE), 13 (SPHERICAL), 14 (CONTENT_LIGHT_LEVEL), 15 (ICC_PROFILE), 16 (S12M_TIMECOD), 17 (DYNAMIC_HDR_PLUS), 18 (REGIONS_OF_INTEREST), 22 (DETECTION_BOUNDING_BOXES), 20 (SEI_UNREGISTERED))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sidedata.create`
+
+Ffmpeg filter: Manipulate video frame side data.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set a mode of operation. (default: 0, possible values: 0 (select), 1 (delete))
+- `type` (of type `int?`, which defaults to `null`): set side data type. (default: -1, possible values: 0 (PANSCAN), 1 (A53_CC), 2 (STEREO3D), 3 (MATRIXENCODING), 4 (DOWNMIX_INFO), 5 (REPLAYGAIN), 6 (DISPLAYMATRIX), 7 (AFD), 8 (MOTION_VECTORS), 9 (SKIP_SAMPLES), 10 (AUDIO_SERVICE_TYPE), 11 (MASTERING_DISPLAY_METADATA), 12 (GOP_TIMECODE), 13 (SPHERICAL), 14 (CONTENT_LIGHT_LEVEL), 15 (ICC_PROFILE), 16 (S12M_TIMECOD), 17 (DYNAMIC_HDR_PLUS), 18 (REGIONS_OF_INTEREST), 22 (DETECTION_BOUNDING_BOXES), 20 (SEI_UNREGISTERED))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sierpinski`
+
+Ffmpeg filter: Render a Sierpinski fractal.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?seed : int?,
+ ?jump : int?, ?type : int?, ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `rate` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `seed` (of type `int?`, which defaults to `null`): set the seed. (default: -1)
+- `jump` (of type `int?`, which defaults to `null`): set the jump. (default: 100)
+- `type` (of type `int?`, which defaults to `null`): set fractal type. (default: 0, possible values: 0 (carpet), 1 (triangle))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.sierpinski.create`
+
+Ffmpeg filter: Render a Sierpinski fractal.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?, ?seed : int?,
+ ?jump : int?, ?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `s` (of type `string?`, which defaults to `null`): set frame size. (default: 640x480)
+- `rate` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set frame rate. (default: 25)
+- `seed` (of type `int?`, which defaults to `null`): set the seed. (default: -1)
+- `jump` (of type `int?`, which defaults to `null`): set the jump. (default: 100)
+- `type` (of type `int?`, which defaults to `null`): set fractal type. (default: 0, possible values: 0 (carpet), 1 (triangle))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.signalstats`
+
+Ffmpeg filter: Generate statistics from video analysis.
+
+Type:
+
+```
+(?stat : int?, ?out : int?, ?c : string?, ?color : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `stat` (of type `int?`, which defaults to `null`): set statistics filters. (default: 0, possible values: 1 (tout), 2 (vrep), 4 (brng))
+- `out` (of type `int?`, which defaults to `null`): set video filter. (default: -1, possible values: 0 (tout), 1 (vrep), 2 (brng))
+- `c` (of type `string?`, which defaults to `null`): set highlight color. (default: yellow)
+- `color` (of type `string?`, which defaults to `null`): set highlight color. (default: yellow)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.signalstats.create`
+
+Ffmpeg filter: Generate statistics from video analysis.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?stat : int?, ?out : int?, ?c : string?, ?color : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `stat` (of type `int?`, which defaults to `null`): set statistics filters. (default: 0, possible values: 1 (tout), 2 (vrep), 4 (brng))
+- `out` (of type `int?`, which defaults to `null`): set video filter. (default: -1, possible values: 0 (tout), 1 (vrep), 2 (brng))
+- `c` (of type `string?`, which defaults to `null`): set highlight color. (default: yellow)
+- `color` (of type `string?`, which defaults to `null`): set highlight color. (default: yellow)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.signature`
+
+Ffmpeg filter: Calculate the MPEG-7 video signature This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?detectmode : int?, ?nb_inputs : int?, ?filename : string?, ?format : int?,
+ ?th_d : int?, ?th_dc : int?, ?th_xh : int?, ?th_di : int?, ?th_it : float?,
+ ffmpeg.filter.graph, [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `detectmode` (of type `int?`, which defaults to `null`): set the detectmode. (default: 0, possible values: 0 (off), 1 (full), 2 (fast))
+- `nb_inputs` (of type `int?`, which defaults to `null`): number of inputs. (default: 1)
+- `filename` (of type `string?`, which defaults to `null`): filename for output files. (default: )
+- `format` (of type `int?`, which defaults to `null`): set output format. (default: 0, possible values: 0 (binary), 1 (xml))
+- `th_d` (of type `int?`, which defaults to `null`): threshold to detect one word as similar. (default: 9000)
+- `th_dc` (of type `int?`, which defaults to `null`): threshold to detect all words as similar. (default: 60000)
+- `th_xh` (of type `int?`, which defaults to `null`): threshold to detect frames as similar. (default: 116)
+- `th_di` (of type `int?`, which defaults to `null`): minimum length of matching sequence in frames. (default: 0)
+- `th_it` (of type `float?`, which defaults to `null`): threshold for relation of good to all frames. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.signature.create`
+
+Ffmpeg filter: Calculate the MPEG-7 video signature This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?detectmode : int?, ?nb_inputs : int?, ?filename : string?, ?format : int?,
+ ?th_d : int?, ?th_dc : int?, ?th_xh : int?, ?th_di : int?, ?th_it : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `detectmode` (of type `int?`, which defaults to `null`): set the detectmode. (default: 0, possible values: 0 (off), 1 (full), 2 (fast))
+- `nb_inputs` (of type `int?`, which defaults to `null`): number of inputs. (default: 1)
+- `filename` (of type `string?`, which defaults to `null`): filename for output files. (default: )
+- `format` (of type `int?`, which defaults to `null`): set output format. (default: 0, possible values: 0 (binary), 1 (xml))
+- `th_d` (of type `int?`, which defaults to `null`): threshold to detect one word as similar. (default: 9000)
+- `th_dc` (of type `int?`, which defaults to `null`): threshold to detect all words as similar. (default: 60000)
+- `th_xh` (of type `int?`, which defaults to `null`): threshold to detect frames as similar. (default: 116)
+- `th_di` (of type `int?`, which defaults to `null`): minimum length of matching sequence in frames. (default: 0)
+- `th_it` (of type `float?`, which defaults to `null`): threshold for relation of good to all frames. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.silencedetect`
+
+Ffmpeg filter: Detect silence.
+
+Type:
+
+```
+(?n : float?, ?noise : float?, ?d : int?, ?duration : int?, ?mono : bool?,
+ ?m : bool?, ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `n` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `noise` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `d` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `duration` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `mono` (of type `bool?`, which defaults to `null`): check each channel separately. (default: false)
+- `m` (of type `bool?`, which defaults to `null`): check each channel separately. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.silencedetect.create`
+
+Ffmpeg filter: Detect silence.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : float?, ?noise : float?, ?d : int?, ?duration : int?, ?mono : bool?,
+ ?m : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `noise` (of type `float?`, which defaults to `null`): set noise tolerance. (default: 0.001)
+- `d` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `duration` (of type `int?`, which defaults to `null`): set minimum duration in seconds. (default: 2000000)
+- `mono` (of type `bool?`, which defaults to `null`): check each channel separately. (default: false)
+- `m` (of type `bool?`, which defaults to `null`): check each channel separately. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.silenceremove`
+
+Ffmpeg filter: Remove silence.
+
+Type:
+
+```
+(?start_periods : int?, ?start_duration : int?, ?start_threshold : float?,
+ ?start_silence : int?, ?start_mode : int?, ?stop_periods : int?,
+ ?stop_duration : int?, ?stop_threshold : float?, ?stop_silence : int?,
+ ?stop_mode : int?, ?detection : int?, ?window : int?, ?timestamp : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `start_periods` (of type `int?`, which defaults to `null`): set periods of silence parts to skip from start. (default: 0)
+- `start_duration` (of type `int?`, which defaults to `null`): set start duration of non-silence part. (default: 0)
+- `start_threshold` (of type `float?`, which defaults to `null`): set threshold for start silence detection. (default: 0.)
+- `start_silence` (of type `int?`, which defaults to `null`): set start duration of silence part to keep. (default: 0)
+- `start_mode` (of type `int?`, which defaults to `null`): set which channel will trigger trimming from start. (default: 0, possible values: 0 (any), 1 (all))
+- `stop_periods` (of type `int?`, which defaults to `null`): set periods of silence parts to skip from end. (default: 0)
+- `stop_duration` (of type `int?`, which defaults to `null`): set stop duration of silence part. (default: 0)
+- `stop_threshold` (of type `float?`, which defaults to `null`): set threshold for stop silence detection. (default: 0.)
+- `stop_silence` (of type `int?`, which defaults to `null`): set stop duration of silence part to keep. (default: 0)
+- `stop_mode` (of type `int?`, which defaults to `null`): set which channel will trigger trimming from end. (default: 1, possible values: 0 (any), 1 (all))
+- `detection` (of type `int?`, which defaults to `null`): set how silence is detected. (default: 1, possible values: 0 (avg), 1 (rms), 2 (peak), 3 (median), 4 (ptp), 5 (dev))
+- `window` (of type `int?`, which defaults to `null`): set duration of window for silence detection. (default: 20000)
+- `timestamp` (of type `int?`, which defaults to `null`): set how every output frame timestamp is processed. (default: 0, possible values: 0 (write), 1 (copy))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.silenceremove.create`
+
+Ffmpeg filter: Remove silence.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?start_periods : int?, ?start_duration : int?, ?start_threshold : float?,
+ ?start_silence : int?, ?start_mode : int?, ?stop_periods : int?,
+ ?stop_duration : int?, ?stop_threshold : float?, ?stop_silence : int?,
+ ?stop_mode : int?, ?detection : int?, ?window : int?, ?timestamp : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `start_periods` (of type `int?`, which defaults to `null`): set periods of silence parts to skip from start. (default: 0)
+- `start_duration` (of type `int?`, which defaults to `null`): set start duration of non-silence part. (default: 0)
+- `start_threshold` (of type `float?`, which defaults to `null`): set threshold for start silence detection. (default: 0.)
+- `start_silence` (of type `int?`, which defaults to `null`): set start duration of silence part to keep. (default: 0)
+- `start_mode` (of type `int?`, which defaults to `null`): set which channel will trigger trimming from start. (default: 0, possible values: 0 (any), 1 (all))
+- `stop_periods` (of type `int?`, which defaults to `null`): set periods of silence parts to skip from end. (default: 0)
+- `stop_duration` (of type `int?`, which defaults to `null`): set stop duration of silence part. (default: 0)
+- `stop_threshold` (of type `float?`, which defaults to `null`): set threshold for stop silence detection. (default: 0.)
+- `stop_silence` (of type `int?`, which defaults to `null`): set stop duration of silence part to keep. (default: 0)
+- `stop_mode` (of type `int?`, which defaults to `null`): set which channel will trigger trimming from end. (default: 1, possible values: 0 (any), 1 (all))
+- `detection` (of type `int?`, which defaults to `null`): set how silence is detected. (default: 1, possible values: 0 (avg), 1 (rms), 2 (peak), 3 (median), 4 (ptp), 5 (dev))
+- `window` (of type `int?`, which defaults to `null`): set duration of window for silence detection. (default: 20000)
+- `timestamp` (of type `int?`, which defaults to `null`): set how every output frame timestamp is processed. (default: 0, possible values: 0 (write), 1 (copy))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sinc`
+
+Ffmpeg filter: Generate a sinc kaiser-windowed low-pass, high-pass, band-pass, or band-reject FIR coefficients.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ?nb_samples : int?, ?n : int?, ?hp : float?,
+ ?lp : float?, ?phase : float?, ?beta : float?, ?att : float?,
+ ?round : bool?, ?hptaps : int?, ?lptaps : int?, ffmpeg.filter.graph) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `hp` (of type `float?`, which defaults to `null`): set high-pass filter frequency. (default: 0.)
+- `lp` (of type `float?`, which defaults to `null`): set low-pass filter frequency. (default: 0.)
+- `phase` (of type `float?`, which defaults to `null`): set filter phase response. (default: 50.)
+- `beta` (of type `float?`, which defaults to `null`): set kaiser window beta. (default: -1.)
+- `att` (of type `float?`, which defaults to `null`): set stop-band attenuation. (default: 120.)
+- `round` (of type `bool?`, which defaults to `null`): enable rounding. (default: false)
+- `hptaps` (of type `int?`, which defaults to `null`): set number of taps for high-pass filter. (default: 0)
+- `lptaps` (of type `int?`, which defaults to `null`): set number of taps for low-pass filter. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.sinc.create`
+
+Ffmpeg filter: Generate a sinc kaiser-windowed low-pass, high-pass, band-pass, or band-reject FIR coefficients.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_rate : int?, ?r : int?, ?nb_samples : int?, ?n : int?, ?hp : float?,
+ ?lp : float?, ?phase : float?, ?beta : float?, ?att : float?,
+ ?round : bool?, ?hptaps : int?, ?lptaps : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `nb_samples` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `n` (of type `int?`, which defaults to `null`): set the number of samples per requested frame. (default: 1024)
+- `hp` (of type `float?`, which defaults to `null`): set high-pass filter frequency. (default: 0.)
+- `lp` (of type `float?`, which defaults to `null`): set low-pass filter frequency. (default: 0.)
+- `phase` (of type `float?`, which defaults to `null`): set filter phase response. (default: 50.)
+- `beta` (of type `float?`, which defaults to `null`): set kaiser window beta. (default: -1.)
+- `att` (of type `float?`, which defaults to `null`): set stop-band attenuation. (default: 120.)
+- `round` (of type `bool?`, which defaults to `null`): enable rounding. (default: false)
+- `hptaps` (of type `int?`, which defaults to `null`): set number of taps for high-pass filter. (default: 0)
+- `lptaps` (of type `int?`, which defaults to `null`): set number of taps for low-pass filter. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sine`
+
+Ffmpeg filter: Generate sine wave audio signal.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?beep_factor : float?, ?b : float?,
+ ?sample_rate : int?, ?r : int?, ?duration : int?, ?d : int?,
+ ?samples_per_frame : string?, ffmpeg.filter.graph) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set the sine frequency. (default: 440.)
+- `f` (of type `float?`, which defaults to `null`): set the sine frequency. (default: 440.)
+- `beep_factor` (of type `float?`, which defaults to `null`): set the beep frequency factor. (default: 0.)
+- `b` (of type `float?`, which defaults to `null`): set the beep frequency factor. (default: 0.)
+- `sample_rate` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `duration` (of type `int?`, which defaults to `null`): set the audio duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set the audio duration. (default: 0)
+- `samples_per_frame` (of type `string?`, which defaults to `null`): set the number of samples per frame. (default: 1024)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.sine.create`
+
+Ffmpeg filter: Generate sine wave audio signal.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?beep_factor : float?, ?b : float?,
+ ?sample_rate : int?, ?r : int?, ?duration : int?, ?d : int?,
+ ?samples_per_frame : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set the sine frequency. (default: 440.)
+- `f` (of type `float?`, which defaults to `null`): set the sine frequency. (default: 440.)
+- `beep_factor` (of type `float?`, which defaults to `null`): set the beep frequency factor. (default: 0.)
+- `b` (of type `float?`, which defaults to `null`): set the beep frequency factor. (default: 0.)
+- `sample_rate` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `r` (of type `int?`, which defaults to `null`): set the sample rate. (default: 44100)
+- `duration` (of type `int?`, which defaults to `null`): set the audio duration. (default: 0)
+- `d` (of type `int?`, which defaults to `null`): set the audio duration. (default: 0)
+- `samples_per_frame` (of type `string?`, which defaults to `null`): set the number of samples per frame. (default: 1024)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.siti`
+
+Ffmpeg filter: Calculate spatial information (SI) and temporal information (TI).
+
+Type:
+
+```
+(?print_summary : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `print_summary` (of type `bool?`, which defaults to `null`): Print summary showing average values. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.siti.create`
+
+Ffmpeg filter: Calculate spatial information (SI) and temporal information (TI).. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?print_summary : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `print_summary` (of type `bool?`, which defaults to `null`): Print summary showing average values. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.smartblur`
+
+Ffmpeg filter: Blur the input video without impacting the outlines.
+
+Type:
+
+```
+(?luma_radius : float?, ?lr : float?, ?luma_strength : float?, ?ls : float?,
+ ?luma_threshold : int?, ?lt : int?, ?chroma_radius : float?, ?cr : float?,
+ ?chroma_strength : float?, ?cs : float?, ?chroma_threshold : int?,
+ ?ct : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_radius` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `lr` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `luma_strength` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `ls` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `luma_threshold` (of type `int?`, which defaults to `null`): set luma threshold. (default: 0)
+- `lt` (of type `int?`, which defaults to `null`): set luma threshold. (default: 0)
+- `chroma_radius` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `cr` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `chroma_strength` (of type `float?`, which defaults to `null`): set chroma strength. (default: -2.)
+- `cs` (of type `float?`, which defaults to `null`): set chroma strength. (default: -2.)
+- `chroma_threshold` (of type `int?`, which defaults to `null`): set chroma threshold. (default: -31)
+- `ct` (of type `int?`, which defaults to `null`): set chroma threshold. (default: -31)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.smartblur.create`
+
+Ffmpeg filter: Blur the input video without impacting the outlines.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_radius : float?, ?lr : float?, ?luma_strength : float?, ?ls : float?,
+ ?luma_threshold : int?, ?lt : int?, ?chroma_radius : float?, ?cr : float?,
+ ?chroma_strength : float?, ?cs : float?, ?chroma_threshold : int?,
+ ?ct : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_radius` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `lr` (of type `float?`, which defaults to `null`): set luma radius. (default: 1.)
+- `luma_strength` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `ls` (of type `float?`, which defaults to `null`): set luma strength. (default: 1.)
+- `luma_threshold` (of type `int?`, which defaults to `null`): set luma threshold. (default: 0)
+- `lt` (of type `int?`, which defaults to `null`): set luma threshold. (default: 0)
+- `chroma_radius` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `cr` (of type `float?`, which defaults to `null`): set chroma radius. (default: -0.9)
+- `chroma_strength` (of type `float?`, which defaults to `null`): set chroma strength. (default: -2.)
+- `cs` (of type `float?`, which defaults to `null`): set chroma strength. (default: -2.)
+- `chroma_threshold` (of type `int?`, which defaults to `null`): set chroma threshold. (default: -31)
+- `ct` (of type `int?`, which defaults to `null`): set chroma threshold. (default: -31)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.smptebars`
+
+Ffmpeg filter: Generate SMPTE color bars.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.smptebars.create`
+
+Ffmpeg filter: Generate SMPTE color bars.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.smptehdbars`
+
+Ffmpeg filter: Generate SMPTE HD color bars.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.smptehdbars.create`
+
+Ffmpeg filter: Generate SMPTE HD color bars.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sobel`
+
+Ffmpeg filter: Apply sobel operator.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sobel.create`
+
+Ffmpeg filter: Apply sobel operator.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sobel_opencl`
+
+Ffmpeg filter: Apply sobel operator
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sobel_opencl.create`
+
+Ffmpeg filter: Apply sobel operator. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?scale : float?, ?delta : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 1.)
+- `delta` (of type `float?`, which defaults to `null`): set delta. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sofalizer`
+
+Ffmpeg filter: SOFAlizer (Spatially Oriented Format for Acoustics).
+
+Type:
+
+```
+(?sofa : string?, ?gain : float?, ?rotation : float?, ?elevation : float?,
+ ?radius : float?, ?type : int?, ?speakers : string?, ?lfegain : float?,
+ ?framesize : int?, ?normalize : bool?, ?interpolate : bool?,
+ ?minphase : bool?, ?anglestep : float?, ?radstep : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sofa` (of type `string?`, which defaults to `null`): sofa filename
+- `gain` (of type `float?`, which defaults to `null`): set gain in dB. (default: 0.)
+- `rotation` (of type `float?`, which defaults to `null`): set rotation. (default: 0.)
+- `elevation` (of type `float?`, which defaults to `null`): set elevation. (default: 0.)
+- `radius` (of type `float?`, which defaults to `null`): set radius. (default: 1.)
+- `type` (of type `int?`, which defaults to `null`): set processing. (default: 1, possible values: 0 (time), 1 (freq))
+- `speakers` (of type `string?`, which defaults to `null`): set speaker custom positions
+- `lfegain` (of type `float?`, which defaults to `null`): set lfe gain. (default: 0.)
+- `framesize` (of type `int?`, which defaults to `null`): set frame size. (default: 1024)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize IRs. (default: true)
+- `interpolate` (of type `bool?`, which defaults to `null`): interpolate IRs from neighbors. (default: false)
+- `minphase` (of type `bool?`, which defaults to `null`): minphase IRs. (default: false)
+- `anglestep` (of type `float?`, which defaults to `null`): set neighbor search angle step. (default: 0.5)
+- `radstep` (of type `float?`, which defaults to `null`): set neighbor search radius step. (default: 0.01)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.sofalizer.create`
+
+Ffmpeg filter: SOFAlizer (Spatially Oriented Format for Acoustics).. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sofa : string?, ?gain : float?, ?rotation : float?, ?elevation : float?,
+ ?radius : float?, ?type : int?, ?speakers : string?, ?lfegain : float?,
+ ?framesize : int?, ?normalize : bool?, ?interpolate : bool?,
+ ?minphase : bool?, ?anglestep : float?, ?radstep : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sofa` (of type `string?`, which defaults to `null`): sofa filename
+- `gain` (of type `float?`, which defaults to `null`): set gain in dB. (default: 0.)
+- `rotation` (of type `float?`, which defaults to `null`): set rotation. (default: 0.)
+- `elevation` (of type `float?`, which defaults to `null`): set elevation. (default: 0.)
+- `radius` (of type `float?`, which defaults to `null`): set radius. (default: 1.)
+- `type` (of type `int?`, which defaults to `null`): set processing. (default: 1, possible values: 0 (time), 1 (freq))
+- `speakers` (of type `string?`, which defaults to `null`): set speaker custom positions
+- `lfegain` (of type `float?`, which defaults to `null`): set lfe gain. (default: 0.)
+- `framesize` (of type `int?`, which defaults to `null`): set frame size. (default: 1024)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize IRs. (default: true)
+- `interpolate` (of type `bool?`, which defaults to `null`): interpolate IRs from neighbors. (default: false)
+- `minphase` (of type `bool?`, which defaults to `null`): minphase IRs. (default: false)
+- `anglestep` (of type `float?`, which defaults to `null`): set neighbor search angle step. (default: 0.5)
+- `radstep` (of type `float?`, which defaults to `null`): set neighbor search radius step. (default: 0.01)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.spectrumsynth`
+
+Ffmpeg filter: Convert input spectrum videos to audio output.
+
+Type:
+
+```
+(?sample_rate : int?, ?channels : int?, ?scale : int?, ?slide : int?,
+ ?win_func : int?, ?overlap : float?, ?orientation : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `channels` (of type `int?`, which defaults to `null`): set channels. (default: 1)
+- `scale` (of type `int?`, which defaults to `null`): set input amplitude scale. (default: 1, possible values: 0 (lin), 1 (log))
+- `slide` (of type `int?`, which defaults to `null`): set input sliding mode. (default: 2, possible values: 0 (replace), 1 (scroll), 2 (fullframe), 3 (rscroll))
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 0, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 1.)
+- `orientation` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (vertical), 1 (horizontal))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.spectrumsynth.create`
+
+Ffmpeg filter: Convert input spectrum videos to audio output.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?sample_rate : int?, ?channels : int?, ?scale : int?, ?slide : int?,
+ ?win_func : int?, ?overlap : float?, ?orientation : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `sample_rate` (of type `int?`, which defaults to `null`): set sample rate. (default: 44100)
+- `channels` (of type `int?`, which defaults to `null`): set channels. (default: 1)
+- `scale` (of type `int?`, which defaults to `null`): set input amplitude scale. (default: 1, possible values: 0 (lin), 1 (log))
+- `slide` (of type `int?`, which defaults to `null`): set input sliding mode. (default: 2, possible values: 0 (replace), 1 (scroll), 2 (fullframe), 3 (rscroll))
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 0, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 1.)
+- `orientation` (of type `int?`, which defaults to `null`): set orientation. (default: 0, possible values: 0 (vertical), 1 (horizontal))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.speechnorm`
+
+Ffmpeg filter: Speech Normalizer.
+
+Type:
+
+```
+(?peak : float?, ?p : float?, ?expansion : float?, ?e : float?,
+ ?compression : float?, ?c : float?, ?threshold : float?, ?t : float?,
+ ?raise : float?, ?r : float?, ?fall : float?, ?f : float?,
+ ?channels : string?, ?h : string?, ?invert : bool?, ?i : bool?,
+ ?link : bool?, ?l : bool?, ?rms : float?, ?m : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `peak` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `p` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `expansion` (of type `float?`, which defaults to `null`): set the max expansion factor. (default: 2.)
+- `e` (of type `float?`, which defaults to `null`): set the max expansion factor. (default: 2.)
+- `compression` (of type `float?`, which defaults to `null`): set the max compression factor. (default: 2.)
+- `c` (of type `float?`, which defaults to `null`): set the max compression factor. (default: 2.)
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `t` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `raise` (of type `float?`, which defaults to `null`): set the expansion raising amount. (default: 0.001)
+- `r` (of type `float?`, which defaults to `null`): set the expansion raising amount. (default: 0.001)
+- `fall` (of type `float?`, which defaults to `null`): set the compression raising amount. (default: 0.001)
+- `f` (of type `float?`, which defaults to `null`): set the compression raising amount. (default: 0.001)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `h` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `invert` (of type `bool?`, which defaults to `null`): set inverted filtering. (default: false)
+- `i` (of type `bool?`, which defaults to `null`): set inverted filtering. (default: false)
+- `link` (of type `bool?`, which defaults to `null`): set linked channels filtering. (default: false)
+- `l` (of type `bool?`, which defaults to `null`): set linked channels filtering. (default: false)
+- `rms` (of type `float?`, which defaults to `null`): set the RMS value. (default: 0.)
+- `m` (of type `float?`, which defaults to `null`): set the RMS value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.speechnorm.create`
+
+Ffmpeg filter: Speech Normalizer.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?peak : float?, ?p : float?, ?expansion : float?, ?e : float?,
+ ?compression : float?, ?c : float?, ?threshold : float?, ?t : float?,
+ ?raise : float?, ?r : float?, ?fall : float?, ?f : float?,
+ ?channels : string?, ?h : string?, ?invert : bool?, ?i : bool?,
+ ?link : bool?, ?l : bool?, ?rms : float?, ?m : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `peak` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `p` (of type `float?`, which defaults to `null`): set the peak value. (default: 0.95)
+- `expansion` (of type `float?`, which defaults to `null`): set the max expansion factor. (default: 2.)
+- `e` (of type `float?`, which defaults to `null`): set the max expansion factor. (default: 2.)
+- `compression` (of type `float?`, which defaults to `null`): set the max compression factor. (default: 2.)
+- `c` (of type `float?`, which defaults to `null`): set the max compression factor. (default: 2.)
+- `threshold` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `t` (of type `float?`, which defaults to `null`): set the threshold value. (default: 0.)
+- `raise` (of type `float?`, which defaults to `null`): set the expansion raising amount. (default: 0.001)
+- `r` (of type `float?`, which defaults to `null`): set the expansion raising amount. (default: 0.001)
+- `fall` (of type `float?`, which defaults to `null`): set the compression raising amount. (default: 0.001)
+- `f` (of type `float?`, which defaults to `null`): set the compression raising amount. (default: 0.001)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `h` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `invert` (of type `bool?`, which defaults to `null`): set inverted filtering. (default: false)
+- `i` (of type `bool?`, which defaults to `null`): set inverted filtering. (default: false)
+- `link` (of type `bool?`, which defaults to `null`): set linked channels filtering. (default: false)
+- `l` (of type `bool?`, which defaults to `null`): set linked channels filtering. (default: false)
+- `rms` (of type `float?`, which defaults to `null`): set the RMS value. (default: 0.)
+- `m` (of type `float?`, which defaults to `null`): set the RMS value. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.split`
+
+Ffmpeg filter: Pass on the input to N video outputs. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?outputs : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+[ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `outputs` (of type `int?`, which defaults to `null`): set number of outputs. (default: 2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.split.create`
+
+Ffmpeg filter: Pass on the input to N video outputs. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?outputs : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `outputs` (of type `int?`, which defaults to `null`): set number of outputs. (default: 2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.spp`
+
+Ffmpeg filter: Apply a simple post processing filter.
+
+Type:
+
+```
+(?quality : int?, ?qp : int?, ?mode : int?, ?use_bframe_qp : bool?,
+ ?dct : int?, ?idct : int?, ?bits_per_sample : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `quality` (of type `int?`, which defaults to `null`): set quality. (default: 3)
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set thresholding mode. (default: 0, possible values: 0 (hard), 1 (soft))
+- `use_bframe_qp` (of type `bool?`, which defaults to `null`): use B-frames' QP. (default: false)
+- `dct` (of type `int?`, which defaults to `null`): DCT algorithm. (default: 0, possible values: 0 (auto), 1 (fastint), 2 (int), 3 (mmx), 5 (altivec), 6 (faan))
+- `idct` (of type `int?`, which defaults to `null`): select IDCT implementation. (default: 0, possible values: 0 (auto), 1 (int), 2 (simple), 3 (simplemmx), 7 (arm), 8 (altivec), 10 (simplearm), 16 (simplearmv5te), 17 (simplearmv6), 22 (simpleneon), 14 (xvid), 14 (xvidmmx), 20 (faani), 128 (simpleauto))
+- `bits_per_sample` (of type `int?`, which defaults to `null`): Default: 8
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.spp.create`
+
+Ffmpeg filter: Apply a simple post processing filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?quality : int?, ?qp : int?, ?mode : int?, ?use_bframe_qp : bool?,
+ ?dct : int?, ?idct : int?, ?bits_per_sample : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `quality` (of type `int?`, which defaults to `null`): set quality. (default: 3)
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `mode` (of type `int?`, which defaults to `null`): set thresholding mode. (default: 0, possible values: 0 (hard), 1 (soft))
+- `use_bframe_qp` (of type `bool?`, which defaults to `null`): use B-frames' QP. (default: false)
+- `dct` (of type `int?`, which defaults to `null`): DCT algorithm. (default: 0, possible values: 0 (auto), 1 (fastint), 2 (int), 3 (mmx), 5 (altivec), 6 (faan))
+- `idct` (of type `int?`, which defaults to `null`): select IDCT implementation. (default: 0, possible values: 0 (auto), 1 (int), 2 (simple), 3 (simplemmx), 7 (arm), 8 (altivec), 10 (simplearm), 16 (simplearmv5te), 17 (simplearmv6), 22 (simpleneon), 14 (xvid), 14 (xvidmmx), 20 (faani), 128 (simpleauto))
+- `bits_per_sample` (of type `int?`, which defaults to `null`): Default: 8
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.sr`
+
+Ffmpeg filter: Apply DNN-based image super resolution to the input.
+
+Type:
+
+```
+(?dnn_backend : int?, ?scale_factor : int?, ?model : string?,
+ ?input : string?, ?output : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend used for model execution. (default: 1)
+- `scale_factor` (of type `int?`, which defaults to `null`): scale factor for SRCNN model. (default: 2)
+- `model` (of type `string?`, which defaults to `null`): path to model file specifying network architecture and its parameters
+- `input` (of type `string?`, which defaults to `null`): input name of the model. (default: x)
+- `output` (of type `string?`, which defaults to `null`): output name of the model. (default: y)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.sr.create`
+
+Ffmpeg filter: Apply DNN-based image super resolution to the input.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dnn_backend : int?, ?scale_factor : int?, ?model : string?,
+ ?input : string?, ?output : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dnn_backend` (of type `int?`, which defaults to `null`): DNN backend used for model execution. (default: 1)
+- `scale_factor` (of type `int?`, which defaults to `null`): scale factor for SRCNN model. (default: 2)
+- `model` (of type `string?`, which defaults to `null`): path to model file specifying network architecture and its parameters
+- `input` (of type `string?`, which defaults to `null`): input name of the model. (default: x)
+- `output` (of type `string?`, which defaults to `null`): output name of the model. (default: y)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ssim`
+
+Ffmpeg filter: Calculate the SSIM between two video streams.
+
+Type:
+
+```
+(?stats_file : string?, ?f : string?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `f` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.ssim.create`
+
+Ffmpeg filter: Calculate the SSIM between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?stats_file : string?, ?f : string?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `f` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.ssim360`
+
+Ffmpeg filter: Calculate the SSIM between two 360 video streams.
+
+Type:
+
+```
+(?stats_file : string?, ?f : string?, ?compute_chroma : int?,
+ ?frame_skip_ratio : int?, ?ref_projection : int?, ?main_projection : int?,
+ ?ref_stereo : int?, ?main_stereo : int?, ?ref_pad : float?,
+ ?main_pad : float?, ?use_tape : int?, ?heatmap_str : string?,
+ ?default_heatmap_width : int?, ?default_heatmap_height : int?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `f` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `compute_chroma` (of type `int?`, which defaults to `null`): Specifies if non-luma channels must be computed. (default: 1)
+- `frame_skip_ratio` (of type `int?`, which defaults to `null`): Specifies the number of frames to be skipped from evaluation, for every evaluated frame. (default: 0)
+- `ref_projection` (of type `int?`, which defaults to `null`): projection of the reference video. (default: 4, possible values: 4 (e), 4 (equirect), 0 (c3x2), 1 (c2x3), 2 (barrel), 3 (barrelsplit))
+- `main_projection` (of type `int?`, which defaults to `null`): projection of the main video. (default: 5, possible values: 4 (e), 4 (equirect), 0 (c3x2), 1 (c2x3), 2 (barrel), 3 (barrelsplit))
+- `ref_stereo` (of type `int?`, which defaults to `null`): stereo format of the reference video. (default: 2, possible values: 2 (mono), 0 (tb), 1 (lr))
+- `main_stereo` (of type `int?`, which defaults to `null`): stereo format of main video. (default: 3, possible values: 2 (mono), 0 (tb), 1 (lr))
+- `ref_pad` (of type `float?`, which defaults to `null`): Expansion (padding) coefficient for each cube face of the reference video. (default: 0.)
+- `main_pad` (of type `float?`, which defaults to `null`): Expansion (padding) coeffiecient for each cube face of the main video. (default: 0.)
+- `use_tape` (of type `int?`, which defaults to `null`): Specifies if the tape based SSIM 360 algorithm must be used independent of the input video types. (default: 0)
+- `heatmap_str` (of type `string?`, which defaults to `null`): Heatmap data for view-based evaluation. For heatmap file format, please refer to EntSphericalVideoHeatmapData.
+- `default_heatmap_width` (of type `int?`, which defaults to `null`): Default heatmap dimension. Will be used when dimension is not specified in heatmap data.. (default: 32)
+- `default_heatmap_height` (of type `int?`, which defaults to `null`): Default heatmap dimension. Will be used when dimension is not specified in heatmap data.. (default: 16)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.ssim360.create`
+
+Ffmpeg filter: Calculate the SSIM between two 360 video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?stats_file : string?, ?f : string?, ?compute_chroma : int?,
+ ?frame_skip_ratio : int?, ?ref_projection : int?, ?main_projection : int?,
+ ?ref_stereo : int?, ?main_stereo : int?, ?ref_pad : float?,
+ ?main_pad : float?, ?use_tape : int?, ?heatmap_str : string?,
+ ?default_heatmap_width : int?, ?default_heatmap_height : int?,
+ ?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `f` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `compute_chroma` (of type `int?`, which defaults to `null`): Specifies if non-luma channels must be computed. (default: 1)
+- `frame_skip_ratio` (of type `int?`, which defaults to `null`): Specifies the number of frames to be skipped from evaluation, for every evaluated frame. (default: 0)
+- `ref_projection` (of type `int?`, which defaults to `null`): projection of the reference video. (default: 4, possible values: 4 (e), 4 (equirect), 0 (c3x2), 1 (c2x3), 2 (barrel), 3 (barrelsplit))
+- `main_projection` (of type `int?`, which defaults to `null`): projection of the main video. (default: 5, possible values: 4 (e), 4 (equirect), 0 (c3x2), 1 (c2x3), 2 (barrel), 3 (barrelsplit))
+- `ref_stereo` (of type `int?`, which defaults to `null`): stereo format of the reference video. (default: 2, possible values: 2 (mono), 0 (tb), 1 (lr))
+- `main_stereo` (of type `int?`, which defaults to `null`): stereo format of main video. (default: 3, possible values: 2 (mono), 0 (tb), 1 (lr))
+- `ref_pad` (of type `float?`, which defaults to `null`): Expansion (padding) coefficient for each cube face of the reference video. (default: 0.)
+- `main_pad` (of type `float?`, which defaults to `null`): Expansion (padding) coeffiecient for each cube face of the main video. (default: 0.)
+- `use_tape` (of type `int?`, which defaults to `null`): Specifies if the tape based SSIM 360 algorithm must be used independent of the input video types. (default: 0)
+- `heatmap_str` (of type `string?`, which defaults to `null`): Heatmap data for view-based evaluation. For heatmap file format, please refer to EntSphericalVideoHeatmapData.
+- `default_heatmap_width` (of type `int?`, which defaults to `null`): Default heatmap dimension. Will be used when dimension is not specified in heatmap data.. (default: 32)
+- `default_heatmap_height` (of type `int?`, which defaults to `null`): Default heatmap dimension. Will be used when dimension is not specified in heatmap data.. (default: 16)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.stereo3d`
+
+Ffmpeg filter: Convert video stereoscopic 3D view.
+
+Type:
+
+```
+(?in : int?, ?out : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `in` (of type `int?`, which defaults to `null`): set input format. (default: 18, possible values: 24 (ab2l), 24 (tb2l), 25 (ab2r), 25 (tb2r), 22 (abl), 22 (tbl), 23 (abr), 23 (tbr), 26 (al), 27 (ar), 20 (sbs2l), 21 (sbs2r), 18 (sbsl), 19 (sbsr), 16 (irl), 17 (irr), 30 (icl), 31 (icr))
+- `out` (of type `int?`, which defaults to `null`): set output format. (default: 3, possible values: 24 (ab2l), 24 (tb2l), 25 (ab2r), 25 (tb2r), 22 (abl), 22 (tbl), 23 (abr), 23 (tbr), 6 (agmc), 7 (agmd), 4 (agmg), 5 (agmh), 26 (al), 27 (ar), 12 (arbg), 2 (arcc), 3 (arcd), 0 (arcg), 1 (arch), 13 (argg), 10 (aybc), 11 (aybd), 8 (aybg), 9 (aybh), 16 (irl), 17 (irr), 14 (ml), 15 (mr), 20 (sbs2l), 21 (sbs2r), 18 (sbsl), 19 (sbsr), 28 (chl), 29 (chr), 30 (icl), 31 (icr), 32 (hdmi))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.stereo3d.create`
+
+Ffmpeg filter: Convert video stereoscopic 3D view.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?in : int?, ?out : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `in` (of type `int?`, which defaults to `null`): set input format. (default: 18, possible values: 24 (ab2l), 24 (tb2l), 25 (ab2r), 25 (tb2r), 22 (abl), 22 (tbl), 23 (abr), 23 (tbr), 26 (al), 27 (ar), 20 (sbs2l), 21 (sbs2r), 18 (sbsl), 19 (sbsr), 16 (irl), 17 (irr), 30 (icl), 31 (icr))
+- `out` (of type `int?`, which defaults to `null`): set output format. (default: 3, possible values: 24 (ab2l), 24 (tb2l), 25 (ab2r), 25 (tb2r), 22 (abl), 22 (tbl), 23 (abr), 23 (tbr), 6 (agmc), 7 (agmd), 4 (agmg), 5 (agmh), 26 (al), 27 (ar), 12 (arbg), 2 (arcc), 3 (arcd), 0 (arcg), 1 (arch), 13 (argg), 10 (aybc), 11 (aybd), 8 (aybg), 9 (aybh), 16 (irl), 17 (irr), 14 (ml), 15 (mr), 20 (sbs2l), 21 (sbs2r), 18 (sbsl), 19 (sbsr), 28 (chl), 29 (chr), 30 (icl), 31 (icr), 32 (hdmi))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.stereotools`
+
+Ffmpeg filter: Apply various stereo tools.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?balance_in : float?,
+ ?balance_out : float?, ?softclip : bool?, ?mutel : bool?, ?muter : bool?,
+ ?phasel : bool?, ?phaser : bool?, ?mode : int?, ?slev : float?,
+ ?sbal : float?, ?mlev : float?, ?mpan : float?, ?base : float?,
+ ?delay : float?, ?sclevel : float?, ?phase : float?, ?bmode_in : int?,
+ ?bmode_out : int?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `balance_in` (of type `float?`, which defaults to `null`): set balance in. (default: 0.)
+- `balance_out` (of type `float?`, which defaults to `null`): set balance out. (default: 0.)
+- `softclip` (of type `bool?`, which defaults to `null`): enable softclip. (default: false)
+- `mutel` (of type `bool?`, which defaults to `null`): mute L. (default: false)
+- `muter` (of type `bool?`, which defaults to `null`): mute R. (default: false)
+- `phasel` (of type `bool?`, which defaults to `null`): phase L. (default: false)
+- `phaser` (of type `bool?`, which defaults to `null`): phase R. (default: false)
+- `mode` (of type `int?`, which defaults to `null`): set stereo mode. (default: 0, possible values: 0 (lr>lr), 1 (lr>ms), 2 (ms>lr), 3 (lr>ll), 4 (lr>rr), 5 (lr>l+r), 6 (lr>rl), 7 (ms>ll), 8 (ms>rr), 9 (ms>rl), 10 (lr>l-r))
+- `slev` (of type `float?`, which defaults to `null`): set side level. (default: 1.)
+- `sbal` (of type `float?`, which defaults to `null`): set side balance. (default: 0.)
+- `mlev` (of type `float?`, which defaults to `null`): set middle level. (default: 1.)
+- `mpan` (of type `float?`, which defaults to `null`): set middle pan. (default: 0.)
+- `base` (of type `float?`, which defaults to `null`): set stereo base. (default: 0.)
+- `delay` (of type `float?`, which defaults to `null`): set delay. (default: 0.)
+- `sclevel` (of type `float?`, which defaults to `null`): set S/C level. (default: 1.)
+- `phase` (of type `float?`, which defaults to `null`): set stereo phase. (default: 0.)
+- `bmode_in` (of type `int?`, which defaults to `null`): set balance in mode. (default: 0, possible values: 0 (balance), 1 (amplitude), 2 (power))
+- `bmode_out` (of type `int?`, which defaults to `null`): set balance out mode. (default: 0, possible values: 0 (balance), 1 (amplitude), 2 (power))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.stereotools.create`
+
+Ffmpeg filter: Apply various stereo tools.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?level_in : float?, ?level_out : float?, ?balance_in : float?,
+ ?balance_out : float?, ?softclip : bool?, ?mutel : bool?, ?muter : bool?,
+ ?phasel : bool?, ?phaser : bool?, ?mode : int?, ?slev : float?,
+ ?sbal : float?, ?mlev : float?, ?mpan : float?, ?base : float?,
+ ?delay : float?, ?sclevel : float?, ?phase : float?, ?bmode_in : int?,
+ ?bmode_out : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `level_in` (of type `float?`, which defaults to `null`): set level in. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set level out. (default: 1.)
+- `balance_in` (of type `float?`, which defaults to `null`): set balance in. (default: 0.)
+- `balance_out` (of type `float?`, which defaults to `null`): set balance out. (default: 0.)
+- `softclip` (of type `bool?`, which defaults to `null`): enable softclip. (default: false)
+- `mutel` (of type `bool?`, which defaults to `null`): mute L. (default: false)
+- `muter` (of type `bool?`, which defaults to `null`): mute R. (default: false)
+- `phasel` (of type `bool?`, which defaults to `null`): phase L. (default: false)
+- `phaser` (of type `bool?`, which defaults to `null`): phase R. (default: false)
+- `mode` (of type `int?`, which defaults to `null`): set stereo mode. (default: 0, possible values: 0 (lr>lr), 1 (lr>ms), 2 (ms>lr), 3 (lr>ll), 4 (lr>rr), 5 (lr>l+r), 6 (lr>rl), 7 (ms>ll), 8 (ms>rr), 9 (ms>rl), 10 (lr>l-r))
+- `slev` (of type `float?`, which defaults to `null`): set side level. (default: 1.)
+- `sbal` (of type `float?`, which defaults to `null`): set side balance. (default: 0.)
+- `mlev` (of type `float?`, which defaults to `null`): set middle level. (default: 1.)
+- `mpan` (of type `float?`, which defaults to `null`): set middle pan. (default: 0.)
+- `base` (of type `float?`, which defaults to `null`): set stereo base. (default: 0.)
+- `delay` (of type `float?`, which defaults to `null`): set delay. (default: 0.)
+- `sclevel` (of type `float?`, which defaults to `null`): set S/C level. (default: 1.)
+- `phase` (of type `float?`, which defaults to `null`): set stereo phase. (default: 0.)
+- `bmode_in` (of type `int?`, which defaults to `null`): set balance in mode. (default: 0, possible values: 0 (balance), 1 (amplitude), 2 (power))
+- `bmode_out` (of type `int?`, which defaults to `null`): set balance out mode. (default: 0, possible values: 0 (balance), 1 (amplitude), 2 (power))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.stereowiden`
+
+Ffmpeg filter: Apply stereo widening effect.
+
+Type:
+
+```
+(?delay : float?, ?feedback : float?, ?crossfeed : float?, ?drymix : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `delay` (of type `float?`, which defaults to `null`): set delay time. (default: 20.)
+- `feedback` (of type `float?`, which defaults to `null`): set feedback gain. (default: 0.3)
+- `crossfeed` (of type `float?`, which defaults to `null`): set cross feed. (default: 0.3)
+- `drymix` (of type `float?`, which defaults to `null`): set dry-mix. (default: 0.8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.stereowiden.create`
+
+Ffmpeg filter: Apply stereo widening effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?delay : float?, ?feedback : float?, ?crossfeed : float?, ?drymix : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `delay` (of type `float?`, which defaults to `null`): set delay time. (default: 20.)
+- `feedback` (of type `float?`, which defaults to `null`): set feedback gain. (default: 0.3)
+- `crossfeed` (of type `float?`, which defaults to `null`): set cross feed. (default: 0.3)
+- `drymix` (of type `float?`, which defaults to `null`): set dry-mix. (default: 0.8)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.streamselect`
+
+Ffmpeg filter: Select video streams This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?map : string?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> [ffmpeg.filter.audio] * [ffmpeg.filter.video]
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): number of input streams. (default: 2)
+- `map` (of type `string?`, which defaults to `null`): input indexes to remap to outputs
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.streamselect.create`
+
+Ffmpeg filter: Select video streams This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime. This filter has dynamic outputs: returned value is a tuple of audio and video outputs. Total number of outputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?map : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): number of input streams. (default: 2)
+- `map` (of type `string?`, which defaults to `null`): input indexes to remap to outputs
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `[ffmpeg.filter.audio] * [ffmpeg.filter.video]`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.subtitles`
+
+Ffmpeg filter: Render text subtitles onto input video using the libass library.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?original_size : string?,
+ ?fontsdir : string?, ?alpha : bool?, ?charenc : string?,
+ ?stream_index : int?, ?si : int?, ?force_style : string?,
+ ?wrap_unicode : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `f` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `original_size` (of type `string?`, which defaults to `null`): set the size of the original video (used to scale fonts)
+- `fontsdir` (of type `string?`, which defaults to `null`): set the directory containing the fonts to read
+- `alpha` (of type `bool?`, which defaults to `null`): enable processing of alpha channel. (default: false)
+- `charenc` (of type `string?`, which defaults to `null`): set input character encoding
+- `stream_index` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `si` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `force_style` (of type `string?`, which defaults to `null`): force subtitle style
+- `wrap_unicode` (of type `bool?`, which defaults to `null`): break lines according to the Unicode Line Breaking Algorithm
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.subtitles.create`
+
+Ffmpeg filter: Render text subtitles onto input video using the libass library.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filename : string?, ?f : string?, ?original_size : string?,
+ ?fontsdir : string?, ?alpha : bool?, ?charenc : string?,
+ ?stream_index : int?, ?si : int?, ?force_style : string?,
+ ?wrap_unicode : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filename` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `f` (of type `string?`, which defaults to `null`): set the filename of file to read
+- `original_size` (of type `string?`, which defaults to `null`): set the size of the original video (used to scale fonts)
+- `fontsdir` (of type `string?`, which defaults to `null`): set the directory containing the fonts to read
+- `alpha` (of type `bool?`, which defaults to `null`): enable processing of alpha channel. (default: false)
+- `charenc` (of type `string?`, which defaults to `null`): set input character encoding
+- `stream_index` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `si` (of type `int?`, which defaults to `null`): set stream index. (default: -1)
+- `force_style` (of type `string?`, which defaults to `null`): force subtitle style
+- `wrap_unicode` (of type `bool?`, which defaults to `null`): break lines according to the Unicode Line Breaking Algorithm
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.super2xsai`
+
+Ffmpeg filter: Scale the input by 2x using the Super2xSaI pixel art algorithm.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.super2xsai.create`
+
+Ffmpeg filter: Scale the input by 2x using the Super2xSaI pixel art algorithm.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.superequalizer`
+
+Ffmpeg filter: Apply 18 band equalization filter.
+
+Type:
+
+```
+(?1b : float?, ?2b : float?, ?3b : float?, ?4b : float?, ?5b : float?,
+ ?6b : float?, ?7b : float?, ?8b : float?, ?9b : float?, ?10b : float?,
+ ?11b : float?, ?12b : float?, ?13b : float?, ?14b : float?, ?15b : float?,
+ ?16b : float?, ?17b : float?, ?18b : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `1b` (of type `float?`, which defaults to `null`): set 65Hz band gain. (default: 1.)
+- `2b` (of type `float?`, which defaults to `null`): set 92Hz band gain. (default: 1.)
+- `3b` (of type `float?`, which defaults to `null`): set 131Hz band gain. (default: 1.)
+- `4b` (of type `float?`, which defaults to `null`): set 185Hz band gain. (default: 1.)
+- `5b` (of type `float?`, which defaults to `null`): set 262Hz band gain. (default: 1.)
+- `6b` (of type `float?`, which defaults to `null`): set 370Hz band gain. (default: 1.)
+- `7b` (of type `float?`, which defaults to `null`): set 523Hz band gain. (default: 1.)
+- `8b` (of type `float?`, which defaults to `null`): set 740Hz band gain. (default: 1.)
+- `9b` (of type `float?`, which defaults to `null`): set 1047Hz band gain. (default: 1.)
+- `10b` (of type `float?`, which defaults to `null`): set 1480Hz band gain. (default: 1.)
+- `11b` (of type `float?`, which defaults to `null`): set 2093Hz band gain. (default: 1.)
+- `12b` (of type `float?`, which defaults to `null`): set 2960Hz band gain. (default: 1.)
+- `13b` (of type `float?`, which defaults to `null`): set 4186Hz band gain. (default: 1.)
+- `14b` (of type `float?`, which defaults to `null`): set 5920Hz band gain. (default: 1.)
+- `15b` (of type `float?`, which defaults to `null`): set 8372Hz band gain. (default: 1.)
+- `16b` (of type `float?`, which defaults to `null`): set 11840Hz band gain. (default: 1.)
+- `17b` (of type `float?`, which defaults to `null`): set 16744Hz band gain. (default: 1.)
+- `18b` (of type `float?`, which defaults to `null`): set 20000Hz band gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.superequalizer.create`
+
+Ffmpeg filter: Apply 18 band equalization filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?1b : float?, ?2b : float?, ?3b : float?, ?4b : float?, ?5b : float?,
+ ?6b : float?, ?7b : float?, ?8b : float?, ?9b : float?, ?10b : float?,
+ ?11b : float?, ?12b : float?, ?13b : float?, ?14b : float?, ?15b : float?,
+ ?16b : float?, ?17b : float?, ?18b : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `1b` (of type `float?`, which defaults to `null`): set 65Hz band gain. (default: 1.)
+- `2b` (of type `float?`, which defaults to `null`): set 92Hz band gain. (default: 1.)
+- `3b` (of type `float?`, which defaults to `null`): set 131Hz band gain. (default: 1.)
+- `4b` (of type `float?`, which defaults to `null`): set 185Hz band gain. (default: 1.)
+- `5b` (of type `float?`, which defaults to `null`): set 262Hz band gain. (default: 1.)
+- `6b` (of type `float?`, which defaults to `null`): set 370Hz band gain. (default: 1.)
+- `7b` (of type `float?`, which defaults to `null`): set 523Hz band gain. (default: 1.)
+- `8b` (of type `float?`, which defaults to `null`): set 740Hz band gain. (default: 1.)
+- `9b` (of type `float?`, which defaults to `null`): set 1047Hz band gain. (default: 1.)
+- `10b` (of type `float?`, which defaults to `null`): set 1480Hz band gain. (default: 1.)
+- `11b` (of type `float?`, which defaults to `null`): set 2093Hz band gain. (default: 1.)
+- `12b` (of type `float?`, which defaults to `null`): set 2960Hz band gain. (default: 1.)
+- `13b` (of type `float?`, which defaults to `null`): set 4186Hz band gain. (default: 1.)
+- `14b` (of type `float?`, which defaults to `null`): set 5920Hz band gain. (default: 1.)
+- `15b` (of type `float?`, which defaults to `null`): set 8372Hz band gain. (default: 1.)
+- `16b` (of type `float?`, which defaults to `null`): set 11840Hz band gain. (default: 1.)
+- `17b` (of type `float?`, which defaults to `null`): set 16744Hz band gain. (default: 1.)
+- `18b` (of type `float?`, which defaults to `null`): set 20000Hz band gain. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.surround`
+
+Ffmpeg filter: Apply audio surround upmix filter.
+
+Type:
+
+```
+(?chl_out : string?, ?chl_in : string?, ?level_in : float?,
+ ?level_out : float?, ?lfe : bool?, ?lfe_low : int?, ?lfe_high : int?,
+ ?lfe_mode : int?, ?smooth : float?, ?angle : float?, ?focus : float?,
+ ?fc_in : float?, ?fc_out : float?, ?fl_in : float?, ?fl_out : float?,
+ ?fr_in : float?, ?fr_out : float?, ?sl_in : float?, ?sl_out : float?,
+ ?sr_in : float?, ?sr_out : float?, ?bl_in : float?, ?bl_out : float?,
+ ?br_in : float?, ?br_out : float?, ?bc_in : float?, ?bc_out : float?,
+ ?lfe_in : float?, ?lfe_out : float?, ?allx : float?, ?ally : float?,
+ ?fcx : float?, ?flx : float?, ?frx : float?, ?blx : float?, ?brx : float?,
+ ?slx : float?, ?srx : float?, ?bcx : float?, ?fcy : float?, ?fly : float?,
+ ?fry : float?, ?bly : float?, ?bry : float?, ?sly : float?, ?sry : float?,
+ ?bcy : float?, ?win_size : int?, ?win_func : int?, ?overlap : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `chl_out` (of type `string?`, which defaults to `null`): set output channel layout. (default: 5.1)
+- `chl_in` (of type `string?`, which defaults to `null`): set input channel layout. (default: stereo)
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `lfe` (of type `bool?`, which defaults to `null`): output LFE. (default: true)
+- `lfe_low` (of type `int?`, which defaults to `null`): LFE low cut off. (default: 128)
+- `lfe_high` (of type `int?`, which defaults to `null`): LFE high cut off. (default: 256)
+- `lfe_mode` (of type `int?`, which defaults to `null`): set LFE channel mode. (default: 0, possible values: 0 (add), 1 (sub))
+- `smooth` (of type `float?`, which defaults to `null`): set temporal smoothness strength. (default: 0.)
+- `angle` (of type `float?`, which defaults to `null`): set soundfield transform angle. (default: 90.)
+- `focus` (of type `float?`, which defaults to `null`): set soundfield transform focus. (default: 0.)
+- `fc_in` (of type `float?`, which defaults to `null`): set front center channel input level. (default: 1.)
+- `fc_out` (of type `float?`, which defaults to `null`): set front center channel output level. (default: 1.)
+- `fl_in` (of type `float?`, which defaults to `null`): set front left channel input level. (default: 1.)
+- `fl_out` (of type `float?`, which defaults to `null`): set front left channel output level. (default: 1.)
+- `fr_in` (of type `float?`, which defaults to `null`): set front right channel input level. (default: 1.)
+- `fr_out` (of type `float?`, which defaults to `null`): set front right channel output level. (default: 1.)
+- `sl_in` (of type `float?`, which defaults to `null`): set side left channel input level. (default: 1.)
+- `sl_out` (of type `float?`, which defaults to `null`): set side left channel output level. (default: 1.)
+- `sr_in` (of type `float?`, which defaults to `null`): set side right channel input level. (default: 1.)
+- `sr_out` (of type `float?`, which defaults to `null`): set side right channel output level. (default: 1.)
+- `bl_in` (of type `float?`, which defaults to `null`): set back left channel input level. (default: 1.)
+- `bl_out` (of type `float?`, which defaults to `null`): set back left channel output level. (default: 1.)
+- `br_in` (of type `float?`, which defaults to `null`): set back right channel input level. (default: 1.)
+- `br_out` (of type `float?`, which defaults to `null`): set back right channel output level. (default: 1.)
+- `bc_in` (of type `float?`, which defaults to `null`): set back center channel input level. (default: 1.)
+- `bc_out` (of type `float?`, which defaults to `null`): set back center channel output level. (default: 1.)
+- `lfe_in` (of type `float?`, which defaults to `null`): set lfe channel input level. (default: 1.)
+- `lfe_out` (of type `float?`, which defaults to `null`): set lfe channel output level. (default: 1.)
+- `allx` (of type `float?`, which defaults to `null`): set all channel's x spread. (default: -1.)
+- `ally` (of type `float?`, which defaults to `null`): set all channel's y spread. (default: -1.)
+- `fcx` (of type `float?`, which defaults to `null`): set front center channel x spread. (default: 0.5)
+- `flx` (of type `float?`, which defaults to `null`): set front left channel x spread. (default: 0.5)
+- `frx` (of type `float?`, which defaults to `null`): set front right channel x spread. (default: 0.5)
+- `blx` (of type `float?`, which defaults to `null`): set back left channel x spread. (default: 0.5)
+- `brx` (of type `float?`, which defaults to `null`): set back right channel x spread. (default: 0.5)
+- `slx` (of type `float?`, which defaults to `null`): set side left channel x spread. (default: 0.5)
+- `srx` (of type `float?`, which defaults to `null`): set side right channel x spread. (default: 0.5)
+- `bcx` (of type `float?`, which defaults to `null`): set back center channel x spread. (default: 0.5)
+- `fcy` (of type `float?`, which defaults to `null`): set front center channel y spread. (default: 0.5)
+- `fly` (of type `float?`, which defaults to `null`): set front left channel y spread. (default: 0.5)
+- `fry` (of type `float?`, which defaults to `null`): set front right channel y spread. (default: 0.5)
+- `bly` (of type `float?`, which defaults to `null`): set back left channel y spread. (default: 0.5)
+- `bry` (of type `float?`, which defaults to `null`): set back right channel y spread. (default: 0.5)
+- `sly` (of type `float?`, which defaults to `null`): set side left channel y spread. (default: 0.5)
+- `sry` (of type `float?`, which defaults to `null`): set side right channel y spread. (default: 0.5)
+- `bcy` (of type `float?`, which defaults to `null`): set back center channel y spread. (default: 0.5)
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 4096)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.surround.create`
+
+Ffmpeg filter: Apply audio surround upmix filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?chl_out : string?, ?chl_in : string?, ?level_in : float?,
+ ?level_out : float?, ?lfe : bool?, ?lfe_low : int?, ?lfe_high : int?,
+ ?lfe_mode : int?, ?smooth : float?, ?angle : float?, ?focus : float?,
+ ?fc_in : float?, ?fc_out : float?, ?fl_in : float?, ?fl_out : float?,
+ ?fr_in : float?, ?fr_out : float?, ?sl_in : float?, ?sl_out : float?,
+ ?sr_in : float?, ?sr_out : float?, ?bl_in : float?, ?bl_out : float?,
+ ?br_in : float?, ?br_out : float?, ?bc_in : float?, ?bc_out : float?,
+ ?lfe_in : float?, ?lfe_out : float?, ?allx : float?, ?ally : float?,
+ ?fcx : float?, ?flx : float?, ?frx : float?, ?blx : float?, ?brx : float?,
+ ?slx : float?, ?srx : float?, ?bcx : float?, ?fcy : float?, ?fly : float?,
+ ?fry : float?, ?bly : float?, ?bry : float?, ?sly : float?, ?sry : float?,
+ ?bcy : float?, ?win_size : int?, ?win_func : int?, ?overlap : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `chl_out` (of type `string?`, which defaults to `null`): set output channel layout. (default: 5.1)
+- `chl_in` (of type `string?`, which defaults to `null`): set input channel layout. (default: stereo)
+- `level_in` (of type `float?`, which defaults to `null`): set input level. (default: 1.)
+- `level_out` (of type `float?`, which defaults to `null`): set output level. (default: 1.)
+- `lfe` (of type `bool?`, which defaults to `null`): output LFE. (default: true)
+- `lfe_low` (of type `int?`, which defaults to `null`): LFE low cut off. (default: 128)
+- `lfe_high` (of type `int?`, which defaults to `null`): LFE high cut off. (default: 256)
+- `lfe_mode` (of type `int?`, which defaults to `null`): set LFE channel mode. (default: 0, possible values: 0 (add), 1 (sub))
+- `smooth` (of type `float?`, which defaults to `null`): set temporal smoothness strength. (default: 0.)
+- `angle` (of type `float?`, which defaults to `null`): set soundfield transform angle. (default: 90.)
+- `focus` (of type `float?`, which defaults to `null`): set soundfield transform focus. (default: 0.)
+- `fc_in` (of type `float?`, which defaults to `null`): set front center channel input level. (default: 1.)
+- `fc_out` (of type `float?`, which defaults to `null`): set front center channel output level. (default: 1.)
+- `fl_in` (of type `float?`, which defaults to `null`): set front left channel input level. (default: 1.)
+- `fl_out` (of type `float?`, which defaults to `null`): set front left channel output level. (default: 1.)
+- `fr_in` (of type `float?`, which defaults to `null`): set front right channel input level. (default: 1.)
+- `fr_out` (of type `float?`, which defaults to `null`): set front right channel output level. (default: 1.)
+- `sl_in` (of type `float?`, which defaults to `null`): set side left channel input level. (default: 1.)
+- `sl_out` (of type `float?`, which defaults to `null`): set side left channel output level. (default: 1.)
+- `sr_in` (of type `float?`, which defaults to `null`): set side right channel input level. (default: 1.)
+- `sr_out` (of type `float?`, which defaults to `null`): set side right channel output level. (default: 1.)
+- `bl_in` (of type `float?`, which defaults to `null`): set back left channel input level. (default: 1.)
+- `bl_out` (of type `float?`, which defaults to `null`): set back left channel output level. (default: 1.)
+- `br_in` (of type `float?`, which defaults to `null`): set back right channel input level. (default: 1.)
+- `br_out` (of type `float?`, which defaults to `null`): set back right channel output level. (default: 1.)
+- `bc_in` (of type `float?`, which defaults to `null`): set back center channel input level. (default: 1.)
+- `bc_out` (of type `float?`, which defaults to `null`): set back center channel output level. (default: 1.)
+- `lfe_in` (of type `float?`, which defaults to `null`): set lfe channel input level. (default: 1.)
+- `lfe_out` (of type `float?`, which defaults to `null`): set lfe channel output level. (default: 1.)
+- `allx` (of type `float?`, which defaults to `null`): set all channel's x spread. (default: -1.)
+- `ally` (of type `float?`, which defaults to `null`): set all channel's y spread. (default: -1.)
+- `fcx` (of type `float?`, which defaults to `null`): set front center channel x spread. (default: 0.5)
+- `flx` (of type `float?`, which defaults to `null`): set front left channel x spread. (default: 0.5)
+- `frx` (of type `float?`, which defaults to `null`): set front right channel x spread. (default: 0.5)
+- `blx` (of type `float?`, which defaults to `null`): set back left channel x spread. (default: 0.5)
+- `brx` (of type `float?`, which defaults to `null`): set back right channel x spread. (default: 0.5)
+- `slx` (of type `float?`, which defaults to `null`): set side left channel x spread. (default: 0.5)
+- `srx` (of type `float?`, which defaults to `null`): set side right channel x spread. (default: 0.5)
+- `bcx` (of type `float?`, which defaults to `null`): set back center channel x spread. (default: 0.5)
+- `fcy` (of type `float?`, which defaults to `null`): set front center channel y spread. (default: 0.5)
+- `fly` (of type `float?`, which defaults to `null`): set front left channel y spread. (default: 0.5)
+- `fry` (of type `float?`, which defaults to `null`): set front right channel y spread. (default: 0.5)
+- `bly` (of type `float?`, which defaults to `null`): set back left channel y spread. (default: 0.5)
+- `bry` (of type `float?`, which defaults to `null`): set back right channel y spread. (default: 0.5)
+- `sly` (of type `float?`, which defaults to `null`): set side left channel y spread. (default: 0.5)
+- `sry` (of type `float?`, which defaults to `null`): set side right channel y spread. (default: 0.5)
+- `bcy` (of type `float?`, which defaults to `null`): set back center channel y spread. (default: 0.5)
+- `win_size` (of type `int?`, which defaults to `null`): set window size. (default: 4096)
+- `win_func` (of type `int?`, which defaults to `null`): set window function. (default: 1, possible values: 0 (rect), 4 (bartlett), 1 (hann), 1 (hanning), 2 (hamming), 3 (blackman), 5 (welch), 6 (flattop), 7 (bharris), 8 (bnuttall), 11 (bhann), 9 (sine), 10 (nuttall), 12 (lanczos), 13 (gauss), 14 (tukey), 15 (dolph), 16 (cauchy), 17 (parzen), 18 (poisson), 19 (bohman), 20 (kaiser))
+- `overlap` (of type `float?`, which defaults to `null`): set window overlap. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.swaprect`
+
+Ffmpeg filter: Swap 2 rectangular objects in video.
+
+Type:
+
+```
+(?w : string?, ?h : string?, ?x1 : string?, ?y1 : string?, ?x2 : string?,
+ ?y2 : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): set rect width. (default: w/2)
+- `h` (of type `string?`, which defaults to `null`): set rect height. (default: h/2)
+- `x1` (of type `string?`, which defaults to `null`): set 1st rect x top left coordinate. (default: w/2)
+- `y1` (of type `string?`, which defaults to `null`): set 1st rect y top left coordinate. (default: h/2)
+- `x2` (of type `string?`, which defaults to `null`): set 2nd rect x top left coordinate. (default: 0)
+- `y2` (of type `string?`, which defaults to `null`): set 2nd rect y top left coordinate. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.swaprect.create`
+
+Ffmpeg filter: Swap 2 rectangular objects in video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?w : string?, ?h : string?, ?x1 : string?, ?y1 : string?, ?x2 : string?,
+ ?y2 : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): set rect width. (default: w/2)
+- `h` (of type `string?`, which defaults to `null`): set rect height. (default: h/2)
+- `x1` (of type `string?`, which defaults to `null`): set 1st rect x top left coordinate. (default: w/2)
+- `y1` (of type `string?`, which defaults to `null`): set 1st rect y top left coordinate. (default: h/2)
+- `x2` (of type `string?`, which defaults to `null`): set 2nd rect x top left coordinate. (default: 0)
+- `y2` (of type `string?`, which defaults to `null`): set 2nd rect y top left coordinate. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.swapuv`
+
+Ffmpeg filter: Swap U and V components.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.swapuv.create`
+
+Ffmpeg filter: Swap U and V components.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tblend`
+
+Ffmpeg filter: Blend successive frames.
+
+Type:
+
+```
+(?c0_mode : int?, ?c1_mode : int?, ?c2_mode : int?, ?c3_mode : int?,
+ ?all_mode : int?, ?c0_expr : string?, ?c1_expr : string?,
+ ?c2_expr : string?, ?c3_expr : string?, ?all_expr : string?,
+ ?c0_opacity : float?, ?c1_opacity : float?, ?c2_opacity : float?,
+ ?c3_opacity : float?, ?all_opacity : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0_mode` (of type `int?`, which defaults to `null`): set component #0 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c1_mode` (of type `int?`, which defaults to `null`): set component #1 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c2_mode` (of type `int?`, which defaults to `null`): set component #2 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c3_mode` (of type `int?`, which defaults to `null`): set component #3 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `all_mode` (of type `int?`, which defaults to `null`): set blend mode for all components. (default: -1, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c0_expr` (of type `string?`, which defaults to `null`): set color component #0 expression
+- `c1_expr` (of type `string?`, which defaults to `null`): set color component #1 expression
+- `c2_expr` (of type `string?`, which defaults to `null`): set color component #2 expression
+- `c3_expr` (of type `string?`, which defaults to `null`): set color component #3 expression
+- `all_expr` (of type `string?`, which defaults to `null`): set expression for all color components
+- `c0_opacity` (of type `float?`, which defaults to `null`): set color component #0 opacity. (default: 1.)
+- `c1_opacity` (of type `float?`, which defaults to `null`): set color component #1 opacity. (default: 1.)
+- `c2_opacity` (of type `float?`, which defaults to `null`): set color component #2 opacity. (default: 1.)
+- `c3_opacity` (of type `float?`, which defaults to `null`): set color component #3 opacity. (default: 1.)
+- `all_opacity` (of type `float?`, which defaults to `null`): set opacity for all color components. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tblend.create`
+
+Ffmpeg filter: Blend successive frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0_mode : int?, ?c1_mode : int?, ?c2_mode : int?, ?c3_mode : int?,
+ ?all_mode : int?, ?c0_expr : string?, ?c1_expr : string?,
+ ?c2_expr : string?, ?c3_expr : string?, ?all_expr : string?,
+ ?c0_opacity : float?, ?c1_opacity : float?, ?c2_opacity : float?,
+ ?c3_opacity : float?, ?all_opacity : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0_mode` (of type `int?`, which defaults to `null`): set component #0 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c1_mode` (of type `int?`, which defaults to `null`): set component #1 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c2_mode` (of type `int?`, which defaults to `null`): set component #2 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c3_mode` (of type `int?`, which defaults to `null`): set component #3 blend mode. (default: 0, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `all_mode` (of type `int?`, which defaults to `null`): set blend mode for all components. (default: -1, possible values: 1 (addition), 28 (addition128), 28 (grainmerge), 2 (and), 3 (average), 4 (burn), 5 (darken), 6 (difference), 7 (difference128), 7 (grainextract), 8 (divide), 9 (dodge), 10 (exclusion), 32 (extremity), 31 (freeze), 27 (glow), 11 (hardlight), 25 (hardmix), 30 (heat), 12 (lighten), 26 (linearlight), 13 (multiply), 29 (multiply128), 14 (negation), 0 (normal), 15 (or), 16 (overlay), 17 (phoenix), 18 (pinlight), 19 (reflect), 20 (screen), 21 (softlight), 22 (subtract), 23 (vividlight), 24 (xor), 33 (softdifference), 34 (geometric), 35 (harmonic), 36 (bleach), 37 (stain), 38 (interpolate), 39 (hardoverlay))
+- `c0_expr` (of type `string?`, which defaults to `null`): set color component #0 expression
+- `c1_expr` (of type `string?`, which defaults to `null`): set color component #1 expression
+- `c2_expr` (of type `string?`, which defaults to `null`): set color component #2 expression
+- `c3_expr` (of type `string?`, which defaults to `null`): set color component #3 expression
+- `all_expr` (of type `string?`, which defaults to `null`): set expression for all color components
+- `c0_opacity` (of type `float?`, which defaults to `null`): set color component #0 opacity. (default: 1.)
+- `c1_opacity` (of type `float?`, which defaults to `null`): set color component #1 opacity. (default: 1.)
+- `c2_opacity` (of type `float?`, which defaults to `null`): set color component #2 opacity. (default: 1.)
+- `c3_opacity` (of type `float?`, which defaults to `null`): set color component #3 opacity. (default: 1.)
+- `all_opacity` (of type `float?`, which defaults to `null`): set opacity for all color components. (default: 1.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.telecine`
+
+Ffmpeg filter: Apply a telecine pattern.
+
+Type:
+
+```
+(?first_field : int?, ?pattern : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): select first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `pattern` (of type `string?`, which defaults to `null`): pattern that describe for how many fields a frame is to be displayed. (default: 23)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.telecine.create`
+
+Ffmpeg filter: Apply a telecine pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?first_field : int?, ?pattern : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): select first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `pattern` (of type `string?`, which defaults to `null`): pattern that describe for how many fields a frame is to be displayed. (default: 23)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.testsrc`
+
+Ffmpeg filter: Generate test pattern.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?decimals : int?, ?n : int?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `decimals` (of type `int?`, which defaults to `null`): set number of decimals to show. (default: 0)
+- `n` (of type `int?`, which defaults to `null`): set number of decimals to show. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.testsrc.create`
+
+Ffmpeg filter: Generate test pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?decimals : int?, ?n : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `decimals` (of type `int?`, which defaults to `null`): set number of decimals to show. (default: 0)
+- `n` (of type `int?`, which defaults to `null`): set number of decimals to show. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.testsrc2`
+
+Ffmpeg filter: Generate another test pattern.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?alpha : int?,
+ ffmpeg.filter.graph) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `alpha` (of type `int?`, which defaults to `null`): set global alpha (opacity). (default: 255)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.testsrc2.create`
+
+Ffmpeg filter: Generate another test pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?alpha : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `alpha` (of type `int?`, which defaults to `null`): set global alpha (opacity). (default: 255)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.thistogram`
+
+Ffmpeg filter: Compute and draw a temporal histogram.
+
+Type:
+
+```
+(?width : int?, ?w : int?, ?display_mode : int?, ?d : int?,
+ ?levels_mode : int?, ?m : int?, ?components : int?, ?c : int?,
+ ?bgopacity : float?, ?b : float?, ?envelope : bool?, ?e : bool?,
+ ?ecolor : string?, ?ec : string?, ?slide : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `width` (of type `int?`, which defaults to `null`): set width. (default: 0)
+- `w` (of type `int?`, which defaults to `null`): set width. (default: 0)
+- `display_mode` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `d` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `levels_mode` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `m` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `components` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `c` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.9)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.9)
+- `envelope` (of type `bool?`, which defaults to `null`): display envelope. (default: false)
+- `e` (of type `bool?`, which defaults to `null`): display envelope. (default: false)
+- `ecolor` (of type `string?`, which defaults to `null`): set envelope color. (default: gold)
+- `ec` (of type `string?`, which defaults to `null`): set envelope color. (default: gold)
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 1, possible values: 0 (frame), 1 (replace), 2 (scroll), 3 (rscroll), 4 (picture))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.thistogram.create`
+
+Ffmpeg filter: Compute and draw a temporal histogram.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?width : int?, ?w : int?, ?display_mode : int?, ?d : int?,
+ ?levels_mode : int?, ?m : int?, ?components : int?, ?c : int?,
+ ?bgopacity : float?, ?b : float?, ?envelope : bool?, ?e : bool?,
+ ?ecolor : string?, ?ec : string?, ?slide : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `width` (of type `int?`, which defaults to `null`): set width. (default: 0)
+- `w` (of type `int?`, which defaults to `null`): set width. (default: 0)
+- `display_mode` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `d` (of type `int?`, which defaults to `null`): set display mode. (default: 2, possible values: 0 (overlay), 1 (parade), 2 (stack))
+- `levels_mode` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `m` (of type `int?`, which defaults to `null`): set levels mode. (default: 0, possible values: 0 (linear), 1 (logarithmic))
+- `components` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `c` (of type `int?`, which defaults to `null`): set color components to display. (default: 7)
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.9)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.9)
+- `envelope` (of type `bool?`, which defaults to `null`): display envelope. (default: false)
+- `e` (of type `bool?`, which defaults to `null`): display envelope. (default: false)
+- `ecolor` (of type `string?`, which defaults to `null`): set envelope color. (default: gold)
+- `ec` (of type `string?`, which defaults to `null`): set envelope color. (default: gold)
+- `slide` (of type `int?`, which defaults to `null`): set slide mode. (default: 1, possible values: 0 (frame), 1 (replace), 2 (scroll), 3 (rscroll), 4 (picture))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.threshold`
+
+Ffmpeg filter: Threshold first video stream using other video streams.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.threshold.create`
+
+Ffmpeg filter: Threshold first video stream using other video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.thumbnail`
+
+Ffmpeg filter: Select the most representative frame in a given sequence of consecutive frames.
+
+Type:
+
+```
+(?n : int?, ?log : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set the frames batch size. (default: 100)
+- `log` (of type `int?`, which defaults to `null`): force stats logging level. (default: 32, possible values: -8 (quiet), 32 (info), 40 (verbose))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.thumbnail.create`
+
+Ffmpeg filter: Select the most representative frame in a given sequence of consecutive frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : int?, ?log : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set the frames batch size. (default: 100)
+- `log` (of type `int?`, which defaults to `null`): force stats logging level. (default: 32, possible values: -8 (quiet), 32 (info), 40 (verbose))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.thumbnail_cuda`
+
+Ffmpeg filter: Select the most representative frame in a given sequence of consecutive frames.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set the frames batch size. (default: 100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.thumbnail_cuda.create`
+
+Ffmpeg filter: Select the most representative frame in a given sequence of consecutive frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set the frames batch size. (default: 100)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tile`
+
+Ffmpeg filter: Tile several successive frames together.
+
+Type:
+
+```
+(?layout : string?, ?nb_frames : int?, ?margin : int?, ?padding : int?,
+ ?color : string?, ?overlap : int?, ?init_padding : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `layout` (of type `string?`, which defaults to `null`): set grid size. (default: 6x5)
+- `nb_frames` (of type `int?`, which defaults to `null`): set maximum number of frame to render. (default: 0)
+- `margin` (of type `int?`, which defaults to `null`): set outer border margin in pixels. (default: 0)
+- `padding` (of type `int?`, which defaults to `null`): set inner border thickness in pixels. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the unused area. (default: black)
+- `overlap` (of type `int?`, which defaults to `null`): set how many frames to overlap for each render. (default: 0)
+- `init_padding` (of type `int?`, which defaults to `null`): set how many frames to initially pad. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tile.create`
+
+Ffmpeg filter: Tile several successive frames together.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?layout : string?, ?nb_frames : int?, ?margin : int?, ?padding : int?,
+ ?color : string?, ?overlap : int?, ?init_padding : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `layout` (of type `string?`, which defaults to `null`): set grid size. (default: 6x5)
+- `nb_frames` (of type `int?`, which defaults to `null`): set maximum number of frame to render. (default: 0)
+- `margin` (of type `int?`, which defaults to `null`): set outer border margin in pixels. (default: 0)
+- `padding` (of type `int?`, which defaults to `null`): set inner border thickness in pixels. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the unused area. (default: black)
+- `overlap` (of type `int?`, which defaults to `null`): set how many frames to overlap for each render. (default: 0)
+- `init_padding` (of type `int?`, which defaults to `null`): set how many frames to initially pad. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tiltshelf`
+
+Ffmpeg filter: Apply a tilt shelf filter.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.tiltshelf.create`
+
+Ffmpeg filter: Apply a tilt shelf filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tinterlace`
+
+Ffmpeg filter: Perform temporal field interlacing.
+
+Type:
+
+```
+(?mode : int?, ?flags : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select interlace mode. (default: 0, possible values: 0 (merge), 1 (drop_even), 2 (drop_odd), 3 (pad), 4 (interleave_top), 5 (interleave_bottom), 6 (interlacex2), 7 (mergex2))
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 0, possible values: 1 (low_pass_filter), 1 (vlpf), 2 (complex_filter), 2 (cvlpf), 4 (exact_tb), 8 (bypass_il))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tinterlace.create`
+
+Ffmpeg filter: Perform temporal field interlacing.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?flags : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): select interlace mode. (default: 0, possible values: 0 (merge), 1 (drop_even), 2 (drop_odd), 3 (pad), 4 (interleave_top), 5 (interleave_bottom), 6 (interlacex2), 7 (mergex2))
+- `flags` (of type `int?`, which defaults to `null`): set flags. (default: 0, possible values: 1 (low_pass_filter), 1 (vlpf), 2 (complex_filter), 2 (cvlpf), 4 (exact_tb), 8 (bypass_il))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tlut2`
+
+Ffmpeg filter: Compute and apply a lookup table from two successive frames.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: x)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: x)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: x)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: x)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tlut2.create`
+
+Ffmpeg filter: Compute and apply a lookup table from two successive frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?c0 : string?, ?c1 : string?, ?c2 : string?, ?c3 : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `c0` (of type `string?`, which defaults to `null`): set component #0 expression. (default: x)
+- `c1` (of type `string?`, which defaults to `null`): set component #1 expression. (default: x)
+- `c2` (of type `string?`, which defaults to `null`): set component #2 expression. (default: x)
+- `c3` (of type `string?`, which defaults to `null`): set component #3 expression. (default: x)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tmedian`
+
+Ffmpeg filter: Pick median pixels from successive frames.
+
+Type:
+
+```
+(?radius : int?, ?planes : int?, ?percentile : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set median filter radius. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `percentile` (of type `float?`, which defaults to `null`): set percentile. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tmedian.create`
+
+Ffmpeg filter: Pick median pixels from successive frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?radius : int?, ?planes : int?, ?percentile : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set median filter radius. (default: 1)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `percentile` (of type `float?`, which defaults to `null`): set percentile. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tmidequalizer`
+
+Ffmpeg filter: Apply Temporal Midway Equalization.
+
+Type:
+
+```
+(?radius : int?, ?sigma : float?, ?planes : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set radius. (default: 5)
+- `sigma` (of type `float?`, which defaults to `null`): set sigma. (default: 0.5)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tmidequalizer.create`
+
+Ffmpeg filter: Apply Temporal Midway Equalization.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?radius : int?, ?sigma : float?, ?planes : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set radius. (default: 5)
+- `sigma` (of type `float?`, which defaults to `null`): set sigma. (default: 0.5)
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tmix`
+
+Ffmpeg filter: Mix successive video frames.
+
+Type:
+
+```
+(?frames : int?, ?weights : string?, ?scale : float?, ?planes : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `frames` (of type `int?`, which defaults to `null`): set number of successive frames to mix. (default: 3)
+- `weights` (of type `string?`, which defaults to `null`): set weight for each frame. (default: 1 1 1)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 0.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tmix.create`
+
+Ffmpeg filter: Mix successive video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frames : int?, ?weights : string?, ?scale : float?, ?planes : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frames` (of type `int?`, which defaults to `null`): set number of successive frames to mix. (default: 3)
+- `weights` (of type `string?`, which defaults to `null`): set weight for each frame. (default: 1 1 1)
+- `scale` (of type `float?`, which defaults to `null`): set scale. (default: 0.)
+- `planes` (of type `int?`, which defaults to `null`): set what planes to filter. (default: 15)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tonemap`
+
+Ffmpeg filter: Conversion to/from different dynamic ranges.
+
+Type:
+
+```
+(?tonemap : int?, ?param : float?, ?desat : float?, ?peak : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `tonemap` (of type `int?`, which defaults to `null`): tonemap algorithm selection. (default: 0, possible values: 0 (none), 1 (linear), 2 (gamma), 3 (clip), 4 (reinhard), 5 (hable), 6 (mobius))
+- `param` (of type `float?`, which defaults to `null`): tonemap parameter. (default: nan)
+- `desat` (of type `float?`, which defaults to `null`): desaturation strength. (default: 2.)
+- `peak` (of type `float?`, which defaults to `null`): signal peak override. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tonemap.create`
+
+Ffmpeg filter: Conversion to/from different dynamic ranges.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?tonemap : int?, ?param : float?, ?desat : float?, ?peak : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `tonemap` (of type `int?`, which defaults to `null`): tonemap algorithm selection. (default: 0, possible values: 0 (none), 1 (linear), 2 (gamma), 3 (clip), 4 (reinhard), 5 (hable), 6 (mobius))
+- `param` (of type `float?`, which defaults to `null`): tonemap parameter. (default: nan)
+- `desat` (of type `float?`, which defaults to `null`): desaturation strength. (default: 2.)
+- `peak` (of type `float?`, which defaults to `null`): signal peak override. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tonemap_opencl`
+
+Ffmpeg filter: Perform HDR to SDR conversion with tonemapping.
+
+Type:
+
+```
+(?tonemap : int?, ?transfer : int?, ?t : int?, ?matrix : int?, ?m : int?,
+ ?primaries : int?, ?p : int?, ?range : int?, ?r : int?, ?format : string?,
+ ?peak : float?, ?param : float?, ?desat : float?, ?threshold : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `tonemap` (of type `int?`, which defaults to `null`): tonemap algorithm selection. (default: 0, possible values: 0 (none), 1 (linear), 2 (gamma), 3 (clip), 4 (reinhard), 5 (hable), 6 (mobius))
+- `transfer` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: 1, possible values: 1 (bt709), 14 (bt2020))
+- `t` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: 1, possible values: 1 (bt709), 14 (bt2020))
+- `matrix` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `m` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `primaries` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `p` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `range` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: 1 (tv), 2 (pc), 1 (limited), 2 (full))
+- `r` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: 1 (tv), 2 (pc), 1 (limited), 2 (full))
+- `format` (of type `string?`, which defaults to `null`): output pixel format
+- `peak` (of type `float?`, which defaults to `null`): signal peak override. (default: 0.)
+- `param` (of type `float?`, which defaults to `null`): tonemap parameter. (default: nan)
+- `desat` (of type `float?`, which defaults to `null`): desaturation parameter. (default: 0.5)
+- `threshold` (of type `float?`, which defaults to `null`): scene detection threshold. (default: 0.2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tonemap_opencl.create`
+
+Ffmpeg filter: Perform HDR to SDR conversion with tonemapping.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?tonemap : int?, ?transfer : int?, ?t : int?, ?matrix : int?, ?m : int?,
+ ?primaries : int?, ?p : int?, ?range : int?, ?r : int?, ?format : string?,
+ ?peak : float?, ?param : float?, ?desat : float?, ?threshold : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `tonemap` (of type `int?`, which defaults to `null`): tonemap algorithm selection. (default: 0, possible values: 0 (none), 1 (linear), 2 (gamma), 3 (clip), 4 (reinhard), 5 (hable), 6 (mobius))
+- `transfer` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: 1, possible values: 1 (bt709), 14 (bt2020))
+- `t` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: 1, possible values: 1 (bt709), 14 (bt2020))
+- `matrix` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `m` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `primaries` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `p` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: 1 (bt709), 9 (bt2020))
+- `range` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: 1 (tv), 2 (pc), 1 (limited), 2 (full))
+- `r` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: 1 (tv), 2 (pc), 1 (limited), 2 (full))
+- `format` (of type `string?`, which defaults to `null`): output pixel format
+- `peak` (of type `float?`, which defaults to `null`): signal peak override. (default: 0.)
+- `param` (of type `float?`, which defaults to `null`): tonemap parameter. (default: nan)
+- `desat` (of type `float?`, which defaults to `null`): desaturation parameter. (default: 0.5)
+- `threshold` (of type `float?`, which defaults to `null`): scene detection threshold. (default: 0.2)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tonemap_vaapi`
+
+Ffmpeg filter: VAAPI VPP for tone-mapping
+
+Type:
+
+```
+(?format : string?, ?matrix : string?, ?m : string?, ?primaries : string?,
+ ?p : string?, ?transfer : string?, ?t : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `format` (of type `string?`, which defaults to `null`): Output pixel format set
+- `matrix` (of type `string?`, which defaults to `null`): Output color matrix coefficient set
+- `m` (of type `string?`, which defaults to `null`): Output color matrix coefficient set
+- `primaries` (of type `string?`, which defaults to `null`): Output color primaries set
+- `p` (of type `string?`, which defaults to `null`): Output color primaries set
+- `transfer` (of type `string?`, which defaults to `null`): Output color transfer characteristics set
+- `t` (of type `string?`, which defaults to `null`): Output color transfer characteristics set
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tonemap_vaapi.create`
+
+Ffmpeg filter: VAAPI VPP for tone-mapping. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?format : string?, ?matrix : string?, ?m : string?, ?primaries : string?,
+ ?p : string?, ?transfer : string?, ?t : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `format` (of type `string?`, which defaults to `null`): Output pixel format set
+- `matrix` (of type `string?`, which defaults to `null`): Output color matrix coefficient set
+- `m` (of type `string?`, which defaults to `null`): Output color matrix coefficient set
+- `primaries` (of type `string?`, which defaults to `null`): Output color primaries set
+- `p` (of type `string?`, which defaults to `null`): Output color primaries set
+- `transfer` (of type `string?`, which defaults to `null`): Output color transfer characteristics set
+- `t` (of type `string?`, which defaults to `null`): Output color transfer characteristics set
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tpad`
+
+Ffmpeg filter: Temporarily pad video frames.
+
+Type:
+
+```
+(?start : int?, ?stop : int?, ?start_mode : int?, ?stop_mode : int?,
+ ?start_duration : int?, ?stop_duration : int?, ?color : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `start` (of type `int?`, which defaults to `null`): set the number of frames to delay input. (default: 0)
+- `stop` (of type `int?`, which defaults to `null`): set the number of frames to add after input finished. (default: 0)
+- `start_mode` (of type `int?`, which defaults to `null`): set the mode of added frames to start. (default: 0, possible values: 0 (add), 1 (clone))
+- `stop_mode` (of type `int?`, which defaults to `null`): set the mode of added frames to end. (default: 0, possible values: 0 (add), 1 (clone))
+- `start_duration` (of type `int?`, which defaults to `null`): set the duration to delay input. (default: 0)
+- `stop_duration` (of type `int?`, which defaults to `null`): set the duration to pad input. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the added frames. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.tpad.create`
+
+Ffmpeg filter: Temporarily pad video frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?start : int?, ?stop : int?, ?start_mode : int?, ?stop_mode : int?,
+ ?start_duration : int?, ?stop_duration : int?, ?color : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `start` (of type `int?`, which defaults to `null`): set the number of frames to delay input. (default: 0)
+- `stop` (of type `int?`, which defaults to `null`): set the number of frames to add after input finished. (default: 0)
+- `start_mode` (of type `int?`, which defaults to `null`): set the mode of added frames to start. (default: 0, possible values: 0 (add), 1 (clone))
+- `stop_mode` (of type `int?`, which defaults to `null`): set the mode of added frames to end. (default: 0, possible values: 0 (add), 1 (clone))
+- `start_duration` (of type `int?`, which defaults to `null`): set the duration to delay input. (default: 0)
+- `stop_duration` (of type `int?`, which defaults to `null`): set the duration to pad input. (default: 0)
+- `color` (of type `string?`, which defaults to `null`): set the color of the added frames. (default: black)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.transpose`
+
+Ffmpeg filter: Transpose input video.
+
+Type:
+
+```
+(?dir : int?, ?passthrough : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dir` (of type `int?`, which defaults to `null`): set transpose direction. (default: 0, possible values: 0 (cclock_flip), 1 (clock), 2 (cclock), 3 (clock_flip))
+- `passthrough` (of type `int?`, which defaults to `null`): do not apply transposition if the input matches the specified geometry. (default: 0, possible values: 0 (none), 2 (portrait), 1 (landscape))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.transpose.create`
+
+Ffmpeg filter: Transpose input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dir : int?, ?passthrough : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dir` (of type `int?`, which defaults to `null`): set transpose direction. (default: 0, possible values: 0 (cclock_flip), 1 (clock), 2 (cclock), 3 (clock_flip))
+- `passthrough` (of type `int?`, which defaults to `null`): do not apply transposition if the input matches the specified geometry. (default: 0, possible values: 0 (none), 2 (portrait), 1 (landscape))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.transpose_opencl`
+
+Ffmpeg filter: Transpose input video
+
+Type:
+
+```
+(?dir : int?, ?passthrough : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dir` (of type `int?`, which defaults to `null`): set transpose direction. (default: 0, possible values: 0 (cclock_flip), 1 (clock), 2 (cclock), 3 (clock_flip))
+- `passthrough` (of type `int?`, which defaults to `null`): do not apply transposition if the input matches the specified geometry. (default: 0, possible values: 0 (none), 2 (portrait), 1 (landscape))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.transpose_opencl.create`
+
+Ffmpeg filter: Transpose input video. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dir : int?, ?passthrough : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dir` (of type `int?`, which defaults to `null`): set transpose direction. (default: 0, possible values: 0 (cclock_flip), 1 (clock), 2 (cclock), 3 (clock_flip))
+- `passthrough` (of type `int?`, which defaults to `null`): do not apply transposition if the input matches the specified geometry. (default: 0, possible values: 0 (none), 2 (portrait), 1 (landscape))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.transpose_vaapi`
+
+Ffmpeg filter: VAAPI VPP for transpose
+
+Type:
+
+```
+(?dir : int?, ?passthrough : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `dir` (of type `int?`, which defaults to `null`): set transpose direction. (default: 0, possible values: 0 (cclock_flip), 1 (clock), 2 (cclock), 3 (clock_flip), 4 (reversal), 5 (hflip), 6 (vflip))
+- `passthrough` (of type `int?`, which defaults to `null`): do not apply transposition if the input matches the specified geometry. (default: 0, possible values: 0 (none), 2 (portrait), 1 (landscape))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.transpose_vaapi.create`
+
+Ffmpeg filter: VAAPI VPP for transpose. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?dir : int?, ?passthrough : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `dir` (of type `int?`, which defaults to `null`): set transpose direction. (default: 0, possible values: 0 (cclock_flip), 1 (clock), 2 (cclock), 3 (clock_flip), 4 (reversal), 5 (hflip), 6 (vflip))
+- `passthrough` (of type `int?`, which defaults to `null`): do not apply transposition if the input matches the specified geometry. (default: 0, possible values: 0 (none), 2 (portrait), 1 (landscape))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.treble`
+
+Ffmpeg filter: Boost or cut upper frequencies.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.treble.create`
+
+Ffmpeg filter: Boost or cut upper frequencies.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?frequency : float?, ?f : float?, ?width_type : int?, ?t : int?,
+ ?width : float?, ?w : float?, ?gain : float?, ?g : float?, ?poles : int?,
+ ?p : int?, ?mix : float?, ?m : float?, ?channels : string?, ?c : string?,
+ ?normalize : bool?, ?n : bool?, ?transform : int?, ?a : int?,
+ ?precision : int?, ?r : int?, ?blocksize : int?, ?b : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `frequency` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `f` (of type `float?`, which defaults to `null`): set central frequency. (default: 3000.)
+- `width_type` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `t` (of type `int?`, which defaults to `null`): set filter-width type. (default: 3, possible values: 1 (h), 3 (q), 2 (o), 4 (s), 5 (k))
+- `width` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `w` (of type `float?`, which defaults to `null`): set width. (default: 0.5)
+- `gain` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `g` (of type `float?`, which defaults to `null`): set gain. (default: 0.)
+- `poles` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `p` (of type `int?`, which defaults to `null`): set number of poles. (default: 2)
+- `mix` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `m` (of type `float?`, which defaults to `null`): set mix. (default: 1.)
+- `channels` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `c` (of type `string?`, which defaults to `null`): set channels to filter. (default: all)
+- `normalize` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `n` (of type `bool?`, which defaults to `null`): normalize coefficients. (default: false)
+- `transform` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `a` (of type `int?`, which defaults to `null`): set transform type. (default: 0, possible values: 0 (di), 1 (dii), 2 (tdi), 3 (tdii), 4 (latt), 5 (svf), 6 (zdf))
+- `precision` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `r` (of type `int?`, which defaults to `null`): set filtering precision. (default: -1, possible values: -1 (auto), 0 (s16), 1 (s32), 2 (f32), 3 (f64))
+- `blocksize` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `b` (of type `int?`, which defaults to `null`): set the block size. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.tremolo`
+
+Ffmpeg filter: Apply tremolo effect.
+
+Type:
+
+```
+(?f : float?, ?d : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `f` (of type `float?`, which defaults to `null`): set frequency in hertz. (default: 5.)
+- `d` (of type `float?`, which defaults to `null`): set depth as percentage. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.tremolo.create`
+
+Ffmpeg filter: Apply tremolo effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?f : float?, ?d : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `f` (of type `float?`, which defaults to `null`): set frequency in hertz. (default: 5.)
+- `d` (of type `float?`, which defaults to `null`): set depth as percentage. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.trim`
+
+Ffmpeg filter: Pick one continuous section from the input, drop the rest.
+
+Type:
+
+```
+(?start : int?, ?starti : int?, ?end : int?, ?endi : int?, ?start_pts : int?,
+ ?end_pts : int?, ?duration : int?, ?durationi : int?, ?start_frame : int?,
+ ?end_frame : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `start` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `starti` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `end` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `endi` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `start_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be  passed. (default: -9223372036854775808)
+- `end_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: -9223372036854775808)
+- `duration` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `durationi` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `start_frame` (of type `int?`, which defaults to `null`): Number of the first frame that should be passed to the output. (default: -1)
+- `end_frame` (of type `int?`, which defaults to `null`): Number of the first frame that should be dropped again. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.trim.create`
+
+Ffmpeg filter: Pick one continuous section from the input, drop the rest.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?start : int?, ?starti : int?, ?end : int?, ?endi : int?, ?start_pts : int?,
+ ?end_pts : int?, ?duration : int?, ?durationi : int?, ?start_frame : int?,
+ ?end_frame : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `start` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `starti` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be passed. (default: 9223372036854775807)
+- `end` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `endi` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: 9223372036854775807)
+- `start_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be  passed. (default: -9223372036854775808)
+- `end_pts` (of type `int?`, which defaults to `null`): Timestamp of the first frame that should be dropped again. (default: -9223372036854775808)
+- `duration` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `durationi` (of type `int?`, which defaults to `null`): Maximum duration of the output. (default: 0)
+- `start_frame` (of type `int?`, which defaults to `null`): Number of the first frame that should be passed to the output. (default: -1)
+- `end_frame` (of type `int?`, which defaults to `null`): Number of the first frame that should be dropped again. (default: 9223372036854775807)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.unpremultiply`
+
+Ffmpeg filter: UnPreMultiply first stream with first plane of second stream. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?planes : int?, ?inplace : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `inplace` (of type `bool?`, which defaults to `null`): enable inplace mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.unpremultiply.create`
+
+Ffmpeg filter: UnPreMultiply first stream with first plane of second stream. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?inplace : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes. (default: 15)
+- `inplace` (of type `bool?`, which defaults to `null`): enable inplace mode. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.unsharp`
+
+Ffmpeg filter: Sharpen or blur the input video.
+
+Type:
+
+```
+(?luma_msize_x : int?, ?lx : int?, ?luma_msize_y : int?, ?ly : int?,
+ ?luma_amount : float?, ?la : float?, ?chroma_msize_x : int?, ?cx : int?,
+ ?chroma_msize_y : int?, ?cy : int?, ?chroma_amount : float?, ?ca : float?,
+ ?alpha_msize_x : int?, ?ax : int?, ?alpha_msize_y : int?, ?ay : int?,
+ ?alpha_amount : float?, ?aa : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_msize_x` (of type `int?`, which defaults to `null`): set luma matrix horizontal size. (default: 5)
+- `lx` (of type `int?`, which defaults to `null`): set luma matrix horizontal size. (default: 5)
+- `luma_msize_y` (of type `int?`, which defaults to `null`): set luma matrix vertical size. (default: 5)
+- `ly` (of type `int?`, which defaults to `null`): set luma matrix vertical size. (default: 5)
+- `luma_amount` (of type `float?`, which defaults to `null`): set luma effect strength. (default: 1.)
+- `la` (of type `float?`, which defaults to `null`): set luma effect strength. (default: 1.)
+- `chroma_msize_x` (of type `int?`, which defaults to `null`): set chroma matrix horizontal size. (default: 5)
+- `cx` (of type `int?`, which defaults to `null`): set chroma matrix horizontal size. (default: 5)
+- `chroma_msize_y` (of type `int?`, which defaults to `null`): set chroma matrix vertical size. (default: 5)
+- `cy` (of type `int?`, which defaults to `null`): set chroma matrix vertical size. (default: 5)
+- `chroma_amount` (of type `float?`, which defaults to `null`): set chroma effect strength. (default: 0.)
+- `ca` (of type `float?`, which defaults to `null`): set chroma effect strength. (default: 0.)
+- `alpha_msize_x` (of type `int?`, which defaults to `null`): set alpha matrix horizontal size. (default: 5)
+- `ax` (of type `int?`, which defaults to `null`): set alpha matrix horizontal size. (default: 5)
+- `alpha_msize_y` (of type `int?`, which defaults to `null`): set alpha matrix vertical size. (default: 5)
+- `ay` (of type `int?`, which defaults to `null`): set alpha matrix vertical size. (default: 5)
+- `alpha_amount` (of type `float?`, which defaults to `null`): set alpha effect strength. (default: 0.)
+- `aa` (of type `float?`, which defaults to `null`): set alpha effect strength. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.unsharp.create`
+
+Ffmpeg filter: Sharpen or blur the input video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_msize_x : int?, ?lx : int?, ?luma_msize_y : int?, ?ly : int?,
+ ?luma_amount : float?, ?la : float?, ?chroma_msize_x : int?, ?cx : int?,
+ ?chroma_msize_y : int?, ?cy : int?, ?chroma_amount : float?, ?ca : float?,
+ ?alpha_msize_x : int?, ?ax : int?, ?alpha_msize_y : int?, ?ay : int?,
+ ?alpha_amount : float?, ?aa : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_msize_x` (of type `int?`, which defaults to `null`): set luma matrix horizontal size. (default: 5)
+- `lx` (of type `int?`, which defaults to `null`): set luma matrix horizontal size. (default: 5)
+- `luma_msize_y` (of type `int?`, which defaults to `null`): set luma matrix vertical size. (default: 5)
+- `ly` (of type `int?`, which defaults to `null`): set luma matrix vertical size. (default: 5)
+- `luma_amount` (of type `float?`, which defaults to `null`): set luma effect strength. (default: 1.)
+- `la` (of type `float?`, which defaults to `null`): set luma effect strength. (default: 1.)
+- `chroma_msize_x` (of type `int?`, which defaults to `null`): set chroma matrix horizontal size. (default: 5)
+- `cx` (of type `int?`, which defaults to `null`): set chroma matrix horizontal size. (default: 5)
+- `chroma_msize_y` (of type `int?`, which defaults to `null`): set chroma matrix vertical size. (default: 5)
+- `cy` (of type `int?`, which defaults to `null`): set chroma matrix vertical size. (default: 5)
+- `chroma_amount` (of type `float?`, which defaults to `null`): set chroma effect strength. (default: 0.)
+- `ca` (of type `float?`, which defaults to `null`): set chroma effect strength. (default: 0.)
+- `alpha_msize_x` (of type `int?`, which defaults to `null`): set alpha matrix horizontal size. (default: 5)
+- `ax` (of type `int?`, which defaults to `null`): set alpha matrix horizontal size. (default: 5)
+- `alpha_msize_y` (of type `int?`, which defaults to `null`): set alpha matrix vertical size. (default: 5)
+- `ay` (of type `int?`, which defaults to `null`): set alpha matrix vertical size. (default: 5)
+- `alpha_amount` (of type `float?`, which defaults to `null`): set alpha effect strength. (default: 0.)
+- `aa` (of type `float?`, which defaults to `null`): set alpha effect strength. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.unsharp_opencl`
+
+Ffmpeg filter: Apply unsharp mask to input video
+
+Type:
+
+```
+(?luma_msize_x : float?, ?lx : float?, ?luma_msize_y : float?, ?ly : float?,
+ ?luma_amount : float?, ?la : float?, ?chroma_msize_x : float?, ?cx : float?,
+ ?chroma_msize_y : float?, ?cy : float?, ?chroma_amount : float?,
+ ?ca : float?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `luma_msize_x` (of type `float?`, which defaults to `null`): Set luma mask horizontal diameter (pixels). (default: 5.)
+- `lx` (of type `float?`, which defaults to `null`): Set luma mask horizontal diameter (pixels). (default: 5.)
+- `luma_msize_y` (of type `float?`, which defaults to `null`): Set luma mask vertical diameter (pixels). (default: 5.)
+- `ly` (of type `float?`, which defaults to `null`): Set luma mask vertical diameter (pixels). (default: 5.)
+- `luma_amount` (of type `float?`, which defaults to `null`): Set luma amount (multiplier). (default: 1.)
+- `la` (of type `float?`, which defaults to `null`): Set luma amount (multiplier). (default: 1.)
+- `chroma_msize_x` (of type `float?`, which defaults to `null`): Set chroma mask horizontal diameter (pixels after subsampling). (default: 5.)
+- `cx` (of type `float?`, which defaults to `null`): Set chroma mask horizontal diameter (pixels after subsampling). (default: 5.)
+- `chroma_msize_y` (of type `float?`, which defaults to `null`): Set chroma mask vertical diameter (pixels after subsampling). (default: 5.)
+- `cy` (of type `float?`, which defaults to `null`): Set chroma mask vertical diameter (pixels after subsampling). (default: 5.)
+- `chroma_amount` (of type `float?`, which defaults to `null`): Set chroma amount (multiplier). (default: 0.)
+- `ca` (of type `float?`, which defaults to `null`): Set chroma amount (multiplier). (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.unsharp_opencl.create`
+
+Ffmpeg filter: Apply unsharp mask to input video. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?luma_msize_x : float?, ?lx : float?, ?luma_msize_y : float?, ?ly : float?,
+ ?luma_amount : float?, ?la : float?, ?chroma_msize_x : float?, ?cx : float?,
+ ?chroma_msize_y : float?, ?cy : float?, ?chroma_amount : float?,
+ ?ca : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `luma_msize_x` (of type `float?`, which defaults to `null`): Set luma mask horizontal diameter (pixels). (default: 5.)
+- `lx` (of type `float?`, which defaults to `null`): Set luma mask horizontal diameter (pixels). (default: 5.)
+- `luma_msize_y` (of type `float?`, which defaults to `null`): Set luma mask vertical diameter (pixels). (default: 5.)
+- `ly` (of type `float?`, which defaults to `null`): Set luma mask vertical diameter (pixels). (default: 5.)
+- `luma_amount` (of type `float?`, which defaults to `null`): Set luma amount (multiplier). (default: 1.)
+- `la` (of type `float?`, which defaults to `null`): Set luma amount (multiplier). (default: 1.)
+- `chroma_msize_x` (of type `float?`, which defaults to `null`): Set chroma mask horizontal diameter (pixels after subsampling). (default: 5.)
+- `cx` (of type `float?`, which defaults to `null`): Set chroma mask horizontal diameter (pixels after subsampling). (default: 5.)
+- `chroma_msize_y` (of type `float?`, which defaults to `null`): Set chroma mask vertical diameter (pixels after subsampling). (default: 5.)
+- `cy` (of type `float?`, which defaults to `null`): Set chroma mask vertical diameter (pixels after subsampling). (default: 5.)
+- `chroma_amount` (of type `float?`, which defaults to `null`): Set chroma amount (multiplier). (default: 0.)
+- `ca` (of type `float?`, which defaults to `null`): Set chroma amount (multiplier). (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.untile`
+
+Ffmpeg filter: Untile a frame into a sequence of frames.
+
+Type:
+
+```
+(?layout : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `layout` (of type `string?`, which defaults to `null`): set grid size. (default: 6x5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.untile.create`
+
+Ffmpeg filter: Untile a frame into a sequence of frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?layout : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `layout` (of type `string?`, which defaults to `null`): set grid size. (default: 6x5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.uspp`
+
+Ffmpeg filter: Apply Ultra Simple / Slow Post-processing filter.
+
+Type:
+
+```
+(?quality : int?, ?qp : int?, ?use_bframe_qp : bool?, ?codec : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `quality` (of type `int?`, which defaults to `null`): set quality. (default: 3)
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `use_bframe_qp` (of type `bool?`, which defaults to `null`): use B-frames' QP. (default: false)
+- `codec` (of type `string?`, which defaults to `null`): Codec name. (default: snow)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.uspp.create`
+
+Ffmpeg filter: Apply Ultra Simple / Slow Post-processing filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?quality : int?, ?qp : int?, ?use_bframe_qp : bool?, ?codec : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `quality` (of type `int?`, which defaults to `null`): set quality. (default: 3)
+- `qp` (of type `int?`, which defaults to `null`): force a constant quantizer parameter. (default: 0)
+- `use_bframe_qp` (of type `bool?`, which defaults to `null`): use B-frames' QP. (default: false)
+- `codec` (of type `string?`, which defaults to `null`): Codec name. (default: snow)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.v360`
+
+Ffmpeg filter: Convert 360 projection of video.
+
+Type:
+
+```
+(?input : int?, ?output : int?, ?interp : int?, ?w : int?, ?h : int?,
+ ?in_stereo : int?, ?out_stereo : int?, ?in_forder : string?,
+ ?out_forder : string?, ?in_frot : string?, ?out_frot : string?,
+ ?in_pad : float?, ?out_pad : float?, ?fin_pad : int?, ?fout_pad : int?,
+ ?yaw : float?, ?pitch : float?, ?roll : float?, ?rorder : string?,
+ ?h_fov : float?, ?v_fov : float?, ?d_fov : float?, ?h_flip : bool?,
+ ?v_flip : bool?, ?d_flip : bool?, ?ih_flip : bool?, ?iv_flip : bool?,
+ ?in_trans : bool?, ?out_trans : bool?, ?ih_fov : float?, ?iv_fov : float?,
+ ?id_fov : float?, ?h_offset : float?, ?v_offset : float?,
+ ?alpha_mask : bool?, ?reset_rot : bool?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `input` (of type `int?`, which defaults to `null`): set input projection. (default: 0, possible values: 0 (e), 0 (equirect), 1 (c3x2), 2 (c6x1), 3 (eac), 5 (dfisheye), 4 (flat), 4 (rectilinear), 4 (gnomonic), 6 (barrel), 6 (fb), 7 (c1x6), 8 (sg), 9 (mercator), 10 (ball), 11 (hammer), 12 (sinusoidal), 13 (fisheye), 14 (pannini), 15 (cylindrical), 17 (tetrahedron), 18 (barrelsplit), 19 (tsp), 20 (hequirect), 20 (he), 21 (equisolid), 22 (og), 23 (octahedron), 24 (cylindricalea))
+- `output` (of type `int?`, which defaults to `null`): set output projection. (default: 1, possible values: 0 (e), 0 (equirect), 1 (c3x2), 2 (c6x1), 3 (eac), 5 (dfisheye), 4 (flat), 4 (rectilinear), 4 (gnomonic), 6 (barrel), 6 (fb), 7 (c1x6), 8 (sg), 9 (mercator), 10 (ball), 11 (hammer), 12 (sinusoidal), 13 (fisheye), 14 (pannini), 15 (cylindrical), 16 (perspective), 17 (tetrahedron), 18 (barrelsplit), 19 (tsp), 20 (hequirect), 20 (he), 21 (equisolid), 22 (og), 23 (octahedron), 24 (cylindricalea))
+- `interp` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (near), 0 (nearest), 1 (line), 1 (linear), 2 (lagrange9), 3 (cube), 3 (cubic), 4 (lanc), 4 (lanczos), 5 (sp16), 5 (spline16), 6 (gauss), 6 (gaussian), 7 (mitchell))
+- `w` (of type `int?`, which defaults to `null`): output width. (default: 0)
+- `h` (of type `int?`, which defaults to `null`): output height. (default: 0)
+- `in_stereo` (of type `int?`, which defaults to `null`): input stereo format. (default: 0, possible values: 0 (2d), 1 (sbs), 2 (tb))
+- `out_stereo` (of type `int?`, which defaults to `null`): output stereo format. (default: 0, possible values: 0 (2d), 1 (sbs), 2 (tb))
+- `in_forder` (of type `string?`, which defaults to `null`): input cubemap face order. (default: rludfb)
+- `out_forder` (of type `string?`, which defaults to `null`): output cubemap face order. (default: rludfb)
+- `in_frot` (of type `string?`, which defaults to `null`): input cubemap face rotation. (default: 000000)
+- `out_frot` (of type `string?`, which defaults to `null`): output cubemap face rotation. (default: 000000)
+- `in_pad` (of type `float?`, which defaults to `null`): percent input cubemap pads. (default: 0.)
+- `out_pad` (of type `float?`, which defaults to `null`): percent output cubemap pads. (default: 0.)
+- `fin_pad` (of type `int?`, which defaults to `null`): fixed input cubemap pads. (default: 0)
+- `fout_pad` (of type `int?`, which defaults to `null`): fixed output cubemap pads. (default: 0)
+- `yaw` (of type `float?`, which defaults to `null`): yaw rotation. (default: 0.)
+- `pitch` (of type `float?`, which defaults to `null`): pitch rotation. (default: 0.)
+- `roll` (of type `float?`, which defaults to `null`): roll rotation. (default: 0.)
+- `rorder` (of type `string?`, which defaults to `null`): rotation order. (default: ypr)
+- `h_fov` (of type `float?`, which defaults to `null`): output horizontal field of view. (default: 0.)
+- `v_fov` (of type `float?`, which defaults to `null`): output vertical field of view. (default: 0.)
+- `d_fov` (of type `float?`, which defaults to `null`): output diagonal field of view. (default: 0.)
+- `h_flip` (of type `bool?`, which defaults to `null`): flip out video horizontally. (default: false)
+- `v_flip` (of type `bool?`, which defaults to `null`): flip out video vertically. (default: false)
+- `d_flip` (of type `bool?`, which defaults to `null`): flip out video indepth. (default: false)
+- `ih_flip` (of type `bool?`, which defaults to `null`): flip in video horizontally. (default: false)
+- `iv_flip` (of type `bool?`, which defaults to `null`): flip in video vertically. (default: false)
+- `in_trans` (of type `bool?`, which defaults to `null`): transpose video input. (default: false)
+- `out_trans` (of type `bool?`, which defaults to `null`): transpose video output. (default: false)
+- `ih_fov` (of type `float?`, which defaults to `null`): input horizontal field of view. (default: 0.)
+- `iv_fov` (of type `float?`, which defaults to `null`): input vertical field of view. (default: 0.)
+- `id_fov` (of type `float?`, which defaults to `null`): input diagonal field of view. (default: 0.)
+- `h_offset` (of type `float?`, which defaults to `null`): output horizontal off-axis offset. (default: 0.)
+- `v_offset` (of type `float?`, which defaults to `null`): output vertical off-axis offset. (default: 0.)
+- `alpha_mask` (of type `bool?`, which defaults to `null`): build mask in alpha plane. (default: false)
+- `reset_rot` (of type `bool?`, which defaults to `null`): reset rotation. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.v360.create`
+
+Ffmpeg filter: Convert 360 projection of video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?input : int?, ?output : int?, ?interp : int?, ?w : int?, ?h : int?,
+ ?in_stereo : int?, ?out_stereo : int?, ?in_forder : string?,
+ ?out_forder : string?, ?in_frot : string?, ?out_frot : string?,
+ ?in_pad : float?, ?out_pad : float?, ?fin_pad : int?, ?fout_pad : int?,
+ ?yaw : float?, ?pitch : float?, ?roll : float?, ?rorder : string?,
+ ?h_fov : float?, ?v_fov : float?, ?d_fov : float?, ?h_flip : bool?,
+ ?v_flip : bool?, ?d_flip : bool?, ?ih_flip : bool?, ?iv_flip : bool?,
+ ?in_trans : bool?, ?out_trans : bool?, ?ih_fov : float?, ?iv_fov : float?,
+ ?id_fov : float?, ?h_offset : float?, ?v_offset : float?,
+ ?alpha_mask : bool?, ?reset_rot : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `input` (of type `int?`, which defaults to `null`): set input projection. (default: 0, possible values: 0 (e), 0 (equirect), 1 (c3x2), 2 (c6x1), 3 (eac), 5 (dfisheye), 4 (flat), 4 (rectilinear), 4 (gnomonic), 6 (barrel), 6 (fb), 7 (c1x6), 8 (sg), 9 (mercator), 10 (ball), 11 (hammer), 12 (sinusoidal), 13 (fisheye), 14 (pannini), 15 (cylindrical), 17 (tetrahedron), 18 (barrelsplit), 19 (tsp), 20 (hequirect), 20 (he), 21 (equisolid), 22 (og), 23 (octahedron), 24 (cylindricalea))
+- `output` (of type `int?`, which defaults to `null`): set output projection. (default: 1, possible values: 0 (e), 0 (equirect), 1 (c3x2), 2 (c6x1), 3 (eac), 5 (dfisheye), 4 (flat), 4 (rectilinear), 4 (gnomonic), 6 (barrel), 6 (fb), 7 (c1x6), 8 (sg), 9 (mercator), 10 (ball), 11 (hammer), 12 (sinusoidal), 13 (fisheye), 14 (pannini), 15 (cylindrical), 16 (perspective), 17 (tetrahedron), 18 (barrelsplit), 19 (tsp), 20 (hequirect), 20 (he), 21 (equisolid), 22 (og), 23 (octahedron), 24 (cylindricalea))
+- `interp` (of type `int?`, which defaults to `null`): set interpolation method. (default: 1, possible values: 0 (near), 0 (nearest), 1 (line), 1 (linear), 2 (lagrange9), 3 (cube), 3 (cubic), 4 (lanc), 4 (lanczos), 5 (sp16), 5 (spline16), 6 (gauss), 6 (gaussian), 7 (mitchell))
+- `w` (of type `int?`, which defaults to `null`): output width. (default: 0)
+- `h` (of type `int?`, which defaults to `null`): output height. (default: 0)
+- `in_stereo` (of type `int?`, which defaults to `null`): input stereo format. (default: 0, possible values: 0 (2d), 1 (sbs), 2 (tb))
+- `out_stereo` (of type `int?`, which defaults to `null`): output stereo format. (default: 0, possible values: 0 (2d), 1 (sbs), 2 (tb))
+- `in_forder` (of type `string?`, which defaults to `null`): input cubemap face order. (default: rludfb)
+- `out_forder` (of type `string?`, which defaults to `null`): output cubemap face order. (default: rludfb)
+- `in_frot` (of type `string?`, which defaults to `null`): input cubemap face rotation. (default: 000000)
+- `out_frot` (of type `string?`, which defaults to `null`): output cubemap face rotation. (default: 000000)
+- `in_pad` (of type `float?`, which defaults to `null`): percent input cubemap pads. (default: 0.)
+- `out_pad` (of type `float?`, which defaults to `null`): percent output cubemap pads. (default: 0.)
+- `fin_pad` (of type `int?`, which defaults to `null`): fixed input cubemap pads. (default: 0)
+- `fout_pad` (of type `int?`, which defaults to `null`): fixed output cubemap pads. (default: 0)
+- `yaw` (of type `float?`, which defaults to `null`): yaw rotation. (default: 0.)
+- `pitch` (of type `float?`, which defaults to `null`): pitch rotation. (default: 0.)
+- `roll` (of type `float?`, which defaults to `null`): roll rotation. (default: 0.)
+- `rorder` (of type `string?`, which defaults to `null`): rotation order. (default: ypr)
+- `h_fov` (of type `float?`, which defaults to `null`): output horizontal field of view. (default: 0.)
+- `v_fov` (of type `float?`, which defaults to `null`): output vertical field of view. (default: 0.)
+- `d_fov` (of type `float?`, which defaults to `null`): output diagonal field of view. (default: 0.)
+- `h_flip` (of type `bool?`, which defaults to `null`): flip out video horizontally. (default: false)
+- `v_flip` (of type `bool?`, which defaults to `null`): flip out video vertically. (default: false)
+- `d_flip` (of type `bool?`, which defaults to `null`): flip out video indepth. (default: false)
+- `ih_flip` (of type `bool?`, which defaults to `null`): flip in video horizontally. (default: false)
+- `iv_flip` (of type `bool?`, which defaults to `null`): flip in video vertically. (default: false)
+- `in_trans` (of type `bool?`, which defaults to `null`): transpose video input. (default: false)
+- `out_trans` (of type `bool?`, which defaults to `null`): transpose video output. (default: false)
+- `ih_fov` (of type `float?`, which defaults to `null`): input horizontal field of view. (default: 0.)
+- `iv_fov` (of type `float?`, which defaults to `null`): input vertical field of view. (default: 0.)
+- `id_fov` (of type `float?`, which defaults to `null`): input diagonal field of view. (default: 0.)
+- `h_offset` (of type `float?`, which defaults to `null`): output horizontal off-axis offset. (default: 0.)
+- `v_offset` (of type `float?`, which defaults to `null`): output vertical off-axis offset. (default: 0.)
+- `alpha_mask` (of type `bool?`, which defaults to `null`): build mask in alpha plane. (default: false)
+- `reset_rot` (of type `bool?`, which defaults to `null`): reset rotation. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vaguedenoiser`
+
+Ffmpeg filter: Apply a Wavelet based Denoiser.
+
+Type:
+
+```
+(?threshold : float?, ?method : int?, ?nsteps : int?, ?percent : float?,
+ ?planes : int?, ?type : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set filtering strength. (default: 2.)
+- `method` (of type `int?`, which defaults to `null`): set filtering method. (default: 2, possible values: 0 (hard), 1 (soft), 2 (garrote))
+- `nsteps` (of type `int?`, which defaults to `null`): set number of steps. (default: 6)
+- `percent` (of type `float?`, which defaults to `null`): set percent of full denoising. (default: 85.)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `type` (of type `int?`, which defaults to `null`): set threshold type. (default: 0, possible values: 0 (universal), 1 (bayes))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vaguedenoiser.create`
+
+Ffmpeg filter: Apply a Wavelet based Denoiser.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?threshold : float?, ?method : int?, ?nsteps : int?, ?percent : float?,
+ ?planes : int?, ?type : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `threshold` (of type `float?`, which defaults to `null`): set filtering strength. (default: 2.)
+- `method` (of type `int?`, which defaults to `null`): set filtering method. (default: 2, possible values: 0 (hard), 1 (soft), 2 (garrote))
+- `nsteps` (of type `int?`, which defaults to `null`): set number of steps. (default: 6)
+- `percent` (of type `float?`, which defaults to `null`): set percent of full denoising. (default: 85.)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `type` (of type `int?`, which defaults to `null`): set threshold type. (default: 0, possible values: 0 (universal), 1 (bayes))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.varblur`
+
+Ffmpeg filter: Apply Variable Blur filter.
+
+Type:
+
+```
+(?min_r : int?, ?max_r : int?, ?planes : int?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `min_r` (of type `int?`, which defaults to `null`): set min blur radius. (default: 0)
+- `max_r` (of type `int?`, which defaults to `null`): set max blur radius. (default: 8)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.varblur.create`
+
+Ffmpeg filter: Apply Variable Blur filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?min_r : int?, ?max_r : int?, ?planes : int?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `min_r` (of type `int?`, which defaults to `null`): set min blur radius. (default: 0)
+- `max_r` (of type `int?`, which defaults to `null`): set max blur radius. (default: 8)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vectorscope`
+
+Ffmpeg filter: Video vectorscope.
+
+Type:
+
+```
+(?mode : int?, ?m : int?, ?x : int?, ?y : int?, ?intensity : float?,
+ ?i : float?, ?envelope : int?, ?e : int?, ?graticule : int?, ?g : int?,
+ ?opacity : float?, ?o : float?, ?flags : int?, ?f : int?,
+ ?bgopacity : float?, ?b : float?, ?lthreshold : float?, ?l : float?,
+ ?hthreshold : float?, ?h : float?, ?colorspace : int?, ?c : int?,
+ ?tint0 : float?, ?t0 : float?, ?tint1 : float?, ?t1 : float?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set vectorscope mode. (default: 0, possible values: 0 (gray), 0 (tint), 1 (color), 2 (color2), 3 (color3), 4 (color4), 5 (color5))
+- `m` (of type `int?`, which defaults to `null`): set vectorscope mode. (default: 0, possible values: 0 (gray), 0 (tint), 1 (color), 2 (color2), 3 (color3), 4 (color4), 5 (color5))
+- `x` (of type `int?`, which defaults to `null`): set color component on X axis. (default: 1)
+- `y` (of type `int?`, which defaults to `null`): set color component on Y axis. (default: 2)
+- `intensity` (of type `float?`, which defaults to `null`): set intensity. (default: 0.004)
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 0.004)
+- `envelope` (of type `int?`, which defaults to `null`): set envelope. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `e` (of type `int?`, which defaults to `null`): set envelope. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `graticule` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (color), 3 (invert))
+- `g` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (color), 3 (invert))
+- `opacity` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `o` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `flags` (of type `int?`, which defaults to `null`): set graticule flags. (default: 4, possible values: 1 (white), 2 (black), 4 (name))
+- `f` (of type `int?`, which defaults to `null`): set graticule flags. (default: 4, possible values: 1 (white), 2 (black), 4 (name))
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.3)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.3)
+- `lthreshold` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.)
+- `l` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.)
+- `hthreshold` (of type `float?`, which defaults to `null`): set high threshold. (default: 1.)
+- `h` (of type `float?`, which defaults to `null`): set high threshold. (default: 1.)
+- `colorspace` (of type `int?`, which defaults to `null`): set colorspace. (default: 0, possible values: 0 (auto), 1 (601), 2 (709))
+- `c` (of type `int?`, which defaults to `null`): set colorspace. (default: 0, possible values: 0 (auto), 1 (601), 2 (709))
+- `tint0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `t0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `tint1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `t1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vectorscope.create`
+
+Ffmpeg filter: Video vectorscope.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?m : int?, ?x : int?, ?y : int?, ?intensity : float?,
+ ?i : float?, ?envelope : int?, ?e : int?, ?graticule : int?, ?g : int?,
+ ?opacity : float?, ?o : float?, ?flags : int?, ?f : int?,
+ ?bgopacity : float?, ?b : float?, ?lthreshold : float?, ?l : float?,
+ ?hthreshold : float?, ?h : float?, ?colorspace : int?, ?c : int?,
+ ?tint0 : float?, ?t0 : float?, ?tint1 : float?, ?t1 : float?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set vectorscope mode. (default: 0, possible values: 0 (gray), 0 (tint), 1 (color), 2 (color2), 3 (color3), 4 (color4), 5 (color5))
+- `m` (of type `int?`, which defaults to `null`): set vectorscope mode. (default: 0, possible values: 0 (gray), 0 (tint), 1 (color), 2 (color2), 3 (color3), 4 (color4), 5 (color5))
+- `x` (of type `int?`, which defaults to `null`): set color component on X axis. (default: 1)
+- `y` (of type `int?`, which defaults to `null`): set color component on Y axis. (default: 2)
+- `intensity` (of type `float?`, which defaults to `null`): set intensity. (default: 0.004)
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 0.004)
+- `envelope` (of type `int?`, which defaults to `null`): set envelope. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `e` (of type `int?`, which defaults to `null`): set envelope. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `graticule` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (color), 3 (invert))
+- `g` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (color), 3 (invert))
+- `opacity` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `o` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `flags` (of type `int?`, which defaults to `null`): set graticule flags. (default: 4, possible values: 1 (white), 2 (black), 4 (name))
+- `f` (of type `int?`, which defaults to `null`): set graticule flags. (default: 4, possible values: 1 (white), 2 (black), 4 (name))
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.3)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.3)
+- `lthreshold` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.)
+- `l` (of type `float?`, which defaults to `null`): set low threshold. (default: 0.)
+- `hthreshold` (of type `float?`, which defaults to `null`): set high threshold. (default: 1.)
+- `h` (of type `float?`, which defaults to `null`): set high threshold. (default: 1.)
+- `colorspace` (of type `int?`, which defaults to `null`): set colorspace. (default: 0, possible values: 0 (auto), 1 (601), 2 (709))
+- `c` (of type `int?`, which defaults to `null`): set colorspace. (default: 0, possible values: 0 (auto), 1 (601), 2 (709))
+- `tint0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `t0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `tint1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `t1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vflip`
+
+Ffmpeg filter: Flip the input video vertically.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vflip.create`
+
+Ffmpeg filter: Flip the input video vertically.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vfrdet`
+
+Ffmpeg filter: Variable frame rate detect filter.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vfrdet.create`
+
+Ffmpeg filter: Variable frame rate detect filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vibrance`
+
+Ffmpeg filter: Boost or alter saturation.
+
+Type:
+
+```
+(?intensity : float?, ?rbal : float?, ?gbal : float?, ?bbal : float?,
+ ?rlum : float?, ?glum : float?, ?blum : float?, ?alternate : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `intensity` (of type `float?`, which defaults to `null`): set the intensity value. (default: 0.)
+- `rbal` (of type `float?`, which defaults to `null`): set the red balance value. (default: 1.)
+- `gbal` (of type `float?`, which defaults to `null`): set the green balance value. (default: 1.)
+- `bbal` (of type `float?`, which defaults to `null`): set the blue balance value. (default: 1.)
+- `rlum` (of type `float?`, which defaults to `null`): set the red luma coefficient. (default: 0.072186)
+- `glum` (of type `float?`, which defaults to `null`): set the green luma coefficient. (default: 0.715158)
+- `blum` (of type `float?`, which defaults to `null`): set the blue luma coefficient. (default: 0.212656)
+- `alternate` (of type `bool?`, which defaults to `null`): use alternate colors. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vibrance.create`
+
+Ffmpeg filter: Boost or alter saturation.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?intensity : float?, ?rbal : float?, ?gbal : float?, ?bbal : float?,
+ ?rlum : float?, ?glum : float?, ?blum : float?, ?alternate : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `intensity` (of type `float?`, which defaults to `null`): set the intensity value. (default: 0.)
+- `rbal` (of type `float?`, which defaults to `null`): set the red balance value. (default: 1.)
+- `gbal` (of type `float?`, which defaults to `null`): set the green balance value. (default: 1.)
+- `bbal` (of type `float?`, which defaults to `null`): set the blue balance value. (default: 1.)
+- `rlum` (of type `float?`, which defaults to `null`): set the red luma coefficient. (default: 0.072186)
+- `glum` (of type `float?`, which defaults to `null`): set the green luma coefficient. (default: 0.715158)
+- `blum` (of type `float?`, which defaults to `null`): set the blue luma coefficient. (default: 0.212656)
+- `alternate` (of type `bool?`, which defaults to `null`): use alternate colors. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vibrato`
+
+Ffmpeg filter: Apply vibrato effect.
+
+Type:
+
+```
+(?f : float?, ?d : float?, ffmpeg.filter.graph, ffmpeg.filter.audio) ->
+ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `f` (of type `float?`, which defaults to `null`): set frequency in hertz. (default: 5.)
+- `d` (of type `float?`, which defaults to `null`): set depth as percentage. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.vibrato.create`
+
+Ffmpeg filter: Apply vibrato effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?f : float?, ?d : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `f` (of type `float?`, which defaults to `null`): set frequency in hertz. (default: 5.)
+- `d` (of type `float?`, which defaults to `null`): set depth as percentage. (default: 0.5)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vidstabdetect`
+
+Ffmpeg filter: Extract relative transformations, pass 1 of 2 for stabilization (see vidstabtransform for pass 2).
+
+Type:
+
+```
+(?result : string?, ?shakiness : int?, ?accuracy : int?, ?stepsize : int?,
+ ?mincontrast : float?, ?show : int?, ?tripod : int?, ?fileformat : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `result` (of type `string?`, which defaults to `null`): path to the file used to write the transforms. (default: transforms.trf)
+- `shakiness` (of type `int?`, which defaults to `null`): how shaky is the video and how quick is the camera? 1: little (fast) 10: very strong/quick (slow). (default: 5)
+- `accuracy` (of type `int?`, which defaults to `null`): (>=shakiness) 1: low 15: high (slow). (default: 15)
+- `stepsize` (of type `int?`, which defaults to `null`): region around minimum is scanned with 1 pixel resolution. (default: 6)
+- `mincontrast` (of type `float?`, which defaults to `null`): below this contrast a field is discarded (0-1). (default: 0.25)
+- `show` (of type `int?`, which defaults to `null`): 0: draw nothing; 1,2: show fields and transforms. (default: 0)
+- `tripod` (of type `int?`, which defaults to `null`): virtual tripod mode (if >0): motion is compared to a reference reference frame (frame # is the value). (default: 0)
+- `fileformat` (of type `int?`, which defaults to `null`): transforms data file format. (default: 2, possible values: 1 (ascii), 2 (binary))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vidstabdetect.create`
+
+Ffmpeg filter: Extract relative transformations, pass 1 of 2 for stabilization (see vidstabtransform for pass 2).. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?result : string?, ?shakiness : int?, ?accuracy : int?, ?stepsize : int?,
+ ?mincontrast : float?, ?show : int?, ?tripod : int?, ?fileformat : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `result` (of type `string?`, which defaults to `null`): path to the file used to write the transforms. (default: transforms.trf)
+- `shakiness` (of type `int?`, which defaults to `null`): how shaky is the video and how quick is the camera? 1: little (fast) 10: very strong/quick (slow). (default: 5)
+- `accuracy` (of type `int?`, which defaults to `null`): (>=shakiness) 1: low 15: high (slow). (default: 15)
+- `stepsize` (of type `int?`, which defaults to `null`): region around minimum is scanned with 1 pixel resolution. (default: 6)
+- `mincontrast` (of type `float?`, which defaults to `null`): below this contrast a field is discarded (0-1). (default: 0.25)
+- `show` (of type `int?`, which defaults to `null`): 0: draw nothing; 1,2: show fields and transforms. (default: 0)
+- `tripod` (of type `int?`, which defaults to `null`): virtual tripod mode (if >0): motion is compared to a reference reference frame (frame # is the value). (default: 0)
+- `fileformat` (of type `int?`, which defaults to `null`): transforms data file format. (default: 2, possible values: 1 (ascii), 2 (binary))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vidstabtransform`
+
+Ffmpeg filter: Transform the frames, pass 2 of 2 for stabilization (see vidstabdetect for pass 1).
+
+Type:
+
+```
+(?input : string?, ?smoothing : int?, ?optalgo : int?, ?maxshift : int?,
+ ?maxangle : float?, ?crop : int?, ?invert : int?, ?relative : int?,
+ ?zoom : float?, ?optzoom : int?, ?zoomspeed : float?, ?interpol : int?,
+ ?tripod : bool?, ?debug : bool?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `input` (of type `string?`, which defaults to `null`): set path to the file storing the transforms. (default: transforms.trf)
+- `smoothing` (of type `int?`, which defaults to `null`): set number of frames*2 + 1 used for lowpass filtering. (default: 15)
+- `optalgo` (of type `int?`, which defaults to `null`): set camera path optimization algo. (default: 0, possible values: 0 (opt), 1 (gauss), 2 (avg))
+- `maxshift` (of type `int?`, which defaults to `null`): set maximal number of pixels to translate image. (default: -1)
+- `maxangle` (of type `float?`, which defaults to `null`): set maximal angle in rad to rotate image. (default: -1.)
+- `crop` (of type `int?`, which defaults to `null`): set cropping mode. (default: 0, possible values: 0 (keep), 1 (black))
+- `invert` (of type `int?`, which defaults to `null`): invert transforms. (default: 0)
+- `relative` (of type `int?`, which defaults to `null`): consider transforms as relative. (default: 1)
+- `zoom` (of type `float?`, which defaults to `null`): set percentage to zoom (>0: zoom in, <0: zoom out. (default: 0.)
+- `optzoom` (of type `int?`, which defaults to `null`): set optimal zoom (0: nothing, 1: optimal static zoom, 2: optimal dynamic zoom). (default: 1)
+- `zoomspeed` (of type `float?`, which defaults to `null`): for adative zoom: percent to zoom maximally each frame. (default: 0.25)
+- `interpol` (of type `int?`, which defaults to `null`): set type of interpolation. (default: 2, possible values: 0 (no), 1 (linear), 2 (bilinear), 3 (bicubic))
+- `tripod` (of type `bool?`, which defaults to `null`): enable virtual tripod mode (same as relative=0:smoothing=0). (default: false)
+- `debug` (of type `bool?`, which defaults to `null`): enable debug mode and writer global motions information to file. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vidstabtransform.create`
+
+Ffmpeg filter: Transform the frames, pass 2 of 2 for stabilization (see vidstabdetect for pass 1).. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?input : string?, ?smoothing : int?, ?optalgo : int?, ?maxshift : int?,
+ ?maxangle : float?, ?crop : int?, ?invert : int?, ?relative : int?,
+ ?zoom : float?, ?optzoom : int?, ?zoomspeed : float?, ?interpol : int?,
+ ?tripod : bool?, ?debug : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `input` (of type `string?`, which defaults to `null`): set path to the file storing the transforms. (default: transforms.trf)
+- `smoothing` (of type `int?`, which defaults to `null`): set number of frames*2 + 1 used for lowpass filtering. (default: 15)
+- `optalgo` (of type `int?`, which defaults to `null`): set camera path optimization algo. (default: 0, possible values: 0 (opt), 1 (gauss), 2 (avg))
+- `maxshift` (of type `int?`, which defaults to `null`): set maximal number of pixels to translate image. (default: -1)
+- `maxangle` (of type `float?`, which defaults to `null`): set maximal angle in rad to rotate image. (default: -1.)
+- `crop` (of type `int?`, which defaults to `null`): set cropping mode. (default: 0, possible values: 0 (keep), 1 (black))
+- `invert` (of type `int?`, which defaults to `null`): invert transforms. (default: 0)
+- `relative` (of type `int?`, which defaults to `null`): consider transforms as relative. (default: 1)
+- `zoom` (of type `float?`, which defaults to `null`): set percentage to zoom (>0: zoom in, <0: zoom out. (default: 0.)
+- `optzoom` (of type `int?`, which defaults to `null`): set optimal zoom (0: nothing, 1: optimal static zoom, 2: optimal dynamic zoom). (default: 1)
+- `zoomspeed` (of type `float?`, which defaults to `null`): for adative zoom: percent to zoom maximally each frame. (default: 0.25)
+- `interpol` (of type `int?`, which defaults to `null`): set type of interpolation. (default: 2, possible values: 0 (no), 1 (linear), 2 (bilinear), 3 (bicubic))
+- `tripod` (of type `bool?`, which defaults to `null`): enable virtual tripod mode (same as relative=0:smoothing=0). (default: false)
+- `debug` (of type `bool?`, which defaults to `null`): enable debug mode and writer global motions information to file. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vif`
+
+Ffmpeg filter: Calculate the VIF between two video streams.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vif.create`
+
+Ffmpeg filter: Calculate the VIF between two video streams.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?eof_action : int?, ?shortest : bool?, ?repeatlast : bool?,
+ ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vignette`
+
+Ffmpeg filter: Make or reverse a vignette effect.
+
+Type:
+
+```
+(?angle : string?, ?a : string?, ?x0 : string?, ?y0 : string?, ?mode : int?,
+ ?eval : int?, ?dither : bool?, ?aspect : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `angle` (of type `string?`, which defaults to `null`): set lens angle. (default: PI/5)
+- `a` (of type `string?`, which defaults to `null`): set lens angle. (default: PI/5)
+- `x0` (of type `string?`, which defaults to `null`): set circle center position on x-axis. (default: w/2)
+- `y0` (of type `string?`, which defaults to `null`): set circle center position on y-axis. (default: h/2)
+- `mode` (of type `int?`, which defaults to `null`): set forward/backward mode. (default: 0, possible values: 0 (forward), 1 (backward))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `dither` (of type `bool?`, which defaults to `null`): set dithering. (default: true)
+- `aspect` (of type `string?`, which defaults to `null`): set aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vignette.create`
+
+Ffmpeg filter: Make or reverse a vignette effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?angle : string?, ?a : string?, ?x0 : string?, ?y0 : string?, ?mode : int?,
+ ?eval : int?, ?dither : bool?, ?aspect : string?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `angle` (of type `string?`, which defaults to `null`): set lens angle. (default: PI/5)
+- `a` (of type `string?`, which defaults to `null`): set lens angle. (default: PI/5)
+- `x0` (of type `string?`, which defaults to `null`): set circle center position on x-axis. (default: w/2)
+- `y0` (of type `string?`, which defaults to `null`): set circle center position on y-axis. (default: h/2)
+- `mode` (of type `int?`, which defaults to `null`): set forward/backward mode. (default: 0, possible values: 0 (forward), 1 (backward))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (init), 1 (frame))
+- `dither` (of type `bool?`, which defaults to `null`): set dithering. (default: true)
+- `aspect` (of type `string?`, which defaults to `null`): set aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.virtualbass`
+
+Ffmpeg filter: Audio Virtual Bass.
+
+Type:
+
+```
+(?cutoff : float?, ?strength : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `cutoff` (of type `float?`, which defaults to `null`): set virtual bass cutoff. (default: 250.)
+- `strength` (of type `float?`, which defaults to `null`): set virtual bass strength. (default: 3.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.virtualbass.create`
+
+Ffmpeg filter: Audio Virtual Bass.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?cutoff : float?, ?strength : float?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `cutoff` (of type `float?`, which defaults to `null`): set virtual bass cutoff. (default: 250.)
+- `strength` (of type `float?`, which defaults to `null`): set virtual bass strength. (default: 3.)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vmafmotion`
+
+Ffmpeg filter: Calculate the VMAF Motion score.
+
+Type:
+
+```
+(?stats_file : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.vmafmotion.create`
+
+Ffmpeg filter: Calculate the VMAF Motion score.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?stats_file : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `stats_file` (of type `string?`, which defaults to `null`): Set file where to store per-frame difference information
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.volume`
+
+Ffmpeg filter: Change input volume.
+
+Type:
+
+```
+(?volume : string?, ?precision : int?, ?eval : int?, ?replaygain : int?,
+ ?replaygain_preamp : float?, ?replaygain_noclip : bool?,
+ ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `volume` (of type `string?`, which defaults to `null`): set volume adjustment expression. (default: 1.0)
+- `precision` (of type `int?`, which defaults to `null`): select mathematical precision. (default: 1, possible values: 0 (fixed), 1 (float), 2 (double))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (once), 1 (frame))
+- `replaygain` (of type `int?`, which defaults to `null`): Apply replaygain side data when present. (default: 0, possible values: 0 (drop), 1 (ignore), 2 (track), 3 (album))
+- `replaygain_preamp` (of type `float?`, which defaults to `null`): Apply replaygain pre-amplification. (default: 0.)
+- `replaygain_noclip` (of type `bool?`, which defaults to `null`): Apply replaygain clipping prevention. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.volume.create`
+
+Ffmpeg filter: Change input volume.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?volume : string?, ?precision : int?, ?eval : int?, ?replaygain : int?,
+ ?replaygain_preamp : float?, ?replaygain_noclip : bool?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `volume` (of type `string?`, which defaults to `null`): set volume adjustment expression. (default: 1.0)
+- `precision` (of type `int?`, which defaults to `null`): select mathematical precision. (default: 1, possible values: 0 (fixed), 1 (float), 2 (double))
+- `eval` (of type `int?`, which defaults to `null`): specify when to evaluate expressions. (default: 0, possible values: 0 (once), 1 (frame))
+- `replaygain` (of type `int?`, which defaults to `null`): Apply replaygain side data when present. (default: 0, possible values: 0 (drop), 1 (ignore), 2 (track), 3 (album))
+- `replaygain_preamp` (of type `float?`, which defaults to `null`): Apply replaygain pre-amplification. (default: 0.)
+- `replaygain_noclip` (of type `bool?`, which defaults to `null`): Apply replaygain clipping prevention. (default: true)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.volumedetect`
+
+Ffmpeg filter: Detect audio volume.
+
+Type:
+
+```
+(ffmpeg.filter.graph, ffmpeg.filter.audio) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+### `ffmpeg.filter.volumedetect.create`
+
+Ffmpeg filter: Detect audio volume.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.audio`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.audio) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vstack`
+
+Ffmpeg filter: Stack video inputs vertically. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.vstack.create`
+
+Ffmpeg filter: Stack video inputs vertically. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.vstack_vaapi`
+
+Ffmpeg filter: "VA-API" vstack This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ?width : int?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): Force termination when the shortest input terminates. (default: false)
+- `width` (of type `int?`, which defaults to `null`): Set output width (0 to use the width of input 0). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.vstack_vaapi.create`
+
+Ffmpeg filter: "VA-API" vstack This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ?width : int?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): Force termination when the shortest input terminates. (default: false)
+- `width` (of type `int?`, which defaults to `null`): Set output width (0 to use the width of input 0). (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.w3fdif`
+
+Ffmpeg filter: Apply Martin Weston three field deinterlace.
+
+Type:
+
+```
+(?filter : int?, ?mode : int?, ?parity : int?, ?deint : int?,
+ ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `filter` (of type `int?`, which defaults to `null`): specify the filter. (default: 1, possible values: 0 (simple), 1 (complex))
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 1, possible values: 0 (frame), 1 (field))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.w3fdif.create`
+
+Ffmpeg filter: Apply Martin Weston three field deinterlace.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?filter : int?, ?mode : int?, ?parity : int?, ?deint : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `filter` (of type `int?`, which defaults to `null`): specify the filter. (default: 1, possible values: 0 (simple), 1 (complex))
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 1, possible values: 0 (frame), 1 (field))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.waveform`
+
+Ffmpeg filter: Video waveform monitor.
+
+Type:
+
+```
+(?mode : int?, ?m : int?, ?intensity : float?, ?i : float?, ?mirror : bool?,
+ ?r : bool?, ?display : int?, ?d : int?, ?components : int?, ?c : int?,
+ ?envelope : int?, ?e : int?, ?filter : int?, ?f : int?, ?graticule : int?,
+ ?g : int?, ?opacity : float?, ?o : float?, ?flags : int?, ?fl : int?,
+ ?scale : int?, ?s : int?, ?bgopacity : float?, ?b : float?, ?tint0 : float?,
+ ?t0 : float?, ?tint1 : float?, ?t1 : float?, ?fitmode : int?, ?fm : int?,
+ ?input : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 1, possible values: 0 (row), 1 (column))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 1, possible values: 0 (row), 1 (column))
+- `intensity` (of type `float?`, which defaults to `null`): set intensity. (default: 0.04)
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 0.04)
+- `mirror` (of type `bool?`, which defaults to `null`): set mirroring. (default: true)
+- `r` (of type `bool?`, which defaults to `null`): set mirroring. (default: true)
+- `display` (of type `int?`, which defaults to `null`): set display mode. (default: 1, possible values: 0 (overlay), 1 (stack), 2 (parade))
+- `d` (of type `int?`, which defaults to `null`): set display mode. (default: 1, possible values: 0 (overlay), 1 (stack), 2 (parade))
+- `components` (of type `int?`, which defaults to `null`): set components to display. (default: 1)
+- `c` (of type `int?`, which defaults to `null`): set components to display. (default: 1)
+- `envelope` (of type `int?`, which defaults to `null`): set envelope to display. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `e` (of type `int?`, which defaults to `null`): set envelope to display. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `filter` (of type `int?`, which defaults to `null`): set filter. (default: 0, possible values: 0 (lowpass), 1 (flat), 2 (aflat), 3 (chroma), 4 (color), 5 (acolor), 6 (xflat), 7 (yflat))
+- `f` (of type `int?`, which defaults to `null`): set filter. (default: 0, possible values: 0 (lowpass), 1 (flat), 2 (aflat), 3 (chroma), 4 (color), 5 (acolor), 6 (xflat), 7 (yflat))
+- `graticule` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (orange), 3 (invert))
+- `g` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (orange), 3 (invert))
+- `opacity` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `o` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `flags` (of type `int?`, which defaults to `null`): set graticule flags. (default: 1, possible values: 1 (numbers), 2 (dots))
+- `fl` (of type `int?`, which defaults to `null`): set graticule flags. (default: 1, possible values: 1 (numbers), 2 (dots))
+- `scale` (of type `int?`, which defaults to `null`): set scale. (default: 0, possible values: 0 (digital), 1 (millivolts), 2 (ire))
+- `s` (of type `int?`, which defaults to `null`): set scale. (default: 0, possible values: 0 (digital), 1 (millivolts), 2 (ire))
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.75)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.75)
+- `tint0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `t0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `tint1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `t1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `fitmode` (of type `int?`, which defaults to `null`): set fit mode. (default: 0, possible values: 0 (none), 1 (size))
+- `fm` (of type `int?`, which defaults to `null`): set fit mode. (default: 0, possible values: 0 (none), 1 (size))
+- `input` (of type `int?`, which defaults to `null`): set input formats selection. (default: 1, possible values: 0 (all), 1 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.waveform.create`
+
+Ffmpeg filter: Video waveform monitor.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?m : int?, ?intensity : float?, ?i : float?, ?mirror : bool?,
+ ?r : bool?, ?display : int?, ?d : int?, ?components : int?, ?c : int?,
+ ?envelope : int?, ?e : int?, ?filter : int?, ?f : int?, ?graticule : int?,
+ ?g : int?, ?opacity : float?, ?o : float?, ?flags : int?, ?fl : int?,
+ ?scale : int?, ?s : int?, ?bgopacity : float?, ?b : float?, ?tint0 : float?,
+ ?t0 : float?, ?tint1 : float?, ?t1 : float?, ?fitmode : int?, ?fm : int?,
+ ?input : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): set mode. (default: 1, possible values: 0 (row), 1 (column))
+- `m` (of type `int?`, which defaults to `null`): set mode. (default: 1, possible values: 0 (row), 1 (column))
+- `intensity` (of type `float?`, which defaults to `null`): set intensity. (default: 0.04)
+- `i` (of type `float?`, which defaults to `null`): set intensity. (default: 0.04)
+- `mirror` (of type `bool?`, which defaults to `null`): set mirroring. (default: true)
+- `r` (of type `bool?`, which defaults to `null`): set mirroring. (default: true)
+- `display` (of type `int?`, which defaults to `null`): set display mode. (default: 1, possible values: 0 (overlay), 1 (stack), 2 (parade))
+- `d` (of type `int?`, which defaults to `null`): set display mode. (default: 1, possible values: 0 (overlay), 1 (stack), 2 (parade))
+- `components` (of type `int?`, which defaults to `null`): set components to display. (default: 1)
+- `c` (of type `int?`, which defaults to `null`): set components to display. (default: 1)
+- `envelope` (of type `int?`, which defaults to `null`): set envelope to display. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `e` (of type `int?`, which defaults to `null`): set envelope to display. (default: 0, possible values: 0 (none), 1 (instant), 2 (peak), 3 (peak+instant))
+- `filter` (of type `int?`, which defaults to `null`): set filter. (default: 0, possible values: 0 (lowpass), 1 (flat), 2 (aflat), 3 (chroma), 4 (color), 5 (acolor), 6 (xflat), 7 (yflat))
+- `f` (of type `int?`, which defaults to `null`): set filter. (default: 0, possible values: 0 (lowpass), 1 (flat), 2 (aflat), 3 (chroma), 4 (color), 5 (acolor), 6 (xflat), 7 (yflat))
+- `graticule` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (orange), 3 (invert))
+- `g` (of type `int?`, which defaults to `null`): set graticule. (default: 0, possible values: 0 (none), 1 (green), 2 (orange), 3 (invert))
+- `opacity` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `o` (of type `float?`, which defaults to `null`): set graticule opacity. (default: 0.75)
+- `flags` (of type `int?`, which defaults to `null`): set graticule flags. (default: 1, possible values: 1 (numbers), 2 (dots))
+- `fl` (of type `int?`, which defaults to `null`): set graticule flags. (default: 1, possible values: 1 (numbers), 2 (dots))
+- `scale` (of type `int?`, which defaults to `null`): set scale. (default: 0, possible values: 0 (digital), 1 (millivolts), 2 (ire))
+- `s` (of type `int?`, which defaults to `null`): set scale. (default: 0, possible values: 0 (digital), 1 (millivolts), 2 (ire))
+- `bgopacity` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.75)
+- `b` (of type `float?`, which defaults to `null`): set background opacity. (default: 0.75)
+- `tint0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `t0` (of type `float?`, which defaults to `null`): set 1st tint. (default: 0.)
+- `tint1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `t1` (of type `float?`, which defaults to `null`): set 2nd tint. (default: 0.)
+- `fitmode` (of type `int?`, which defaults to `null`): set fit mode. (default: 0, possible values: 0 (none), 1 (size))
+- `fm` (of type `int?`, which defaults to `null`): set fit mode. (default: 0, possible values: 0 (none), 1 (size))
+- `input` (of type `int?`, which defaults to `null`): set input formats selection. (default: 1, possible values: 0 (all), 1 (first))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.weave`
+
+Ffmpeg filter: Weave input video fields into frames.
+
+Type:
+
+```
+(?first_field : int?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): set first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.weave.create`
+
+Ffmpeg filter: Weave input video fields into frames.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?first_field : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `first_field` (of type `int?`, which defaults to `null`): set first field. (default: 0, possible values: 0 (top), 0 (t), 1 (bottom), 1 (b))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xbr`
+
+Ffmpeg filter: Scale the input using xBR algorithm.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set scale factor. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.xbr.create`
+
+Ffmpeg filter: Scale the input using xBR algorithm.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?n : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `n` (of type `int?`, which defaults to `null`): set scale factor. (default: 3)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xcorrelate`
+
+Ffmpeg filter: Cross-correlate first video stream with second video stream.
+
+Type:
+
+```
+(?planes : int?, ?secondary : int?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to cross-correlate. (default: 7)
+- `secondary` (of type `int?`, which defaults to `null`): when to process secondary frame. (default: 1, possible values: 0 (first), 1 (all))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.xcorrelate.create`
+
+Ffmpeg filter: Cross-correlate first video stream with second video stream.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?planes : int?, ?secondary : int?, ?eof_action : int?, ?shortest : bool?,
+ ?repeatlast : bool?, ?ts_sync_mode : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `planes` (of type `int?`, which defaults to `null`): set planes to cross-correlate. (default: 7)
+- `secondary` (of type `int?`, which defaults to `null`): when to process secondary frame. (default: 1, possible values: 0 (first), 1 (all))
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xfade`
+
+Ffmpeg filter: Cross fade one video with another video.
+
+Type:
+
+```
+(?transition : int?, ?duration : int?, ?offset : int?, ?expr : string?,
+ ffmpeg.filter.graph, ffmpeg.filter.video, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `transition` (of type `int?`, which defaults to `null`): set cross fade transition. (default: 0, possible values: -1 (custom), 0 (fade), 1 (wipeleft), 2 (wiperight), 3 (wipeup), 4 (wipedown), 5 (slideleft), 6 (slideright), 7 (slideup), 8 (slidedown), 9 (circlecrop), 10 (rectcrop), 11 (distance), 12 (fadeblack), 13 (fadewhite), 14 (radial), 15 (smoothleft), 16 (smoothright), 17 (smoothup), 18 (smoothdown), 19 (circleopen), 20 (circleclose), 21 (vertopen), 22 (vertclose), 23 (horzopen), 24 (horzclose), 25 (dissolve), 26 (pixelize), 27 (diagtl), 28 (diagtr), 29 (diagbl), 30 (diagbr), 31 (hlslice), 32 (hrslice), 33 (vuslice), 34 (vdslice), 35 (hblur), 36 (fadegrays), 37 (wipetl), 38 (wipetr), 39 (wipebl), 40 (wipebr), 41 (squeezeh), 42 (squeezev), 43 (zoomin), 44 (fadefast), 45 (fadeslow), 46 (hlwind), 47 (hrwind), 48 (vuwind), 49 (vdwind), 50 (coverleft), 51 (coverright), 52 (coverup), 53 (coverdown), 54 (revealleft), 55 (revealright), 56 (revealup), 57 (revealdown))
+- `duration` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 1000000)
+- `offset` (of type `int?`, which defaults to `null`): set cross fade start relative to first input stream. (default: 0)
+- `expr` (of type `string?`, which defaults to `null`): set expression for custom transition
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.xfade.create`
+
+Ffmpeg filter: Cross fade one video with another video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?transition : int?, ?duration : int?, ?offset : int?, ?expr : string?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `transition` (of type `int?`, which defaults to `null`): set cross fade transition. (default: 0, possible values: -1 (custom), 0 (fade), 1 (wipeleft), 2 (wiperight), 3 (wipeup), 4 (wipedown), 5 (slideleft), 6 (slideright), 7 (slideup), 8 (slidedown), 9 (circlecrop), 10 (rectcrop), 11 (distance), 12 (fadeblack), 13 (fadewhite), 14 (radial), 15 (smoothleft), 16 (smoothright), 17 (smoothup), 18 (smoothdown), 19 (circleopen), 20 (circleclose), 21 (vertopen), 22 (vertclose), 23 (horzopen), 24 (horzclose), 25 (dissolve), 26 (pixelize), 27 (diagtl), 28 (diagtr), 29 (diagbl), 30 (diagbr), 31 (hlslice), 32 (hrslice), 33 (vuslice), 34 (vdslice), 35 (hblur), 36 (fadegrays), 37 (wipetl), 38 (wipetr), 39 (wipebl), 40 (wipebr), 41 (squeezeh), 42 (squeezev), 43 (zoomin), 44 (fadefast), 45 (fadeslow), 46 (hlwind), 47 (hrwind), 48 (vuwind), 49 (vdwind), 50 (coverleft), 51 (coverright), 52 (coverup), 53 (coverdown), 54 (revealleft), 55 (revealright), 56 (revealup), 57 (revealdown))
+- `duration` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 1000000)
+- `offset` (of type `int?`, which defaults to `null`): set cross fade start relative to first input stream. (default: 0)
+- `expr` (of type `string?`, which defaults to `null`): set expression for custom transition
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xfade_opencl`
+
+Ffmpeg filter: Cross fade one video with another video.
+
+Type:
+
+```
+(?transition : int?, ?source : string?, ?kernel : string?, ?duration : int?,
+ ?offset : int?, ffmpeg.filter.graph, ffmpeg.filter.video,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `transition` (of type `int?`, which defaults to `null`): set cross fade transition. (default: 1, possible values: 0 (custom), 1 (fade), 2 (wipeleft), 3 (wiperight), 4 (wipeup), 5 (wipedown), 6 (slideleft), 7 (slideright), 8 (slideup), 9 (slidedown))
+- `source` (of type `string?`, which defaults to `null`): set OpenCL program source file for custom transition
+- `kernel` (of type `string?`, which defaults to `null`): set kernel name in program file for custom transition
+- `duration` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 1000000)
+- `offset` (of type `int?`, which defaults to `null`): set cross fade start relative to first input stream. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.xfade_opencl.create`
+
+Ffmpeg filter: Cross fade one video with another video.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?transition : int?, ?source : string?, ?kernel : string?, ?duration : int?,
+ ?offset : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `transition` (of type `int?`, which defaults to `null`): set cross fade transition. (default: 1, possible values: 0 (custom), 1 (fade), 2 (wipeleft), 3 (wiperight), 4 (wipeup), 5 (wipedown), 6 (slideleft), 7 (slideright), 8 (slideup), 9 (slidedown))
+- `source` (of type `string?`, which defaults to `null`): set OpenCL program source file for custom transition
+- `kernel` (of type `string?`, which defaults to `null`): set kernel name in program file for custom transition
+- `duration` (of type `int?`, which defaults to `null`): set cross fade duration. (default: 1000000)
+- `offset` (of type `int?`, which defaults to `null`): set cross fade start relative to first input stream. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video, ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xmedian`
+
+Ffmpeg filter: Pick median pixels from several video inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?planes : int?, ?percentile : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph, [ffmpeg.filter.audio], [ffmpeg.filter.video]) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 3)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `percentile` (of type `float?`, which defaults to `null`): set percentile. (default: 0.5)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.xmedian.create`
+
+Ffmpeg filter: Pick median pixels from several video inputs. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?planes : int?, ?percentile : float?, ?eof_action : int?,
+ ?shortest : bool?, ?repeatlast : bool?, ?ts_sync_mode : int?,
+ ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 3)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 15)
+- `percentile` (of type `float?`, which defaults to `null`): set percentile. (default: 0.5)
+- `eof_action` (of type `int?`, which defaults to `null`): Action to take when encountering EOF from secondary input . (default: 0, possible values: 0 (repeat), 1 (endall), 2 (pass))
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `repeatlast` (of type `bool?`, which defaults to `null`): extend last frame of secondary streams beyond EOF. (default: true)
+- `ts_sync_mode` (of type `int?`, which defaults to `null`): How strictly to sync streams based on secondary input timestamps. (default: 0, possible values: 0 (default), 1 (nearest))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xstack`
+
+Ffmpeg filter: Stack video inputs into custom layout. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?layout : string?, ?grid : string?, ?shortest : bool?,
+ ?fill : string?, ffmpeg.filter.graph, [ffmpeg.filter.audio],
+ [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `layout` (of type `string?`, which defaults to `null`): set custom layout
+- `grid` (of type `string?`, which defaults to `null`): set fixed size grid layout
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `fill` (of type `string?`, which defaults to `null`): set the color for unused pixels. (default: none)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.xstack.create`
+
+Ffmpeg filter: Stack video inputs into custom layout. This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?layout : string?, ?grid : string?, ?shortest : bool?,
+ ?fill : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): set number of inputs. (default: 2)
+- `layout` (of type `string?`, which defaults to `null`): set custom layout
+- `grid` (of type `string?`, which defaults to `null`): set fixed size grid layout
+- `shortest` (of type `bool?`, which defaults to `null`): force termination when the shortest input terminates. (default: false)
+- `fill` (of type `string?`, which defaults to `null`): set the color for unused pixels. (default: none)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.xstack_vaapi`
+
+Ffmpeg filter: "VA-API" xstack This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ?layout : string?, ?grid : string?,
+ ?grid_tile_size : string?, ?fill : string?, ffmpeg.filter.graph,
+ [ffmpeg.filter.audio], [ffmpeg.filter.video]) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): Force termination when the shortest input terminates. (default: false)
+- `layout` (of type `string?`, which defaults to `null`): Set custom layout
+- `grid` (of type `string?`, which defaults to `null`): set fixed size grid layout
+- `grid_tile_size` (of type `string?`, which defaults to `null`): set tile size in grid layout
+- `fill` (of type `string?`, which defaults to `null`): Set the color for unused pixels. (default: none)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `[ffmpeg.filter.audio]`)
+- `(unlabeled)` (of type `[ffmpeg.filter.video]`)
+
+### `ffmpeg.filter.xstack_vaapi.create`
+
+Ffmpeg filter: "VA-API" xstack This filter has dynamic inputs: last two arguments are lists of audio and video inputs. Total number of inputs is determined at runtime.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?inputs : int?, ?shortest : bool?, ?layout : string?, ?grid : string?,
+ ?grid_tile_size : string?, ?fill : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `inputs` (of type `int?`, which defaults to `null`): Set number of inputs. (default: 2)
+- `shortest` (of type `bool?`, which defaults to `null`): Force termination when the shortest input terminates. (default: false)
+- `layout` (of type `string?`, which defaults to `null`): Set custom layout
+- `grid` (of type `string?`, which defaults to `null`): set fixed size grid layout
+- `grid_tile_size` (of type `string?`, which defaults to `null`): set tile size in grid layout
+- `fill` (of type `string?`, which defaults to `null`): Set the color for unused pixels. (default: none)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `([ffmpeg.filter.audio], [ffmpeg.filter.video]) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.yadif`
+
+Ffmpeg filter: Deinterlace the input image.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 0, possible values: 0 (send_frame), 1 (send_field), 2 (send_frame_nospatial), 3 (send_field_nospatial))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.yadif.create`
+
+Ffmpeg filter: Deinterlace the input image.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 0, possible values: 0 (send_frame), 1 (send_field), 2 (send_frame_nospatial), 3 (send_field_nospatial))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.yadif_cuda`
+
+Ffmpeg filter: Deinterlace CUDA frames
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 0, possible values: 0 (send_frame), 1 (send_field), 2 (send_frame_nospatial), 3 (send_field_nospatial))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.yadif_cuda.create`
+
+Ffmpeg filter: Deinterlace CUDA frames. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?mode : int?, ?parity : int?, ?deint : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `mode` (of type `int?`, which defaults to `null`): specify the interlacing mode. (default: 0, possible values: 0 (send_frame), 1 (send_field), 2 (send_frame_nospatial), 3 (send_field_nospatial))
+- `parity` (of type `int?`, which defaults to `null`): specify the assumed picture field parity. (default: -1, possible values: 0 (tff), 1 (bff), -1 (auto))
+- `deint` (of type `int?`, which defaults to `null`): specify which frames to deinterlace. (default: 0, possible values: 0 (all), 1 (interlaced))
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.yaepblur`
+
+Ffmpeg filter: Yet another edge preserving blur filter.
+
+Type:
+
+```
+(?radius : int?, ?r : int?, ?planes : int?, ?p : int?, ?sigma : int?,
+ ?s : int?, ffmpeg.filter.graph, ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set window radius. (default: 3)
+- `r` (of type `int?`, which defaults to `null`): set window radius. (default: 3)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `p` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `sigma` (of type `int?`, which defaults to `null`): set blur strength. (default: 128)
+- `s` (of type `int?`, which defaults to `null`): set blur strength. (default: 128)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.yaepblur.create`
+
+Ffmpeg filter: Yet another edge preserving blur filter.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?radius : int?, ?r : int?, ?planes : int?, ?p : int?, ?sigma : int?,
+ ?s : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `radius` (of type `int?`, which defaults to `null`): set window radius. (default: 3)
+- `r` (of type `int?`, which defaults to `null`): set window radius. (default: 3)
+- `planes` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `p` (of type `int?`, which defaults to `null`): set planes to filter. (default: 1)
+- `sigma` (of type `int?`, which defaults to `null`): set blur strength. (default: 128)
+- `s` (of type `int?`, which defaults to `null`): set blur strength. (default: 128)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.yuvtestsrc`
+
+Ffmpeg filter: Generate YUV test pattern.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.yuvtestsrc.create`
+
+Ffmpeg filter: Generate YUV test pattern.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.zmq`
+
+Ffmpeg filter: Receive commands through ZMQ and broker them to filters.
+
+Type:
+
+```
+(?bind_address : string?, ?b : string?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `bind_address` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `b` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.zmq.create`
+
+Ffmpeg filter: Receive commands through ZMQ and broker them to filters.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?bind_address : string?, ?b : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `bind_address` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `b` (of type `string?`, which defaults to `null`): set bind address. (default: tcp://*:5555)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.zoneplate`
+
+Ffmpeg filter: Generate zone-plate.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?precision : int?, ?xo : int?,
+ ?yo : int?, ?to : int?, ?k0 : int?, ?kx : int?, ?ky : int?, ?kt : int?,
+ ?kxt : int?, ?kyt : int?, ?kxy : int?, ?kx2 : int?, ?ky2 : int?,
+ ?kt2 : int?, ?ku : int?, ?kv : int?, ffmpeg.filter.graph) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `precision` (of type `int?`, which defaults to `null`): set LUT precision. (default: 10)
+- `xo` (of type `int?`, which defaults to `null`): set X-axis offset. (default: 0)
+- `yo` (of type `int?`, which defaults to `null`): set Y-axis offset. (default: 0)
+- `to` (of type `int?`, which defaults to `null`): set T-axis offset. (default: 0)
+- `k0` (of type `int?`, which defaults to `null`): set 0-order phase. (default: 0)
+- `kx` (of type `int?`, which defaults to `null`): set 1-order X-axis phase. (default: 0)
+- `ky` (of type `int?`, which defaults to `null`): set 1-order Y-axis phase. (default: 0)
+- `kt` (of type `int?`, which defaults to `null`): set 1-order T-axis phase. (default: 0)
+- `kxt` (of type `int?`, which defaults to `null`): set X-axis*T-axis product phase. (default: 0)
+- `kyt` (of type `int?`, which defaults to `null`): set Y-axis*T-axis product phase. (default: 0)
+- `kxy` (of type `int?`, which defaults to `null`): set X-axis*Y-axis product phase. (default: 0)
+- `kx2` (of type `int?`, which defaults to `null`): set 2-order X-axis phase. (default: 0)
+- `ky2` (of type `int?`, which defaults to `null`): set 2-order Y-axis phase. (default: 0)
+- `kt2` (of type `int?`, which defaults to `null`): set 2-order T-axis phase. (default: 0)
+- `ku` (of type `int?`, which defaults to `null`): set 0-order U-color phase. (default: 0)
+- `kv` (of type `int?`, which defaults to `null`): set 0-order V-color phase. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+### `ffmpeg.filter.zoneplate.create`
+
+Ffmpeg filter: Generate zone-plate.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?size : string?, ?s : string?, ?rate : string?, ?r : string?,
+ ?duration : int?, ?d : int?, ?sar : string?, ?precision : int?, ?xo : int?,
+ ?yo : int?, ?to : int?, ?k0 : int?, ?kx : int?, ?ky : int?, ?kt : int?,
+ ?kxt : int?, ?kyt : int?, ?kxy : int?, ?kx2 : int?, ?ky2 : int?,
+ ?kt2 : int?, ?ku : int?, ?kv : int?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `size` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `s` (of type `string?`, which defaults to `null`): set video size. (default: 320x240)
+- `rate` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `r` (of type `string?`, which defaults to `null`): set video rate. (default: 25)
+- `duration` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `d` (of type `int?`, which defaults to `null`): set video duration. (default: -1)
+- `sar` (of type `string?`, which defaults to `null`): set video sample aspect ratio. (default: 1/1)
+- `precision` (of type `int?`, which defaults to `null`): set LUT precision. (default: 10)
+- `xo` (of type `int?`, which defaults to `null`): set X-axis offset. (default: 0)
+- `yo` (of type `int?`, which defaults to `null`): set Y-axis offset. (default: 0)
+- `to` (of type `int?`, which defaults to `null`): set T-axis offset. (default: 0)
+- `k0` (of type `int?`, which defaults to `null`): set 0-order phase. (default: 0)
+- `kx` (of type `int?`, which defaults to `null`): set 1-order X-axis phase. (default: 0)
+- `ky` (of type `int?`, which defaults to `null`): set 1-order Y-axis phase. (default: 0)
+- `kt` (of type `int?`, which defaults to `null`): set 1-order T-axis phase. (default: 0)
+- `kxt` (of type `int?`, which defaults to `null`): set X-axis*T-axis product phase. (default: 0)
+- `kyt` (of type `int?`, which defaults to `null`): set Y-axis*T-axis product phase. (default: 0)
+- `kxy` (of type `int?`, which defaults to `null`): set X-axis*Y-axis product phase. (default: 0)
+- `kx2` (of type `int?`, which defaults to `null`): set 2-order X-axis phase. (default: 0)
+- `ky2` (of type `int?`, which defaults to `null`): set 2-order Y-axis phase. (default: 0)
+- `kt2` (of type `int?`, which defaults to `null`): set 2-order T-axis phase. (default: 0)
+- `ku` (of type `int?`, which defaults to `null`): set 0-order U-color phase. (default: 0)
+- `kv` (of type `int?`, which defaults to `null`): set 0-order V-color phase. (default: 0)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `() -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.zoompan`
+
+Ffmpeg filter: Apply Zoom & Pan effect.
+
+Type:
+
+```
+(?zoom : string?, ?z : string?, ?x : string?, ?y : string?, ?d : string?,
+ ?s : string?, ?fps : string?, ffmpeg.filter.graph, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `zoom` (of type `string?`, which defaults to `null`): set the zoom expression. (default: 1)
+- `z` (of type `string?`, which defaults to `null`): set the zoom expression. (default: 1)
+- `x` (of type `string?`, which defaults to `null`): set the x expression. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y expression. (default: 0)
+- `d` (of type `string?`, which defaults to `null`): set the duration expression. (default: 90)
+- `s` (of type `string?`, which defaults to `null`): set the output image size. (default: hd720)
+- `fps` (of type `string?`, which defaults to `null`): set the output framerate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.zoompan.create`
+
+Ffmpeg filter: Apply Zoom & Pan effect.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?zoom : string?, ?z : string?, ?x : string?, ?y : string?, ?d : string?,
+ ?s : string?, ?fps : string?, ffmpeg.filter.graph) -> unit
+```
+
+Arguments:
+
+- `zoom` (of type `string?`, which defaults to `null`): set the zoom expression. (default: 1)
+- `z` (of type `string?`, which defaults to `null`): set the zoom expression. (default: 1)
+- `x` (of type `string?`, which defaults to `null`): set the x expression. (default: 0)
+- `y` (of type `string?`, which defaults to `null`): set the y expression. (default: 0)
+- `d` (of type `string?`, which defaults to `null`): set the duration expression. (default: 90)
+- `s` (of type `string?`, which defaults to `null`): set the output image size. (default: hd720)
+- `fps` (of type `string?`, which defaults to `null`): set the output framerate. (default: 25)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+### `ffmpeg.filter.zscale`
+
+Ffmpeg filter: Apply resizing, colorspace and bit depth conversion.
+
+Type:
+
+```
+(?w : string?, ?width : string?, ?h : string?, ?height : string?,
+ ?size : string?, ?s : string?, ?dither : int?, ?d : int?, ?filter : int?,
+ ?f : int?, ?out_range : int?, ?range : int?, ?r : int?, ?primaries : int?,
+ ?p : int?, ?transfer : int?, ?t : int?, ?matrix : int?, ?m : int?,
+ ?in_range : int?, ?rangein : int?, ?rin : int?, ?primariesin : int?,
+ ?pin : int?, ?transferin : int?, ?tin : int?, ?matrixin : int?, ?min : int?,
+ ?chromal : int?, ?c : int?, ?chromalin : int?, ?cin : int?, ?npl : float?,
+ ?agamma : bool?, ?param_a : float?, ?param_b : float?, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width
+- `width` (of type `string?`, which defaults to `null`): Output video width
+- `h` (of type `string?`, which defaults to `null`): Output video height
+- `height` (of type `string?`, which defaults to `null`): Output video height
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `dither` (of type `int?`, which defaults to `null`): set dither type. (default: 0, possible values: 0 (none), 1 (ordered), 2 (random), 3 (error_diffusion))
+- `d` (of type `int?`, which defaults to `null`): set dither type. (default: 0, possible values: 0 (none), 1 (ordered), 2 (random), 3 (error_diffusion))
+- `filter` (of type `int?`, which defaults to `null`): set filter type. (default: 1, possible values: 0 (point), 1 (bilinear), 2 (bicubic), 3 (spline16), 4 (spline36), 5 (lanczos))
+- `f` (of type `int?`, which defaults to `null`): set filter type. (default: 1, possible values: 0 (point), 1 (bilinear), 2 (bicubic), 3 (spline16), 4 (spline36), 5 (lanczos))
+- `out_range` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `range` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `r` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `primaries` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `p` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `transfer` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `t` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `matrix` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `m` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `in_range` (of type `int?`, which defaults to `null`): set input color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `rangein` (of type `int?`, which defaults to `null`): set input color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `rin` (of type `int?`, which defaults to `null`): set input color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `primariesin` (of type `int?`, which defaults to `null`): set input color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `pin` (of type `int?`, which defaults to `null`): set input color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `transferin` (of type `int?`, which defaults to `null`): set input transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `tin` (of type `int?`, which defaults to `null`): set input transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `matrixin` (of type `int?`, which defaults to `null`): set input colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `min` (of type `int?`, which defaults to `null`): set input colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `chromal` (of type `int?`, which defaults to `null`): set output chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `c` (of type `int?`, which defaults to `null`): set output chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `chromalin` (of type `int?`, which defaults to `null`): set input chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `cin` (of type `int?`, which defaults to `null`): set input chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `npl` (of type `float?`, which defaults to `null`): set nominal peak luminance. (default: nan)
+- `agamma` (of type `bool?`, which defaults to `null`): allow approximate gamma. (default: true)
+- `param_a` (of type `float?`, which defaults to `null`): parameter A, which is parameter "b" for bicubic, and the number of filter taps for lanczos. (default: nan)
+- `param_b` (of type `float?`, which defaults to `null`): parameter B, which is parameter "c" for bicubic. (default: nan)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `ffmpeg.filter.zscale.create`
+
+Ffmpeg filter: Apply resizing, colorspace and bit depth conversion.. Use this operator to initiate the filter independently of its inputs, to be able to send commands to the filter instance.
+
+Type:
+
+```
+(?w : string?, ?width : string?, ?h : string?, ?height : string?,
+ ?size : string?, ?s : string?, ?dither : int?, ?d : int?, ?filter : int?,
+ ?f : int?, ?out_range : int?, ?range : int?, ?r : int?, ?primaries : int?,
+ ?p : int?, ?transfer : int?, ?t : int?, ?matrix : int?, ?m : int?,
+ ?in_range : int?, ?rangein : int?, ?rin : int?, ?primariesin : int?,
+ ?pin : int?, ?transferin : int?, ?tin : int?, ?matrixin : int?, ?min : int?,
+ ?chromal : int?, ?c : int?, ?chromalin : int?, ?cin : int?, ?npl : float?,
+ ?agamma : bool?, ?param_a : float?, ?param_b : float?, ffmpeg.filter.graph) ->
+unit
+```
+
+Arguments:
+
+- `w` (of type `string?`, which defaults to `null`): Output video width
+- `width` (of type `string?`, which defaults to `null`): Output video width
+- `h` (of type `string?`, which defaults to `null`): Output video height
+- `height` (of type `string?`, which defaults to `null`): Output video height
+- `size` (of type `string?`, which defaults to `null`): set video size
+- `s` (of type `string?`, which defaults to `null`): set video size
+- `dither` (of type `int?`, which defaults to `null`): set dither type. (default: 0, possible values: 0 (none), 1 (ordered), 2 (random), 3 (error_diffusion))
+- `d` (of type `int?`, which defaults to `null`): set dither type. (default: 0, possible values: 0 (none), 1 (ordered), 2 (random), 3 (error_diffusion))
+- `filter` (of type `int?`, which defaults to `null`): set filter type. (default: 1, possible values: 0 (point), 1 (bilinear), 2 (bicubic), 3 (spline16), 4 (spline36), 5 (lanczos))
+- `f` (of type `int?`, which defaults to `null`): set filter type. (default: 1, possible values: 0 (point), 1 (bilinear), 2 (bicubic), 3 (spline16), 4 (spline36), 5 (lanczos))
+- `out_range` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `range` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `r` (of type `int?`, which defaults to `null`): set color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `primaries` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `p` (of type `int?`, which defaults to `null`): set color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `transfer` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `t` (of type `int?`, which defaults to `null`): set transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `matrix` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `m` (of type `int?`, which defaults to `null`): set colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `in_range` (of type `int?`, which defaults to `null`): set input color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `rangein` (of type `int?`, which defaults to `null`): set input color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `rin` (of type `int?`, which defaults to `null`): set input color range. (default: -1, possible values: -1 (input), 0 (limited), 1 (full), -1 (unknown), 0 (tv), 1 (pc))
+- `primariesin` (of type `int?`, which defaults to `null`): set input color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `pin` (of type `int?`, which defaults to `null`): set input color primaries. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (170m), 7 (240m), 9 (2020), 2 (unknown), 1 (bt709), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (film), 9 (bt2020), 10 (smpte428), 11 (smpte431), 12 (smpte432), 22 (jedec-p22), 22 (ebu3213))
+- `transferin` (of type `int?`, which defaults to `null`): set input transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `tin` (of type `int?`, which defaults to `null`): set input transfer characteristic. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 6 (601), 8 (linear), 14 (2020_10), 15 (2020_12), 2 (unknown), 4 (bt470m), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 1 (bt709), 8 (linear), 9 (log100), 10 (log316), 14 (bt2020-10), 15 (bt2020-12), 16 (smpte2084), 11 (iec61966-2-4), 13 (iec61966-2-1), 18 (arib-std-b67))
+- `matrixin` (of type `int?`, which defaults to `null`): set input colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `min` (of type `int?`, which defaults to `null`): set input colorspace matrix. (default: -1, possible values: -1 (input), 1 (709), 2 (unspecified), 5 (470bg), 6 (170m), 9 (2020_ncl), 10 (2020_cl), 2 (unknown), 0 (gbr), 1 (bt709), 4 (fcc), 5 (bt470bg), 6 (smpte170m), 7 (smpte240m), 8 (ycgco), 9 (bt2020nc), 10 (bt2020c), 12 (chroma-derived-nc), 13 (chroma-derived-c), 14 (ictcp))
+- `chromal` (of type `int?`, which defaults to `null`): set output chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `c` (of type `int?`, which defaults to `null`): set output chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `chromalin` (of type `int?`, which defaults to `null`): set input chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `cin` (of type `int?`, which defaults to `null`): set input chroma location. (default: -1, possible values: -1 (input), 0 (left), 1 (center), 2 (topleft), 3 (top), 4 (bottomleft), 5 (bottom))
+- `npl` (of type `float?`, which defaults to `null`): set nominal peak luminance. (default: nan)
+- `agamma` (of type `bool?`, which defaults to `null`): allow approximate gamma. (default: true)
+- `param_a` (of type `float?`, which defaults to `null`): parameter A, which is parameter "b" for bicubic, and the number of filter taps for lanczos. (default: nan)
+- `param_b` (of type `float?`, which defaults to `null`): parameter B, which is parameter "c" for bicubic. (default: nan)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+
+Methods:
+
+- `output` (of type `ffmpeg.filter.video`): Filter output(s)
+- `process_command` (of type `(?fast : bool, string, string) -> string`): `process_command(?fast, "command", "argument")` sends the given command to this filter. Set `fast` to `true` to only execute the command when it is fast.
+- `set_input` (of type `(ffmpeg.filter.video) -> unit`): Set the filter's input(s)
+
+## Source / Fade
+
+### `fade.skip`
+
+Fade when the metadata trigger is received and then skip.
+
+Type:
+
+```
+(?id : string, ?duration : float, ?curve : float?,
+ ?override_duration : string, ?override_type : string,
+ ?override_curve : string, ?persist_overrides : bool,
+ ?override_skip : string, ?initial_metadata : [string * string],
+ ?type : string, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"fade.skip"`): Force the value of the source ID.
+- `duration` (of type `float`, which defaults to `5.`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override.
+- `curve` (of type `float?`, which defaults to `null`): Fade curve. Default if `null`.
+- `override_duration` (of type `string`, which defaults to `"liq_fade_skip"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for the current track.
+- `override_type` (of type `string`, which defaults to `"liq_fade_skip_type"`): Metadata field which, if present and correct, overrides the 'type' parameter for the current track.
+- `override_curve` (of type `string`, which defaults to `"liq_fade_skip_curve"`): Metadata field which, if presents and correct, overrides the `curve` parameter for the current track. Use `"default"` to set to default value.
+- `persist_overrides` (of type `bool`, which defaults to `false`): Keep duration and type overrides on track change.
+- `override_skip` (of type `string`, which defaults to `"liq_skip_meta"`): Metadata field which, when present and set to "true", will trigger the fade
+- `initial_metadata` (of type `[string * string]`, which defaults to `[]`): Initial metadata.
+- `type` (of type `string`, which defaults to `"lin"`): Fader shape (lin|sin|log|exp): linear, sinusoidal, logarithmic or exponential.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fade_duration` (of type `() -> float`): 
+- `fade_type` (of type `() -> string`): 
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `smooth_add`
+
+Mixes two streams, with faded transitions between the state when only the normal stream is available and when the special stream gets added on top of it.
+
+Type:
+
+```
+(?duration : float, ?p : {float}, normal : source(audio=pcm('a), 'b),
+ special : source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `duration` (of type `float`, which defaults to `1.`): Duration of the fade in seconds.
+- `p` (of type `{float}`, which defaults to `0.2`): Portion of amplitude of the normal source in the mix.
+- `normal` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): The normal source, which could be called the carrier too.
+- `special` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): The special source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Input
+
+### `input.mplayer`
+
+Stream data from mplayer.
+
+Type:
+
+```
+(?id : string, ?restart : bool, ?restart_on_error : bool, ?buffer : float,
+ ?max : float, string) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"input.mplayer"`)
+- `restart` (of type `bool`, which defaults to `true`): restart on exit.
+- `restart_on_error` (of type `bool`, which defaults to `false`): restart on exit with error.
+- `buffer` (of type `float`, which defaults to `0.2`): Duration of the pre-buffered data.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `(unlabeled)` (of type `string`): data URI.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Output
+
+### `output.external.ffmpeg`
+
+Output to ffmpeg.
+
+Type:
+
+```
+(?id : string?, ?show_command : bool, ?flush : bool, ?fallible : bool,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit),
+ ?reopen_on_metadata : (([string * string]) -> bool),
+ ?reopen_on_error : ((error
+                      .{
+                        kind : string,
+                        message : string,
+                        trace : [
+                                 {
+                                   position_end : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   position_start : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   to_string : (?prefix : string) -> string
+                                 }]
+                      }?) -> float?),
+ ?reopen_when : (() -> bool), ?reopen_delay : {float},
+ ?on_reopen : (() -> unit), ?start : bool, string, source(audio=pcm(stereo),
+ video=canvas)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `show_command` (of type `bool`, which defaults to `false`)
+- `flush` (of type `bool`, which defaults to `false`): Perform a flush after each write.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `reopen_on_metadata` (of type `([string * string]) -> bool`, which defaults to `fun (_) -> false`): Callback called on metadata. If returned value is `true`, the file is reopened.
+- `reopen_on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }?) -> float?`, which defaults to `<fun>`): Callback called when there is an error. Error is raised when returning `null`. Otherwise, the file is reopened after the returned value, in seconds.
+- `reopen_when` (of type `() -> bool`, which defaults to `{false}`): Callback called on each frame. If returned value is `true`, the file is reopened.
+- `reopen_delay` (of type `{float}`, which defaults to `120.`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
+- `on_reopen` (of type `() -> unit`, which defaults to `{()}`): Callback executed when the output is reopened.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If true, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `source(audio=pcm(stereo), video=canvas)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reopen` (of type `() -> unit`): Reopen the output pipe. The actual reopening happens the next time the output has some data to output.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.file.dash`
+
+Output an MPEG-DASH playlist.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?codec : string, ?bitrate : int, ?start : bool,
+ ?playlist : string, directory : string, source(audio=pcm(stereo))) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `codec` (of type `string`, which defaults to `"libmp3lame"`): Codec to use for audio (following FFmpeg's conventions).
+- `bitrate` (of type `int`, which defaults to `128`)
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If true, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `playlist` (of type `string`, which defaults to `"stream.mpd"`): Playlist name
+- `directory` (of type `string`): Directory to write to
+- `(unlabeled)` (of type `source(audio=pcm(stereo))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reopen` (of type `() -> unit`): Reopen the output pipe. The actual reopening happens the next time the output has some data to output.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.file.dash.ffmpeg`
+
+Output an MPEG-DASH playlist using ffmpeg
+
+Type:
+
+```
+(?id : string?, ?flush : bool, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit),
+ ?reopen_on_metadata : (([string * string]) -> bool),
+ ?reopen_on_error : ((error
+                      .{
+                        kind : string,
+                        message : string,
+                        trace : [
+                                 {
+                                   position_end : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   position_start : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   to_string : (?prefix : string) -> string
+                                 }]
+                      }?) -> float?),
+ ?reopen_when : (() -> bool), ?reopen_delay : {float},
+ ?on_reopen : (() -> unit), ?start : bool, ?playlist : string,
+ directory : string, source(audio=pcm(stereo), video=canvas)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `flush` (of type `bool`, which defaults to `false`): Perform a flush after each write.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `reopen_on_metadata` (of type `([string * string]) -> bool`, which defaults to `fun (_) -> false`): Callback called on metadata. If returned value is `true`, the file is reopened.
+- `reopen_on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }?) -> float?`, which defaults to `<fun>`): Callback called when there is an error. Error is raised when returning `null`. Otherwise, the file is reopened after the returned value, in seconds.
+- `reopen_when` (of type `() -> bool`, which defaults to `{false}`): Callback called on each frame. If returned value is `true`, the file is reopened.
+- `reopen_delay` (of type `{float}`, which defaults to `120.`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
+- `on_reopen` (of type `() -> unit`, which defaults to `{()}`): Callback executed when the output is reopened.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If true, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `playlist` (of type `string`, which defaults to `"stream.mpd"`): Playlist name
+- `directory` (of type `string`): Directory to write to
+- `(unlabeled)` (of type `source(audio=pcm(stereo), video=canvas)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reopen` (of type `() -> unit`): Reopen the output pipe. The actual reopening happens the next time the output has some data to output.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.file.hls.ffmpeg`
+
+Output a HLS playlist using ffmpeg
+
+Type:
+
+```
+(?id : string?, ?flush : bool, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit),
+ ?reopen_on_metadata : (([string * string]) -> bool),
+ ?reopen_on_error : ((error
+                      .{
+                        kind : string,
+                        message : string,
+                        trace : [
+                                 {
+                                   position_end : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   position_start : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   to_string : (?prefix : string) -> string
+                                 }]
+                      }?) -> float?),
+ ?reopen_when : (() -> bool), ?reopen_delay : {float},
+ ?on_reopen : (() -> unit), ?start : bool, ?playlist : string,
+ directory : string, source(audio=pcm(stereo), video=canvas)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `flush` (of type `bool`, which defaults to `false`): Perform a flush after each write.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `reopen_on_metadata` (of type `([string * string]) -> bool`, which defaults to `fun (_) -> false`): Callback called on metadata. If returned value is `true`, the file is reopened.
+- `reopen_on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }?) -> float?`, which defaults to `<fun>`): Callback called when there is an error. Error is raised when returning `null`. Otherwise, the file is reopened after the returned value, in seconds.
+- `reopen_when` (of type `() -> bool`, which defaults to `{false}`): Callback called on each frame. If returned value is `true`, the file is reopened.
+- `reopen_delay` (of type `{float}`, which defaults to `120.`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
+- `on_reopen` (of type `() -> unit`, which defaults to `{()}`): Callback executed when the output is reopened.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If true, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `playlist` (of type `string`, which defaults to `"stream.m3u8"`): Playlist name
+- `directory` (of type `string`): Directory to write to
+- `(unlabeled)` (of type `source(audio=pcm(stereo), video=canvas)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reopen` (of type `() -> unit`): Reopen the output pipe. The actual reopening happens the next time the output has some data to output.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Sound synthesis
+
+### `dtmf`
+
+Generate DTMF tones.
+
+Type:
+
+```
+(?duration : float, ?delay : float, string) -> source(audio='a)
+where
+  'a is a track of type: pcm, pcm_s16 or pcm_f32 and a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks
+```
+
+Arguments:
+
+- `duration` (of type `float`, which defaults to `0.1`): Duration of a tone (in seconds).
+- `delay` (of type `float`, which defaults to `0.05`): Dealy between two successive tones (in seconds).
+- `(unlabeled)` (of type `string`): String describing DTMF tones to generates: it should contains characters 0 to 9, A to D, or * or #.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `metronome`
+
+Indicate beats.
+
+Type:
+
+```
+(?frequency : float, ?float) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `frequency` (of type `float`, which defaults to `440.`): Frequency of the sound.
+- `(unlabeled)` (of type `float`, which defaults to `60.`): Number of beats per minute.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Track processing
+
+### `chop`
+
+Regularly insert track boundaries in a stream (useful for testing tracks).
+
+Type:
+
+```
+(?every : {float}, ?metadata : {[string * string]}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `every` (of type `{float}`, which defaults to `3.`): Duration of a track (in seconds).
+- `metadata` (of type `{[string * string]}`, which defaults to `[]`): Metadata for tracks.
+- `(unlabeled)` (of type `source('a)`): The stream.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `fallback.skip`
+
+Special track insensitive fallback that always skips current song before switching.
+
+Type:
+
+```
+(source('a), ?fallback : source('a)?) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a) where 'a is a set of internal tracks`): The main source.
+- `fallback` (of type `source('a)? where 'a is a set of internal tracks`, which defaults to `null`): The fallback source. Defaults to `blank` if `null`.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `map_first_track`
+
+Apply a function to the first track of a source
+
+Type:
+
+```
+(?id : string?, ((source('a)) -> source('a)), source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"map_first_track"`): Force the value of the source ID.
+- `(unlabeled)` (of type `(source('a)) -> source('a)`): The applied function.
+- `(unlabeled)` (of type `source('a)`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `native.fallback`
+
+At the beginning of each track, select the first ready child.
+
+Type:
+
+```
+(?id : string?, ?track_sensitive : bool, [source('a)]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `track_sensitive` (of type `bool`, which defaults to `true`): Re-select only on end of tracks.
+- `(unlabeled)` (of type `[source('a)]`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(source('A)) -> unit`): Set the source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `native.once`
+
+Create a source that plays only one track of the input source.
+
+Type:
+
+```
+(source('a)) -> source('a)
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `native.sequence`
+
+Play only one track of every successive source, except for the last one which is played as much as available.
+
+Type:
+
+```
+(?id : string?,
+ [source('a)
+  .{
+    buffered : () -> [string * float],
+    duration : () -> float,
+    elapsed : () -> float,
+    fallible : bool,
+    id : () -> string,
+    is_active : () -> bool,
+    is_ready : () -> bool,
+    is_up : () -> bool,
+    last_metadata : () -> [string * string]?,
+    log : 
+    {level : (() -> int?).{set : (int) -> unit}
+    },
+    on_metadata : ((([string * string]) -> unit)) -> unit,
+    on_shutdown : ((() -> unit)) -> unit,
+    on_track : ((([string * string]) -> unit)) -> unit,
+    on_wake_up : ((() -> unit)) -> unit,
+    remaining : () -> float,
+    seek : (float) -> float,
+    self_sync : () -> bool,
+    skip : () -> unit,
+    time : () -> float
+  }]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `[source('a)
+ .{
+   buffered : () -> [string * float],
+   duration : () -> float,
+   elapsed : () -> float,
+   fallible : bool,
+   id : () -> string,
+   is_active : () -> bool,
+   is_ready : () -> bool,
+   is_up : () -> bool,
+   last_metadata : () -> [string * string]?,
+   log : 
+   {level : (() -> int?).{set : (int) -> unit}
+   },
+   on_metadata : ((([string * string]) -> unit)) -> unit,
+   on_shutdown : ((() -> unit)) -> unit,
+   on_track : ((([string * string]) -> unit)) -> unit,
+   on_wake_up : ((() -> unit)) -> unit,
+   remaining : () -> float,
+   seek : (float) -> float,
+   self_sync : () -> bool,
+   skip : () -> unit,
+   time : () -> float
+ }]`): List of sources to play tracks from.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `native.switch`
+
+Select the first source whose predicate is true in a list. If the second argument is a getter, the source will be dynamically created.
+
+Type:
+
+```
+(?id : string?, ?track_sensitive : bool, [{bool} * source('a)]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `track_sensitive` (of type `bool`, which defaults to `true`): Re-select only on end of tracks.
+- `(unlabeled)` (of type `[{bool} * source('a)]`): Sources with the predicate telling when they can be played.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(source('A)) -> unit`): Set the source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `notify_metadata`
+
+Use notify to display metadata info.
+
+Type:
+
+```
+(?urgency : string, ?icon : string, ?timeout : float,
+ ?display : (([string * string]) -> string), ?title : string, 'b
+ .{on_metadata : ((([string * string]) -> unit)) -> 'a}) -> 'a
+```
+
+Arguments:
+
+- `urgency` (of type `string`, which defaults to `"low"`): Urgency (low|normal|critical).
+- `icon` (of type `string`, which defaults to `"stock_smiley-22"`): Icon filename or stock icon to display.
+- `timeout` (of type `float`, which defaults to `3.`): Timeout in seconds.
+- `display` (of type `([string * string]) -> string`, which defaults to `<fun>`): Function used to display a metadata packet.
+- `title` (of type `string`, which defaults to `"Liquidsoap: new track"`): Title of the notification message.
+- `(unlabeled)` (of type `'b.{on_metadata : ((([string * string]) -> unit)) -> 'a}`)
+
+### `osd_metadata`
+
+Use X On Screen Display to display metadata info.
+
+Type:
+
+```
+(?color : string, ?position : string, ?font : string,
+ ?display : (([string * string]) -> string), 'b
+ .{on_metadata : ((([string * string]) -> unit)) -> 'a}) -> 'a
+```
+
+Arguments:
+
+- `color` (of type `string`, which defaults to `"green"`): Color of the text.
+- `position` (of type `string`, which defaults to `"top"`): Position of the text (top|middle|bottom).
+- `font` (of type `string`, which defaults to `"-*-courier-*-r-*-*-*-240-*-*-*-*-*-*"`): Font used (xfontsel is your friend...)
+- `display` (of type `([string * string]) -> string`, which defaults to `<fun>`): Function used to display a metadata packet.
+- `(unlabeled)` (of type `'b.{on_metadata : ((([string * string]) -> unit)) -> 'a}`)
+
+### `overlap_sources`
+
+Rotate between overlapping sources. Next track starts according to 'liq_start_next' offset metadata.
+
+Type:
+
+```
+(?id : string?, ?normalize : bool, ?start_next : string,
+ ?weights : [{float}], [source('a)]) -> source('a)
+where
+  'a is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"overlap_sources"`): Force the value of the source ID.
+- `normalize` (of type `bool`, which defaults to `false`)
+- `start_next` (of type `string`, which defaults to `"liq_start_next"`): Metadata field indicating when the next track should start, relative to current track's time.
+- `weights` (of type `[{float}]`, which defaults to `[]`): Relative weight of the sources in the sum. The empty list stands for the homogeneous distribution.
+- `(unlabeled)` (of type `[source('a)]
+where
+  'a is a set of tracks to be muxed into a source and a set of internal tracks`): Sources to toggle from
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Insert metadata in the source. The `new_track` parameter indicates whether a track boundary should also be inserted (by default, no track is inserted).
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `playlog`
+
+Keep a record of played files. This is primarily useful to know when a song was last played and avoid repetitions.
+
+Type:
+
+```
+(?duration : float, ?persistency : string?,
+ ?hash : (([string * string]) -> string)) -> unit
+```
+
+Arguments:
+
+- `duration` (of type `float`, which defaults to `inf`): Duration (in seconds) after which songs are forgotten. By default, songs are not forgotten which means that the playlog will contain all the songs ever played.
+- `persistency` (of type `string?`, which defaults to `null`): Set a file name where the values are stored and loaded in case the script is restarted.
+- `hash` (of type `([string * string]) -> string`, which defaults to `<fun>`): Function to extract an identifier from the metadata. By default, the filename is used but we could return the artist to know when a song from a given artist was last played for instance.
+
+Methods:
+
+- `add` (of type `([string * string]) -> unit`): Record that file with given metadata has been played.
+- `last` (of type `([string * string]) -> float`): How long ago a file was played (in seconds), `infinity` is returned if the song has never been played.
+
+### `rotate.merge`
+
+Same operator as rotate but merges tracks from each sources. For instance, `rotate.merge([intro,main,outro])` creates a source that plays a sequence `[intro,main,outro]` as single track and loops back.
+
+Type:
+
+```
+(?id : string?, ?transitions : [(source('a), source('a)) -> source('a)],
+ ?weights : [{int}], [source('a)]) -> source('a)
+where
+  'a is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"rotate.merge"`): Force the value of the source ID.
+- `transitions` (of type `[(source('a), source('a)) -> source('a)]
+where
+  'a is a set of tracks to be muxed into a source and a set of internal tracks`, which defaults to `[]`): Transition functions, padded with `fun (x,y) -> y` functions.
+- `weights` (of type `[{int}]`, which defaults to `[]`): Weights of the children (padded with 1), defining for each child how many tracks are played from it per round, if that many are actually available.
+- `(unlabeled)` (of type `[source('a)]
+where
+  'a is a set of tracks to be muxed into a source and a set of internal tracks`): Sequence of sources to be merged
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?
+where
+  'A is a set of tracks to be muxed into a source and a set of internal tracks`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `server.insert_metadata`
+
+Register a server/telnet command to update a source's metadata. Returns a new source, which will receive the updated metadata. The command has the following format: insert key1="val1",key2="val2",...
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Insert metadata in the source. The `new_track` parameter indicates whether a track boundary should also be inserted (by default, no track is inserted).
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `skipper`
+
+Regularly skip tracks from a source (useful for testing skipping).
+
+Type:
+
+```
+(?every : {float}, source('a).{skip : () -> unit, time : () -> float}) ->
+source('a)
+```
+
+Arguments:
+
+- `every` (of type `{float}`, which defaults to `5.`): How often to skip tracks.
+- `(unlabeled)` (of type `source('a).{skip : () -> unit, time : () -> float}`): The stream.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Video processing
+
+### `input.external.ffmpeg`
+
+Input from ffmpeg.
+
+Type:
+
+```
+(?id : string, ?show_command : bool, ?restart : bool,
+ ?restart_on_error : bool, ?buffer : float, ?max : float, string) ->
+source(audio=pcm(stereo), video=canvas('a))
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"input.external.ffmpeg"`)
+- `show_command` (of type `bool`, which defaults to `false`)
+- `restart` (of type `bool`, which defaults to `true`): restart on exit.
+- `restart_on_error` (of type `bool`, which defaults to `false`): restart on exit with error.
+- `buffer` (of type `float`, which defaults to `0.2`): Duration of the pre-buffered data.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `(unlabeled)` (of type `string`): ffmpeg options specifying the input
+
+### `video.external.testsrc`
+
+ffmpeg's test source video (useful for testing and debugging).
+
+Type:
+
+```
+(?id : string, ?restart : bool, ?restart_on_error : bool, ?buffer : float,
+ ?max : float, ?framerate : int) -> source(audio=pcm(stereo),
+video=canvas('a))
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"video.external.testsrc"`)
+- `restart` (of type `bool`, which defaults to `true`): restart on exit.
+- `restart_on_error` (of type `bool`, which defaults to `false`): restart on exit with error.
+- `buffer` (of type `float`, which defaults to `0.2`): Duration of the pre-buffered data.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `framerate` (of type `int`, which defaults to `0`)
+
+## Source / Visualization
+
+### `server.rms`
+
+Register a command that outputs the RMS of the returned source.
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): Current value for the RMS volume.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.vumeter`
+
+VU meter: display the audio volume (RMS in dB). This adds a video track to the source.
+
+Type:
+
+```
+(?rms_min : float, ?rms_max : float, ?window : float, ?color : int,
+ ?persistence : float, 'b
+ .{audio : pcm('a), metadata? : metadata, track_marks? : track_marks}) ->
+source(audio=pcm('a), video=canvas('c), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `rms_min` (of type `float`, which defaults to `-35.`): Minimal volume (dB).
+- `rms_max` (of type `float`, which defaults to `0.`): Maximal volume (dB).
+- `window` (of type `float`, which defaults to `0.1`): Duration in seconds of volume computation.
+- `color` (of type `int`, which defaults to `16711680`): Color of the display (0xRRGGBB).
+- `persistence` (of type `float`, which defaults to `0.`): Persistence of the display (s).
+- `(unlabeled)` (of type `'b.{audio : pcm('a), metadata? : metadata, track_marks? : track_marks}
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `vumeter`
+
+VU meter: display the audio volume (RMS in dB) on the standard output.
+
+Type:
+
+```
+(?rms_min : float, ?rms_max : float, ?window : float, ?scroll : bool,
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `rms_min` (of type `float`, which defaults to `-25.`): Minimal volume (dB).
+- `rms_max` (of type `float`, which defaults to `-5.`): Maximal volume (dB).
+- `window` (of type `float`, which defaults to `0.5`): Duration in seconds of volume computation.
+- `scroll` (of type `bool`, which defaults to `false`): Update the display in the same line.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): Current value for the RMS volume.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Uncategorized
+
+### `cross.plot`
+
+Plot the first crossfade transition. Used for visualizing and testing crossfade transitions.
+
+Type:
+
+```
+(?png : 'a?, ?dir : string?, source(audio=pcm('b), 'c)) ->
+source(audio=pcm('b), 'c)
+where
+  'c is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `png` (of type `'a?`, which defaults to `null`)
+- `dir` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(audio=pcm('b), 'c)
+where
+  'c is a set of tracks to be muxed into a source and a set of internal tracks`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `cross_duration` (of type `() -> float`): Get the current crossfade duration.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
diff --git a/website/content/doc-2.2.5/reference-header.md b/website/content/doc-2.2.5/reference-header.md
new file mode 100644
index 00000000..60ff6786
--- /dev/null
+++ b/website/content/doc-2.2.5/reference-header.md
@@ -0,0 +1,15 @@
+# Liquidsoap scripting language reference
+
+The **Source / ...** categories contain all functions that return sources.
+The **Input** functions are those which build elementary sources
+(playing files, synthesizing sound, etc.).
+The **Output** functions are those which take a source and register it
+for being streamed to the outside (file, soundcard, audio server, etc.).
+The **Visualization** functions are experimental ones that let you
+visualize in real-time some aspects of the audio stream.
+The **Sound Processing** functions are those which basically work on the source
+as a continuous audio stream. They would typically be mixers of streams,
+audio effects or analysis.
+Finally, **Track Processing** functions are basically all
+others, often having a behaviour that depends on or affects the extra
+information that liquidsoap puts in streams: track limits and metadata.
diff --git a/website/content/doc-2.2.5/reference.md b/website/content/doc-2.2.5/reference.md
new file mode 100644
index 00000000..94f110ed
--- /dev/null
+++ b/website/content/doc-2.2.5/reference.md
@@ -0,0 +1,21668 @@
+# Liquidsoap scripting language reference
+
+The **Source / ...** categories contain all functions that return sources.
+The **Input** functions are those which build elementary sources
+(playing files, synthesizing sound, etc.).
+The **Output** functions are those which take a source and register it
+for being streamed to the outside (file, soundcard, audio server, etc.).
+The **Visualization** functions are experimental ones that let you
+visualize in real-time some aspects of the audio stream.
+The **Sound Processing** functions are those which basically work on the source
+as a continuous audio stream. They would typically be mixers of streams,
+audio effects or analysis.
+Finally, **Track Processing** functions are basically all
+others, often having a behaviour that depends on or affects the extra
+information that liquidsoap puts in streams: track limits and metadata.
+
+- [Bool](#bool)
+- [Configuration](#configuration)
+- [File](#file)
+- [Getter](#getter)
+- [Interaction](#interaction)
+- [Internet](#internet)
+- [Liquidsoap](#liquidsoap)
+- [List](#list)
+- [Math](#math)
+- [Metadata](#metadata)
+- [Programming](#programming)
+- [Settings](#settings)
+- [Source / Audio processing](#source-audio-processing)
+- [Source / Conversion](#source-conversion)
+- [Source / FFmpeg filter](#source-ffmpeg-filter)
+- [Source / Fade](#source-fade)
+- [Source / Input](#source-input)
+- [Source / Liquidsoap](#source-liquidsoap)
+- [Source / MIDI processing](#source-midi-processing)
+- [Source / Output](#source-output)
+- [Source / Sound synthesis](#source-sound-synthesis)
+- [Source / Testing](#source-testing)
+- [Source / Track processing](#source-track-processing)
+- [Source / Video processing](#source-video-processing)
+- [Source / Visualization](#source-visualization)
+- [String](#string)
+- [System](#system)
+- [Time](#time)
+- [Track / Audio processing](#track-audio-processing)
+- [Track / Conversion](#track-conversion)
+- [Track / FFmpeg filter](#track-ffmpeg-filter)
+- [Track / Track processing](#track-track-processing)
+- [Track / Video processing](#track-video-processing)
+- [Uncategorized](#uncategorized)
+
+## Bool
+
+### `!=`
+
+Comparison of comparable values.
+
+Type:
+
+```
+('a, 'a) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `<`
+
+Comparison of comparable values.
+
+Type:
+
+```
+('a, 'a) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `<=`
+
+Comparison of comparable values.
+
+Type:
+
+```
+('a, 'a) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `==`
+
+Comparison of comparable values.
+
+Type:
+
+```
+('a, 'a) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `>`
+
+Comparison of comparable values.
+
+Type:
+
+```
+('a, 'a) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `>=`
+
+Comparison of comparable values.
+
+Type:
+
+```
+('a, 'a) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `and`
+
+Return the conjunction of its arguments
+
+Type:
+
+```
+({bool}, {bool}) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{bool}`)
+- `(unlabeled)` (of type `{bool}`)
+
+### `not`
+
+Returns the negation of its argument.
+
+Type:
+
+```
+(bool) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `bool`)
+
+### `or`
+
+Return the disjunction of its arguments
+
+Type:
+
+```
+({bool}, {bool}) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{bool}`)
+- `(unlabeled)` (of type `{bool}`)
+
+### `random.bool`
+
+Generate a random boolean.
+
+Type:
+
+```
+() -> bool
+```
+
+## Configuration
+
+### `configure.bindir`
+
+Liquidsoap's Internal script directory.
+
+Type:
+
+```
+string
+```
+
+### `configure.default_font`
+
+Liquidsoap's default font file.
+
+Type:
+
+```
+string
+```
+
+### `configure.libdir`
+
+Liquidsoap's library directory.
+
+Type:
+
+```
+string
+```
+
+### `configure.logdir`
+
+Liquidsoap's logging directory.
+
+Type:
+
+```
+string
+```
+
+### `configure.rundir`
+
+Liquidsoap's PID file directory.
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.architecture`
+
+Build-time configuration value for architecture
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.git_sha`
+
+Git sha used to compile liquidsoap.
+
+Type:
+
+```
+string?
+```
+
+### `liquidsoap.build_config.host`
+
+Build-time configuration value for host
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.is_release`
+
+Is this build a release build?
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.is_snapshot`
+
+Is this build a development snapshot?
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.native_c_compiler`
+
+Build-time configuration value for native_c_compiler
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.native_c_libraries`
+
+Build-time configuration value for native_c_libraries
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.ocaml_version`
+
+OCaml version used to compile liquidspap.
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.ocamlopt_cflags`
+
+Build-time configuration value for ocamlopt_cflags
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.optionals.alsa`
+
+Build-time configuration for alsa
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.ao`
+
+Build-time configuration for ao
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.bjack`
+
+Build-time configuration for bjack
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.camlimages`
+
+Build-time configuration for camlimages
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.dssi`
+
+Build-time configuration for dssi
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.faad`
+
+Build-time configuration for faad
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.fdkaac`
+
+Build-time configuration for fdkaac
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.ffmpeg`
+
+Build-time configuration for ffmpeg
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.flac`
+
+Build-time configuration for flac
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.frei0r`
+
+Build-time configuration for frei0r
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.gd`
+
+Build-time configuration for gd
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.graphics`
+
+Build-time configuration for graphics
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.gstreamer`
+
+Build-time configuration for gstreamer
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.imagelib`
+
+Build-time configuration for imagelib
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.inotify`
+
+Build-time configuration for inotify
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.irc`
+
+Build-time configuration for irc
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.ladspa`
+
+Build-time configuration for ladspa
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.lame`
+
+Build-time configuration for lame
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.lastfm`
+
+Build-time configuration for lastfm
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.lilv`
+
+Build-time configuration for lilv
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.lo`
+
+Build-time configuration for lo
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.mad`
+
+Build-time configuration for mad
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.mem_usage`
+
+Build-time configuration for mem_usage
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.memtrace`
+
+Build-time configuration for memtrace
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.ogg`
+
+Build-time configuration for ogg
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.opus`
+
+Build-time configuration for opus
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.osc`
+
+Build-time configuration for osc
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.oss`
+
+Build-time configuration for oss
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.portaudio`
+
+Build-time configuration for portaudio
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.posix_time2`
+
+Build-time configuration for posix_time2
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.prometheus`
+
+Build-time configuration for prometheus
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.pulseaudio`
+
+Build-time configuration for pulseaudio
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.samplerate`
+
+Build-time configuration for samplerate
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.sdl`
+
+Build-time configuration for sdl
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.shine`
+
+Build-time configuration for shine
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.soundtouch`
+
+Build-time configuration for soundtouch
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.speex`
+
+Build-time configuration for speex
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.srt`
+
+Build-time configuration for srt
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.ssl`
+
+Build-time configuration for ssl
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.taglib`
+
+Build-time configuration for taglib
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.theora`
+
+Build-time configuration for theora
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.tls`
+
+Build-time configuration for tls
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.vorbis`
+
+Build-time configuration for vorbis
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.winsvc`
+
+Build-time configuration for winsvc
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.optionals.xmlplaylist`
+
+Build-time configuration for xmlplaylist
+
+Type:
+
+```
+bool
+```
+
+### `liquidsoap.build_config.system`
+
+Build-time configuration value for system
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.build_config.target`
+
+Build-time configuration value for target
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.version`
+
+Liquidsoap version string.
+
+Type:
+
+```
+string
+```
+
+## File
+
+### `file.contents`
+
+Read the whole contents of a file.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.copy`
+
+Copy a file. Arguments and implementation follows the POSIX `cp` command line specifications.
+
+Type:
+
+```
+(?recursive : bool, ?force : bool, ?preserve : bool, string, string) -> unit
+```
+
+Arguments:
+
+- `recursive` (of type `bool`, which defaults to `false`): Copy file hierarchies.
+- `force` (of type `bool`, which defaults to `false`): If a file descriptor for a destination file cannot be obtained attempt to unlink the destination file and proceed.
+- `preserve` (of type `bool`, which defaults to `false`): Duplicate source files attributes in the destination file.
+- `(unlabeled)` (of type `string`): Source
+- `(unlabeled)` (of type `string`): Destination
+
+### `file.digest`
+
+Return an MD5 digest for the given file.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.download`
+
+Download file using a regular http.get request. Returns `true` on success.
+
+Type:
+
+```
+(filename : string, ?timeout : float, string) -> bool
+```
+
+Arguments:
+
+- `filename` (of type `string`): Downloaded filename.
+- `timeout` (of type `float`, which defaults to `5.`): Timeout in seconds
+- `(unlabeled)` (of type `string`)
+
+### `file.exists`
+
+Returns true if the file or directory exists.
+
+Type:
+
+```
+(string) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.extension`
+
+Returns a file's extension.
+
+Type:
+
+```
+(?dir_sep : string, ?leading_dot : bool, string) -> string
+```
+
+Arguments:
+
+- `dir_sep` (of type `string`, which defaults to `"/"`): Directory separator.
+- `leading_dot` (of type `bool`, which defaults to `true`): Return extension with a leading dot, e.g. `.foo`.
+- `(unlabeled)` (of type `string`)
+
+### `file.getter`
+
+Getter to the contents of a file.
+
+Type:
+
+```
+(string) -> () -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Name of the file from which the contents should be taken.
+
+### `file.getter.float`
+
+Float getter from a file.
+
+Type:
+
+```
+(?default : float, string) -> {float}
+```
+
+Arguments:
+
+- `default` (of type `float`, which defaults to `0.`): Default value when the file contains invalid data.
+- `(unlabeled)` (of type `string`): Name of the file from which the contents should be taken.
+
+### `file.is_directory`
+
+Returns true if the file exists and is a directory.
+
+Type:
+
+```
+(string) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.iterator`
+
+Iterate over the contents of a file.
+
+Type:
+
+```
+(string) -> () -> string?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.lines`
+
+Get the list of lines of a file.
+
+Type:
+
+```
+(string) -> [string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.lines.iterator`
+
+Iterate over the lines of a file.
+
+Type:
+
+```
+(string) -> () -> string?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.ls`
+
+List all the files in a directory.
+
+Type:
+
+```
+(?absolute : bool, ?recursive : bool, ?pattern : string?, ?sorted : bool,
+ string) -> [string]
+```
+
+Arguments:
+
+- `absolute` (of type `bool`, which defaults to `false`): Whether to return absolute paths.
+- `recursive` (of type `bool`, which defaults to `false`): Whether to look recursively in subdirectories.
+- `pattern` (of type `string?`, which defaults to `null`): Pattern that the filenames should match (e.g. `"*.mp3"`).
+- `sorted` (of type `bool`, which defaults to `false`): Return results in a sorted order.
+- `(unlabeled)` (of type `string`): Directory to look in.
+
+### `file.metadata`
+
+Read metadata from a file.
+
+Type:
+
+```
+(string, ?exclude : [string]) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+- `exclude` (of type `[string]`, which defaults to `[]`): Decoders to exclude
+
+### `file.metadata.ffmpeg`
+
+Read metadata from a file using the ffmpeg decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.flac`
+
+Read metadata from a file using the flac decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.flac_native`
+
+Read metadata from a file using the flac_native decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.id3`
+
+Read metadata from a file using the id3 decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.id3v1`
+
+Read metadata from a file using the id3v1 decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.id3v2`
+
+Read metadata from a file using the id3v2 decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.image`
+
+Read metadata from a file using the image decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.mp4`
+
+Read metadata from a file using the mp4 decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.native`
+
+Read metadata from a file using the native decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.ogg`
+
+Read metadata from a file using the ogg decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.ogg_native`
+
+Read metadata from a file using the ogg_native decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.taglib`
+
+Read metadata from a file using the taglib decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.metadata.video-metadata`
+
+Read metadata from a file using the video-metadata decoder.
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the metadata should be read.
+
+### `file.mime`
+
+Get a file's mime type. Uses libmagic if enabled, otherwise try to get the value using the file binary. Returns `null()` if no value can be found.
+
+Type:
+
+```
+(string) -> string?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): The file to test
+
+### `file.mime.cli`
+
+Get a file's mime type by calling the `file` command line binary.
+
+Type:
+
+```
+(string) -> string?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.mime.magic`
+
+Get the MIME type of a file.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.mkdir`
+
+Create a directory.
+
+Type:
+
+```
+(?perms : int, string) -> unit
+```
+
+Arguments:
+
+- `perms` (of type `int`, which defaults to `493`): Default file rights if created (default is `0o755`).
+- `(unlabeled)` (of type `string`)
+
+### `file.move`
+
+Move a file
+
+Type:
+
+```
+(?force : bool, string, string) -> unit
+```
+
+Arguments:
+
+- `force` (of type `bool`, which defaults to `false`): Do not prompt for confirmation if the destination path exists.
+- `(unlabeled)` (of type `string`): Source
+- `(unlabeled)` (of type `string`): Destination
+
+### `file.mtime`
+
+Last modification time.
+
+Type:
+
+```
+(string) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.open`
+
+Open a file.
+
+Type:
+
+```
+(?write : bool, ?create : bool?, ?append : bool, ?non_blocking : bool,
+ ?perms : int, string) -> socket
+```
+
+Arguments:
+
+- `write` (of type `bool`, which defaults to `false`): Open file for writing
+- `create` (of type `bool?`, which defaults to `null`): Create if nonexistent. Default: `false` in read-only mode, `true` when writing.
+- `append` (of type `bool`, which defaults to `false`): Append data if file exists.
+- `non_blocking` (of type `bool`, which defaults to `false`): Open in non-blocking mode.
+- `perms` (of type `int`, which defaults to `420`): Default file rights if created. Default: `0o644`
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `close` (of type `() -> unit`): Close the socket.
+- `non_blocking` (of type `(bool) -> unit`): Set the non-blocking flag on the socket
+- `read` (of type `((?timeout : float?) -> string)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): Read data from a socket. Reading is done when the function returns an empty string `""`.
+- `type` (of type `string`): Socket type
+- `write` (of type `((?timeout : float?, string) -> unit)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): Write data to a socket
+
+### `file.read`
+
+Read the content of a file. Returns a function of type `()->string`. File is done reading when function returns the empty string `""`.
+
+Type:
+
+```
+(string) -> () -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.remove`
+
+Remove a file.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.replaygain`
+
+Compute the ReplayGain for a file (in dB).
+
+Type:
+
+```
+(?id : string?, ?ratio : float, string) -> float?
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `ratio` (of type `float`, which defaults to `50.`): Decoding ratio. A value of `50` means try to decode the file `50x` faster than real time, if possible. Use this setting to lower CPU peaks when computing replaygain tags.
+- `(unlabeled)` (of type `string`): File name.
+
+### `file.rmdir`
+
+Remove a directory and its content.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.size`
+
+File size in bytes.
+
+Type:
+
+```
+(string) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.temp`
+
+Return a fresh temporary filename. The temporary file is created empty, with permissions 0o600 (readable and writable only by the file owner).
+
+Type:
+
+```
+(?cleanup : bool, string, string) -> string
+```
+
+Arguments:
+
+- `cleanup` (of type `bool`, which defaults to `false`): Delete the file on shutdown
+- `(unlabeled)` (of type `string`): File suffix
+- `(unlabeled)` (of type `string`): File prefix
+
+### `file.temp_dir`
+
+Return a fresh temporary directory name. The temporary directory is created empty, in the default tmp directory, with permissions 0o700 (readable, writable and listable only by the file owner).
+
+Type:
+
+```
+(?cleanup : bool, string, ?string) -> string
+```
+
+Arguments:
+
+- `cleanup` (of type `bool`, which defaults to `false`): Delete the file on shutdown
+- `(unlabeled)` (of type `string`): Directory name suffix.
+- `(unlabeled)` (of type `string`, which defaults to `""`): Directory name prefix.
+
+### `file.touch`
+
+Ensure that a file exists, creating it empty if it does not.
+
+Type:
+
+```
+(?perms : int, string) -> unit
+```
+
+Arguments:
+
+- `perms` (of type `int`, which defaults to `420`)
+- `(unlabeled)` (of type `string`): Path of the file.
+
+### `file.umask`
+
+Get the process's file mode creation mask.
+
+Type:
+
+```
+() -> int
+```
+
+### `file.umask.set`
+
+Set process's file mode creation mask.
+
+Type:
+
+```
+(int) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`)
+
+### `file.watch`
+
+Call a function when a file is modified. Returns unwatch function in `unwatch` method.
+
+Type:
+
+```
+(string, (() -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File to watch.
+- `(unlabeled)` (of type `() -> unit`): Handler function.
+
+Methods:
+
+- `unwatch` (of type `() -> unit`): Function to remove the watch on the file.
+
+### `file.which`
+
+`file.which("progname")` looks for an executable named "progname" using directories from the PATH environment variable and returns "" if it could not find one.
+
+Type:
+
+```
+(string) -> string?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.write`
+
+Write data to a file.
+
+Type:
+
+```
+(data : {string?}, ?perms : int, ?append : bool, string) -> unit
+```
+
+Arguments:
+
+- `data` (of type `{string?}`): Data to write. If passing a callback `() -> string?`, the callback must return `null` or `""` when it has finished sending all its data.
+- `perms` (of type `int`, which defaults to `420`): Default file rights if created. Default: `0o644`.
+- `append` (of type `bool`, which defaults to `false`): Append data if file exists.
+- `(unlabeled)` (of type `string`): Path to write to
+
+### `file.write.stream`
+
+Stream data to a file. Returns a callback to write to the file. Execute with `null` or `""` to signify the end of the writing operation.
+
+Type:
+
+```
+(?perms : int, ?append : bool, string) -> (string?) -> unit
+```
+
+Arguments:
+
+- `perms` (of type `int`, which defaults to `420`): Default file rights if created. Default: `0o644`.
+- `append` (of type `bool`, which defaults to `false`): Append data if file exists.
+- `(unlabeled)` (of type `string`): Path to write to
+
+### `medialib`
+
+A library to store the metadata of files in given folders and query them. This is useful to generate playlists based on metadata.
+
+Type:
+
+```
+(?id : string?, ?persistency : string?, ?refresh : float?,
+ ?standardize : (([string * string]) -> [string * string]),
+ ?initial_progress : bool, ?directories : [string], ?string?) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `persistency` (of type `string?`, which defaults to `null`): Store the database in given file, which is reuse to populate the database on next run.
+- `refresh` (of type `float?`, which defaults to `null`): Scan directories for new files every given number of seconds (by default the database is never updated).
+- `standardize` (of type `([string * string]) -> [string * string]`, which defaults to `<fun>`): Function mapped on metadata when indexing. It can be used to change the field names to standard ones, pretreat data, etc.
+- `initial_progress` (of type `bool`, which defaults to `true`): Show progress of library being indexed at startup.
+- `directories` (of type `[string]`, which defaults to `[]`): Directories to look for files in.
+- `(unlabeled)` (of type `string?`, which defaults to `null`): Directory to look for files in.
+
+Methods:
+
+- `add_directory` (of type `(string) -> unit`): Add a new directory which should be scanned.
+- `clear` (of type `() -> unit`): Remove all known metadata.
+- `find` (of type `(?case_sensitive : bool, ?artist : string?, ?artist_contains : string?,
+ ?artist_matches : string?, ?album : string?, ?genre : string?,
+ ?title : string?, ?title_contains : string?, ?filename : string?,
+ ?filename_contains : string?, ?filename_matches : string?, ?year : int?,
+ ?year_ge : int?, ?year_lt : int?, ?bpm : int?, ?bpm_ge : int?, ?int?,
+ ?predicate : (([string * string]) -> bool)) -> [string]`): Find files according to conditions on metadata.
+- `refresh` (of type `() -> unit`): Update metadatas and look for new files.
+
+### `path.basename`
+
+Get the base name of a path, i.e. the name of the file without the full path. For instance `file.basename("/tmp/folder/bla.mp3")` returns `"bla.mp3"`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `path.concat`
+
+Concatenate two paths, using the appropriate directory separator.
+
+Type:
+
+```
+(string, string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+### `path.dirname`
+
+Get the directory name of a path.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `path.home.unrelate`
+
+Expand path that start with '~' with the current home directory.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `path.remove_extension`
+
+Remove the file extension from a path.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `playlist.files`
+
+Retrieve the list of files contained in a playlist.
+
+Type:
+
+```
+(?id : string?, ?mime_type : string?, ?timeout : float,
+ ?cue_in_metadata : string?, ?cue_out_metadata : string?, string) -> 
+[string]
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `mime_type` (of type `string?`, which defaults to `null`): Default MIME type for the playlist. `null` means automatic detection.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout for resolving the playlist
+- `cue_in_metadata` (of type `string?`, which defaults to `"liq_cue_in"`): Metadata for cue in points. Disabled if `null`.
+- `cue_out_metadata` (of type `string?`, which defaults to `"liq_cue_out"`): Metadata for cue out points. Disabled if `null`.
+- `(unlabeled)` (of type `string`): Path to the playlist
+
+### `socket.unix.client`
+
+Open a named UNIX socket and connect as a client.
+
+Type:
+
+```
+(?non_blocking : bool, string) -> socket
+```
+
+Arguments:
+
+- `non_blocking` (of type `bool`, which defaults to `false`): Open in non-blocking mode.
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `close` (of type `() -> unit`): 
+- `read` (of type `((?timeout : float?) -> string)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): 
+- `type` (of type `string`): 
+- `write` (of type `((?timeout : float?, string) -> unit)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): 
+
+### `socket.unix.listen`
+
+Open a named socket and wait for a client to connect
+
+Type:
+
+```
+(?non_blocking : bool, string) -> socket
+```
+
+Arguments:
+
+- `non_blocking` (of type `bool`, which defaults to `false`): Open in non-blocking mode.
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `close` (of type `() -> unit`): 
+- `read` (of type `((?timeout : float?) -> string)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): 
+- `type` (of type `string`): 
+- `write` (of type `((?timeout : float?, string) -> unit)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): 
+
+## Getter
+
+### `getter`
+
+Create a getter.
+
+Type:
+
+```
+({'a}) -> {'a}
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a}`): Value from which the getter should be created.
+
+### `getter.case`
+
+Return a value depending on whether the getter is constant or not.
+
+Type:
+
+```
+({'a}, (('a) -> 'b), (((() -> 'a)) -> 'b)) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a}`): Getter to inspect.
+- `(unlabeled)` (of type `('a) -> 'b`)
+- `(unlabeled)` (of type `((() -> 'a)) -> 'b`)
+
+### `getter.changes`
+
+Detect whether the value of the getter changes.
+
+Type:
+
+```
+({'a}) -> () -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a} where 'a is an orderable type`)
+
+### `getter.float_of_int`
+
+Convert an int getter to a float getter.
+
+Type:
+
+```
+({int}) -> {float}
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{int}`)
+
+### `getter.function`
+
+Construct a function returning the value of a getter.
+
+Type:
+
+```
+({'a}) -> () -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a}`)
+
+### `getter.get`
+
+Get the value of a getter.
+
+Type:
+
+```
+({'a}) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a}`)
+
+### `getter.int_of_float`
+
+Convert a float getter to a int getter.
+
+Type:
+
+```
+({float}) -> {int}
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{float}`)
+
+### `getter.is_constant`
+
+Determine if a getter is a constant.
+
+Type:
+
+```
+({'a}) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a}`)
+
+### `getter.map`
+
+Apply a function on a getter.
+
+Type:
+
+```
+((('a) -> 'b), {'a}) -> {'b}
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b`): Function to apply.
+- `(unlabeled)` (of type `{'a}`)
+
+### `getter.map.memoize`
+
+Apply a function on a getter. If the input value has not changed compared to last call, the previous result is returned without computing the function again.
+
+Type:
+
+```
+((('a) -> 'b), {'a}) -> {'b} where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b where 'a is an orderable type`): Function to apply.
+- `(unlabeled)` (of type `{'a} where 'a is an orderable type`)
+
+### `getter.merge`
+
+Give the latest value among two getters.
+
+Type:
+
+```
+({'a}, {'a}) -> () -> 'a where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{'a} where 'a is an orderable type`)
+- `(unlabeled)` (of type `{'a} where 'a is an orderable type`)
+
+### `getter.on_change`
+
+Execute a function when the value of the getter changes.
+
+Type:
+
+```
+((('a) -> unit), {'a}) -> () -> 'a where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> unit where 'a is an orderable type`)
+- `(unlabeled)` (of type `{'a} where 'a is an orderable type`)
+
+## Interaction
+
+### `audioscrobbler.nowplaying`
+
+Submit a now playing song using the audioscrobbler protocol.
+
+Type:
+
+```
+(user : string, password : string, ?host : string, ?port : int,
+ ?length : bool, [string * string]) -> unit
+```
+
+Arguments:
+
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `host` (of type `string`, which defaults to `"post.audioscrobbler.com"`): Host for audioscrobbling submissions.
+- `port` (of type `int`, which defaults to `80`): Port for audioscrobbling submissions.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `audioscrobbler.submit`
+
+Submit a played song using the audioscrobbler protocol.
+
+Type:
+
+```
+(?source : string, user : string, password : string, ?host : string,
+ ?port : int, ?length : bool, [string * string]) -> unit
+```
+
+Arguments:
+
+- `source` (of type `string`, which defaults to `"broadcast"`): Source for tracks. Should be one of: "broadcast", "user", "recommendation" or "unknown". Since liquidsoap is intended for radio broadcasting, this is the default. Sources other than user don't need duration to be set.
+- `user` (of type `string`)
+- `password` (of type `string`)
+- `host` (of type `string`, which defaults to `"post.audioscrobbler.com"`): Host for audioscrobbling submissions.
+- `port` (of type `int`, which defaults to `80`): Port for audioscrobbling submissions.
+- `length` (of type `bool`, which defaults to `false`): Try to submit length information. This operation can be CPU intensive. Value forced to true when used with the "user" source type.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `icy.update_metadata`
+
+Update metata on an icecast mountpoint using the ICY protocol.
+
+Type:
+
+```
+(?host : string, ?port : int, ?user : string, ?transport : http_transport,
+ ?password : string, ?mount : string, ?icy_id : int, ?protocol : string,
+ ?encoding : string?, ?headers : [string * string], [string * string]) ->
+unit
+```
+
+Arguments:
+
+- `host` (of type `string`, which defaults to `"localhost"`)
+- `port` (of type `int`, which defaults to `8000`)
+- `user` (of type `string`, which defaults to `"source"`)
+- `transport` (of type `http_transport`, which defaults to `<unix_transport>`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `password` (of type `string`, which defaults to `"hackme"`)
+- `mount` (of type `string`, which defaults to `""`): Source mount point. Mandatory when streaming to icecast.
+- `icy_id` (of type `int`, which defaults to `1`): Shoutcast source ID. Only supported by Shoutcast v2.
+- `protocol` (of type `string`, which defaults to `"http"`): Protocol to use. One of: "icy", "http" or "https"
+- `encoding` (of type `string?`, which defaults to `null`): Encoding used to send metadata, default (UTF-8) if null.
+- `headers` (of type `[string * string]`, which defaults to `[("User-Agent", "Liquidsoap/2.2.5 (Unix; OCaml 4.14.1)")]`): Additional headers.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `osc.bool`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, bool) -> () -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `bool`): Initial value.
+
+### `osc.float`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, float) -> () -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float`): Initial value.
+
+### `osc.float_pair`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, (float * float)) -> () -> float * float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float * float`): Initial value.
+
+### `osc.int`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, int) -> () -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int`): Initial value.
+
+### `osc.int_pair`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, (int * int)) -> () -> int * int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int * int`): Initial value.
+
+### `osc.native.float`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, float) -> () -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float`): Initial value.
+
+### `osc.native.float_pair`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, (float * float)) -> () -> float * float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float * float`): Initial value.
+
+### `osc.native.int`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, int) -> () -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int`): Initial value.
+
+### `osc.native.int_pair`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, (int * int)) -> () -> int * int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int * int`): Initial value.
+
+### `osc.native.on_float`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((float) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(float) -> unit`): Callback function.
+
+### `osc.native.on_float_pair`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, (((float * float)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `((float * float)) -> unit`): Callback function.
+
+### `osc.native.on_int`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((int) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(int) -> unit`): Callback function.
+
+### `osc.native.on_int_pair`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, (((int * int)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `((int * int)) -> unit`): Callback function.
+
+### `osc.native.on_string`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((string) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(string) -> unit`): Callback function.
+
+### `osc.native.on_string_pair`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, (((string * string)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `((string * string)) -> unit`): Callback function.
+
+### `osc.native.send_float`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, float) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float`): Value to send.
+
+### `osc.native.send_float_pair`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, (float * float)) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float * float`): Value to send.
+
+### `osc.native.send_int`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, int) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int`): Value to send.
+
+### `osc.native.send_int_pair`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, (int * int)) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int * int`): Value to send.
+
+### `osc.native.send_string`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, string) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string`): Value to send.
+
+### `osc.native.send_string_pair`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, (string * string)) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string * string`): Value to send.
+
+### `osc.native.string`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, string) -> () -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string`): Initial value.
+
+### `osc.native.string_pair`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, (string * string)) -> () -> string * string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string * string`): Initial value.
+
+### `osc.on_bool`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((bool) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(bool) -> unit`): Callback function.
+
+### `osc.on_float`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((float) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(float) -> unit`): Callback function.
+
+### `osc.on_float_pair`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, (((float * float)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `((float * float)) -> unit`): Callback function.
+
+### `osc.on_int`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((int) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(int) -> unit`): Callback function.
+
+### `osc.on_int_pair`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, (((int * int)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `((int * int)) -> unit`): Callback function.
+
+### `osc.on_string`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, ((string) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `(string) -> unit`): Callback function.
+
+### `osc.on_string_pair`
+
+Register a callback on OSC messages.
+
+Type:
+
+```
+(string, (((string * string)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `((string * string)) -> unit`): Callback function.
+
+### `osc.send_bool`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, bool) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `bool`): Value to send.
+
+### `osc.send_float`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, float) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float`): Value to send.
+
+### `osc.send_float_pair`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, (float * float)) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `float * float`): Value to send.
+
+### `osc.send_int`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, int) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int`): Value to send.
+
+### `osc.send_int_pair`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, (int * int)) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `int * int`): Value to send.
+
+### `osc.send_string`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, string) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string`): Value to send.
+
+### `osc.send_string_pair`
+
+Send a value to an OSC client.
+
+Type:
+
+```
+(host : string, port : int, string, (string * string)) -> unit
+```
+
+Arguments:
+
+- `host` (of type `string`): OSC client address.
+- `port` (of type `int`): OSC client port.
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string * string`): Value to send.
+
+### `osc.string`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, string) -> () -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string`): Initial value.
+
+### `osc.string_pair`
+
+Read from an OSC path.
+
+Type:
+
+```
+(string, (string * string)) -> () -> string * string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): OSC path.
+- `(unlabeled)` (of type `string * string`): Initial value.
+
+### `prometheus.counter`
+
+Register a prometheus counter
+
+Type:
+
+```
+(help : string, ?namespace : string, ?subsystem : string, labels : [string],
+ string) -> (label_values : [string]) -> (float) -> unit
+```
+
+Arguments:
+
+- `help` (of type `string`): Help of the metric
+- `namespace` (of type `string`, which defaults to `""`): namespace of the metric
+- `subsystem` (of type `string`, which defaults to `""`): subsystem of the metric
+- `labels` (of type `[string]`): labels for the metric
+- `(unlabeled)` (of type `string`): Name of the metric
+
+### `prometheus.gauge`
+
+Register a prometheus gauge
+
+Type:
+
+```
+(help : string, ?namespace : string, ?subsystem : string, labels : [string],
+ string) -> (label_values : [string]) -> (float) -> unit
+```
+
+Arguments:
+
+- `help` (of type `string`): Help of the metric
+- `namespace` (of type `string`, which defaults to `""`): namespace of the metric
+- `subsystem` (of type `string`, which defaults to `""`): subsystem of the metric
+- `labels` (of type `[string]`): labels for the metric
+- `(unlabeled)` (of type `string`): Name of the metric
+
+### `prometheus.summary`
+
+Register a prometheus summary
+
+Type:
+
+```
+(help : string, ?namespace : string, ?subsystem : string, labels : [string],
+ string) -> (label_values : [string]) -> (float) -> unit
+```
+
+Arguments:
+
+- `help` (of type `string`): Help of the metric
+- `namespace` (of type `string`, which defaults to `""`): namespace of the metric
+- `subsystem` (of type `string`, which defaults to `""`): subsystem of the metric
+- `labels` (of type `[string]`): labels for the metric
+- `(unlabeled)` (of type `string`): Name of the metric
+
+### `server.register`
+
+Register a command. You can then execute this function through the server, either telnet or socket.
+
+Type:
+
+```
+(?namespace : string?, ?description : string, ?usage : string?, string,
+ ((string) -> string)) -> unit
+```
+
+Arguments:
+
+- `namespace` (of type `string?`, which defaults to `null`): Used to group multiple commands for the same functionality. If specified, the command will be named `namespace.command`.
+- `description` (of type `string`, which defaults to `"No documentation available."`): A description of your command.
+- `usage` (of type `string?`, which defaults to `null`): Description of how the command should be used.
+- `(unlabeled)` (of type `string`): Name of the command.
+- `(unlabeled)` (of type `(string) -> string`): Function called when the command is executed. It takes as argument the argument passed on the commandline and returns the message which will be printed on the commandline.
+
+### `server.telnet`
+
+Enable telnet server.
+
+Type:
+
+```
+(?port : int) -> unit
+```
+
+Arguments:
+
+- `port` (of type `int`, which defaults to `1234`): Port on which we should listen.
+
+## Internet
+
+### `harbor.http.middleware.register`
+
+Register a new harbor middleware
+
+Type:
+
+```
+(((
+   {
+     body : (?timeout : float) -> string,
+     data : (?timeout : float) -> string,
+     headers : [string * string],
+     http_version : string,
+     method : string,
+     path : string,
+     query : [string * string]
+   }, (() -> string)
+   .{
+     content_type : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     data : (({string}) -> unit)
+     .{current : () -> {string}
+     },
+     header : (string, string) -> unit,
+     headers : (([string * string]) -> unit)
+     .{current : () -> [string * string]
+     },
+     html : ({string}) -> unit,
+     http_version : ((string) -> unit)
+     .{current : () -> string
+     },
+     json : (?compact : bool, 'C) -> unit,
+     multipart_form : (?boundary : string?,
+                       [
+                        {
+                          attributes : [string * string],
+                          contents : {string},
+                          headers : ['A * 'B],
+                          name : string
+                        }]) -> unit,
+     redirect : (?status_code : int, string) -> unit,
+     send_status : (socket
+                    .{
+                      close : () -> unit,
+                      non_blocking : (bool) -> unit,
+                      read : ((?timeout : float?) -> string)
+                      .{wait : (?timeout : float?, (() -> unit)) -> unit
+                      },
+                      type : string,
+                      write : (string) -> unit
+                    }) -> unit,
+     status_code : ((int) -> unit)
+     .{current : () -> int
+     },
+     status_message : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     status_sent : () -> bool
+   },
+   ((
+     {
+       body : (?timeout : float) -> string,
+       data : (?timeout : float) -> string,
+       headers : [string * string],
+       http_version : string,
+       method : string,
+       path : string,
+       query : [string * string]
+     }, (() -> string)
+     .{
+       content_type : ((string?) -> unit)
+       .{current : () -> string?
+       },
+       data : (({string}) -> unit)
+       .{current : () -> {string}
+       },
+       header : (string, string) -> unit,
+       headers : (([string * string]) -> unit)
+       .{current : () -> [string * string]
+       },
+       html : ({string}) -> unit,
+       http_version : ((string) -> unit)
+       .{current : () -> string
+       },
+       json : (?compact : bool, 'C) -> unit,
+       multipart_form : (?boundary : string?,
+                         [
+                          {
+                            attributes : [string * string],
+                            contents : {string},
+                            headers : ['A * 'B],
+                            name : string
+                          }]) -> unit,
+       redirect : (?status_code : int, string) -> unit,
+       send_status : (socket
+                      .{
+                        close : () -> unit,
+                        non_blocking : (bool) -> unit,
+                        read : ((?timeout : float?) -> string)
+                        .{wait : (?timeout : float?, (() -> unit)) -> unit
+                        },
+                        type : string,
+                        write : (string) -> unit
+                      }) -> unit,
+       status_code : ((int) -> unit)
+       .{current : () -> int
+       },
+       status_message : ((string?) -> unit)
+       .{current : () -> string?
+       },
+       status_sent : () -> bool
+     }) -> unit)) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(
+ {
+   body : (?timeout : float) -> string,
+   data : (?timeout : float) -> string,
+   headers : [string * string],
+   http_version : string,
+   method : string,
+   path : string,
+   query : [string * string]
+ }, (() -> string)
+ .{
+   content_type : ((string?) -> unit)
+   .{current : () -> string?
+   },
+   data : (({string}) -> unit)
+   .{current : () -> {string}
+   },
+   header : (string, string) -> unit,
+   headers : (([string * string]) -> unit)
+   .{current : () -> [string * string]
+   },
+   html : ({string}) -> unit,
+   http_version : ((string) -> unit)
+   .{current : () -> string
+   },
+   json : (?compact : bool, 'C) -> unit,
+   multipart_form : (?boundary : string?,
+                     [
+                      {
+                        attributes : [string * string],
+                        contents : {string},
+                        headers : ['A * 'B],
+                        name : string
+                      }]) -> unit,
+   redirect : (?status_code : int, string) -> unit,
+   send_status : (socket
+                  .{
+                    close : () -> unit,
+                    non_blocking : (bool) -> unit,
+                    read : ((?timeout : float?) -> string)
+                    .{wait : (?timeout : float?, (() -> unit)) -> unit
+                    },
+                    type : string,
+                    write : (string) -> unit
+                  }) -> unit,
+   status_code : ((int) -> unit)
+   .{current : () -> int
+   },
+   status_message : ((string?) -> unit)
+   .{current : () -> string?
+   },
+   status_sent : () -> bool
+ },
+ ((
+   {
+     body : (?timeout : float) -> string,
+     data : (?timeout : float) -> string,
+     headers : [string * string],
+     http_version : string,
+     method : string,
+     path : string,
+     query : [string * string]
+   }, (() -> string)
+   .{
+     content_type : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     data : (({string}) -> unit)
+     .{current : () -> {string}
+     },
+     header : (string, string) -> unit,
+     headers : (([string * string]) -> unit)
+     .{current : () -> [string * string]
+     },
+     html : ({string}) -> unit,
+     http_version : ((string) -> unit)
+     .{current : () -> string
+     },
+     json : (?compact : bool, 'C) -> unit,
+     multipart_form : (?boundary : string?,
+                       [
+                        {
+                          attributes : [string * string],
+                          contents : {string},
+                          headers : ['A * 'B],
+                          name : string
+                        }]) -> unit,
+     redirect : (?status_code : int, string) -> unit,
+     send_status : (socket
+                    .{
+                      close : () -> unit,
+                      non_blocking : (bool) -> unit,
+                      read : ((?timeout : float?) -> string)
+                      .{wait : (?timeout : float?, (() -> unit)) -> unit
+                      },
+                      type : string,
+                      write : (string) -> unit
+                    }) -> unit,
+     status_code : ((int) -> unit)
+     .{current : () -> int
+     },
+     status_message : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     status_sent : () -> bool
+   }) -> unit)) -> unit`)
+
+### `harbor.http.register`
+
+Register a HTTP handler on the harbor. The handler function receives as argument the full requested information and returns the answer sent to the client, including HTTP headers. This function registers exact path matches, i.e. `"/users"`, `"/index.hml"` as well as fragment matches, i.e. `"/user/:id"`, `"/users/:id/collabs/:cid"`, etc. If you need more advanced matching, use `harbor.http.register.regexp` to match regular expressions. Paths are resolved in the order they are declared and can override default harbor paths such as metadata handlers. The handler receives the request details as a record and a response handler. Matched fragments are reported as part of the response `query` parameter. The response handler can be used to fill up details about the http response, which will be converted into a plain HTTP response string after the handler returns.
+
+Type:
+
+```
+(?port : int, ?transport : http_transport
+ .{default_port : int, name : string, protocol : string}, ?method : string,
+ string,
+ ((
+   {
+     body : (?timeout : float) -> string,
+     data : (?timeout : float) -> string,
+     headers : [string * string],
+     http_version : string,
+     method : string,
+     path : string,
+     query : [string * string]
+   }, (() -> string)
+   .{
+     content_type : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     data : (({string}) -> unit)
+     .{current : () -> {string}
+     },
+     header : (string, string) -> unit,
+     headers : (([string * string]) -> unit)
+     .{current : () -> [string * string]
+     },
+     html : ({string}) -> unit,
+     http_version : ((string) -> unit)
+     .{current : () -> string
+     },
+     json : (?compact : bool, 'C) -> unit,
+     multipart_form : (?boundary : string?,
+                       [
+                        {
+                          attributes : [string * string],
+                          contents : {string},
+                          headers : ['A * 'B],
+                          name : string
+                        }]) -> unit,
+     redirect : (?status_code : int, string) -> unit,
+     send_status : (socket
+                    .{
+                      close : () -> unit,
+                      non_blocking : (bool) -> unit,
+                      read : ((?timeout : float?) -> string)
+                      .{wait : (?timeout : float?, (() -> unit)) -> unit
+                      },
+                      type : string,
+                      write : (string) -> unit
+                    }) -> unit,
+     status_code : ((int) -> unit)
+     .{current : () -> int
+     },
+     status_message : ((string?) -> unit)
+     .{current : () -> string?
+     },
+     status_sent : () -> bool
+   }) -> unit)) -> unit
+```
+
+Arguments:
+
+- `port` (of type `int`, which defaults to `8000`): Port to serve.
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{name="unix", protocol="http", default_port=80}`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `method` (of type `string`, which defaults to `"GET"`): Accepted method ("GET" / "POST" / "PUT" / "DELETE" / "HEAD" / "OPTIONS").
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `(
+ {
+   body : (?timeout : float) -> string,
+   data : (?timeout : float) -> string,
+   headers : [string * string],
+   http_version : string,
+   method : string,
+   path : string,
+   query : [string * string]
+ }, (() -> string)
+ .{
+   content_type : ((string?) -> unit)
+   .{current : () -> string?
+   },
+   data : (({string}) -> unit)
+   .{current : () -> {string}
+   },
+   header : (string, string) -> unit,
+   headers : (([string * string]) -> unit)
+   .{current : () -> [string * string]
+   },
+   html : ({string}) -> unit,
+   http_version : ((string) -> unit)
+   .{current : () -> string
+   },
+   json : (?compact : bool, 'C) -> unit,
+   multipart_form : (?boundary : string?,
+                     [
+                      {
+                        attributes : [string * string],
+                        contents : {string},
+                        headers : ['A * 'B],
+                        name : string
+                      }]) -> unit,
+   redirect : (?status_code : int, string) -> unit,
+   send_status : (socket
+                  .{
+                    close : () -> unit,
+                    non_blocking : (bool) -> unit,
+                    read : ((?timeout : float?) -> string)
+                    .{wait : (?timeout : float?, (() -> unit)) -> unit
+                    },
+                    type : string,
+                    write : (string) -> unit
+                  }) -> unit,
+   status_code : ((int) -> unit)
+   .{current : () -> int
+   },
+   status_message : ((string?) -> unit)
+   .{current : () -> string?
+   },
+   status_sent : () -> bool
+ }) -> unit`)
+
+### `harbor.http.register.simple`
+
+Register a HTTP handler on the harbor. This function offers a simple API, suitable for quick implementation of HTTP handlers. See `harbor.http.register` for a node/express like alternative API.
+
+Type:
+
+```
+(?port : int, ?transport : http_transport
+ .{default_port : int, name : string, protocol : string}, ?method : string,
+ string,
+ ((
+   {
+     body : (?timeout : float) -> string,
+     data : (?timeout : float) -> string,
+     headers : [string * string],
+     http_version : string,
+     method : string,
+     path : string,
+     query : [string * string],
+     socket : socket
+     .{
+       close : () -> unit,
+       non_blocking : (bool) -> unit,
+       read : ((?timeout : float?) -> string)
+       .{wait : (?timeout : float?, (() -> unit)) -> unit
+       },
+       type : string,
+       write : ((?timeout : float?, string) -> unit)
+       .{wait : (?timeout : float?, (() -> unit)) -> unit
+       }
+     }
+   }) -> {string}?)) -> unit
+```
+
+Arguments:
+
+- `port` (of type `int`, which defaults to `8000`): Port to serve.
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{name="unix", protocol="http", default_port=80}`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `method` (of type `string`, which defaults to `"GET"`): Accepted method ("GET" / "POST" / "PUT" / "DELETE" / "HEAD" / "OPTIONS").
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `(
+ {
+   body : (?timeout : float) -> string,
+   data : (?timeout : float) -> string,
+   headers : [string * string],
+   http_version : string,
+   method : string,
+   path : string,
+   query : [string * string],
+   socket : socket
+   .{
+     close : () -> unit,
+     non_blocking : (bool) -> unit,
+     read : ((?timeout : float?) -> string)
+     .{wait : (?timeout : float?, (() -> unit)) -> unit
+     },
+     type : string,
+     write : ((?timeout : float?, string) -> unit)
+     .{wait : (?timeout : float?, (() -> unit)) -> unit
+     }
+   }
+ }) -> {string}?`)
+
+### `harbor.http.register.simple.regexp`
+
+Register a HTTP handler on the harbor with a generic regexp `path`. This function offers a simple API, suitable for quick implementation of HTTP handlers. See `harbor.http.register` for a node/express like alternative API.
+
+Type:
+
+```
+(?port : int, ?transport : http_transport
+ .{default_port : int, name : string, protocol : string}, ?method : string,
+ regexp,
+ ((
+   {
+     data : (?timeout : float) -> string,
+     headers : [string * string],
+     http_version : string,
+     method : string,
+     path : string,
+     query : [string * string],
+     socket : socket
+     .{
+       close : () -> unit,
+       non_blocking : (bool) -> unit,
+       read : ((?timeout : float?) -> string)
+       .{wait : (?timeout : float?, (() -> unit)) -> unit
+       },
+       type : string,
+       write : ((?timeout : float?, string) -> unit)
+       .{wait : (?timeout : float?, (() -> unit)) -> unit
+       }
+     }
+   }) -> {string}?)) -> unit
+```
+
+Arguments:
+
+- `port` (of type `int`, which defaults to `8000`): Port to serve.
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{name="unix", protocol="http", default_port=80}`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `method` (of type `string`, which defaults to `"GET"`): Accepted method ("GET" / "POST" / "PUT" / "DELETE" / "HEAD" / "OPTIONS").
+- `(unlabeled)` (of type `regexp`)
+- `(unlabeled)` (of type `(
+ {
+   data : (?timeout : float) -> string,
+   headers : [string * string],
+   http_version : string,
+   method : string,
+   path : string,
+   query : [string * string],
+   socket : socket
+   .{
+     close : () -> unit,
+     non_blocking : (bool) -> unit,
+     read : ((?timeout : float?) -> string)
+     .{wait : (?timeout : float?, (() -> unit)) -> unit
+     },
+     type : string,
+     write : ((?timeout : float?, string) -> unit)
+     .{wait : (?timeout : float?, (() -> unit)) -> unit
+     }
+   }
+ }) -> {string}?`)
+
+### `harbor.http.static`
+
+Serve a static path.
+
+Type:
+
+```
+(?transport : http_transport
+ .{default_port : int, name : string, protocol : string}, ?port : int,
+ ?path : string, ?browse : bool, ?content_type : ((string) -> string?),
+ ?headers : [string * string], string) -> unit
+```
+
+Arguments:
+
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{default_port=80, protocol="http", name="unix"}`): Http transport. Use `http.transport.ssl` or http.transport.secure_transport`, when available, to enable HTTPS output
+- `port` (of type `int`, which defaults to `8000`): Port for incoming harbor (http) connections.
+- `path` (of type `string`, which defaults to `"/"`): Base path.
+- `browse` (of type `bool`, which defaults to `false`): List files in directories.
+- `content_type` (of type `(string) -> string?`, which defaults to `<fun>.{magic=<fun>, cli=<fun>}`): Callback to specify Content-Type on a per file basis. Default: file.mime if compiled or file CLI if present.
+- `headers` (of type `[string * string]`, which defaults to `[("Access-Control-Allow-Origin", "*")]`): Default response headers.
+- `(unlabeled)` (of type `string`): Local path to be served.
+
+### `harbor.remove`
+
+Remove a registered handler on the harbor.
+
+Type:
+
+```
+(?port : int, ?method : string, regexp) -> unit
+```
+
+Arguments:
+
+- `port` (of type `int`, which defaults to `8000`): Port to serve.
+- `method` (of type `string`, which defaults to `"GET"`): Method served.
+- `(unlabeled)` (of type `regexp`): URI served.
+
+### `host.of_internet_address`
+
+Find a host by internet address
+
+Type:
+
+```
+(internet_address) -> 
+{
+  addresses : [internet_address.{is_ipv6 : bool, to_string : () -> string}],
+  aliases : [string],
+  domain : socket_domain,
+  name : string}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `internet_address`)
+
+### `host.of_name`
+
+Find a host by name
+
+Type:
+
+```
+(string) -> 
+{
+  addresses : [internet_address.{is_ipv6 : bool, to_string : () -> string}],
+  aliases : [string],
+  domain : socket_domain,
+  name : string}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): hostname
+
+### `http.delete`
+
+Perform a full http DELETE request.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.delete.stream`
+
+Perform a full http DELETE request.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string,
+ on_body_data : ((string?) -> unit)) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+- `on_body_data` (of type `(string?) -> unit`): function called when receiving response body data. `null` or `""` means that all the data has been passed.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.get`
+
+Perform a full http GET request.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string) -> string
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.get.stream`
+
+Perform a full http GET request.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string,
+ on_body_data : ((string?) -> unit)) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+- `on_body_data` (of type `(string?) -> unit`): function called when receiving response body data. `null` or `""` means that all the data has been passed.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.head`
+
+Perform a full http HEAD request.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.head.stream`
+
+Perform a full http HEAD request.
+
+Type:
+
+```
+(?headers : [string * string], ?http_version : string?, ?redirect : bool,
+ ?timeout : float?, ?normalize_url : bool, string,
+ on_body_data : ((string?) -> unit)) -> unit
+```
+
+Arguments:
+
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+- `on_body_data` (of type `(string?) -> unit`): function called when receiving response body data. `null` or `""` means that all the data has been passed.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.headers.content_disposition`
+
+Extract the content-disposition header
+
+Type:
+
+```
+([string * string]) -> 
+{args : [string * string?], filename? : string, name? : string, type : string
+}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `http.headers.content_type`
+
+Extract the content-type header
+
+Type:
+
+```
+([string * string?]) -> {args : [string * string], mime : string}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string?]`)
+
+### `http.headers.extname`
+
+Try to get a filename from a request's headers.
+
+Type:
+
+```
+([string * string]) -> string?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `http.multipart_form_data`
+
+Prepare a list of data to be sent as multipart form data.
+
+Type:
+
+```
+(?boundary : string?,
+ [
+  {
+    attributes : [string * string],
+    contents : {string},
+    headers : ['a * 'b],
+    name : string
+  }]) -> unit
+```
+
+Arguments:
+
+- `boundary` (of type `string?`, which defaults to `null`): Specify boundary to use for multipart/form-data.
+- `(unlabeled)` (of type `[
+ {
+   attributes : [string * string],
+   contents : {string},
+   headers : ['a * 'b],
+   name : string
+ }]`): data to insert
+
+Methods:
+
+- `boundary` (of type `string`): 
+- `contents` (of type `{string}`): 
+
+### `http.post`
+
+Perform a full http POST request.
+
+Type:
+
+```
+(?data : {string}, ?headers : [string * string], ?http_version : string?,
+ ?redirect : bool, ?timeout : float?, ?normalize_url : bool, string) ->
+string
+```
+
+Arguments:
+
+- `data` (of type `{string}`, which defaults to `""`): POST data. Use a `string` getter to stream data and return `""` when all data has been passed.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.post.file`
+
+Send a file via POST request encoded in multipart/form-data. The contents can either be directly specified (with the `contents` argument) or taken from a file (with the `file` argument).
+
+Type:
+
+```
+(?name : string, ?content_type : string?, ?headers : [string * string],
+ ?boundary : string?, ?filename : string?, ?file : string?,
+ ?contents : {string}?, ?timeout : float?, ?redirect : bool, string) ->
+string
+```
+
+Arguments:
+
+- `name` (of type `string`, which defaults to `"file"`): Name of the field field
+- `content_type` (of type `string?`, which defaults to `null`): Content-type (mime) for the file.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `boundary` (of type `string?`, which defaults to `null`): Specify boundary to use for multipart/form-data.
+- `filename` (of type `string?`, which defaults to `null`): File name sent in the request.
+- `file` (of type `string?`, which defaults to `null`): File whose contents is to be sent in the request.
+- `contents` (of type `{string}?`, which defaults to `null`): Contents of the file sent in the request.
+- `timeout` (of type `float?`, which defaults to `null`): Timeout in seconds.
+- `redirect` (of type `bool`, which defaults to `true`): Follow reidrections.
+- `(unlabeled)` (of type `string`): URL to post to.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.post.stream`
+
+Perform a full http POST request.
+
+Type:
+
+```
+(?data : {string}, ?headers : [string * string], ?http_version : string?,
+ ?redirect : bool, ?timeout : float?, ?normalize_url : bool, string,
+ on_body_data : ((string?) -> unit)) -> unit
+```
+
+Arguments:
+
+- `data` (of type `{string}`, which defaults to `""`): POST data. Use a `string` getter to stream data and return `""` when all data has been passed.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+- `on_body_data` (of type `(string?) -> unit`): function called when receiving response body data. `null` or `""` means that all the data has been passed.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.put`
+
+Perform a full http PUT request.
+
+Type:
+
+```
+(?data : {string}, ?headers : [string * string], ?http_version : string?,
+ ?redirect : bool, ?timeout : float?, ?normalize_url : bool, string) ->
+string
+```
+
+Arguments:
+
+- `data` (of type `{string}`, which defaults to `""`): POST data. Use a `string` getter to stream data and return `""` when all data has been passed.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.put.file`
+
+Send a file via PUT request encoded in multipart/form-data. The contents can either be directly specified (with the `contents` argument) or taken from a file (with the `file` argument).
+
+Type:
+
+```
+(?name : string, ?content_type : string?, ?headers : [string * string],
+ ?boundary : string?, ?filename : string?, ?file : string?,
+ ?contents : {string}?, ?timeout : float?, ?redirect : bool, string) ->
+string
+```
+
+Arguments:
+
+- `name` (of type `string`, which defaults to `"file"`): Name of the field field
+- `content_type` (of type `string?`, which defaults to `null`): Content-type (mime) for the file.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `boundary` (of type `string?`, which defaults to `null`): Specify boundary to use for multipart/form-data.
+- `filename` (of type `string?`, which defaults to `null`): File name sent in the request.
+- `file` (of type `string?`, which defaults to `null`): File whose contents is to be sent in the request.
+- `contents` (of type `{string}?`, which defaults to `null`): Contents of the file sent in the request.
+- `timeout` (of type `float?`, which defaults to `null`): Timeout in seconds.
+- `redirect` (of type `bool`, which defaults to `true`): Follow reidrections.
+- `(unlabeled)` (of type `string`): URL to put to.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.put.stream`
+
+Perform a full http PUT request.
+
+Type:
+
+```
+(?data : {string}, ?headers : [string * string], ?http_version : string?,
+ ?redirect : bool, ?timeout : float?, ?normalize_url : bool, string,
+ on_body_data : ((string?) -> unit)) -> unit
+```
+
+Arguments:
+
+- `data` (of type `{string}`, which defaults to `""`): POST data. Use a `string` getter to stream data and return `""` when all data has been passed.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `http_version` (of type `string?`, which defaults to `null`): Http request version.
+- `redirect` (of type `bool`, which defaults to `true`): Perform redirections if needed.
+- `timeout` (of type `float?`, which defaults to `10.`): Timeout for network operations in seconds.
+- `normalize_url` (of type `bool`, which defaults to `true`): Normalize url, replacing spaces with `%20` and more.
+- `(unlabeled)` (of type `string`): Requested URL, e.g. `"http://www.liquidsoap.info/"`.
+- `on_body_data` (of type `(string?) -> unit`): function called when receiving response body data. `null` or `""` means that all the data has been passed.
+
+Methods:
+
+- `headers` (of type `[string * string]`): HTTP headers.
+- `http_version` (of type `string`): Version of the HTTP protocol.
+- `status_code` (of type `int`): Status code.
+- `status_message` (of type `string`): Status message.
+
+### `http.response`
+
+Initiate a response handler with pre-filled values.
+
+Type:
+
+```
+(?http_version : string, ?status_code : int?, ?status_message : string?,
+ ?headers : [string * string], ?content_type : string?, ?data : {string}) ->
+() -> string
+```
+
+Arguments:
+
+- `http_version` (of type `string`, which defaults to `"1.1"`)
+- `status_code` (of type `int?`, which defaults to `null`)
+- `status_message` (of type `string?`, which defaults to `null`)
+- `headers` (of type `[string * string]`, which defaults to `[]`)
+- `content_type` (of type `string?`, which defaults to `null`)
+- `data` (of type `{string}`, which defaults to `""`)
+
+Methods:
+
+- `content_type` (of type `((string?) -> unit).{current : () -> string?}`): Set `"Content-Type"` header
+- `data` (of type `(({string}) -> unit).{current : () -> {string}}`): Set response data.
+- `header` (of type `(string, string) -> unit`): Set a single header on the response
+- `headers` (of type `(([string * string]) -> unit).{current : () -> [string * string]}`): Replace response headers.
+- `html` (of type `({string}) -> unit`): Set content-type to html and data to argument value
+- `http_version` (of type `((string) -> unit).{current : () -> string}`): Set http protocol version
+- `json` (of type `(?compact : bool, 'A) -> unit`): Set content-type to json and data to `json.stringify` of the argument
+- `multipart_form` (of type `(?boundary : string?,
+ [
+  {
+    attributes : [string * string],
+    contents : {string},
+    headers : ['A * 'B],
+    name : string
+  }]) -> unit`): 
+- `redirect` (of type `(?status_code : int, string) -> unit`): Set `status_code` and `Location:` header for a HTTP redirect response
+- `send_status` (of type `('A.{write : (string) -> unit}) -> unit`): 
+- `status_code` (of type `((int) -> unit).{current : () -> int}`): Set response status code
+- `status_message` (of type `((string?) -> unit).{current : () -> string?}`): Set response status message
+- `status_sent` (of type `() -> bool`): 
+
+### `http.transport.ssl`
+
+Https transport using libssl
+
+Type:
+
+```
+(?read_timeout : float?, ?write_timeout : float?, ?password : string?,
+ ?min_protocol : string?, ?max_protocol : string?, ?certificate : string?,
+ ?key : string?) -> http_transport
+```
+
+Arguments:
+
+- `read_timeout` (of type `float?`, which defaults to `null`): Read timeout
+- `write_timeout` (of type `float?`, which defaults to `null`): Write timeout
+- `password` (of type `string?`, which defaults to `null`): SSL certificate password
+- `min_protocol` (of type `string?`, which defaults to `null`): Minimal accepted SSL protocol. One of, from least recent to most recent: `"ssl.3"`, `"tls.1"`, `"tls.1.1"`, `"tls.1.2"` or `"tls.1.3"`. The most recent available protocol between client and server is negotiated when initiating communication between minimal and maximal protocol version. All protocols up to `"tls.1.2"` and above are now deprecated so you might want to set this value to one of those two. Default to lowest support protocol if not set.
+- `max_protocol` (of type `string?`, which defaults to `null`): Maximal accepted SSL protocol. One of, from least recent to most recent: `"ssl.3"`, `"tls.1"`, `"tls.1.1"`, `"tls.1.2"` or `"tls.1.3"`. The most recent available protocol between client and server is negotiated when initiating communication between minimal and maximal protocol version. Defaults to highest protocol supported if not set.
+- `certificate` (of type `string?`, which defaults to `null`): Path to certificate file. Required in server mode, e.g. `input.harbor`, etc. If passed in client mode, certificate is added to the list of valid certificates.
+- `key` (of type `string?`, which defaults to `null`): Path to certificate private key. Required in server mode, e.g. `input.harbor`, etc.
+
+Methods:
+
+- `default_port` (of type `int`): Transport default port
+- `name` (of type `string`): Transport name
+- `protocol` (of type `string`): Transport protocol
+
+### `http.transport.tls`
+
+Https transport using libtls
+
+Type:
+
+```
+(?read_timeout : float?, ?write_timeout : float?, ?certificate : string?,
+ ?key : string?) -> http_transport
+```
+
+Arguments:
+
+- `read_timeout` (of type `float?`, which defaults to `null`): Read timeout. Defaults to harbor's timeout if `null`.
+- `write_timeout` (of type `float?`, which defaults to `null`): Write timeout. Defaults to harbor's timeout if `null`.
+- `certificate` (of type `string?`, which defaults to `null`): Path to certificate file. Required in server mode, e.g. `input.harbor`, etc. If passed in client mode, certificate is added to the list of valid certificates.
+- `key` (of type `string?`, which defaults to `null`): Path to certificate private key. Required in server mode, e.g. `input.harbor`, etc. Unused in client mode.
+
+Methods:
+
+- `default_port` (of type `int`): Transport default port
+- `name` (of type `string`): Transport name
+- `protocol` (of type `string`): Transport protocol
+
+### `http.transport.unix`
+
+Http unencrypted transport
+
+Type:
+
+```
+http_transport.{default_port : int, name : string, protocol : string}
+```
+
+### `http.user_agent`
+
+Default user-agent
+
+Type:
+
+```
+string
+```
+
+### `socket.address.internet_address`
+
+Create a socket address for a internet address.
+
+Type:
+
+```
+(internet_address.{is_ipv6 : bool, to_string : () -> string}, int) ->
+socket_address
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `internet_address.{is_ipv6 : bool, to_string : () -> string}`): Internet address.
+- `(unlabeled)` (of type `int`): port
+
+Methods:
+
+- `domain` (of type `socket_domain`): Socket domain
+- `internet_address` (of type `internet_address.{is_ipv6 : bool, to_string : () -> string}`): Internet address
+- `port` (of type `int`): Port
+
+### `socket.address.unix`
+
+Create a socket address for a unix file socket.
+
+Type:
+
+```
+(string) -> socket_address
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Unix socket path
+
+Methods:
+
+- `domain` (of type `socket_domain`): Socket domain
+- `path` (of type `string`): Unix socket path
+
+### `socket.domain.inet`
+
+Inet socket domain
+
+Type:
+
+```
+socket_domain
+```
+
+### `socket.domain.inet6`
+
+Inet6 socket domain
+
+Type:
+
+```
+socket_domain
+```
+
+### `socket.domain.unix`
+
+Unix socket domain
+
+Type:
+
+```
+socket_domain
+```
+
+### `socket.internet_address`
+
+Return an internet address from its string representation.
+
+Type:
+
+```
+(string) -> internet_address
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Socket internet address.
+
+Methods:
+
+- `is_ipv6` (of type `bool`): Is the internet address a ipv6 address?
+- `to_string` (of type `() -> string`): String representation of the internet address
+
+### `socket.internet_address.any`
+
+A special IPv4 address, for use only with `socket.bind`, representing all the Internet addresses that the host machine possesses.
+
+Type:
+
+```
+internet_address.{is_ipv6 : bool, to_string : () -> string}
+```
+
+### `socket.internet_address.ipv6.any`
+
+A special IPv6 address, for use only with `socket.bind`, representing all the Internet addresses that the host machine possesses.
+
+Type:
+
+```
+internet_address.{is_ipv6 : bool, to_string : () -> string}
+```
+
+### `socket.internet_address.ipv6.loopback`
+
+A special IPv6 address representing the host machine (`::1`).
+
+Type:
+
+```
+internet_address.{is_ipv6 : bool, to_string : () -> string}
+```
+
+### `socket.internet_address.loopback`
+
+A special IPv4 address representing the host machine (`127.0.0.1`).
+
+Type:
+
+```
+internet_address.{is_ipv6 : bool, to_string : () -> string}
+```
+
+### `socket.pair`
+
+Create a pair of sockets connected together.
+
+Type:
+
+```
+(?domain : socket_domain, ?type : socket_type, ?protocol : int) -> socket
+```
+
+Arguments:
+
+- `domain` (of type `socket_domain`, which defaults to `socket.domain.inet`): Socket domain.
+- `type` (of type `socket_type`, which defaults to `socket.type.stream`): Socket type
+- `protocol` (of type `int`, which defaults to `0`): Protocol type. `0` selects the default protocol for that kind of sockets.
+
+Methods:
+
+- `close` (of type `() -> unit`): Close the socket.
+- `non_blocking` (of type `(bool) -> unit`): Set the non-blocking flag on the socket
+- `read` (of type `((?timeout : float?) -> string)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): Read data from a socket. Reading is done when the function returns an empty string `""`.
+- `type` (of type `string`): Socket type
+- `write` (of type `((?timeout : float?, string) -> unit)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): Write data to a socket
+
+### `socket.type.dgram`
+
+Dgram socket type
+
+Type:
+
+```
+socket_type
+```
+
+### `socket.type.raw`
+
+Raw socket type
+
+Type:
+
+```
+socket_type
+```
+
+### `socket.type.stream`
+
+Stream socket type
+
+Type:
+
+```
+socket_type
+```
+
+### `socket.unix`
+
+Create a unix socket.
+
+Type:
+
+```
+(?domain : socket_domain, ?type : socket_type, ?protocol : int) -> socket
+```
+
+Arguments:
+
+- `domain` (of type `socket_domain`, which defaults to `socket.domain.inet`): Socket domain.
+- `type` (of type `socket_type`, which defaults to `socket.type.stream`): Socket type
+- `protocol` (of type `int`, which defaults to `0`): Protocol type. `0` selects the default protocol for that kind of sockets.
+
+Methods:
+
+- `accept` (of type `(?timeout : float?) ->
+socket
+.{
+  close : () -> unit,
+  non_blocking : (bool) -> unit,
+  read : ((?timeout : float?) -> string)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  },
+  type : string,
+  write : ((?timeout : float?, string) -> unit)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  }
+} * socket_address`): Accept connections on the given socket. The returned socket is a socket connected to the client; the returned address is the address of the connecting client. Timeout defaults to harbor's accept_timeout if `null`.
+- `bind` (of type `(socket_address) -> unit`): Bind a socket to an address.
+- `close` (of type `() -> unit`): Close the socket.
+- `connect` (of type `(socket_address) -> unit`): Connect a socket to an address.
+- `listen` (of type `(int) -> unit`): Set up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.
+- `non_blocking` (of type `(bool) -> unit`): Set the non-blocking flag on the socket
+- `read` (of type `((?timeout : float?) -> string)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): Read data from a socket. Reading is done when the function returns an empty string `""`.
+- `type` (of type `string`): Socket type
+- `write` (of type `((?timeout : float?, string) -> unit)
+.{wait : (?timeout : float?, (() -> unit)) -> unit}`): Write data to a socket
+
+## Liquidsoap
+
+### `clock`
+
+Assign a new clock to the given source (and to other time-dependent sources) and return the source. It is a conveniency wrapper around clock.assign_new(), allowing more concise scripts in some cases.
+
+Type:
+
+```
+(?sync : string, ?id : string?, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `sync` (of type `string`, which defaults to `"auto"`): Synchronization mode. One of: `"auto"`, `"cpu"`, or `"none"`. Defaults to `"auto"`, which synchronizes with the CPU clock if none of the active sources are attached to their own clock (e.g. ALSA input, etc). `"cpu"` always synchronizes with the CPU clock. `"none"` removes all synchronization control.
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source('a)`)
+
+### `clock.assign_new`
+
+Create a new clock and assign it to a list of sources.
+
+Type:
+
+```
+(?id : string?,
+ ?on_error : ((error
+               .{
+                 kind : string,
+                 message : string,
+                 trace : [
+                          {
+                            position_end : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            position_start : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            to_string : (?prefix : string) -> string
+                          }]
+               }) -> unit)?,
+ ?sync : string, [source('a)]) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Identifier for the new clock. The default empty string means that the identifier of the first source will be used.
+- `on_error` (of type `((error
+  .{
+    kind : string,
+    message : string,
+    trace : [
+             {
+               position_end : 
+               {character_offset : int, filename : string, line_number : int
+               },
+               position_start : 
+               {character_offset : int, filename : string, line_number : int
+               },
+               to_string : (?prefix : string) -> string
+             }]
+  }) -> unit)?`, which defaults to `null`): Error callback executed when a streaming error occurs. When passed, all streaming
+errors are silenced. Intended mostly for debugging purposes.
+- `sync` (of type `string`, which defaults to `"auto"`): Synchronization mode. One of: `"auto"`, `"cpu"`, or `"none"`. Defaults to `"auto"`, which synchronizes with the CPU clock if none of the active sources are attached to their own clock (e.g. ALSA input, etc). `"cpu"` always synchronizes with the CPU clock. `"none"` removes all synchronization control.
+- `(unlabeled)` (of type `[source('a)]`): List of sources to which the new clock will be assigned.
+
+### `clock.log`
+
+Create a log of clock times for all the clocks initially present. The log is in a simple format which you can directly use with gnuplot.
+
+Type:
+
+```
+(?delay : float, ?every : float, string) -> unit
+```
+
+Arguments:
+
+- `delay` (of type `float`, which defaults to `0.`): Delay before setting up the clock logger. This should be used to ensure that the logger starts only after the clocks are created.
+- `every` (of type `float`, which defaults to `1.`): Polling interval.
+- `(unlabeled)` (of type `string`): Path of the log file.
+
+### `clock.status`
+
+Get the current time (in clock ticks) for all allocated clocks.
+
+Type:
+
+```
+() -> [string * int]
+```
+
+### `clock.status.seconds`
+
+Get the current time in seconds for all allocated clocks.
+
+Type:
+
+```
+() -> [string * float]
+```
+
+### `clock.unify`
+
+Enforce that a list of sources all belong to the same clock.
+
+Type:
+
+```
+([source('a)]) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[source('a)]`)
+
+### `decoder.add`
+
+Register an external decoder. The encoder should output in WAV format to his standard output (stdout) and read data from its standard input (stdin).
+
+Type:
+
+```
+(name : string, description : string, ?mimes : [string],
+ ?file_extensions : [string], ?priority : int, test : ((string) -> int),
+ string) -> unit
+```
+
+Arguments:
+
+- `name` (of type `string`): Format/decoder's name.
+- `description` (of type `string`): Description of the decoder.
+- `mimes` (of type `[string]`, which defaults to `[]`): List of mime types supported by this decoder. Empty means any mime type should be accepted.
+- `file_extensions` (of type `[string]`, which defaults to `[]`): List of file extensions. Empty means any file extension should be accepted.
+- `priority` (of type `int`, which defaults to `1`): Decoder priority
+- `test` (of type `(string) -> int`): Function used to determine if a file should be decoded by the decoder. Returned values are: 0: no decodable audio, -1: decodable audio but number of audio channels unknown, x: fixed number of decodable audio channels.
+- `(unlabeled)` (of type `string`): Process to start.
+
+### `decoder.metadata.add`
+
+Register an external file metadata decoder.
+
+Type:
+
+```
+(?priority : {int}, string,
+ ((metadata : [string * string], string) -> [string * string])) -> unit
+```
+
+Arguments:
+
+- `priority` (of type `{int}`, which defaults to `1`): Resolver's priority.
+- `(unlabeled)` (of type `string`): Format/resolver's name.
+- `(unlabeled)` (of type `(metadata : [string * string], string) -> [string * string]`): Process to start. The function takes the format and filename as argument and returns a list of (name,value) fields.
+
+### `decoder.oblivious.add`
+
+Register an external file decoder. The encoder should output in WAV format to his standard output (stdout) and read data from the file it receives. The estimated remaining duration for this decoder will be unknown until the `buffer` last seconds of the file. If possible, it is recommended to decode from stdin and use `decoder.add`.
+
+Type:
+
+```
+(name : string, description : string, test : ((string) -> int),
+ ?priority : int, ?mimes : [string], ?file_extensions : [string],
+ ?buffer : float, ((string) -> string)) -> unit
+```
+
+Arguments:
+
+- `name` (of type `string`): Format/decoder's name.
+- `description` (of type `string`): Description of the decoder.
+- `test` (of type `(string) -> int`): Function used to determine if a file should be decoded by the decoder. Returned values are: 0: no decodable audio, -1: decodable audio but number of audio channels unknown, x: fixed number of decodable audio channels.
+- `priority` (of type `int`, which defaults to `1`): Decoder priority
+- `mimes` (of type `[string]`, which defaults to `[]`): List of mime types supported by this decoder. Empty means any mime type should be accepted.
+- `file_extensions` (of type `[string]`, which defaults to `[]`): List of file extensions. Empty means any file extension should be accepted.
+- `buffer` (of type `float`, which defaults to `5.`)
+- `(unlabeled)` (of type `(string) -> string`): Process to start. The function takes the filename as argument and returns the process to start.
+
+### `enable_autocue_metadata`
+
+Enable autocue metadata resolver. This resolver will process any file decoded by Liquidsoap and add cue-in/out and crossfade metadata when these values can be computed. This function sets `settings.request.prefetch` to `2` to account for the latency introduced by the `autocue` computation when resolving reausts and sets `settings.crossfade.assume_autocue` to `true` as well. For a finer-grained processing, use the `autocue:` protocol.
+
+Type:
+
+```
+() -> unit
+```
+
+### `enable_external_faad_decoder`
+
+Enable or disable external FAAD (AAC/AAC+/M4A) decoders. Does not work on Win32. Please note that built-in support for faad is available in liquidsoap if compiled and should be preferred over the external decoder.
+
+Type:
+
+```
+() -> unit
+```
+
+### `enable_external_ffmpeg_decoder`
+
+Enable ffmpeg decoder.
+
+Type:
+
+```
+() -> unit
+```
+
+### `enable_external_flac_decoder`
+
+Enable external FLAC decoders. Please note that built-in support for FLAC is available in liquidsoap if compiled and should be preferred over the external decoder.
+
+Type:
+
+```
+() -> unit
+```
+
+### `enable_external_mpc_decoder`
+
+Enable external Musepack decoder.
+
+Type:
+
+```
+() -> unit
+```
+
+### `enable_replaygain_metadata`
+
+Enable ReplayGain metadata resolver. This resolver will process any file decoded by Liquidsoap and add a `replaygain_track_gain` metadata when this value could be computed. For a finer-grained replay gain processing, use the `replaygain:` protocol.
+
+Type:
+
+```
+(?ratio : float) -> unit
+```
+
+Arguments:
+
+- `ratio` (of type `float`, which defaults to `50.`): Decoding ratio. A value of `50.` means try to decode the file `50x` faster than real time, if possible. Use this setting to lower CPU peaks when computing replaygain tags.
+
+### `encoder.content_type`
+
+Return the content-type (mime) of an encoder, if known.
+
+Type:
+
+```
+(format('a)) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `format('a)`)
+
+### `encoder.extension`
+
+Return the file extension of an encoder, if known.
+
+Type:
+
+```
+(format('a)) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `format('a)`)
+
+### `liquidsoap.chroot.make`
+
+Export all the files required to install liquidsoap in a root folder. Useful for packaging and docker images.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `liquidsoap.executable`
+
+Path to the Liquidsoap executable.
+
+Type:
+
+```
+string
+```
+
+### `liquidsoap.version.at_least`
+
+Ensure that Liquidsoap version is greater or equal to given one.
+
+Type:
+
+```
+(string) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Minimal version.
+
+### `log`
+
+Log a message.
+
+Type:
+
+```
+(?label : string, ?level : int, string) -> unit
+```
+
+Arguments:
+
+- `label` (of type `string`, which defaults to `"lang"`)
+- `level` (of type `int`, which defaults to `3`)
+- `(unlabeled)` (of type `string`)
+
+### `log.critical`
+
+Log a critical message
+
+Type:
+
+```
+(?label : string, string) -> unit
+```
+
+Arguments:
+
+- `label` (of type `string`, which defaults to `"lang"`)
+- `(unlabeled)` (of type `string`)
+
+### `log.debug`
+
+Log a debug message
+
+Type:
+
+```
+(?label : string, string) -> unit
+```
+
+Arguments:
+
+- `label` (of type `string`, which defaults to `"lang"`)
+- `(unlabeled)` (of type `string`)
+
+### `log.file`
+
+Get and set the file logging
+
+Type:
+
+```
+() -> bool
+```
+
+### `log.important`
+
+Log an important message
+
+Type:
+
+```
+(?label : string, string) -> unit
+```
+
+Arguments:
+
+- `label` (of type `string`, which defaults to `"lang"`)
+- `(unlabeled)` (of type `string`)
+
+### `log.info`
+
+Log a normal message
+
+Type:
+
+```
+(?label : string, string) -> unit
+```
+
+Arguments:
+
+- `label` (of type `string`, which defaults to `"lang"`)
+- `(unlabeled)` (of type `string`)
+
+### `log.level`
+
+Get and set the log level.
+
+Type:
+
+```
+() -> int
+```
+
+### `log.severe`
+
+Log a severe message
+
+Type:
+
+```
+(?label : string, string) -> unit
+```
+
+Arguments:
+
+- `label` (of type `string`, which defaults to `"lang"`)
+- `(unlabeled)` (of type `string`)
+
+### `log.stdout`
+
+Get and set logging to stdout
+
+Type:
+
+```
+() -> bool
+```
+
+### `playlist.parse`
+
+Try to parse a local playlist. Return a list of (metadata,URI) items, where metadata is a list of (key,value) bindings.
+
+Type:
+
+```
+(?path : string, ?mime : string?, string) -> [[string * string] * string]
+```
+
+Arguments:
+
+- `path` (of type `string`, which defaults to `""`): Default path for files.
+- `mime` (of type `string?`, which defaults to `null`): Mime type for the playlist
+- `(unlabeled)` (of type `string`)
+
+### `playlist.parse.cue`
+
+Parse CUE playlists
+
+Type:
+
+```
+(string, ?pwd : string?) -> [[string * string] * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Playlist file
+- `pwd` (of type `string?`, which defaults to `null`): Current directory to use for relative file path.
+
+### `playlist.parse.m3u`
+
+Parse M3U playlists
+
+Type:
+
+```
+(string, ?pwd : string?) -> [[string * string] * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Playlist file
+- `pwd` (of type `string?`, which defaults to `null`): Current directory to use for relative file path.
+
+### `playlist.parse.register`
+
+Register a new playlist parser. An empty playlist is considered as a failure to resolve.
+
+Type:
+
+```
+(format : string, strict : bool,
+ ((?pwd : string, string) -> [[string * string] * string])) -> unit
+```
+
+Arguments:
+
+- `format` (of type `string`): Playlist format. If possible, a mime-type.
+- `strict` (of type `bool`): True if playlist format can be detected unambiguously.
+- `(unlabeled)` (of type `(?pwd : string, string) -> [[string * string] * string]`): Playlist parser
+
+### `playlist.parse.scpls`
+
+Parse SCPLS playlists
+
+Type:
+
+```
+(string, ?pwd : string?) -> [[string * string] * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Playlist file
+- `pwd` (of type `string?`, which defaults to `null`): Current directory to use for relative file path.
+
+### `playlist.parse.xml`
+
+Parse XML playlists
+
+Type:
+
+```
+(string, ?pwd : string?) -> [[string * string] * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Playlist file
+- `pwd` (of type `string?`, which defaults to `null`): Current directory to use for relative file path.
+
+### `process.uri`
+
+Create a process: uri, replacing `:` with `$(colon)`.
+
+Type:
+
+```
+(?timeout : 'a?, extname : 'b, ?uri : string, string) -> string
+```
+
+Arguments:
+
+- `timeout` (of type `'a?`, which defaults to `null`)
+- `extname` (of type `'b`): Output file extension (with no leading '.')
+- `uri` (of type `string`, which defaults to `""`): Input uri
+- `(unlabeled)` (of type `string`): Command line to execute
+
+### `profiler.disable`
+
+Record profiling statistics.
+
+Type:
+
+```
+() -> unit
+```
+
+### `profiler.enable`
+
+Record profiling statistics.
+
+Type:
+
+```
+() -> unit
+```
+
+### `profiler.print`
+
+Print profiling information.
+
+Type:
+
+```
+() -> unit
+```
+
+### `profiler.run`
+
+Time a function with the profiler.
+
+Type:
+
+```
+(string, (() -> 'a)) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Name of the profiled function.
+- `(unlabeled)` (of type `() -> 'a`): Function to profile.
+
+### `profiler.stats.string`
+
+Profiling statistics.
+
+Type:
+
+```
+() -> string
+```
+
+### `prometheus.latency`
+
+Monitor a source's internal latencies on Prometheus
+
+Type:
+
+```
+(?window : float, ?prefix : string, labels : [string]) ->
+(label_values : [string], source('a)) -> unit
+```
+
+Arguments:
+
+- `window` (of type `float`, which defaults to `5.`): Window over which mean and peak metrics are reported.
+- `prefix` (of type `string`, which defaults to `"liquidsoap_"`): Prefix for the metric's name
+- `labels` (of type `[string]`): labels for the metric
+
+### `protocol.add`
+
+Register a new protocol.
+
+Type:
+
+```
+(?temporary : bool, ?static : bool, ?syntax : string, ?doc : string, string,
+ ((rlog : ((string) -> unit), maxtime : float, string) -> [string])) -> unit
+```
+
+Arguments:
+
+- `temporary` (of type `bool`, which defaults to `false`): if true, file is removed when it is finished.
+- `static` (of type `bool`, which defaults to `false`): if true, then requests can be resolved once and for all. Typically, static protocols can be used to create infallible sources.
+- `syntax` (of type `string`, which defaults to `"Undocumented"`): URI syntax.
+- `doc` (of type `string`, which defaults to `"Undocumented"`): Protocol documentation.
+- `(unlabeled)` (of type `string`): Protocol name. Resolver will be called on uris of the form: `<protocol name>:...`.
+- `(unlabeled)` (of type `(rlog : ((string) -> unit), maxtime : float, string) -> [string]`): Protocol resolver. Receives a function to log protocol resolution, the `<arg>` in `<protocol name>:<arg>` and the max delay that resolution should take.
+
+### `request.create`
+
+Create a request from an URI.
+
+Type:
+
+```
+(?indicators : [string], ?cue_in_metadata : string?,
+ ?cue_out_metadata : string?, ?persistent : bool, ?resolve_metadata : bool,
+ ?excluded_metadata_resolvers : [string], ?temporary : bool, string) ->
+request
+```
+
+Arguments:
+
+- `indicators` (of type `[string]`, which defaults to `[]`)
+- `cue_in_metadata` (of type `string?`, which defaults to `"liq_cue_in"`): Metadata for cue in points. Disabled if `null`.
+- `cue_out_metadata` (of type `string?`, which defaults to `"liq_cue_out"`): Metadata for cue out points. Disabled if `null`.
+- `persistent` (of type `bool`, which defaults to `false`): Indicate that the request is persistent, i.e. that it may be used again once it has been played.
+- `resolve_metadata` (of type `bool`, which defaults to `true`): Set to `false` to prevent metadata resolution on this request.
+- `excluded_metadata_resolvers` (of type `[string]`, which defaults to `[]`): List of metadata resolves to exclude when resolving metadata.
+- `temporary` (of type `bool`, which defaults to `false`): Indicate that the request is a temporary file: it will be destroyed after being played.
+- `(unlabeled)` (of type `string`)
+
+### `request.destroy`
+
+Destroying a request causes any temporary associated file to be deleted, and releases its RID. Persistent requests resist to destroying, unless forced.
+
+Type:
+
+```
+(?force : bool, request) -> unit
+```
+
+Arguments:
+
+- `force` (of type `bool`, which defaults to `false`): Destroy the request even if it is persistent.
+- `(unlabeled)` (of type `request`)
+
+### `request.duration`
+
+Compute the duration in seconds of audio data contained in a request. The computation may be expensive. Returns `null` if computation failed, typically if the file was not recognized as valid audio.
+
+Type:
+
+```
+(?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float,
+ string) -> float?
+```
+
+Arguments:
+
+- `resolve_metadata` (of type `bool`, which defaults to `true`): Set to `false` to prevent metadata resolution on this request.
+- `metadata` (of type `[string * string]`, which defaults to `[]`): Optional metadata used to decode the file, e.g. `ffmpeg_options`.
+- `timeout` (of type `float`, which defaults to `30.`): Limit in seconds to the duration of the resolving.
+- `(unlabeled)` (of type `string`)
+
+### `request.filename`
+
+Return a valid local filename if the request is ready, and the empty string otherwise.
+
+Type:
+
+```
+(request) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.id`
+
+Identifier of a request.
+
+Type:
+
+```
+(request) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.log`
+
+Get log data associated to a request.
+
+Type:
+
+```
+(request) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.metadata`
+
+Get the metadata associated to a request.
+
+Type:
+
+```
+(request) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.read_metadata`
+
+Force reading the metadata of a request.
+
+Type:
+
+```
+(request) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.resolve`
+
+Resolve a request, i.e. attempt to get a valid local file. The operation can take some time. Return true if the resolving was successful, false otherwise (timeout or invalid URI). The request should not be decoded afterward: this is mostly useful to download files such as playlists, etc.
+
+Type:
+
+```
+(?content_type : source('a)?, ?timeout : float, request) -> bool
+```
+
+Arguments:
+
+- `content_type` (of type `source('a)?`, which defaults to `null`): If specified, the request will be decoded with the same content type as the given source.
+- `timeout` (of type `float`, which defaults to `30.`): Limit in seconds to the duration of the resolving.
+- `(unlabeled)` (of type `request`)
+
+### `request.resolved`
+
+Check if a request is resolved, i.e. is associated to a valid local file.
+
+Type:
+
+```
+(request) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.status`
+
+Current status of a request. Can be idle, resolving, ready, playing or destroyed.
+
+Type:
+
+```
+(request) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `request.uri`
+
+Initial URI of a request.
+
+Type:
+
+```
+(request) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `request`)
+
+### `runtime.cpu.usage_getter`
+
+Create a function returning CPU usage (in `float` percent so `0.2` means `20%`) since the last time it was called.
+
+Type:
+
+```
+() -> () -> {system : float, total : float, user : float}
+```
+
+### `runtime.gc.compact`
+
+Perform a full major collection and compact the heap. Note that heap compaction is a lengthy operation.
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.gc.full_major`
+
+Trigger full major garbage collection.
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.gc.major`
+
+Trigger a minor collection and finish the current major collection cycle..
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.gc.major_slice`
+
+Do a minor collection and a slice of major collection. The optional argument `n` is the size of the slice: the GC will do enough work to free (on average) `n` words of memory. If `0` (its default), the GC will try to do enough work to ensure that the next automatic slice has no work to do.
+
+Type:
+
+```
+(?int) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`, which defaults to `0`): Size of the slice
+
+### `runtime.gc.minor`
+
+Trigger full minor garbage collection.
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.memory`
+
+Returns information about the system and process' memory usage. Requires `mem_usage` for a full report.
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `pretty` (of type `
+{
+  process_managed_memory : string,
+  process_physical_memory : string,
+  process_private_memory : string,
+  process_swapped_memory : string,
+  process_virtual_memory : string,
+  total_physical_memory : string,
+  total_used_physical_memory : string,
+  total_used_virtual_memory : string,
+  total_virtual_memory : string
+}`): 
+- `process_managed_memory` (of type `int`): 
+- `process_physical_memory` (of type `int`): 
+- `process_private_memory` (of type `int`): 
+- `process_swapped_memory` (of type `int`): 
+- `process_virtual_memory` (of type `int`): 
+- `total_physical_memory` (of type `int`): 
+- `total_used_physical_memory` (of type `int`): 
+- `total_used_virtual_memory` (of type `int`): 
+- `total_virtual_memory` (of type `int`): 
+
+### `seconds_of_main`
+
+Convert a number of main ticks in seconds.
+
+Type:
+
+```
+(int) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`)
+
+### `server.execute`
+
+Execute a liquidsoap server command.
+
+Type:
+
+```
+(string, ?string) -> [string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Command to execute.
+- `(unlabeled)` (of type `string`, which defaults to `""`): Argument for the command.
+
+## List
+
+### `_::_`
+
+Add an element at the top of a list.
+
+Type:
+
+```
+('a, ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+- `(unlabeled)` (of type `['a]`)
+
+### `_[_]`
+
+l[k] returns the first v such that (k,v) is in the list l (or "" if no such v exists).
+
+Type:
+
+```
+(['a * string], 'a) -> string where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a * string] where 'a is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `list.add`
+
+Add an element at the top of a list.
+
+Type:
+
+```
+('a, ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.append`
+
+Concatenate two lists.
+
+Type:
+
+```
+(['a], ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.assoc`
+
+Associate a value to a key in an association list. This functions raises `error.not_found` if no default value is specified.
+
+Type:
+
+```
+(?default : 'a?, 'b, ['b * 'a]) -> 'a where 'b is an orderable type
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`): Value returned if the key is not found.
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `['b * 'a] where 'b is an orderable type`)
+
+### `list.assoc.filter`
+
+Keep only the elements of an association list satisfying a given predicate.
+
+Type:
+
+```
+((('a, 'b) -> bool), ['a * 'b]) -> ['a * 'b]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a, 'b) -> bool`)
+- `(unlabeled)` (of type `['a * 'b]`)
+
+### `list.assoc.filter_map`
+
+Map a function of every element of the associative list, removing the entry if the function returns `null`.
+
+Type:
+
+```
+((('a, 'b) -> 'c?), ['a * 'b]) -> ['c]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a, 'b) -> 'c?`)
+- `(unlabeled)` (of type `['a * 'b]`)
+
+### `list.assoc.mem`
+
+`list.assoc.mem(key,l)` returns `true` if `l` contains a pair (key,value).
+
+Type:
+
+```
+('a, ['a * 'b]) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`): Key to look for
+- `(unlabeled)` (of type `['a * 'b] where 'a is an orderable type`): List of pairs (key,value)
+
+### `list.assoc.remove`
+
+Remove the first pair from an associative list.
+
+Type:
+
+```
+('a, ['a * 'b]) -> ['a * 'b] where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`): Key of pair to be removed.
+- `(unlabeled)` (of type `['a * 'b] where 'a is an orderable type`): List of pairs (key,value).
+
+### `list.assoc.remove.all`
+
+Remove all pairs with given key from an associative list.
+
+Type:
+
+```
+('a, ['a * 'b]) -> ['a * 'b] where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`): Key of pairs to be removed.
+- `(unlabeled)` (of type `['a * 'b] where 'a is an orderable type`): List of pairs (key,value).
+
+### `list.case`
+
+Define a function by case analysis, depending on whether a list is empty or not.
+
+Type:
+
+```
+(['a], 'b, (('a, ['a]) -> 'b)) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`): List to perform case analysis on.
+- `(unlabeled)` (of type `'b`): Result when the list is empty.
+- `(unlabeled)` (of type `('a, ['a]) -> 'b`): Result when the list is non-empty.
+
+### `list.cons`
+
+Add an element at the top of a list.
+
+Type:
+
+```
+('a, ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.dcase`
+
+"Delayed" version of `list.case` where the value on empty list is only evaluated if necessary.
+
+Type:
+
+```
+(['a], (() -> 'b), (('a, ['a]) -> 'b)) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+- `(unlabeled)` (of type `() -> 'b`)
+- `(unlabeled)` (of type `('a, ['a]) -> 'b`)
+
+### `list.exists`
+
+Check that a predicate is satisfied for some element in a list.
+
+Type:
+
+```
+((('a) -> bool), ['a]) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> bool`): Predicate.
+- `(unlabeled)` (of type `['a]`): List
+
+### `list.filter`
+
+Filter a list according to a predicate. The order in which elements are handled is not specified (and is currently implemented from the right).
+
+Type:
+
+```
+(?remove : (('a) -> unit), (('a) -> bool), ['a]) -> ['a]
+```
+
+Arguments:
+
+- `remove` (of type `('a) -> unit`, which defaults to `fun (_) -> ()`): Function called on an element when it is removed.
+- `(unlabeled)` (of type `('a) -> bool`): Predicate indicating whether an element should be kept or not.
+- `(unlabeled)` (of type `['a]`): List to filter.
+
+### `list.filter_map`
+
+Map a function on a list (like `list.map`) excepting that the value is removed if the function returns `null`.
+
+Type:
+
+```
+((('a) -> 'b?), ['a]) -> ['b]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b?`): Function called on every element of the list.
+- `(unlabeled)` (of type `['a]`): The list.
+
+### `list.find`
+
+First element satisfying a predicate. Raises `error.not_found` if not element is found and no default value was specified.
+
+Type:
+
+```
+(?default : 'a?, (('a) -> bool), ['a]) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`): Returned value when the predicate is not found.
+- `(unlabeled)` (of type `('a) -> bool`): Predicate.
+- `(unlabeled)` (of type `['a]`): List
+
+### `list.flatten`
+
+Concatenate all the elements of a list of lists.
+
+Type:
+
+```
+([['a]]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[['a]]`)
+
+### `list.fold`
+
+Fold a function on every element of a list: `list.fold(f,x1,[e1,..,en]) is f(...f(f(x1,e1),e2)...,en)`.
+
+Type:
+
+```
+((('a, 'b) -> 'a), 'a, ['b]) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a, 'b) -> 'a`): Function `f` for which `f(x,e)` which will be called on every element `e` with the current value of `x`, returning the new value of `x`.
+- `(unlabeled)` (of type `'a`): Initial value x1, to be updated by successive calls of `f(x,e)`.
+- `(unlabeled)` (of type `['b]`)
+
+### `list.fold.right`
+
+Fold a function on every element of a list. Similar to `list.fold` but iterates from the right of the list. It is slightly more efficient than `list.fold`.
+
+Type:
+
+```
+((('a, 'b) -> 'b), 'b, ['a]) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a, 'b) -> 'b`): Function `f` for which `f(x,e)` which will be called on every element `e` with the current value of `x`, returning the new value of `x`.
+- `(unlabeled)` (of type `'b`): Initial value x1, to be updated by successive calls of `f(x,e)`.
+- `(unlabeled)` (of type `['a]`)
+
+### `list.for_all`
+
+Check that a predicate is satisfied for every element in a list.
+
+Type:
+
+```
+((('a) -> bool), ['a]) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> bool`): Predicate.
+- `(unlabeled)` (of type `['a]`): List
+
+### `list.hd`
+
+Return the head (first element) of a list, or `default` if the list is empty.
+
+Type:
+
+```
+(?default : 'a?, ['a]) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`): Default value if key does not exist.
+- `(unlabeled)` (of type `['a]`)
+
+### `list.ind`
+
+Define a function by induction on a list. This is slightly more efficient than defining a recursive function. The list is scanned from the right.
+
+Type:
+
+```
+(['a], 'b, (('a, ['a], 'b) -> 'b)) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`): List to perform induction on.
+- `(unlabeled)` (of type `'b`): Result when the list is empty.
+- `(unlabeled)` (of type `('a, ['a], 'b) -> 'b`): Result when the list is non-empty, given the current element, the tail and the result of the recursive call on the tail.
+
+### `list.index`
+
+First index where a predicate is satisfied.
+
+Type:
+
+```
+((('a) -> bool), ['a]) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> bool`): Predicate.
+- `(unlabeled)` (of type `['a]`): List
+
+### `list.indexed`
+
+Add indices to every element of a list, so that it can be accessed with the notation `l[n]`.
+
+Type:
+
+```
+(['a]) -> [int * 'a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+
+### `list.init`
+
+Initialize a list.
+
+Type:
+
+```
+(int, ((int) -> 'a)) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Number of elements in the list.
+- `(unlabeled)` (of type `(int) -> 'a`): Function such that `f i` is the `i`th element.
+
+### `list.insert`
+
+Returns a copy of the given list with a new element inserted at a given position. Raises `error.not_found` if the list has less than `index` elements.
+
+Type:
+
+```
+(int, 'a, ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Index to insert at, starting at `0`.
+- `(unlabeled)` (of type `'a`): Element to insert
+- `(unlabeled)` (of type `['a]`): List to insert into.
+
+### `list.is_empty`
+
+Determining whether a list is empty or not.
+
+Type:
+
+```
+(['a]) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+
+### `list.iter`
+
+Call a function on every element of a list.
+
+Type:
+
+```
+((('a) -> unit), ['a]) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> unit`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.iterator`
+
+Create an iterator over the elements of a list.
+
+Type:
+
+```
+(['a?]) -> () -> 'a?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a?]`)
+
+### `list.iteri`
+
+Call a function on every element of a list, along with its index.
+
+Type:
+
+```
+(((int, 'a) -> unit), ['a]) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(int, 'a) -> unit`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.last`
+
+Return the last element of a list.
+
+Type:
+
+```
+(?default : 'a?, ['a]) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.length`
+
+Compute the length of a list, i.e., the number of its elements.
+
+Type:
+
+```
+(['a]) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+
+### `list.make`
+
+Create a list with given length, filled with given element.
+
+Type:
+
+```
+(int, 'a) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Number of elements in the list.
+- `(unlabeled)` (of type `'a`): Element to fill the list with.
+
+### `list.map`
+
+Map a function on every element of a list.
+
+Type:
+
+```
+((('a) -> 'b), ['a]) -> ['b]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.map.right`
+
+Map a function on every element of a list, starting from the right. This function is tail-recursive.
+
+Type:
+
+```
+((('a) -> 'b), ['a]) -> ['b]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.mapi`
+
+Map a function on every element of a list, along with its index.
+
+Type:
+
+```
+(((int, 'a) -> 'b), ['a]) -> ['b]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(int, 'a) -> 'b`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.mem`
+
+Check whether an element belongs to a list.
+
+Type:
+
+```
+('a, ['a]) -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `['a] where 'a is an orderable type`)
+
+### `list.nth`
+
+Get the n-th element of a list (the first element is at position 0), or `default` if element does not exist.
+
+Type:
+
+```
+(?default : 'a?, ['a], int) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`): Default element. Raises `error.not_found` if `null` and no element can be found in the list.
+- `(unlabeled)` (of type `['a]`)
+- `(unlabeled)` (of type `int`)
+
+### `list.pick`
+
+Pick a random element in a list.
+
+Type:
+
+```
+(?default : 'a?, ['a]) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`): Value returned if the list is empty.
+- `(unlabeled)` (of type `['a]`): List in which the element should be picked.
+
+### `list.prefix`
+
+Compute the beginning of a list.
+
+Type:
+
+```
+(int, ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Number of elements in the returned list.
+- `(unlabeled)` (of type `['a]`): List whose prefix should be taken.
+
+### `list.remove`
+
+Remove the first occurrence of a value from a list.
+
+Type:
+
+```
+('a, ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+- `(unlabeled)` (of type `['a]`)
+
+### `list.rev`
+
+Revert list order.
+
+Type:
+
+```
+(['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+
+### `list.shuffle`
+
+Shuffle the content of a list. The function returns a list with the same elements but in different, random, order.
+
+Type:
+
+```
+(['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+
+### `list.sort`
+
+Sort a list according to a comparison function.
+
+Type:
+
+```
+((('a, 'a) -> int), ['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a, 'a) -> int`): Comparison function f such that f(x,y)<0 when x<y, f(x,y)=0 when x=y, and f(x,y)>0 when x>y.
+- `(unlabeled)` (of type `['a]`): List to sort.
+
+### `list.sort.natural`
+
+Sort a list according to the "natural" order.
+
+Type:
+
+```
+(['a]) -> ['a] where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a] where 'a is an orderable type`): List to sort
+
+### `list.tl`
+
+Return the list without its first element.
+
+Type:
+
+```
+(['a]) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `['a]`)
+
+## Math
+
+### `*`
+
+Multiplication of numbers.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `+`
+
+Addition of numbers.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `-`
+
+Subtraction  of numbers.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `/`
+
+Division of numbers.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `abs`
+
+Absolute value.
+
+Type:
+
+```
+('a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `acos`
+
+Arc cosine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between 0.0 and pi.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `asin`
+
+Arc sine. The argument must fall within the range [-1.0, 1.0]. Result is in radians and is between -pi/2 and pi/2.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `atan`
+
+Arc tangent. Result is in radians and is between -pi/2 and pi/2.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `bool_of_float`
+
+Convert a float to a bool.
+
+Type:
+
+```
+(float) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `bool_of_int`
+
+Convert an int to a bool.
+
+Type:
+
+```
+(int) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`)
+
+### `cos`
+
+Cosine. Argument is in radians.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `cosh`
+
+Hyperbolic cosine. Argument is in radians.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `dB_of_lin`
+
+Convert linear scale into decibels.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `exp`
+
+Exponential.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `float`
+
+Convert a number to a float.
+
+Type:
+
+```
+('a) -> float where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `float_of_int`
+
+Convert an int to a float.
+
+Type:
+
+```
+(int) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`)
+
+### `infinity`
+
+Float representation of infinity.
+
+Type:
+
+```
+float
+```
+
+### `int`
+
+Convert a number to an integer.
+
+Type:
+
+```
+('a) -> int where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `int_of_float`
+
+Convert a float to a int.
+
+Type:
+
+```
+(float) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `lin_of_dB`
+
+Convert decibels into linear scale.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `ln`
+
+Natural logarithm.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `log10`
+
+Base 10 logarithm.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `lsl`
+
+Logical shift left.
+
+Type:
+
+```
+(int, int) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Number to shift.
+- `(unlabeled)` (of type `int`): Number of bits to shift.
+
+### `lsr`
+
+Logical shift right.
+
+Type:
+
+```
+(int, int) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Number to shift.
+- `(unlabeled)` (of type `int`): Number of bits to shift.
+
+### `max`
+
+Compute the maximum of two values.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `max_int`
+
+Maximal representable integer.
+
+Type:
+
+```
+int
+```
+
+### `min`
+
+Compute the minimum of two values.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is an orderable type`)
+- `(unlabeled)` (of type `anything that is an orderable type`)
+
+### `min_int`
+
+Minimal representable integer.
+
+Type:
+
+```
+int
+```
+
+### `mod`
+
+Remainder of division of numbers.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `nan`
+
+A special floating-point value denoting the result of an undefined operation such as 0.0 /. 0.0. Stands for 'not a number'. Any floating-point operation with nan as argument returns nan as result. As for floating-point comparisons, `==`, `<`, `<=`, `>` and `>=` return `false` and `!=` returns `true` if one or both of their arguments is `nan`.
+
+Type:
+
+```
+float
+```
+
+### `pow`
+
+Exponentiation of numbers.
+
+Type:
+
+```
+('a, 'a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+- `(unlabeled)` (of type `anything that is a number type`)
+
+### `random.float`
+
+Generate a random value between `min` (included) and `max` (excluded).
+
+Type:
+
+```
+(?min : float, ?max : float) -> float
+```
+
+Arguments:
+
+- `min` (of type `float`, which defaults to `0.`)
+- `max` (of type `float`, which defaults to `1.`)
+
+### `random.int`
+
+Generate a random value between `min` (included) and `max` (excluded).
+
+Type:
+
+```
+(?min : int, ?max : int) -> int
+```
+
+Arguments:
+
+- `min` (of type `int`, which defaults to `-536870911`)
+- `max` (of type `int`, which defaults to `536870912`)
+
+### `sin`
+
+Sine. Argument is in radians.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `sinh`
+
+Hyperbolic sine. Argument is in radians.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `sqrt`
+
+Square root.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `tan`
+
+Tangent. Argument is in radians.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `tanh`
+
+Hyperbolic tangent. Argument is in radians.
+
+Type:
+
+```
+(float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`)
+
+### `~-`
+
+Returns the opposite of its argument.
+
+Type:
+
+```
+('a) -> 'a where 'a is a number type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `anything that is a number type`)
+
+## Metadata
+
+### `file.cover`
+
+Obtain cover-art for a file. `null` is returned in case there is no such information.
+
+Type:
+
+```
+(string) -> string
+.{
+  color_depth? : int,
+  description? : string,
+  format? : string,
+  height? : int,
+  mime : string,
+  number_of_colors? : int?,
+  picture_type? : int,
+  width? : int}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): File from which the cover should be obtained
+
+### `metadata.artist`
+
+Extract artist from metadata.
+
+Type:
+
+```
+([string * string]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `metadata.comment`
+
+Extract comment from metadata.
+
+Type:
+
+```
+([string * string]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `metadata.cover`
+
+Extract cover from metadata. This function implements cover extraction for the following formats: coverart (ogg), apic (flac, mp3) and pic (mp3).
+
+Type:
+
+```
+(?coverart_mime : string?, [string * string]) -> string
+.{
+  color_depth? : int,
+  description? : string,
+  format? : string,
+  height? : int,
+  mime : string,
+  number_of_colors? : int?,
+  picture_type? : int,
+  width? : int}?
+```
+
+Arguments:
+
+- `coverart_mime` (of type `string?`, which defaults to `null`): Mime type to use for `"coverart"` metadata. Support disabled if `null`.
+- `(unlabeled)` (of type `[string * string]`): Metadata from which the cover should be extracted.
+
+### `metadata.cover.remove`
+
+Remove cover metadata. This is mostly useful in order not to flood logs with coverart when logging metadata.
+
+Type:
+
+```
+([string * string]) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `metadata.deduplicate`
+
+Remove duplicate metadata in a source.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"metadata.deduplicate"`): Source id
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`): source
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `metadata.export`
+
+Cleanup metadata for export. This is used to remove Liquidsoap's internal metadata entries before sending them. List of exported metadata is set using `settings.encoder.metadata.export.set`.
+
+Type:
+
+```
+([string * string]) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `metadata.filename`
+
+Extract filename from metadata.
+
+Type:
+
+```
+([string * string]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `metadata.getter`
+
+Create a getter from a metadata: this is a string, whose value can be changed with a metadata.
+
+Type:
+
+```
+(string, 'a, 'c.{on_metadata : (((['a * string]) -> unit)) -> 'b}) ->
+() -> string where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Initial value.
+- `(unlabeled)` (of type `anything that is an orderable type`): Metadata on which the value should be updated.
+- `(unlabeled)` (of type `'c.{on_metadata : (((['a * string]) -> unit)) -> 'b}
+where 'a is an orderable type`): Source containing the metadata.
+
+### `metadata.getter.float`
+
+Create a float getter from a metadata: this is a float, whose value can be changed with a metadata.
+
+Type:
+
+```
+(float, 'a, 'c.{on_metadata : (((['a * string]) -> unit)) -> 'b}) ->
+() -> float where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`): Initial value.
+- `(unlabeled)` (of type `anything that is an orderable type`): Metadata on which the value should be updated.
+- `(unlabeled)` (of type `'c.{on_metadata : (((['a * string]) -> unit)) -> 'b}
+where 'a is an orderable type`): Source containing the metadata.
+
+### `metadata.json.parse`
+
+Parse metadata from JSON object.
+
+Type:
+
+```
+(string) -> [string * string] as json.object
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `metadata.json.stringify`
+
+Export metadata as JSON object. Cover art, if found, is extracted using `metadata.cover` and exported with key `"cover"` and exported using `string.data_uri.encode`.
+
+Type:
+
+```
+(?coverart_mime : string?, ?base64 : bool, ?compact : bool, ?json5 : bool,
+ [string * string]) -> string
+```
+
+Arguments:
+
+- `coverart_mime` (of type `string?`, which defaults to `null`): Mime type to use for `"coverart"` metadata. Support disasbled if `null`.
+- `base64` (of type `bool`, which defaults to `true`)
+- `compact` (of type `bool`, which defaults to `false`): Output compact text.
+- `json5` (of type `bool`, which defaults to `false`): Use json5 extended spec.
+- `(unlabeled)` (of type `[string * string]`)
+
+### `metadata.title`
+
+Extract title from metadata.
+
+Type:
+
+```
+([string * string]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+
+### `string.apic.parse`
+
+Parse APIC ID3v2 tags (such as those obtained in the APIC tag from `file.metadata.id3v2`). The returned values are: mime, picture type, description, and picture data.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): APIC data.
+
+Methods:
+
+- `description` (of type `string`): Description
+- `mime` (of type `string`): Mime type
+- `picture_type` (of type `int`): Picture type
+
+### `string.pic.parse`
+
+Parse PIC ID3v2 tags (such as those obtained in the PIC tag from `file.metadata.id3v2`). The returned values are: format, picture type, description, and picture data.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): PIC data.
+
+Methods:
+
+- `description` (of type `string`): Description
+- `format` (of type `string`): Picture format
+- `picture_type` (of type `int`): Picture type
+
+### `track.metadata.deduplicate`
+
+Remove duplicate metadata in a track.
+
+Type:
+
+```
+(?id : string?, metadata) -> metadata
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"track.metadata.deduplicate"`)
+- `(unlabeled)` (of type `metadata`)
+
+## Programming
+
+### `assert`
+
+Ensure that a condition is satisfied (raise `error.assertion` exception otherwise).
+
+Type:
+
+```
+(bool) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `bool`): Condition which should be satisfied.
+
+### `error.on_error`
+
+Register a callback to monitor errors raised during the execution of the program. The callback is allow to re-raise a different error if needed.
+
+Type:
+
+```
+(((error
+   .{
+     kind : string,
+     message : string,
+     trace : [
+              {
+                position_end : 
+                {character_offset : int, filename : string, line_number : int
+                },
+                position_start : 
+                {character_offset : int, filename : string, line_number : int
+                },
+                to_string : (?prefix : string) -> string
+              }]
+   }) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }) -> unit`)
+
+### `error.raise`
+
+Raise an error.
+
+Type:
+
+```
+(error, ?string) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `error`): Error kind.
+- `(unlabeled)` (of type `string`, which defaults to `""`): Description of the error.
+
+### `error.register`
+
+Register an error of the given kind
+
+Type:
+
+```
+(string) -> error
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Kind of the error
+
+Methods:
+
+- `kind` (of type `string`): Error kind.
+- `message` (of type `string`): Error message.
+- `trace` (of type `[
+ {
+   position_end : 
+   {character_offset : int, filename : string, line_number : int
+   },
+   position_start : 
+   {character_offset : int, filename : string, line_number : int
+   },
+   to_string : (?prefix : string) -> string
+ }]`): Error stacktrace.
+
+### `failwith`
+
+Major failure.
+
+Type:
+
+```
+(string) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Explanation about the failure.
+
+### `fst`
+
+Get the first component of a pair.
+
+Type:
+
+```
+(('a * 'b)) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a * 'b`)
+
+### `ignore`
+
+Convert anything to unit, preventing warnings.
+
+Type:
+
+```
+('a) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+
+### `memoize`
+
+Memoize the result of a function, making sure it is only executed once.
+
+Type:
+
+```
+((() -> 'a)) -> () -> 'a where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> 'a where 'a is an orderable type`)
+
+### `null`
+
+Create a nullable value.
+
+Type:
+
+```
+(?'a?) -> 'a?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a?`, which defaults to `null`): Value to make nullable.
+
+### `null.case`
+
+Return a result dending on whether a value is nothing or not.
+
+Type:
+
+```
+('a?, (() -> 'b), (('a) -> 'b)) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a?`): Value to reason by case analysis on.
+- `(unlabeled)` (of type `() -> 'b`): Value to return in case we have nothing.
+- `(unlabeled)` (of type `('a) -> 'b`): Value to return in case we have something.
+
+### `null.default`
+
+Return a result dending on whether a value is nothing or not.
+
+Type:
+
+```
+('a?, (() -> 'a)) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a?`): Value to reason by case analysis on.
+- `(unlabeled)` (of type `() -> 'a`): Value to return in case we have nothing.
+
+### `null.defined`
+
+Determine whether a nullable value is not null.
+
+Type:
+
+```
+('a?) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a?`)
+
+### `null.find`
+
+Find the first element of a list for which the image of the function is not `null`. Raises `error.not_found` if not element is found and no default value was specified.
+
+Type:
+
+```
+(?default : 'a??, (('b) -> 'a?), ['b]) -> 'a?
+```
+
+Arguments:
+
+- `default` (of type `'a??`, which defaults to `null`): Returned value when no element is found.
+- `(unlabeled)` (of type `('b) -> 'a?`): Function.
+- `(unlabeled)` (of type `['b]`): List.
+
+### `null.get`
+
+Get the value of a nullable. Raises `error.not_found` if the value is `null` and no default value was specified.
+
+Type:
+
+```
+(?default : 'a?, 'a?) -> 'a
+```
+
+Arguments:
+
+- `default` (of type `'a?`, which defaults to `null`): Returned value when the value is `null`.
+- `(unlabeled)` (of type `'a?`)
+
+### `null.map`
+
+Apply a function on a nullable value if it is not null, and return null otherwise.
+
+Type:
+
+```
+((('a) -> 'b?), 'a?) -> 'b?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b?`)
+- `(unlabeled)` (of type `'a?`)
+
+### `null.to_list`
+
+Convert a nullable value to a list containing zero or one element depending on whether the value is null or not.
+
+Type:
+
+```
+('a?) -> ['a]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a?`)
+
+### `position`
+
+Return the current position in the script
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `character_offset` (of type `int`): character offset
+- `filename` (of type `string`): filename
+- `line_number` (of type `int`): line number
+
+### `predicate.activates`
+
+Detect when a predicate becomes true.
+
+Type:
+
+```
+(?init : bool, (() -> bool)) -> () -> bool
+```
+
+Arguments:
+
+- `init` (of type `bool`, which defaults to `false`): Detect at beginning.
+- `(unlabeled)` (of type `() -> bool`): Predicate.
+
+### `predicate.at_most`
+
+Limit the number of times a predicate is true is a row.
+
+Type:
+
+```
+(int, (() -> bool)) -> () -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Number of times the predicate is allowed to be true.
+- `(unlabeled)` (of type `() -> bool`): Predicate.
+
+### `predicate.changes`
+
+Detect when a predicate changes.
+
+Type:
+
+```
+((() -> 'a)) -> () -> bool where 'a is an orderable type
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> 'a where 'a is an orderable type`): Predicate.
+
+### `predicate.first`
+
+First occurrence of a predicate.
+
+Type:
+
+```
+((() -> bool)) -> () -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> bool`): Predicate.
+
+### `predicate.once`
+
+Become true once every time a predicate is true.
+
+Type:
+
+```
+((() -> bool)) -> () -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> bool`): Predicate.
+
+### `predicate.signal`
+
+Predicate which is true when a signal is sent. The returned predicate has a method `signal` to send the signal.
+
+Type:
+
+```
+() -> () -> bool
+```
+
+Methods:
+
+- `signal` (of type `() -> unit`): Send a signal.
+
+### `print`
+
+Print on standard output.
+
+Type:
+
+```
+(?newline : bool, 'a) -> unit
+```
+
+Arguments:
+
+- `newline` (of type `bool`, which defaults to `true`): If true, a newline is added after displaying the value.
+- `(unlabeled)` (of type `'a`)
+
+### `ref`
+
+Create a reference, i.e. a value which can be modified.
+
+Type:
+
+```
+('a) -> () -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a`)
+
+Methods:
+
+- `set` (of type `('A) -> unit`): Set the value of the reference.
+
+### `ref.getter`
+
+Create a getter from a reference (sometimes useful to remove the `set` method).
+
+Type:
+
+```
+((() -> 'a).{set : ('a) -> unit}) -> () -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(() -> 'a).{set : ('a) -> unit}`)
+
+### `ref.incr`
+
+Increment a reference to an integer.
+
+Type:
+
+```
+((() -> int).{set : (int) -> 'a}) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(() -> int).{set : (int) -> 'a}`)
+
+### `ref.make`
+
+Create a reference from a pair of get / set functions.
+
+Type:
+
+```
+((() -> 'a), (('a) -> unit)) -> () -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> 'a`): Function to retrieve the value of the reference.
+- `(unlabeled)` (of type `('a) -> unit`): Function to change the value of the reference.
+
+Methods:
+
+- `set` (of type `('A) -> unit`): Set the value of the reference.
+
+### `ref.map`
+
+Map functions to a reference.
+
+Type:
+
+```
+((('a) -> 'b), (('b) -> 'a), (() -> 'a).{set : ('a) -> unit}) -> () -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `('a) -> 'b`): Function to apply to the getter.
+- `(unlabeled)` (of type `('b) -> 'a`): Function to apply to the setter.
+- `(unlabeled)` (of type `(() -> 'a).{set : ('a) -> unit}`)
+
+Methods:
+
+- `set` (of type `('A) -> unit`): Set the value of the reference.
+
+### `snd`
+
+Get the second component of a pair.
+
+Type:
+
+```
+(('a * 'b)) -> 'b
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'a * 'b`)
+
+### `thread.on_error`
+
+Register the function to be called when an error of the given kind is raised in a thread. Catches all errors if first argument is `null`.
+
+Type:
+
+```
+(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }?,
+ ((backtrace : string, error
+   .{
+     kind : string,
+     message : string,
+     trace : [
+              {
+                position_end : 
+                {character_offset : int, filename : string, line_number : int
+                },
+                position_start : 
+                {character_offset : int, filename : string, line_number : int
+                },
+                to_string : (?prefix : string) -> string
+              }]
+   }) -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `error
+.{
+  kind : string,
+  message : string,
+  trace : [
+           {
+             position_end : 
+             {character_offset : int, filename : string, line_number : int
+             },
+             position_start : 
+             {character_offset : int, filename : string, line_number : int
+             },
+             to_string : (?prefix : string) -> string
+           }]
+}?`)
+- `(unlabeled)` (of type `(backtrace : string, error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }) -> unit`)
+
+### `thread.pause`
+
+Pause execution for a given amount of seconds. This freezes the calling thread and should not be used in the main streaming loop.
+
+Type:
+
+```
+(float) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float`): Number of seconds of pause.
+
+### `thread.run`
+
+Run a function in a separate thread.
+
+Type:
+
+```
+(?fast : bool, ?delay : float, ?every : {float}?, (() -> unit)) -> unit
+```
+
+Arguments:
+
+- `fast` (of type `bool`, which defaults to `true`): Whether the thread is supposed to return quickly or not. Typically, blocking tasks (e.g. fetching data over the internet) should not be considered to be fast. When set to `false` its priority will be lowered below that of request resolutions and fast timeouts. This is only effective if you set a dedicated queue for fast tasks, see the "scheduler" settings for more details.
+- `delay` (of type `float`, which defaults to `0.`): Delay (in seconds) after which the thread should be launched.
+- `every` (of type `{float}?`, which defaults to `null`): How often (in seconds) the thread should be run. If negative or `null`, run once.
+- `(unlabeled)` (of type `() -> unit`): Function to execute.
+
+### `thread.run.recurrent`
+
+Run a recurrent function in a separate thread.
+
+Type:
+
+```
+(?fast : bool, ?delay : float, (() -> float)) -> unit
+```
+
+Arguments:
+
+- `fast` (of type `bool`, which defaults to `true`): Whether the thread is supposed to return quickly or not. Typically, blocking tasks (e.g. fetching data over the internet) should not be considered to be fast. When set to `false` its priority will be lowered below that of request resolutions and fast timeouts. This is only effective if you set a dedicated queue for fast tasks, see the "scheduler" settings for more details.
+- `delay` (of type `float`, which defaults to `0.`): Delay (in sec.) after which the thread should be launched.
+- `(unlabeled)` (of type `() -> float`): Function to execute recurrently. The returned value is the delay (in sec.) in which the function should be run again (it won't be run if the value is strictly negative).
+
+### `thread.when`
+
+Execute a callback when a predicate is `true`. The predicate is checked `every` seconds and the callback is called when the predicate returns `true` after having been `false`, following the same semantics as `predicate.activates`.
+
+Type:
+
+```
+(?fast : bool, ?init : bool, ?every : {float}, ?once : bool, ?changed : bool,
+ (() -> bool), (() -> 'a)) -> unit
+```
+
+Arguments:
+
+- `fast` (of type `bool`, which defaults to `true`): Whether the callback is supposed to return quickly or not.
+- `init` (of type `bool`, which defaults to `true`): Detect at beginning.
+- `every` (of type `{float}`, which defaults to `0.5`): How often (in sec.) to check for the predicate.
+- `once` (of type `bool`, which defaults to `false`): Execute the function only once.
+- `changed` (of type `bool`, which defaults to `true`): Execute the function only if the predicate was false when last checked.
+- `(unlabeled)` (of type `() -> bool`): Predicate indicating when to execute the function, typically a time interval such as `{10h-10h30}`.
+- `(unlabeled)` (of type `() -> 'a`): Function to execute when the predicate is true.
+
+### `while`
+
+A while loop.
+
+Type:
+
+```
+({bool}, (() -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{bool}`): Condition guarding the loop.
+- `(unlabeled)` (of type `() -> unit`): Function to execute.
+
+## Settings
+
+### `audio.channels`
+
+Channels for audio.
+
+Type:
+
+```
+() -> int
+```
+
+### `audio.samplerate`
+
+Samplerate for audio.
+
+Type:
+
+```
+() -> int
+```
+
+### `frame.duration`
+
+Duration of a frame.
+
+Type:
+
+```
+() -> float
+```
+
+## Source / Audio processing
+
+### `add`
+
+Mix sources, with optional normalization. Only relay metadata from the first available source. Track marks are dropped from all sources.
+
+Type:
+
+```
+(?id : string?, ?normalize : {bool}, ?power : {bool}, ?weights : [{float}],
+ [source('a)]) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `normalize` (of type `{bool}`, which defaults to `true`): Divide by the sum of weights of ready sources (or by the number of ready sources if weights are not specified).
+- `power` (of type `{bool}`, which defaults to `false`): Perform constant-power normalization.
+- `weights` (of type `[{float}]`, which defaults to `[]`): Relative weight of the sources in the sum. The empty list stands for the homogeneous distribution. These are used as amplification coefficients if we are not normalizing.
+- `(unlabeled)` (of type `[source('a)] where 'a is a set of internal tracks`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `amplify`
+
+Multiply the amplitude of the signal.
+
+Type:
+
+```
+(?id : string?, ?override : string?, {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"amplify"`): Force the value of the track ID.
+- `override` (of type `string?`, which defaults to `"liq_amplify"`): Specify the name of a metadata field that, when present and well-formed, overrides the amplification factor for the current track. Well-formed values are floats in decimal notation (e.g. `0.7`) which are taken as normal/linear multiplicative factors; values can be passed in decibels with the suffix `dB` (e.g. `-8.2 dB`, but the spaces do not matter).
+- `(unlabeled)` (of type `{float}`): Multiplicative factor.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `audio.decode.pcm_f32`
+
+Decode audio track to pcm_f32
+
+Type:
+
+```
+(?id : string?, source(audio=pcm_f32('a), 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"audio.decode.pcm_f32"`)
+- `(unlabeled)` (of type `source(audio=pcm_f32('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `audio.decode.pcm_s16`
+
+Decode audio track to pcm_s16
+
+Type:
+
+```
+(?id : string?, source(audio=pcm_s16('a), 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"audio.decode.pcm_s16"`)
+- `(unlabeled)` (of type `source(audio=pcm_s16('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `audio.encode.pcm_f32`
+
+Encode audio track to pcm_f32
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm_f32('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"audio.encode.pcm_f32"`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `audio.encode.pcm_s16`
+
+Encode audio track to pcm_s16
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm_s16('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"audio.encode.pcm_s16"`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `autocue.register`
+
+Register an `autocue` implementation.
+
+Type:
+
+```
+(name : string,
+ ((request_metadata : [string * string], file_metadata : [string * string],
+   string) -> 
+  {
+    amplify? : string,
+    cue_in : float,
+    cue_out : float,
+    extra_metadata? : [string * string],
+    fade_in : float,
+    fade_in_curve? : float,
+    fade_in_type? : string,
+    fade_out : float,
+    fade_out_curve? : float,
+    fade_out_type? : string,
+    start_next? : float}?)) -> unit
+```
+
+Arguments:
+
+- `name` (of type `string`): Name of the implementation
+- `(unlabeled)` (of type `(request_metadata : [string * string], file_metadata : [string * string],
+ string) -> 
+{
+  amplify? : string,
+  cue_in : float,
+  cue_out : float,
+  extra_metadata? : [string * string],
+  fade_in : float,
+  fade_in_curve? : float,
+  fade_in_type? : string,
+  fade_out : float,
+  fade_out_curve? : float,
+  fade_out_type? : string,
+  start_next? : float}?`)
+
+### `clip`
+
+Clip samples, i.e. ensure that all values are between `-1` and `1`: values lower than `-1` become `-1` and values higher than `1` become `1`. `nan` values become `0`.
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"clip"`): Force the value of the track ID.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `delay_line`
+
+Delay the audio signal by a given amount of time.
+
+Type:
+
+```
+(?id : string?, {float}, source(audio=pcm('a), 'b)) -> source(audio=pcm('a),
+'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `{float}`): Duration of the delay in seconds.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `dtmf.detect`
+
+Detect DTMF tones.
+
+Type:
+
+```
+(?id : string?, ?bands : int, ?debug : {bool}, ?duration : {float},
+ ?smoothing : {float}, ?threshold : {float}, source(audio=pcm('a), 'b),
+ ((string) -> unit)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bands` (of type `int`, which defaults to `1024`): Number of frequency bands.
+- `debug` (of type `{bool}`, which defaults to `false`): Show internal values on standard output in order to fine-tune parameters: band number, band frequency, detected intensity and smoothed intensity.
+- `duration` (of type `{float}`, which defaults to `0.05`): Duration for detecting a tone.
+- `smoothing` (of type `{float}`, which defaults to `0.01`): Smoothing time (in seconds) for band indensity (the higher, the less sensitive we are to local variations, but the more time we take to detect a band).
+- `threshold` (of type `{float}`, which defaults to `50.`): Threshold for detecting a band.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`): Source on which DTMF tones should be detected.
+- `(unlabeled)` (of type `(string) -> unit`): Function called with detected key as argument.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `echo`
+
+Add echo.
+
+Type:
+
+```
+(?id : string?, ?delay : {float}, ?feedback : {float}, ?ping_pong : bool,
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `delay` (of type `{float}`, which defaults to `0.5`): Delay in seconds.
+- `feedback` (of type `{float}`, which defaults to `-6.`): Feedback coefficient in dB (negative).
+- `ping_pong` (of type `bool`, which defaults to `false`): Use ping-pong delay.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `file.autocue.metadata`
+
+Return the file's autocue values as metadata suitable for metadata override.
+
+Type:
+
+```
+(metadata : [string * string], string) -> [string * string]
+```
+
+Arguments:
+
+- `metadata` (of type `[string * string]`)
+- `(unlabeled)` (of type `string`)
+
+### `filter`
+
+Perform several kinds of filtering on the signal. Only frequencies below the sampling rate / 4 (generally 10 kHz) are handled well for the `freq` parameter.
+
+Type:
+
+```
+(?id : string?, freq : {float}, mode : string, ?q : {float},
+ ?wetness : {float}, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `freq` (of type `{float}`): Characteristic frequency of the filter.
+- `mode` (of type `string`): Available modes are 'low' (for low-pass filter), 'high' (for high-pass filter), 'band' (for band-pass filter) and 'notch' (for notch / band-stop / band-rejection filter).
+- `q` (of type `{float}`, which defaults to `1.`)
+- `wetness` (of type `{float}`, which defaults to `1.`): How much of the original signal should be added (1. means only filtered and 0. means only original signal).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.fir`
+
+Low-pass FIR filter.
+
+Type:
+
+```
+(?id : string?, beta : float, ?coeffs : int, frequency : float,
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `beta` (of type `float`): Beta should range between 0 and 1.
+- `coeffs` (of type `int`, which defaults to `255`): Number of coefficients
+- `frequency` (of type `float`): Corner frequency in Hz (frequency at which the response is 0.5, that is -6 dB).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.butterworth.bandpass`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency1 : float, frequency2 : float, ?order : int,
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency1` (of type `float`): First corner frequency
+- `frequency2` (of type `float`): Second corner frequency
+- `order` (of type `int`, which defaults to `4`): Filter order
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.butterworth.bandstop`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency1 : float, frequency2 : float, ?order : int,
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency1` (of type `float`): First corner frequency
+- `frequency2` (of type `float`): Second corner frequency
+- `order` (of type `int`, which defaults to `4`): Filter order
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.butterworth.high`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency : float, ?order : int, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `float`): Corner frequency
+- `order` (of type `int`, which defaults to `4`): Filter order
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.butterworth.low`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency : float, ?order : int, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `float`): Corner frequency
+- `order` (of type `int`, which defaults to `4`): Filter order
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.allpass`
+
+All-pass biquad filter.
+
+Type:
+
+```
+(?id : string?, ?bandwidth : {float}, frequency : {float}, source('a)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bandwidth` (of type `{float}`, which defaults to `0.333333333333`): Bandwidth (in octaves)
+- `frequency` (of type `{float}`): Center frequency
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.bandpass`
+
+Band-pass biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?q : {float}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Center frequency
+- `q` (of type `{float}`, which defaults to `1.`): Q
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.high`
+
+High-pass biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?q : {float}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Corner frequency
+- `q` (of type `{float}`, which defaults to `1.`): Q
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.highshelf`
+
+High shelf biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?slope : {float}, source('a)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Center frequency
+- `slope` (of type `{float}`, which defaults to `1.`): Shelf slope (in dB/octave)
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.low`
+
+Low-pass biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?q : {float}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Corner frequency
+- `q` (of type `{float}`, which defaults to `1.`): Q
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.lowshelf`
+
+Low shelf biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?slope : {float}, source('a)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Corner frequency
+- `slope` (of type `{float}`, which defaults to `1.`): Shelf slope (dB/octave)
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.notch`
+
+Band-pass biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?q : {float}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Center frequency
+- `q` (of type `{float}`, which defaults to `1.`): Q
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.eq.peak`
+
+Peak EQ biquad filter.
+
+Type:
+
+```
+(?id : string?, frequency : {float}, ?gain : {float}, ?q : {float},
+ source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Center frequency
+- `gain` (of type `{float}`, which defaults to `1.`): Gain (in dB)
+- `q` (of type `{float}`, which defaults to `1.`): Q
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.resonator.allpass`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency : float, ?q : float, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `float`): Corner frequency
+- `q` (of type `float`, which defaults to `60.`): Quality factor
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.resonator.bandpass`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency : float, ?q : float, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `float`): Corner frequency
+- `q` (of type `float`, which defaults to `60.`): Quality factor
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.iir.resonator.bandstop`
+
+IIR filter
+
+Type:
+
+```
+(?id : string?, frequency : float, ?q : float, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `float`): Corner frequency
+- `q` (of type `float`, which defaults to `60.`): Quality factor
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `filter.rc`
+
+First-order filter (RC filter).
+
+Type:
+
+```
+(?id : string?, frequency : {float}, mode : string, ?wetness : {float},
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `frequency` (of type `{float}`): Cutoff frequency.
+- `mode` (of type `string`): Available modes are 'low' (for low-pass filter), 'high' (for high-pass filter).
+- `wetness` (of type `{float}`, which defaults to `1.`): How much of the original signal should be added (1. means only filtered and 0. means only original signal).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `flanger`
+
+Flanger effect.
+
+Type:
+
+```
+(?id : string?, ?delay : float, ?feedback : {float}, ?freq : {float},
+ ?phase : {float}, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `delay` (of type `float`, which defaults to `0.001`): Delay in seconds.
+- `feedback` (of type `{float}`, which defaults to `0.`): Feedback coefficient in dB.
+- `freq` (of type `{float}`, which defaults to `0.5`): Frequency in Hz.
+- `phase` (of type `{float}`, which defaults to `1.`): Phase difference between channels in radians.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `gate`
+
+Reduce the volume when the stream is silent (typically in order to avoid low intensity noise).
+
+Type:
+
+```
+(?id : string?, ?attack : {float}, ?hold : {float}, ?range : {float},
+ ?release : {float}, ?threshold : {float}, ?window : {float},
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `{float}`, which defaults to `10.`): Time to fully open the gate (ms).
+- `hold` (of type `{float}`, which defaults to `1000.`): Minimum amount of time the gate stays open (ms).
+- `range` (of type `{float}`, which defaults to `-30.`): Difference between closed and open level (dB).
+- `release` (of type `{float}`, which defaults to `2000.`): Time to fully close the gate (ms).
+- `threshold` (of type `{float}`, which defaults to `-30.`): Threshold at which the gate will open (dB).
+- `window` (of type `{float}`, which defaults to `1.`): Duration for computing peak (ms).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gate` (of type `() -> float`): Position of the gate (0. means closed, 1. means open).
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `normalize`
+
+Normalization the volume of a stream (this is also called _automatic gain control_). Dynamic normalization of the signal is sometimes the only option (for instance, for live sources), and can make a listening experience much nicer. However, its dynamic aspect implies some limitations which can go as far as creating saturation in some extreme cases. If possible, consider using some track-based normalization techniques such as those based on ReplayGain. The implementation of Liquidsoap < 2.0 was renamed to `normalize.old`.
+
+Type:
+
+```
+(?id : string?, ?target : {float}, ?up : {float}, ?down : {float},
+ ?gain_min : float, ?gain_max : float, ?lufs : bool, ?lookahead : {float},
+ ?window : {float}, ?threshold : {float}, ?track_sensitive : bool,
+ ?debug : float??, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `target` (of type `{float}`, which defaults to `-13.`): Desired RMS (dB).
+- `up` (of type `{float}`, which defaults to `10.`): Characteristic time to go up.
+- `down` (of type `{float}`, which defaults to `0.1`): Characteristic time to go down.
+- `gain_min` (of type `float`, which defaults to `-12.`): Minimal gain value (dB).
+- `gain_max` (of type `float`, which defaults to `12.`): Maximal gain value (dB).
+- `lufs` (of type `bool`, which defaults to `false`): Use LUFS instead of RMS to compute intensity.
+- `lookahead` (of type `{float}`, which defaults to `0.`): How much time to look ahead of the signal (second). Setting a positive value delays the output by the corresponding amount of time.
+- `window` (of type `{float}`, which defaults to `0.5`): Duration of the window used to compute the current RMS power (second).
+- `threshold` (of type `{float}`, which defaults to `-40.`): Minimal RMS for activaing gain control (dB).
+- `track_sensitive` (of type `bool`, which defaults to `true`)
+- `debug` (of type `float??`, which defaults to `null`): How often to print debug messages, in seconds, useful to finetune the parameters. You should set `set("log.level", 5)` to see them.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`): Source to normalize.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): Current amplification coefficient (in linear scale).
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): Current rms (in linear scale).
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `target_gain` (of type `() -> float`): Current target amplification coefficient (in linear scale).
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `normalize.old`
+
+Normalize the signal. Dynamic normalization of the signal is sometimes the only option, and can make a listening experience much nicer. However, its dynamic aspect implies some limitations which can go as far as creating saturation in some extreme cases. If possible, consider using some track-based normalization techniques such as those based on replay gain. See the documentation for more details. This is the implementation provided in Liquidsoap < 2.0. A new, better and more customizable one is now given in `normalize`.
+
+Type:
+
+```
+(?id : string?, ?gain_max : {float}, ?gain_min : {float}, ?k_down : {float},
+ ?k_up : {float}, ?target : {float}, ?threshold : {float},
+ ?track_sensitive : bool, ?window : float, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `gain_max` (of type `{float}`, which defaults to `6.`): Maximal gain value (dB).
+- `gain_min` (of type `{float}`, which defaults to `-6.`): Minimal gain value (dB).
+- `k_down` (of type `{float}`, which defaults to `0.1`): Coefficient when the power must go down (between 0 and 1, slowest to fastest).
+- `k_up` (of type `{float}`, which defaults to `0.005`): Coefficient when the power must go up (between 0 and 1, slowest to fastest).
+- `target` (of type `{float}`, which defaults to `-13.`): Desired RMS (dB).
+- `threshold` (of type `{float}`, which defaults to `-40.`): Minimal RMS for activaing gain control (dB).
+- `track_sensitive` (of type `bool`, which defaults to `true`): Reset values on every track.
+- `window` (of type `float`, which defaults to `0.1`): Duration of the window used to compute the current RMS power (second).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): Current amplification coefficient.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): Current RMS.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `peak`
+
+Get current peak volume of the source. Returns the source with a method `peak` to compute the current peak volume of the source, with `0.0 <= peak volume <= 1.0`.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `0.5`): Duration of the window (in seconds). A value <= 0, means that computation should not be performed.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `peak` (of type `() -> float`): Current value for the peak volume.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `peak.stereo`
+
+Get current peak volume of the source. Returns the source with a method `peak` to compute the current peak volume of the source, with `0.0 <= peak volume <= 1.0`.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}, source(audio=pcm(stereo), 'a)) ->
+source(audio=pcm(stereo), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `0.5`): Duration of the window (in seconds). A value <= 0, means that computation should not be performed.
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `peak` (of type `() -> float * float`): Current value for the peak volume.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `pipe`
+
+Process audio signal through a given process stdin/stdout.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?data_length : int?, ?max : float,
+ process : string, ?replay_delay : float?, ?restart : bool,
+ ?restart_on_error : bool, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer` (of type `float`, which defaults to `1.`): Duration of the pre-buffered data.
+- `data_length` (of type `int?`, which defaults to `null`): Length passed in the WAV data chunk. Data is streamed so no the consuming program should process it as it comes. Some program operate better when this value is set to `0`, some other when it is set to the maximum length allowed by the WAV specs. Use any negative value to set to maximum length.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `process` (of type `string`): Process used to pipe data to.
+- `replay_delay` (of type `float?`, which defaults to `null`): Replay track marks and metadata from the input source on the output after a given delay. If `null` (default) close and flush the process on each track and metadata to get an exact timing. This parameter is typically used when integrating with `stereotool`.
+- `restart` (of type `bool`, which defaults to `true`): Restart process when exited.
+- `restart_on_error` (of type `bool`, which defaults to `true`): Restart process when exited with error.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `replaygain`
+
+Amplify source tracks according to replaygain metadata. This operator does not compute itself the replaygain: you can use either `enable_replaygain_metadata` or the `replaygain:` protocol for this.
+
+Type:
+
+```
+(?id : string?, ?ebu_r128 : bool, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `ebu_r128` (of type `bool`, which defaults to `true`): Also amplify according to EBU R128 tags.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`): Source to be amplified.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `rms`
+
+Get current RMS volume of the source. Returns the source with a method `rms` to compute the current RMS volume of the source, with `0.0 <= RMS volume <= 1.0`.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `0.5`): Duration of the window (in seconds). A value <= 0, means that computation should not be performed.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): Current value for the RMS volume.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `rms.stereo`
+
+Get current RMS volume of the source. Returns the source with a method `rms` to compute the current RMS volume of the source, with `0.0 <= RMS volume <= 1.0`.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}, source(audio=pcm(stereo), 'a)) ->
+source(audio=pcm(stereo), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `0.5`): Duration of the window (in seconds). A value <= 0, means that computation should not be performed.
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float * float`): Current value for the RMS volume.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `sine.detect`
+
+Detect sine waves.
+
+Type:
+
+```
+(?id : string?, ?bands : int, ?debug : {bool}, ?duration : {float},
+ ?smoothing : {float}, ?threshold : {float}, [float], source(audio=pcm('a),
+ 'b), ((float) -> unit)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bands` (of type `int`, which defaults to `1024`): Number of frequency bands.
+- `debug` (of type `{bool}`, which defaults to `false`): Show internal values on standard output in order to fine-tune parameters: band number, band frequency, detected intensity and smoothed intensity.
+- `duration` (of type `{float}`, which defaults to `0.5`): Duration for detecting a tone.
+- `smoothing` (of type `{float}`, which defaults to `0.01`): Smoothing time (in seconds) for band indensity (the higher, the less sensitive we are to local variations, but the more time we take to detect a band).
+- `threshold` (of type `{float}`, which defaults to `50.`): Threshold for detecting a band.
+- `(unlabeled)` (of type `[float]`): List of frequencies to detect.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`): Source on which sines should be detected.
+- `(unlabeled)` (of type `(float) -> unit`): Function called with detected frequency as argument.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `soundtouch`
+
+Change the rate, the tempo or the pitch of the sound.
+
+Type:
+
+```
+(?id : string?, ?pitch : {float}, ?rate : {float}, ?tempo : {float},
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `pitch` (of type `{float}`, which defaults to `1.`)
+- `rate` (of type `{float}`, which defaults to `1.`)
+- `tempo` (of type `{float}`, which defaults to `1.`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `source.replaygain.compute`
+
+Compute the ReplayGain of the source. Data is accumulated until the `gain` method is called, i.e. the gain is computed _after_ the source has been played..
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `gain` (of type `() -> float`): Suggested gain (in dB).
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `peak` (of type `() -> float`): Peak sample.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reset` (of type `() -> unit`): Reset ReplayGain computation.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo.ms.decode`
+
+Decode mid+side stereo (M/S) to left+right stereo.
+
+Type:
+
+```
+(?id : string?, ?width : float, source(audio=pcm(stereo), 'a)) ->
+source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo.ms.decode"`): Force the value of the track ID.
+- `width` (of type `float`, which defaults to `1.`): Width of the stereo field.
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo.ms.encode`
+
+Encode left+right stereo to mid+side stereo (M/S).
+
+Type:
+
+```
+(?id : string?, source(audio=pcm(stereo), 'a)) -> source(audio=pcm(stereo),
+'a) where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo.ms.encode"`): Force the value of the track ID.
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo.pan`
+
+Pan a stereo sound.
+
+Type:
+
+```
+(?id : string?, ?pan : {float}, ?field : {float}, source(audio=pcm(stereo),
+ 'a)) -> source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo.pan"`): Force the value of the track ID.
+- `pan` (of type `{float}`, which defaults to `0.`): Pan ranges between -1 and 1.
+- `field` (of type `{float}`, which defaults to `90.`): Field width in degrees (between 0 and 90).
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo.width`
+
+Spacializer which allows controlling the width of the signal.
+
+Type:
+
+```
+(?id : string?, ?{float}, source(audio=pcm(stereo), 'a)) ->
+source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo.width"`)
+- `(unlabeled)` (of type `{float}`, which defaults to `0.`): Width of the signal (-1: mono, 0.: original, 1.: wide stereo).
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereotool`
+
+Process an audio source using stereotool
+
+Type:
+
+```
+(?id : string?, library_file : string, ?license_key : string?,
+ ?preset : string?, ?load_type : string, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereotool"`): Force the value of the track ID.
+- `library_file` (of type `string`): Path to the shared library file.
+- `license_key` (of type `string?`, which defaults to `null`)
+- `preset` (of type `string?`, which defaults to `null`): Path to a preset file to load when initializing the operator.
+- `load_type` (of type `string`, which defaults to `"totalinit"`): Load type for preset. One of: "totalinit", "all_settings", "audiofm", "audio", "processing", "repair", "repair_no_pnr" or "sublevel_pnr".
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `api_version` (of type `() -> int`): API version.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `latency` (of type `() -> float`): Get the operator's latency.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `software_version` (of type `() -> int`): Software version.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `unlincensed_used_features` (of type `() -> string?`): Check if the license is valid for the current settings.
+- `valid_license` (of type `() -> bool`): Check if the license is valid for the current settings.
+
+### `stretch`
+
+Slow down or accelerate an audio stream by stretching (sounds lower) or squeezing it (sounds higher).
+
+Type:
+
+```
+(?id : string?, ratio : {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stretch"`): Force the value of the track ID.
+- `ratio` (of type `{float}`): A value higher than 1 means slowing down.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Conversion
+
+### `ffmpeg.decode.audio`
+
+Decode a source's audio content
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('a), 'b)) -> source(audio=pcm('c))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.decode.audio"`)
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.decode.audio_video`
+
+Decode a source's audio and video content
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.copy('b), video=ffmpeg.copy('a))) ->
+source(audio=pcm('c), video=canvas('d))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.decode.audio_video"`)
+- `(unlabeled)` (of type `source(audio=ffmpeg.copy('b), video=ffmpeg.copy('a))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.decode.video`
+
+Decode a source's video content
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.copy('a), 'b)) ->
+source(video=canvas('c))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.decode.video"`)
+- `(unlabeled)` (of type `source(video=ffmpeg.copy('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.encode.audio`
+
+Encode a source's audio content
+
+Type:
+
+```
+(?id : string?, format(audio=pcm('a), 'b), source(audio=pcm('a), 'c)) ->
+source(audio=ffmpeg.copy('d))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.encode.audio"`)
+- `(unlabeled)` (of type `format(audio=pcm('a), 'b)`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'c)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.encode.audio_video`
+
+Encode a source's audio and video content
+
+Type:
+
+```
+(?id : string?, format(audio=pcm('a), video=canvas('b), 'c),
+ source(audio=pcm('a), video=canvas('b))) -> source(audio=ffmpeg.copy('d),
+video=ffmpeg.copy('e))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.encode.audio_video"`)
+- `(unlabeled)` (of type `format(audio=pcm('a), video=canvas('b), 'c)`)
+- `(unlabeled)` (of type `source(audio=pcm('a), video=canvas('b))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.encode.video`
+
+Encode a source's video content
+
+Type:
+
+```
+(?id : string?, format(video=canvas('a), 'b), source(video=canvas('a), 'c)) ->
+source(video=ffmpeg.copy('d))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.encode.video"`)
+- `(unlabeled)` (of type `format(video=canvas('a), 'b)`)
+- `(unlabeled)` (of type `source(video=canvas('a), 'c)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.raw.decode.audio`
+
+Decode a source's audio content
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.audio.raw('a), 'b)) ->
+source(audio=pcm('c))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.raw.decode.audio"`)
+- `(unlabeled)` (of type `source(audio=ffmpeg.audio.raw('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.raw.decode.audio_video`
+
+Decode a source's audio and video content
+
+Type:
+
+```
+(?id : string?, source(audio=ffmpeg.audio.raw('b),
+ video=ffmpeg.video.raw('a))) -> source(audio=pcm('c), video=canvas('d))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.raw.decode.audio_video"`)
+- `(unlabeled)` (of type `source(audio=ffmpeg.audio.raw('b), video=ffmpeg.video.raw('a))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.raw.decode.video`
+
+Decode a source's video content
+
+Type:
+
+```
+(?id : string?, source(video=ffmpeg.video.raw('a), 'b)) ->
+source(video=canvas('c))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.raw.decode.video"`)
+- `(unlabeled)` (of type `source(video=ffmpeg.video.raw('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.raw.encode.audio`
+
+Encode a source's audio content
+
+Type:
+
+```
+(?id : string?, format(audio=ffmpeg.audio.raw('a), 'b), source(audio=pcm('c),
+ 'd)) -> source(audio=ffmpeg.audio.raw('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.raw.encode.audio"`)
+- `(unlabeled)` (of type `format(audio=ffmpeg.audio.raw('a), 'b)`)
+- `(unlabeled)` (of type `source(audio=pcm('c), 'd)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.raw.encode.audio_video`
+
+Encode a source's audio and video content
+
+Type:
+
+```
+(?id : string?, format(audio=ffmpeg.audio.raw('a),
+ video=ffmpeg.video.raw('b), 'c), source(audio=pcm('e), video=canvas('d))) ->
+source(audio=ffmpeg.audio.raw('a), video=ffmpeg.video.raw('b))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.raw.encode.audio_video"`)
+- `(unlabeled)` (of type `format(audio=ffmpeg.audio.raw('a), video=ffmpeg.video.raw('b), 'c)`)
+- `(unlabeled)` (of type `source(audio=pcm('e), video=canvas('d))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `ffmpeg.raw.encode.video`
+
+Encode a source's video content
+
+Type:
+
+```
+(?id : string?, format(video=ffmpeg.video.raw('a), 'b),
+ source(video=canvas('c), 'd)) -> source(video=ffmpeg.video.raw('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"ffmpeg.raw.encode.video"`)
+- `(unlabeled)` (of type `format(video=ffmpeg.video.raw('a), 'b)`)
+- `(unlabeled)` (of type `source(video=canvas('c), 'd)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mean`
+
+Produce mono audio by taking the mean of all audio channels.
+
+Type:
+
+```
+(?id : string?, ?normalize : bool, source(audio=pcm('a), 'b)) ->
+source(audio=pcm(mono), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"mean"`): Force the value of the track ID.
+- `normalize` (of type `bool`, which defaults to `true`): Divide the output volume by the number of channels.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo`
+
+Convert any pcm audio source into a stereo source.
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm(stereo), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo"`)
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo.left`
+
+Extract the left channel of a stereo source
+
+Type:
+
+```
+(?id : string?, source(audio=pcm(stereo), 'a)) -> source(audio=pcm(mono), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo.left"`)
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`): Source to extract from
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `stereo.right`
+
+Extract the right channel of a stereo source
+
+Type:
+
+```
+(?id : string?, source(audio=pcm(stereo), 'a)) -> source(audio=pcm(mono), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"stereo.right"`)
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`): Source to extract from
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `swap`
+
+Swap two channels of a stereo source.
+
+Type:
+
+```
+(?string?, source(audio=pcm(stereo), 'a)) -> source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string?`, which defaults to `"swap"`)
+- `(unlabeled)` (of type `source(audio=pcm(stereo), 'a)
+where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `track.audio.stereo.left`
+
+Extract the left channel of a stereo track
+
+Type:
+
+```
+(?id : string?, pcm(stereo)) -> pcm(mono)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"track.audio.stereo.left"`)
+- `(unlabeled)` (of type `pcm(stereo)`): Track to extract from
+
+### `track.audio.stereo.right`
+
+Extract the right channel of a stereo track
+
+Type:
+
+```
+(?id : string?, pcm(stereo)) -> pcm(mono)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"track.audio.stereo.right"`)
+- `(unlabeled)` (of type `pcm(stereo)`): Track to extract from
+
+## Source / FFmpeg filter
+
+### `ffmpeg.filter.audio.input`
+
+Attach an audio track to a filter's input
+
+Type:
+
+```
+(?id : string?, ?pass_metadata : bool, ffmpeg.filter.graph,
+ ffmpeg.audio.raw('a)) -> ffmpeg.filter.audio
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `pass_metadata` (of type `bool`, which defaults to `true`): Pass liquidsoap's metadata to this stream
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.audio.raw('a)`)
+
+### `ffmpeg.filter.create`
+
+Configure and launch a filter graph
+
+Type:
+
+```
+(((ffmpeg.filter.graph) -> 'a)) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `(ffmpeg.filter.graph) -> 'a`)
+
+### `ffmpeg.filter.video.input`
+
+Attach a video track to a filter's input
+
+Type:
+
+```
+(?id : string?, ?pass_metadata : bool, ffmpeg.filter.graph,
+ ffmpeg.video.raw('a)) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `pass_metadata` (of type `bool`, which defaults to `true`): Pass liquidsoap's metadata to this stream
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.video.raw('a)`)
+
+## Source / Fade
+
+### `cross`
+
+Cross operator, allowing the composition of the _n_ last seconds of a track with the beginning of the next track, using a transition function depending on the relative power of the signal before and after the end of track.
+
+Type:
+
+```
+(?id : string?, ?assume_autocue : bool?, ?conservative : bool,
+ ?duration : {float}, ?minimum : float, ?override_duration : string,
+ ?persist_override : bool, ?width : float,
+ ((
+   {
+     db_level : float,
+     metadata : [string * string],
+     source : source(audio=pcm('a),
+     'b)
+   }, 
+   {
+     db_level : float,
+     metadata : [string * string],
+     source : source(audio=pcm('a),
+     'b)
+   }) -> source(audio=pcm('a), 'b)),
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `assume_autocue` (of type `bool?`, which defaults to `null`): Assume that a track has autocue enabled when all four cue in/out and fade in/out override metadata are present. Defaults to `settings.crossfade.assume_autocue` when `null`.
+- `conservative` (of type `bool`, which defaults to `true`): Do not trust remaining time estimations, always buffering data in advance. This avoids being tricked by skips, either manual or caused by blank.skip().
+- `duration` (of type `{float}`, which defaults to `5.`): Duration (in seconds) of buffered data from each track that is used to compute the transition between tracks.
+- `minimum` (of type `float`, which defaults to `-1.`): Minimum duration (in sec.) for a cross: If the track ends without any warning (e.g. in case of skip) there may not be enough data for a decent composition. Set to 0. to avoid having transitions after skips, or more to avoid transitions on short tracks. With a negative default, transitions always occur.
+- `override_duration` (of type `string`, which defaults to `"liq_cross_duration"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for current track.
+- `persist_override` (of type `bool`, which defaults to `false`): Keep duration override on track change.
+- `width` (of type `float`, which defaults to `2.`): Width of the power computation window.
+- `(unlabeled)` (of type `(
+ {
+   db_level : float,
+   metadata : [string * string],
+   source : source(audio=pcm('a),
+   'b)
+ }, 
+ {
+   db_level : float,
+   metadata : [string * string],
+   source : source(audio=pcm('a),
+   'b)
+ }) -> source(audio=pcm('a), 'b)`): Transition function, composing from the end of a track and the next track. The sources corresponding to the two tracks are decorated with fields indicating the power of the signal before and after the transition (`power`), and the metadata (`metadata`).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `cross_duration` (of type `() -> float`): Get the current crossfade duration.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `cross.simple`
+
+Simple transition for crossfade
+
+Type:
+
+```
+(?fade_in : float, ?fade_out : float,
+ ?initial_fade_in_metadata : [string * string],
+ ?initial_fade_out_metadata : [string * string], source(audio=pcm('a), 'b),
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `fade_in` (of type `float`, which defaults to `3.`): Fade-in duration, if any.
+- `fade_out` (of type `float`, which defaults to `3.`): Fade-out duration, if any.
+- `initial_fade_in_metadata` (of type `[string * string]`, which defaults to `[]`): Initial fade-in metadata
+- `initial_fade_out_metadata` (of type `[string * string]`, which defaults to `[]`): Initial fade-out metadata
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Ending track
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Starting track
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `cross.smart`
+
+Smart transition for crossfade
+
+Type:
+
+```
+(?log : ((string) -> unit), ?fade_in : float, ?fade_out : float,
+ ?default : ((source(audio=pcm('a), 'b), source(audio=pcm('a), 'b)) ->
+             source(audio=pcm('a), 'b)),
+ ?high : float, ?medium : float, ?margin : float, 'c
+ .{
+   db_level : float,
+   metadata : [string * string],
+   source : source(audio=pcm('a),
+   'b)
+ }, 'd
+ .{
+   db_level : float,
+   metadata : [string * string],
+   source : source(audio=pcm('a),
+   'b)
+ }) -> source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `log` (of type `(string) -> unit`, which defaults to `<fun>`): Default logger
+- `fade_in` (of type `float`, which defaults to `3.`): Fade-in duration, if any.
+- `fade_out` (of type `float`, which defaults to `3.`): Fade-out duration, if any.
+- `default` (of type `(source(audio=pcm('a), 'b), source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`, which defaults to `<fun>`): Smart crossfade: transition used when no rule applies (default: sequence).
+- `high` (of type `float`, which defaults to `-15.`): Value, in dB, for loud sound level.
+- `medium` (of type `float`, which defaults to `-32.`): Value, in dB, for medium sound level.
+- `margin` (of type `float`, which defaults to `4.`): Margin to detect sources that have too different sound level for crossing.
+- `(unlabeled)` (of type `'c
+.{
+  db_level : float,
+  metadata : [string * string],
+  source : source(audio=pcm('a),
+  'b)
+}
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Ending track
+- `(unlabeled)` (of type `'d
+.{
+  db_level : float,
+  metadata : [string * string],
+  source : source(audio=pcm('a),
+  'b)
+}
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): Starting track
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `crossfade`
+
+Crossfade between tracks, taking the respective volume levels into account in the choice of the transition.
+
+Type:
+
+```
+(?id : string?, ?duration : float, ?override_duration : string,
+ ?persist_override : bool, ?fade_in : float, ?fade_out : float,
+ ?smart : bool,
+ ?default : ((source(audio=pcm('a), 'b), source(audio=pcm('a), 'b)) ->
+             source(audio=pcm('a), 'b)),
+ ?assume_autocue : bool?, ?high : float, ?medium : float, ?margin : float,
+ ?deduplicate : bool, ?minimum : float, ?width : float, ?conservative : bool,
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float`, which defaults to `5.`): Duration (in seconds) of buffered data from each track that is used to compute the transition between tracks.
+- `override_duration` (of type `string`, which defaults to `"liq_cross_duration"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for current track.
+- `persist_override` (of type `bool`, which defaults to `false`): Keep duration override on track change.
+- `fade_in` (of type `float`, which defaults to `3.`): Fade-in duration, if any.
+- `fade_out` (of type `float`, which defaults to `3.`): Fade-out duration, if any.
+- `smart` (of type `bool`, which defaults to `false`): Enable smart crossfading
+- `default` (of type `(source(audio=pcm('a), 'b), source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`, which defaults to `<fun>`): Smart crossfade: transition used when no rule applies (default: sequence).
+- `assume_autocue` (of type `bool?`, which defaults to `null`): Assume that a track has autocue enabled when all four cue in/out and fade in/out override metadata are present. Defaults to `settings.crossfade.assume_autocue` when `null`.
+- `high` (of type `float`, which defaults to `-15.`): Smart crossfade: value, in dB, for loud sound level.
+- `medium` (of type `float`, which defaults to `-32.`): Smart crossfade: value, in dB, for medium sound level.
+- `margin` (of type `float`, which defaults to `4.`): Smart crossfade: margin to detect sources that have too different sound level for crossing.
+- `deduplicate` (of type `bool`, which defaults to `true`): Crossfade transitions can generate duplicate metadata. When `true`, the operator removes duplicate metadata from the returned source.
+- `minimum` (of type `float`, which defaults to `-1.`): Minimum duration (in sec.) for a cross: If the track ends without any warning (e.g. in case of skip) there may not be enough data for a decent composition. Set to 0. to avoid having transitions after skips, or more to avoid transitions on short tracks. With a negative default, transitions always occur.
+- `width` (of type `float`, which defaults to `2.`): Width of the volume analysis window.
+- `conservative` (of type `bool`, which defaults to `true`): Always prepare for a premature end-of-track.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `cross_duration` (of type `() -> float`): 
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `fade.in`
+
+Fade the beginning of tracks.
+
+Type:
+
+```
+(?id : string, ?duration : float, ?delay : float, ?curve : float?,
+ ?override_duration : string, ?override_type : string,
+ ?override_curve : string, ?override_delay : string,
+ ?persist_overrides : bool, ?track_sensitive : bool,
+ ?initial_metadata : [string * string], ?type : string, source(audio=pcm('a),
+ 'b)) -> source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"fade.in"`): Force the value of the source ID.
+- `duration` (of type `float`, which defaults to `3.`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override.
+- `delay` (of type `float`, which defaults to `0.`): Initial delay before starting fade.
+- `curve` (of type `float?`, which defaults to `null`): Fade curve. Default if `null`.
+- `override_duration` (of type `string`, which defaults to `"liq_fade_in"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for the current track.
+- `override_type` (of type `string`, which defaults to `"liq_fade_in_type"`): Metadata field which, if present and correct, overrides the 'type' parameter for the current track.
+- `override_curve` (of type `string`, which defaults to `"liq_fade_in_curve"`): Metadata field which, if presents and correct, overrides the `curve` parameter for the current track. Use `"default"` to set to default value.
+- `override_delay` (of type `string`, which defaults to `"liq_fade_in_delay"`): Metadata field which, if presents and correct, overrides the initial fade delay.
+- `persist_overrides` (of type `bool`, which defaults to `false`): Keep duration and type overrides on track change.
+- `track_sensitive` (of type `bool`, which defaults to `false`): Be track sensitive (if `false` we only fade in once at the beginning of the track).
+- `initial_metadata` (of type `[string * string]`, which defaults to `[]`): Initial metadata.
+- `type` (of type `string`, which defaults to `"lin"`): Fader shape (lin|sin|log|exp): linear, sinusoidal, logarithmic or exponential.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where
+  'b is a set of tracks to be muxed into a source and a set of internal tracks`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fade_delay` (of type `() -> float`): 
+- `fade_duration` (of type `() -> float`): 
+- `fade_type` (of type `() -> string`): 
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `fade.out`
+
+Fade the end of tracks.
+
+Type:
+
+```
+(?id : string, ?duration : float, ?delay : float, ?curve : float?,
+ ?override_duration : string, ?override_type : string,
+ ?override_curve : string, ?override_delay : string,
+ ?persist_overrides : bool, ?track_sensitive : bool,
+ ?initial_metadata : [string * string], ?type : string, source(audio=pcm('a),
+ 'b)) -> source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"fade.out"`): Force the value of the source ID.
+- `duration` (of type `float`, which defaults to `3.`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override.
+- `delay` (of type `float`, which defaults to `0.`): Initial delay before starting fade.
+- `curve` (of type `float?`, which defaults to `null`): Fade curve. Default if `null`.
+- `override_duration` (of type `string`, which defaults to `"liq_fade_out"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for the current track.
+- `override_type` (of type `string`, which defaults to `"liq_fade_out_type"`): Metadata field which, if present and correct, overrides the 'type' parameter for the current track.
+- `override_curve` (of type `string`, which defaults to `"liq_fade_out_curve"`): Metadata field which, if presents and correct, overrides the `curve` parameter for the current track. Use `"default"` to set to default value.
+- `override_delay` (of type `string`, which defaults to `"liq_fade_out_delay"`): Metadata field which, if presents and correct, overrides the initial fade delay.
+- `persist_overrides` (of type `bool`, which defaults to `false`): Keep duration and type overrides on track change.
+- `track_sensitive` (of type `bool`, which defaults to `false`): Be track sensitive (if `false` we only fade ou once at the beginning of the track).
+- `initial_metadata` (of type `[string * string]`, which defaults to `[]`): Initial metadata.
+- `type` (of type `string`, which defaults to `"lin"`): Fader shape (lin|sin|log|exp): linear, sinusoidal, logarithmic or exponential.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fade_duration` (of type `() -> float`): 
+- `fade_type` (of type `() -> string`): 
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mkfade`
+
+Make a fade function based on a source's clock.
+
+Type:
+
+```
+(?curve : float?, ?type : string, ?start : float, ?stop : float,
+ ?delay : float, ?duration : float, ?on_done : (() -> unit), source('a)) ->
+() -> float
+```
+
+Arguments:
+
+- `curve` (of type `float?`, which defaults to `null`): Fade curve for `"log"` and `"exp"` shapes. If `null`, depends on the type of fade. The higher the value, the shaper the curve.
+- `type` (of type `string`, which defaults to `"lin"`): Fade shape. One of: `"sin"`, `"exp"`, `"log"`, `"lin"`
+- `start` (of type `float`, which defaults to `0.`): Start value.
+- `stop` (of type `float`, which defaults to `1.`): Stop value.
+- `delay` (of type `float`, which defaults to `0.`): Initial delay before starting fade.
+- `duration` (of type `float`, which defaults to `3.`): Duration in seconds.
+- `on_done` (of type `() -> unit`, which defaults to `{()}`): Function to execute when the fade is finished
+- `(unlabeled)` (of type `source('a)`)
+
+## Source / Input
+
+### `blank`
+
+Produce silence and blank images.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `-1.`): Duration of blank tracks in seconds, Negative value means forever.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input`
+
+Input an audio stream using the default operator.
+
+Type:
+
+```
+(?id : string?, ?start : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?fallible : bool) -> source(audio=pcm('A))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If `true`, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.alsa`
+
+Stream from an ALSA input device.
+
+Type:
+
+```
+(?id : string?, ?bufferize : bool, ?clock_safe : bool, ?device : string,
+ ?fallible : bool, ?on_start : (() -> unit), ?on_stop : (() -> unit),
+ ?start : bool) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bufferize` (of type `bool`, which defaults to `true`): Bufferize input
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of a dedicated clock
+- `device` (of type `string`, which defaults to `"default"`): Alsa device to use
+- `fallible` (of type `bool`, which defaults to `false`): Allow the source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.external.avi`
+
+Stream data from an external application.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?max : float, ?restart : bool,
+ ?restart_on_error : bool, {string}) -> source(audio=pcm('a),
+video=canvas('b))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer` (of type `float`, which defaults to `1.`): Duration of the pre-buffered data.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `restart` (of type `bool`, which defaults to `true`): Restart process when exited.
+- `restart_on_error` (of type `bool`, which defaults to `false`): Restart process when exited with error.
+- `(unlabeled)` (of type `{string}`): Command to execute.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `input.external.rawaudio`
+
+Stream raw PCM data (interleaved signed 16 bits little endian integers) from an external application.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?channels : int, ?max : float,
+ ?restart : bool, ?restart_on_error : bool, ?samplerate : int, {string}) ->
+source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer` (of type `float`, which defaults to `2.`): Duration of the pre-buffered data.
+- `channels` (of type `int`, which defaults to `2`): Number of channels.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `restart` (of type `bool`, which defaults to `true`): Restart process when exited.
+- `restart_on_error` (of type `bool`, which defaults to `false`): Restart process when exited with error.
+- `samplerate` (of type `int`, which defaults to `44100`): Samplerate.
+- `(unlabeled)` (of type `{string}`): Command to execute.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.external.rawvideo`
+
+Stream data from an external application.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?max : float, ?restart : bool,
+ ?restart_on_error : bool, {string}) -> source(video=canvas('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer` (of type `float`, which defaults to `1.`): Duration of the pre-buffered data.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `restart` (of type `bool`, which defaults to `true`): Restart process when exited.
+- `restart_on_error` (of type `bool`, which defaults to `false`): Restart process when exited with error.
+- `(unlabeled)` (of type `{string}`): Command to execute.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `input.external.wav`
+
+Stream WAV data from an external application.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?max : float, ?restart : bool,
+ ?restart_on_error : bool, {string}) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer` (of type `float`, which defaults to `2.`): Duration of the pre-buffered data.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `restart` (of type `bool`, which defaults to `true`): Restart process when exited.
+- `restart_on_error` (of type `bool`, which defaults to `false`): Restart process when exited with error.
+- `(unlabeled)` (of type `{string}`): Command to execute.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.ffmpeg`
+
+Create a stream using ffmpeg
+
+Type:
+
+```
+(?id : string?, ?clock_safe : bool, ?debug : bool,
+ ?deduplicate_metadata : bool, ?float_args : [string * float],
+ ?format : string?, ?int_args : [string * int], ?max_buffer : float,
+ ?metadata_filter : (([string * string]) -> [string * string])?,
+ ?new_track_on_metadata : bool, ?on_connect : (() -> unit),
+ ?on_disconnect : (() -> unit),
+ ?on_error : ((error
+               .{
+                 kind : string,
+                 message : string,
+                 trace : [
+                          {
+                            position_end : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            position_start : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            to_string : (?prefix : string) -> string
+                          }]
+               }) -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?poll_delay : float,
+ ?self_sync : {bool}, ?start : bool, ?string_args : [string * string],
+ ?trim_url : bool, {string}) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `clock_safe` (of type `bool`, which defaults to `false`): Force the use of a dedicated clock
+- `debug` (of type `bool`, which defaults to `false`): Run in debugging mode, not catching some exceptions.
+- `deduplicate_metadata` (of type `bool`, which defaults to `true`): Prevent duplicated metadata.
+- `float_args` (of type `[string * float]`, which defaults to `[]`)
+- `format` (of type `string?`, which defaults to `null`): Force a specific input format. Autodetected when passed a null argument
+- `int_args` (of type `[string * int]`, which defaults to `[]`)
+- `max_buffer` (of type `float`, which defaults to `5.`): Maximum uration of buffered data
+- `metadata_filter` (of type `(([string * string]) -> [string * string])?`, which defaults to `null`): Metadata filter function. Returned metadata are set a metadata. Default: filter `id3v2_priv` metadata.
+- `new_track_on_metadata` (of type `bool`, which defaults to `true`): Treat new metadata as new track.
+- `on_connect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when a source is connected.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when a source is disconnected
+- `on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }) -> unit`, which defaults to `fun (_) -> ()`): Callback executed when an error occurs.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `poll_delay` (of type `float`, which defaults to `2.`): Polling delay when trying to connect to the stream.
+- `self_sync` (of type `{bool}`, which defaults to `false`): Should the source control its own timing? Set to `true` if you are having synchronization issues. Should be `false` for most typical cases.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+- `string_args` (of type `[string * string]`, which defaults to `[]`)
+- `trim_url` (of type `bool`, which defaults to `true`): Trim input URL.
+- `(unlabeled)` (of type `{string}`): URL to decode.
+
+Methods:
+
+- `buffer_length` (of type `() -> float`): Get the buffer's length in seconds.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_url` (of type `({string}) -> unit`): Set the source's url.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `status` (of type `() -> string`): Return the current status of the source, either "stopped" (the source isn't trying to relay the HTTP stream), "starting" (polling task is about to begin) "polling" (attempting to connect to the HTTP stream), "connected <url>" (connected to <url>, buffering or playing back the stream) or "stopping" (source is stopping).
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `url` (of type `() -> string`): Return the source's current url.
+
+### `input.harbor`
+
+Create a source that receives a http/icecast stream and forwards it as a stream.
+
+Type:
+
+```
+(?id : string?,
+ ?auth : (({address : string, password : string, user : string}) -> bool)?,
+ ?buffer : float, ?debug : bool, ?dumpfile : string?, ?icy : bool,
+ ?icy_metadata_charset : string?, ?logfile : string?, ?max : float,
+ ?metadata_charset : string?, ?on_connect : (([string * string]) -> unit),
+ ?on_disconnect : (() -> unit), ?password : string, ?port : int,
+ ?replay_metadata : bool, ?timeout : float, ?transport : http_transport,
+ ?user : string, string) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `auth` (of type `(({address : string, password : string, user : string}) -> bool)?`, which defaults to `null`): Authentication function. Receives a record with: `user`, `password` and `address` (client network address) and returns `true` if the user should be granted access for this login. Override any other method if used.
+- `buffer` (of type `float`, which defaults to `12.`): Duration of the pre-buffered data (in seconds). Default value is set to make it possible to use `crossfade` transitions with `input.harbor`. You might be able to reduce it but, in this case, make sure to not use the operator with `crossfade` or make sure that it has enough buffered data for it.
+- `debug` (of type `bool`, which defaults to `false`): Run in debugging mode by not catching some exceptions.
+- `dumpfile` (of type `string?`, which defaults to `null`): Dump stream to file, for debugging purpose. Disabled if null.
+- `icy` (of type `bool`, which defaults to `false`): Enable ICY (shoutcast) protocol.
+- `icy_metadata_charset` (of type `string?`, which defaults to `null`): ICY (shoutcast) metadata charset. Guessed if null. Default for shoutcast is ISO-8859-1. Set to that value if all your clients send metadata using this charset and automatic detection is not working for you.
+- `logfile` (of type `string?`, which defaults to `null`): Log buffer status to file, for debugging purpose. Disabled if null.
+- `max` (of type `float`, which defaults to `20.`): Maximum duration of the buffered data (in seconds).
+- `metadata_charset` (of type `string?`, which defaults to `null`): Metadata charset for non-ICY (shoutcast) source protocols. Guessed if null.
+- `on_connect` (of type `([string * string]) -> unit`, which defaults to `fun (_) -> ()`): Function to execute when a source is connected. Its receives the list of headers, of the form: (<label>,<value>). All labels are lowercase.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Functions to execute when a source is disconnected
+- `password` (of type `string`, which defaults to `"hackme"`): Source password.
+- `port` (of type `int`, which defaults to `8005`): Port used to connect to the source.
+- `replay_metadata` (of type `bool`, which defaults to `false`): Replay last known metadata when switching back to this source. This helps when source has dropped due to temporary connection issues.
+- `timeout` (of type `float`, which defaults to `30.`): Timeout for source connectionn.
+- `transport` (of type `http_transport`, which defaults to `<unix_transport>`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `user` (of type `string`, which defaults to `"source"`): Source user.
+- `(unlabeled)` (of type `string`): Mountpoint to look for.
+
+Methods:
+
+- `buffer_length` (of type `() -> float`): Length of the buffer (in seconds).
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `connected_client` (of type `() -> string?`): Returns the address of the client currently connected, if there is one.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `status` (of type `() -> string`): Current status of the input.
+- `stop` (of type `() -> unit`): Disconnect the client currently connected to the harbor. Does nothing if no client is connected.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.hls`
+
+Play an HLS stream.
+
+Type:
+
+```
+(?id : string?, {string}) -> source('A)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `{string}`): Playlist URI.
+
+Methods:
+
+- `buffer_length` (of type `() -> float`): Get the buffer's length in seconds.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_url` (of type `({string}) -> unit`): Set the source's url.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `status` (of type `() -> string`): Return the current status of the source, either "stopped" (the source isn't trying to relay the HTTP stream), "starting" (polling task is about to begin) "polling" (attempting to connect to the HTTP stream), "connected <url>" (connected to <url>, buffering or playing back the stream) or "stopping" (source is stopping).
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `url` (of type `() -> string`): Return the source's current url.
+
+### `input.hls.native`
+
+Play an HLS stream.
+
+Type:
+
+```
+(?id : string?, ?reload : float, string) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `reload` (of type `float`, which defaults to `10.`): How often (in seconds) the playlist should be reloaded.
+- `(unlabeled)` (of type `string`): Playlist URI.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `input.http`
+
+Create a http stream using ffmpeg
+
+Type:
+
+```
+(?id : string?, ?clock_safe : bool, ?debug : bool,
+ ?deduplicate_metadata : bool, ?float_args : [string * float],
+ ?format : string?, ?int_args : [string * int], ?max_buffer : float,
+ ?metadata_filter : (([string * string]) -> [string * string])?,
+ ?new_track_on_metadata : bool, ?on_connect : (([string * string]) -> unit),
+ ?on_disconnect : (() -> unit),
+ ?on_error : ((error
+               .{
+                 kind : string,
+                 message : string,
+                 trace : [
+                          {
+                            position_end : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            position_start : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            to_string : (?prefix : string) -> string
+                          }]
+               }) -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?poll_delay : float,
+ ?self_sync : {bool?}, ?start : bool, ?string_args : [string * string],
+ ?timeout : float, ?trim_url : bool, ?user_agent : string, {string}) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `clock_safe` (of type `bool`, which defaults to `false`): Force the use of a dedicated clock
+- `debug` (of type `bool`, which defaults to `false`): Run in debugging mode, not catching some exceptions.
+- `deduplicate_metadata` (of type `bool`, which defaults to `true`): Prevent duplicated metadata.
+- `float_args` (of type `[string * float]`, which defaults to `[]`)
+- `format` (of type `string?`, which defaults to `null`): Force a specific input format. Autodetected when passed a null argument
+- `int_args` (of type `[string * int]`, which defaults to `[]`)
+- `max_buffer` (of type `float`, which defaults to `5.`): Maximum uration of buffered data
+- `metadata_filter` (of type `(([string * string]) -> [string * string])?`, which defaults to `null`): Metadata filter function. Returned metadata are set a metadata. Default: filter `id3v2_priv` metadata.
+- `new_track_on_metadata` (of type `bool`, which defaults to `true`): Treat new metadata as new track.
+- `on_connect` (of type `([string * string]) -> unit`, which defaults to `fun (_) -> ()`): Function to execute when a source is connected. Its receives the list of ICY-specific headers, if available.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when a source is disconnected
+- `on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }) -> unit`, which defaults to `fun (_) -> ()`): Callback executed when an error occurs.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `poll_delay` (of type `float`, which defaults to `2.`): Polling delay when trying to connect to the stream.
+- `self_sync` (of type `{bool?}`, which defaults to `null`): Should the source control its own timing? If `null`, the source will control its latency if it can be detected that it is connecting to an `icecast` or `shoutcast` server. Otherwise, see `input.ffmpeg` for more details about this option.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+- `string_args` (of type `[string * string]`, which defaults to `[]`)
+- `timeout` (of type `float`, which defaults to `10.`): Timeout for source connection.
+- `trim_url` (of type `bool`, which defaults to `true`): Trim input URL.
+- `user_agent` (of type `string`, which defaults to `"Liquidsoap/2.2.5 (Unix; OCaml 4.14.1)"`): User agent.
+- `(unlabeled)` (of type `{string}`): URL to decode.
+
+Methods:
+
+- `buffer_length` (of type `() -> float`): Get the buffer's length in seconds.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_url` (of type `({string}) -> unit`): Set the source's url.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `status` (of type `() -> string`): Return the current status of the source, either "stopped" (the source isn't trying to relay the HTTP stream), "starting" (polling task is about to begin) "polling" (attempting to connect to the HTTP stream), "connected <url>" (connected to <url>, buffering or playing back the stream) or "stopping" (source is stopping).
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `url` (of type `() -> string`): Return the source's current url.
+
+### `input.jack`
+
+Get stream from jack.
+
+Type:
+
+```
+(?id : string?, ?buffer_size : int, ?clock_safe : bool, ?fallible : bool,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?server : string,
+ ?start : bool) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer_size` (of type `int`, which defaults to `2`): Set buffer size, in frames. Must be >= 1.
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of a dedicated clock
+- `fallible` (of type `bool`, which defaults to `false`): Allow the source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `server` (of type `string`, which defaults to `""`): Jack server to connect to.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.keyboard.sdl`
+
+Play notes from the keyboard.
+
+Type:
+
+```
+(?id : string?, ?velocity : float) -> source(midi=midi('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `velocity` (of type `float`, which defaults to `0.8`): Velocity of notes.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `input.oss`
+
+Stream from an OSS input device.
+
+Type:
+
+```
+(?id : string?, ?clock_safe : bool, ?device : string, ?fallible : bool,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?start : bool) ->
+source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of a dedicated clock
+- `device` (of type `string`, which defaults to `"/dev/dsp"`): OSS device to use.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.portaudio`
+
+Stream from a portaudio input device.
+
+Type:
+
+```
+(?id : string?, ?buflen : int, ?clock_safe : bool, ?device_id : int?,
+ ?fallible : bool, ?latency : float?, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buflen` (of type `int`, which defaults to `256`): Length of a buffer in samples.
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of a dedicated clock
+- `device_id` (of type `int?`, which defaults to `null`): Device ID. Uses default device if `null`.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
+- `latency` (of type `float?`, which defaults to `null`): Device latency. Only used when specifying device ID.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.pulseaudio`
+
+Stream from a pulseaudio input device.
+
+Type:
+
+```
+(?id : string?, ?client : string, ?clock_safe : bool, ?clock_safe : bool,
+ ?device : string, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool) -> source(audio=pcm('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `client` (of type `string`, which defaults to `"liquidsoap"`)
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of a dedicated clock
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of the dedicated Pulseaudio clock.
+- `device` (of type `string`, which defaults to `""`): Device to use. Uses default if set to "".
+- `fallible` (of type `bool`, which defaults to `false`): Allow the source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.rtmp`
+
+Read an RTMP stream.
+
+Type:
+
+```
+(?id : string?, ?max_buffer : float, ?listen : bool, {string}) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `max_buffer` (of type `float`, which defaults to `5.`): Maximum data buffer in seconds
+- `listen` (of type `bool`, which defaults to `true`): Act as a RTMP server and wait for incoming connection
+- `(unlabeled)` (of type `{string}`): URL to read RTMP from, in the form `rtmp://IP:PORT/ENDPOINT`
+
+Methods:
+
+- `buffer_length` (of type `() -> float`): Get the buffer's length in seconds.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_url` (of type `({string}) -> unit`): Set the source's url.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `status` (of type `() -> string`): Return the current status of the source, either "stopped" (the source isn't trying to relay the HTTP stream), "starting" (polling task is about to begin) "polling" (attempting to connect to the HTTP stream), "connected <url>" (connected to <url>, buffering or playing back the stream) or "stopping" (source is stopping).
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `url` (of type `() -> string`): Return the source's current url.
+
+### `input.srt`
+
+Receive a SRT stream from a distant agent.
+
+Type:
+
+```
+(?id : string?, ?bind_address : string, ?clock_safe : bool,
+ ?connection_timeout : float?, ?content_type : string, ?dump : string,
+ ?enforced_encryption : bool?, ?host : string,
+ ?listen_callback : ((hs_version : int, peeraddr : string,
+                      streamid : string?, srt_socket
+                      .{
+                        bistats : (?clear : bool?, ?instantaneous : bool?) -> 
+                                  {
+                                    byteAvailRcvBuf : int,
+                                    byteAvailSndBuf : int,
+                                    byteMSS : int,
+                                    byteRcvBuf : int,
+                                    byteRcvDrop : int,
+                                    byteRcvDropTotal : int,
+                                    byteRcvUndecrypt : int,
+                                    byteRcvUndecryptTotal : int,
+                                    byteRecv : int,
+                                    byteRecvTotal : int,
+                                    byteRetrans : int,
+                                    byteRetransTotal : int,
+                                    byteSent : int,
+                                    byteSentTotal : int,
+                                    byteSndBuf : int,
+                                    byteSndDrop : int,
+                                    byteSndDropTotal : int,
+                                    mbpsBandwidth : float,
+                                    mbpsMaxBW : float,
+                                    mbpsRecvRate : float,
+                                    mbpsSendRate : float,
+                                    msRTT : float,
+                                    msRcvBuf : int,
+                                    msRcvTsbPdDelay : int,
+                                    msSndBuf : int,
+                                    msSndTsbPdDelay : int,
+                                    msTimeStamp : int,
+                                    pktCongestionWindow : int,
+                                    pktFlightSize : int,
+                                    pktFlowWindow : int,
+                                    pktRcvAvgBelatedTime : float,
+                                    pktRcvBelated : int,
+                                    pktRcvBuf : int,
+                                    pktRcvDrop : int,
+                                    pktRcvDropTotal : int,
+                                    pktRcvFilterExtra : int,
+                                    pktRcvFilterExtraTotal : int,
+                                    pktRcvFilterLoss : int,
+                                    pktRcvFilterLossTotal : int,
+                                    pktRcvFilterSupply : int,
+                                    pktRcvFilterSupplyTotal : int,
+                                    pktRcvLoss : int,
+                                    pktRcvLossTotal : int,
+                                    pktRcvRetrans : int,
+                                    pktRcvUndecrypt : int,
+                                    pktRcvUndecryptTotal : int,
+                                    pktRecv : int,
+                                    pktRecvACK : int,
+                                    pktRecvACKTotal : int,
+                                    pktRecvNAK : int,
+                                    pktRecvNAKTotal : int,
+                                    pktRecvTotal : int,
+                                    pktReorderDistance : int,
+                                    pktRetrans : int,
+                                    pktRetransTotal : int,
+                                    pktSent : int,
+                                    pktSentACK : int,
+                                    pktSentACKTotal : int,
+                                    pktSentNAK : int,
+                                    pktSentNAKTotal : int,
+                                    pktSentTotal : int,
+                                    pktSndBuf : int,
+                                    pktSndDrop : int,
+                                    pktSndDropTotal : int,
+                                    pktSndFilterExtra : int,
+                                    pktSndFilterExtraTotal : int,
+                                    pktSndLoss : int,
+                                    pktSndLossTotal : int,
+                                    usPktSndPeriod : float,
+                                    usSndDuration : int,
+                                    usSndDurationTotal : int},
+                        bstats : (?clear : bool?) -> 
+                                 {
+                                   byteAvailRcvBuf : int,
+                                   byteAvailSndBuf : int,
+                                   byteMSS : int,
+                                   byteRcvBuf : int,
+                                   byteRcvDrop : int,
+                                   byteRcvDropTotal : int,
+                                   byteRcvUndecrypt : int,
+                                   byteRcvUndecryptTotal : int,
+                                   byteRecv : int,
+                                   byteRecvTotal : int,
+                                   byteRetrans : int,
+                                   byteRetransTotal : int,
+                                   byteSent : int,
+                                   byteSentTotal : int,
+                                   byteSndBuf : int,
+                                   byteSndDrop : int,
+                                   byteSndDropTotal : int,
+                                   mbpsBandwidth : float,
+                                   mbpsMaxBW : float,
+                                   mbpsRecvRate : float,
+                                   mbpsSendRate : float,
+                                   msRTT : float,
+                                   msRcvBuf : int,
+                                   msRcvTsbPdDelay : int,
+                                   msSndBuf : int,
+                                   msSndTsbPdDelay : int,
+                                   msTimeStamp : int,
+                                   pktCongestionWindow : int,
+                                   pktFlightSize : int,
+                                   pktFlowWindow : int,
+                                   pktRcvAvgBelatedTime : float,
+                                   pktRcvBelated : int,
+                                   pktRcvBuf : int,
+                                   pktRcvDrop : int,
+                                   pktRcvDropTotal : int,
+                                   pktRcvFilterExtra : int,
+                                   pktRcvFilterExtraTotal : int,
+                                   pktRcvFilterLoss : int,
+                                   pktRcvFilterLossTotal : int,
+                                   pktRcvFilterSupply : int,
+                                   pktRcvFilterSupplyTotal : int,
+                                   pktRcvLoss : int,
+                                   pktRcvLossTotal : int,
+                                   pktRcvRetrans : int,
+                                   pktRcvUndecrypt : int,
+                                   pktRcvUndecryptTotal : int,
+                                   pktRecv : int,
+                                   pktRecvACK : int,
+                                   pktRecvACKTotal : int,
+                                   pktRecvNAK : int,
+                                   pktRecvNAKTotal : int,
+                                   pktRecvTotal : int,
+                                   pktReorderDistance : int,
+                                   pktRetrans : int,
+                                   pktRetransTotal : int,
+                                   pktSent : int,
+                                   pktSentACK : int,
+                                   pktSentACKTotal : int,
+                                   pktSentNAK : int,
+                                   pktSentNAKTotal : int,
+                                   pktSentTotal : int,
+                                   pktSndBuf : int,
+                                   pktSndDrop : int,
+                                   pktSndDropTotal : int,
+                                   pktSndFilterExtra : int,
+                                   pktSndFilterExtraTotal : int,
+                                   pktSndLoss : int,
+                                   pktSndLossTotal : int,
+                                   usPktSndPeriod : float,
+                                   usSndDuration : int,
+                                   usSndDurationTotal : int},
+                        close : () -> unit,
+                        pbkeylen : () -> int,
+                        read_data : () -> int,
+                        read_latency : () -> int,
+                        read_timeout : () -> int,
+                        status : () -> string,
+                        streamid : () -> string,
+                        write_timeout : () -> int
+                      }) -> bool)?,
+ ?max : float, ?messageapi : bool, ?mode : string,
+ ?on_connect : (() -> unit), ?on_disconnect : (() -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?passphrase : string?,
+ ?payload_size : int, ?pbkeylen : int?, ?polling_delay : float, ?port : int,
+ ?read_timeout : float?, ?self_sync : bool, ?start : bool,
+ ?streamid : string?, ?write_timeout : float?) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bind_address` (of type `string`, which defaults to `"0.0.0.0"`): Address to bind on the local machine. Used only in listener mode
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of a dedicated clock
+- `connection_timeout` (of type `float?`, which defaults to `null`): Timeout, in seconds, after which initial connection operations are aborted if no data was received. Uses library's default if `nulll`. Used only in `client` mode.
+- `content_type` (of type `string`, which defaults to `"application/ffmpeg"`): Content-Type (mime type) used to find a decoder for the input stream.
+- `dump` (of type `string`, which defaults to `""`): Dump received data to the given file for debugging. Unused is empty.
+- `enforced_encryption` (of type `bool?`, which defaults to `null`): Enforces that both connection parties have the same passphrase set, or both do not set the passphrase, otherwise the connection is rejected.
+- `host` (of type `string`, which defaults to `"localhost"`): Address to connect to. Used only in caller mode.
+- `listen_callback` (of type `((hs_version : int, peeraddr : string, streamid : string?, srt_socket
+  .{
+    bistats : (?clear : bool?, ?instantaneous : bool?) -> 
+              {
+                byteAvailRcvBuf : int,
+                byteAvailSndBuf : int,
+                byteMSS : int,
+                byteRcvBuf : int,
+                byteRcvDrop : int,
+                byteRcvDropTotal : int,
+                byteRcvUndecrypt : int,
+                byteRcvUndecryptTotal : int,
+                byteRecv : int,
+                byteRecvTotal : int,
+                byteRetrans : int,
+                byteRetransTotal : int,
+                byteSent : int,
+                byteSentTotal : int,
+                byteSndBuf : int,
+                byteSndDrop : int,
+                byteSndDropTotal : int,
+                mbpsBandwidth : float,
+                mbpsMaxBW : float,
+                mbpsRecvRate : float,
+                mbpsSendRate : float,
+                msRTT : float,
+                msRcvBuf : int,
+                msRcvTsbPdDelay : int,
+                msSndBuf : int,
+                msSndTsbPdDelay : int,
+                msTimeStamp : int,
+                pktCongestionWindow : int,
+                pktFlightSize : int,
+                pktFlowWindow : int,
+                pktRcvAvgBelatedTime : float,
+                pktRcvBelated : int,
+                pktRcvBuf : int,
+                pktRcvDrop : int,
+                pktRcvDropTotal : int,
+                pktRcvFilterExtra : int,
+                pktRcvFilterExtraTotal : int,
+                pktRcvFilterLoss : int,
+                pktRcvFilterLossTotal : int,
+                pktRcvFilterSupply : int,
+                pktRcvFilterSupplyTotal : int,
+                pktRcvLoss : int,
+                pktRcvLossTotal : int,
+                pktRcvRetrans : int,
+                pktRcvUndecrypt : int,
+                pktRcvUndecryptTotal : int,
+                pktRecv : int,
+                pktRecvACK : int,
+                pktRecvACKTotal : int,
+                pktRecvNAK : int,
+                pktRecvNAKTotal : int,
+                pktRecvTotal : int,
+                pktReorderDistance : int,
+                pktRetrans : int,
+                pktRetransTotal : int,
+                pktSent : int,
+                pktSentACK : int,
+                pktSentACKTotal : int,
+                pktSentNAK : int,
+                pktSentNAKTotal : int,
+                pktSentTotal : int,
+                pktSndBuf : int,
+                pktSndDrop : int,
+                pktSndDropTotal : int,
+                pktSndFilterExtra : int,
+                pktSndFilterExtraTotal : int,
+                pktSndLoss : int,
+                pktSndLossTotal : int,
+                usPktSndPeriod : float,
+                usSndDuration : int,
+                usSndDurationTotal : int},
+    bstats : (?clear : bool?) -> 
+             {
+               byteAvailRcvBuf : int,
+               byteAvailSndBuf : int,
+               byteMSS : int,
+               byteRcvBuf : int,
+               byteRcvDrop : int,
+               byteRcvDropTotal : int,
+               byteRcvUndecrypt : int,
+               byteRcvUndecryptTotal : int,
+               byteRecv : int,
+               byteRecvTotal : int,
+               byteRetrans : int,
+               byteRetransTotal : int,
+               byteSent : int,
+               byteSentTotal : int,
+               byteSndBuf : int,
+               byteSndDrop : int,
+               byteSndDropTotal : int,
+               mbpsBandwidth : float,
+               mbpsMaxBW : float,
+               mbpsRecvRate : float,
+               mbpsSendRate : float,
+               msRTT : float,
+               msRcvBuf : int,
+               msRcvTsbPdDelay : int,
+               msSndBuf : int,
+               msSndTsbPdDelay : int,
+               msTimeStamp : int,
+               pktCongestionWindow : int,
+               pktFlightSize : int,
+               pktFlowWindow : int,
+               pktRcvAvgBelatedTime : float,
+               pktRcvBelated : int,
+               pktRcvBuf : int,
+               pktRcvDrop : int,
+               pktRcvDropTotal : int,
+               pktRcvFilterExtra : int,
+               pktRcvFilterExtraTotal : int,
+               pktRcvFilterLoss : int,
+               pktRcvFilterLossTotal : int,
+               pktRcvFilterSupply : int,
+               pktRcvFilterSupplyTotal : int,
+               pktRcvLoss : int,
+               pktRcvLossTotal : int,
+               pktRcvRetrans : int,
+               pktRcvUndecrypt : int,
+               pktRcvUndecryptTotal : int,
+               pktRecv : int,
+               pktRecvACK : int,
+               pktRecvACKTotal : int,
+               pktRecvNAK : int,
+               pktRecvNAKTotal : int,
+               pktRecvTotal : int,
+               pktReorderDistance : int,
+               pktRetrans : int,
+               pktRetransTotal : int,
+               pktSent : int,
+               pktSentACK : int,
+               pktSentACKTotal : int,
+               pktSentNAK : int,
+               pktSentNAKTotal : int,
+               pktSentTotal : int,
+               pktSndBuf : int,
+               pktSndDrop : int,
+               pktSndDropTotal : int,
+               pktSndFilterExtra : int,
+               pktSndFilterExtraTotal : int,
+               pktSndLoss : int,
+               pktSndLossTotal : int,
+               usPktSndPeriod : float,
+               usSndDuration : int,
+               usSndDurationTotal : int},
+    close : () -> unit,
+    pbkeylen : () -> int,
+    read_data : () -> int,
+    read_latency : () -> int,
+    read_timeout : () -> int,
+    status : () -> string,
+    streamid : () -> string,
+    write_timeout : () -> int
+  }) -> bool)?`, which defaults to `null`): Callback used to decide whether to accept new incoming connections. Used in listener mode only.
+- `max` (of type `float`, which defaults to `10.`): Maximum duration of the buffered data.
+- `messageapi` (of type `bool`, which defaults to `true`): Use message api
+- `mode` (of type `string`, which defaults to `"listener"`): Mode to operate on. One of: `"listener"` (waits for connection to come in) or `"caller"` (initiate connection to a remote server)
+- `on_connect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when connected.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when disconnected
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when input stops.
+- `passphrase` (of type `string?`, which defaults to `null`): When set to a non-empty string, this option enables encryption and sets the passphrase for it. See `libsrt` documentation for more details.
+- `payload_size` (of type `int`, which defaults to `1316`): Payload size.
+- `pbkeylen` (of type `int?`, which defaults to `null`): Set encryption key length. See `libsrt` documentation for more details.
+- `polling_delay` (of type `float`, which defaults to `2.`): Delay between connection attempts. Used only in caller mode.
+- `port` (of type `int`, which defaults to `8000`): Port to bind on the local machine (listener mode) or to connect to (caller mode). The term `port` as used in SRT is occasionally identical to the term `UDP port`. However SRT offers more flexibility than UDP because it manages ports as its own resources. For example, one port may be shared between various services.
+- `read_timeout` (of type `float?`, which defaults to `1.`): Timeout, in seconds, after which read operations are aborted if no data was received, indefinite if `null`.
+- `self_sync` (of type `bool`, which defaults to `true`): `true` if the source controls its own latency (i.e. the SRT stream is in `live` mode), `false` otherwise (i.e. the stream is in `file` mode.
+- `start` (of type `bool`, which defaults to `true`): Start input as soon as it is available.
+- `streamid` (of type `string?`, which defaults to `null`): Set `streamid`. This value can be retrieved by the listener side when connecting to it. Used in caller mode only.
+- `write_timeout` (of type `float?`, which defaults to `1.`): Timeout, in seconds, after which write operations are aborted if no data was received, indefinite if `null`.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `sockets` (of type `() ->
+[string * srt_socket
+ .{
+   bistats : (?clear : bool?, ?instantaneous : bool?) -> 
+             {
+               byteAvailRcvBuf : int,
+               byteAvailSndBuf : int,
+               byteMSS : int,
+               byteRcvBuf : int,
+               byteRcvDrop : int,
+               byteRcvDropTotal : int,
+               byteRcvUndecrypt : int,
+               byteRcvUndecryptTotal : int,
+               byteRecv : int,
+               byteRecvTotal : int,
+               byteRetrans : int,
+               byteRetransTotal : int,
+               byteSent : int,
+               byteSentTotal : int,
+               byteSndBuf : int,
+               byteSndDrop : int,
+               byteSndDropTotal : int,
+               mbpsBandwidth : float,
+               mbpsMaxBW : float,
+               mbpsRecvRate : float,
+               mbpsSendRate : float,
+               msRTT : float,
+               msRcvBuf : int,
+               msRcvTsbPdDelay : int,
+               msSndBuf : int,
+               msSndTsbPdDelay : int,
+               msTimeStamp : int,
+               pktCongestionWindow : int,
+               pktFlightSize : int,
+               pktFlowWindow : int,
+               pktRcvAvgBelatedTime : float,
+               pktRcvBelated : int,
+               pktRcvBuf : int,
+               pktRcvDrop : int,
+               pktRcvDropTotal : int,
+               pktRcvFilterExtra : int,
+               pktRcvFilterExtraTotal : int,
+               pktRcvFilterLoss : int,
+               pktRcvFilterLossTotal : int,
+               pktRcvFilterSupply : int,
+               pktRcvFilterSupplyTotal : int,
+               pktRcvLoss : int,
+               pktRcvLossTotal : int,
+               pktRcvRetrans : int,
+               pktRcvUndecrypt : int,
+               pktRcvUndecryptTotal : int,
+               pktRecv : int,
+               pktRecvACK : int,
+               pktRecvACKTotal : int,
+               pktRecvNAK : int,
+               pktRecvNAKTotal : int,
+               pktRecvTotal : int,
+               pktReorderDistance : int,
+               pktRetrans : int,
+               pktRetransTotal : int,
+               pktSent : int,
+               pktSentACK : int,
+               pktSentACKTotal : int,
+               pktSentNAK : int,
+               pktSentNAKTotal : int,
+               pktSentTotal : int,
+               pktSndBuf : int,
+               pktSndDrop : int,
+               pktSndDropTotal : int,
+               pktSndFilterExtra : int,
+               pktSndFilterExtraTotal : int,
+               pktSndLoss : int,
+               pktSndLossTotal : int,
+               usPktSndPeriod : float,
+               usSndDuration : int,
+               usSndDurationTotal : int},
+   bstats : (?clear : bool?) -> 
+            {
+              byteAvailRcvBuf : int,
+              byteAvailSndBuf : int,
+              byteMSS : int,
+              byteRcvBuf : int,
+              byteRcvDrop : int,
+              byteRcvDropTotal : int,
+              byteRcvUndecrypt : int,
+              byteRcvUndecryptTotal : int,
+              byteRecv : int,
+              byteRecvTotal : int,
+              byteRetrans : int,
+              byteRetransTotal : int,
+              byteSent : int,
+              byteSentTotal : int,
+              byteSndBuf : int,
+              byteSndDrop : int,
+              byteSndDropTotal : int,
+              mbpsBandwidth : float,
+              mbpsMaxBW : float,
+              mbpsRecvRate : float,
+              mbpsSendRate : float,
+              msRTT : float,
+              msRcvBuf : int,
+              msRcvTsbPdDelay : int,
+              msSndBuf : int,
+              msSndTsbPdDelay : int,
+              msTimeStamp : int,
+              pktCongestionWindow : int,
+              pktFlightSize : int,
+              pktFlowWindow : int,
+              pktRcvAvgBelatedTime : float,
+              pktRcvBelated : int,
+              pktRcvBuf : int,
+              pktRcvDrop : int,
+              pktRcvDropTotal : int,
+              pktRcvFilterExtra : int,
+              pktRcvFilterExtraTotal : int,
+              pktRcvFilterLoss : int,
+              pktRcvFilterLossTotal : int,
+              pktRcvFilterSupply : int,
+              pktRcvFilterSupplyTotal : int,
+              pktRcvLoss : int,
+              pktRcvLossTotal : int,
+              pktRcvRetrans : int,
+              pktRcvUndecrypt : int,
+              pktRcvUndecryptTotal : int,
+              pktRecv : int,
+              pktRecvACK : int,
+              pktRecvACKTotal : int,
+              pktRecvNAK : int,
+              pktRecvNAKTotal : int,
+              pktRecvTotal : int,
+              pktReorderDistance : int,
+              pktRetrans : int,
+              pktRetransTotal : int,
+              pktSent : int,
+              pktSentACK : int,
+              pktSentACKTotal : int,
+              pktSentNAK : int,
+              pktSentNAKTotal : int,
+              pktSentTotal : int,
+              pktSndBuf : int,
+              pktSndDrop : int,
+              pktSndDropTotal : int,
+              pktSndFilterExtra : int,
+              pktSndFilterExtraTotal : int,
+              pktSndLoss : int,
+              pktSndLossTotal : int,
+              usPktSndPeriod : float,
+              usSndDuration : int,
+              usSndDurationTotal : int},
+   close : () -> unit,
+   pbkeylen : () -> int,
+   read_data : () -> int,
+   read_latency : () -> int,
+   read_timeout : () -> int,
+   status : () -> string,
+   streamid : () -> string,
+   write_timeout : () -> int
+ }]`): List of `(connected_address, connected_socket)`
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `input.v4l2`
+
+Stream from a video4linux2 input device, such as a webcam.
+
+Type:
+
+```
+(?id : string?, ?max_buffer : float, ?device : string) ->
+source(video=canvas('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `max_buffer` (of type `float`, which defaults to `0.5`): Maximum data buffer in seconds
+- `device` (of type `string`, which defaults to `"/dev/video0"`): V4L2 device to use.
+
+### `native.request.dynamic`
+
+Play request dynamically created by a given function.
+
+Type:
+
+```
+(?id : string?, ?available : {bool}, ?prefetch : int?,
+ ?retry_delay : {float}, ?timeout : float, (() -> request?)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `available` (of type `{bool}`, which defaults to `true`): Whether some new requests are available (when set to false, it stops after current playing request).
+- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance. Defaults to `settings.request.prefetch` when `null`.
+- `retry_delay` (of type `{float}`, which defaults to `0.1`): Retry after a given time (in seconds) when callback returns `null`.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout (in sec.) for a single download.
+- `(unlabeled)` (of type `() -> request?`)
+
+Methods:
+
+- `add` (of type `(request) -> bool`): 
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): 
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): 
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): 
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(source('A)) -> unit`): Set the source.
+- `set_queue` (of type `([request]) -> unit`): 
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `noise`
+
+Generate audio/video noise source.
+
+Type:
+
+```
+(?id : string?, ?duration : float?) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `playlist`
+
+Read a playlist or a directory and play all files.
+
+Type:
+
+```
+(?id : string?, ?check_next : ((request) -> bool)?, ?prefetch : int?,
+ ?loop : bool, ?mime_type : string?, ?mode : string, ?native : bool,
+ ?on_fail : (() -> [string])?, ?on_reload : ((string) -> unit),
+ ?prefix : string, ?reload : int, ?reload_mode : string, ?timeout : float,
+ ?cue_in_metadata : string?, ?cue_out_metadata : string?, string) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `check_next` (of type `((request) -> bool)?`, which defaults to `null`): Function used to filter next tracks. A candidate track is only validated if the function returns true on it. The function is called before resolution, hence metadata will only be available for requests corresponding to local files. This is typically used to avoid repetitions, but be careful: if the function rejects all attempts, the playlist will enter into a consuming loop and stop playing anything.
+- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance.
+- `loop` (of type `bool`, which defaults to `true`): Loop on the playlist.
+- `mime_type` (of type `string?`, which defaults to `null`): Default MIME type for the playlist. `null` means automatic detection.
+- `mode` (of type `string`, which defaults to `"randomize"`): Play the files in the playlist either in the order ("normal" mode), or shuffle the playlist each time it is loaded, and play it in this order for a whole round ("randomize" mode), or pick a random file in the playlist each time ("random" mode).
+- `native` (of type `bool`, which defaults to `false`): Use native implementation.
+- `on_fail` (of type `(() -> [string])?`, which defaults to `null`): Function executed when too many requests failed and returning the contents of a fixed playlist.
+- `on_reload` (of type `(string) -> unit`, which defaults to `fun (_) -> ()`): Callback called after playlist has reloaded.
+- `prefix` (of type `string`, which defaults to `""`): Add a constant prefix to all requests. Useful for passing extra information using annotate, or for resolution through a particular protocol, such as replaygain.
+- `reload` (of type `int`, which defaults to `0`): Amount of time (in seconds or rounds), when applicable, before which the playlist is reloaded; 0 means never.
+- `reload_mode` (of type `string`, which defaults to `"seconds"`): Unit of the reload parameter, either "never" (never reload the playlist), "rounds", "seconds" or "watch" (reload the file whenever it is changed).
+- `timeout` (of type `float`, which defaults to `20.`): Timeout (in sec.) for a single download.
+- `cue_in_metadata` (of type `string?`, which defaults to `"liq_cue_in"`): Metadata for cue in points. Disabled if `null`.
+- `cue_out_metadata` (of type `string?`, which defaults to `"liq_cue_out"`): Metadata for cue out points. Disabled if `null`.
+- `(unlabeled)` (of type `string`): Playlist URI.
+
+Methods:
+
+- `add` (of type `(request) -> bool`): Add a request to the queue. Requests are resolved before being added. Returns `true` if the request was successfully added.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `length` (of type `() -> int`): Length of the of the playlist (the number of songs it contains).
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `reload` (of type `(?empty_queue : bool, ?uri : string?) -> unit`): Reload the playlist.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `remaining_files` (of type `() -> [string]`): Songs remaining to be played.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): Set the queue of requests. Requests are resolved before being added to the queue. You are responsible for destroying the requests currently in the queue.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `playlist.list`
+
+Play a list of files.
+
+Type:
+
+```
+(?id : string?, ?check_next : ((request) -> bool)?, ?prefetch : int?,
+ ?loop : bool, ?mode : string, ?native : bool, ?on_loop : (() -> unit),
+ ?on_done : (() -> unit), ?max_fail : int, ?cue_in_metadata : string?,
+ ?cue_out_metadata : string?, ?on_fail : (() -> [string])?, ?timeout : float,
+ [string]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `check_next` (of type `((request) -> bool)?`, which defaults to `null`): Function used to filter next tracks. A candidate track is only validated if the function returns true on it. This is typically used to avoid repetitions, but be careful: if the function rejects all attempts, the playlist will enter into a consuming loop and stop playing anything.
+- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance.
+- `loop` (of type `bool`, which defaults to `true`): Loop on the playlist.
+- `mode` (of type `string`, which defaults to `"normal"`): Play the files in the playlist either in the order ("normal" mode), or shuffle the playlist each time it is loaded, and play it in this order for a whole round ("randomize" mode), or pick a random file in the playlist each time ("random" mode).
+- `native` (of type `bool`, which defaults to `false`): Use native implementation, when available.
+- `on_loop` (of type `() -> unit`, which defaults to `{()}`): Function executed when the playlist is about to loop.
+- `on_done` (of type `() -> unit`, which defaults to `{()}`): Function executed when the playlist is finished.
+- `max_fail` (of type `int`, which defaults to `10`): When this number of requests fail to resolve, the whole playlists is considered as failed and `on_fail` is called.
+- `cue_in_metadata` (of type `string?`, which defaults to `"liq_cue_in"`): Metadata for cue in points. Disabled if `null`.
+- `cue_out_metadata` (of type `string?`, which defaults to `"liq_cue_out"`): Metadata for cue out points. Disabled if `null`.
+- `on_fail` (of type `(() -> [string])?`, which defaults to `null`): Function executed when too many requests failed and returning the contents of a fixed playlist.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout (in sec.) for a single download.
+- `(unlabeled)` (of type `[string]`): Playlist.
+
+Methods:
+
+- `add` (of type `(request) -> bool`): Add a request to the queue. Requests are resolved before being added. Returns `true` if the request was successfully added.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `reload` (of type `(?empty_queue : bool, [string]) -> unit`): Reload the playlist with given list of songs.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `remaining_files` (of type `() -> [string]`): Songs remaining to be played.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): Set the queue of requests. Requests are resolved before being added to the queue. You are responsible for destroying the requests currently in the queue.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `request.dynamic`
+
+Play request dynamically created by a given function.
+
+Type:
+
+```
+(?id : string?, ?available : {bool}, ?prefetch : int?,
+ ?retry_delay : {float}, ?timeout : float, (() -> request?)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `available` (of type `{bool}`, which defaults to `true`): Whether some new requests are available (when set to false, it stops after current playing request).
+- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance. Defaults to `settings.request.prefetch` when `null`.
+- `retry_delay` (of type `{float}`, which defaults to `0.1`): Retry after a given time (in seconds) when callback returns `null`.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout (in sec.) for a single download.
+- `(unlabeled)` (of type `() -> request?`)
+
+Methods:
+
+- `add` (of type `(request) -> bool`): Add a request to the queue. Requests are resolved before being added. Returns `true` if the request was successfully added.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): Set the queue of requests. Requests are resolved before being added to the queue. You are responsible for destroying the requests currently in the queue.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `request.once`
+
+Play a request once and become unavailable.
+
+Type:
+
+```
+(?id : string?, ?timeout : float, request) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout in seconds for resolving the request.
+- `(unlabeled)` (of type `request`): Request to play.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `request` (of type `request`): Get the request played by this source
+- `resolve` (of type `() -> bool`): Resolve the request (this is useful to make sure that the source will be available in advance). This function returns `true` if we were able to successfully perform resolution. You should use this method instead of `request.resolve` to make sure that the proper content type is decoded from the request.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `saw`
+
+Generate a saw wave.
+
+Type:
+
+```
+(?id : string?, ?amplitude : {float}, ?duration : float?, ?{float}) ->
+source(audio=pcm*)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `amplitude` (of type `{float}`, which defaults to `1.`): Maximal value of the waveform.
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+- `(unlabeled)` (of type `{float}`, which defaults to `440.`): Frequency of the saw.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `sine`
+
+Generate a sine wave.
+
+Type:
+
+```
+(?id : string?, ?amplitude : {float}, ?duration : float?, ?{float}) ->
+source(audio=pcm*)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `amplitude` (of type `{float}`, which defaults to `1.`): Maximal value of the waveform.
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+- `(unlabeled)` (of type `{float}`, which defaults to `440.`): Frequency of the sine.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `single`
+
+Loop on a request. It never fails if the request is static, meaning that it can be fetched once. Typically, http, ftp, say requests are static, and time is not.
+
+Type:
+
+```
+(?id : string?, ?cue_in_metadata : string?, ?cue_out_metadata : string?,
+ ?fallible : bool, ?prefetch : int?, ?timeout : float, string) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `cue_in_metadata` (of type `string?`, which defaults to `"liq_cue_in"`): Metadata for cue in points. Disabled if `null`.
+- `cue_out_metadata` (of type `string?`, which defaults to `"liq_cue_out"`): Metadata for cue out points. Disabled if `null`.
+- `fallible` (of type `bool`, which defaults to `false`): Enforce fallibility of the request.
+- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance. Defaults to `settings.request.prefetch` when `null`.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout (in sec.) for a single download.
+- `(unlabeled)` (of type `string`): URI where to find the file
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source`
+
+Create a source that muxes the given tracks.
+
+Type:
+
+```
+(?id : string?, 'a.{metadata? : metadata, track_marks? : track_marks}) ->
+source('a) where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `'a.{metadata? : metadata, track_marks? : track_marks}
+where 'a is a set of tracks to be muxed into a source`): Tracks to mux
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.fail`
+
+A source that does not produce anything. No silence, no track at all.
+
+Type:
+
+```
+(?id : string?) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.fail.init`
+
+A source that errors during its initialization phase, used for testing and debugging.
+
+Type:
+
+```
+(?id : string?) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `square`
+
+Generate a square wave.
+
+Type:
+
+```
+(?id : string?, ?amplitude : {float}, ?duration : float?, ?{float}) ->
+source(audio=pcm*)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `amplitude` (of type `{float}`, which defaults to `1.`): Maximal value of the waveform.
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+- `(unlabeled)` (of type `{float}`, which defaults to `440.`): Frequency of the square.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.testsrc`
+
+Generate a test video.
+
+Type:
+
+```
+(?id : string?, ?height : int, ?width : int) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `height` (of type `int`, which defaults to `-1`)
+- `width` (of type `int`, which defaults to `-1`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Liquidsoap
+
+### `buffer`
+
+Create a buffer between two different clocks.
+
+Type:
+
+```
+(?id : string?, ?buffer : float, ?fallible : bool, ?max : float,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?register_telnet : bool,
+ ?start : bool, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer` (of type `float`, which defaults to `1.`): Amount of data to pre-buffer, in seconds.
+- `fallible` (of type `bool`, which defaults to `true`): Allow the child source to fail.
+- `max` (of type `float`, which defaults to `10.`): Maximum amount of buffered data, in seconds.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffer_length` (of type `() -> int`): Buffer length, in main ticks
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `buffer.adaptative`
+
+Create a buffer between two different clocks. The speed of the output is adapted so that no buffer underrun or overrun occurs. This wonderful behavior has a cost: the pitch of the sound might be changed a little.
+
+Type:
+
+```
+(?id : string?, ?averaging : float, ?buffer : float, ?fallible : bool,
+ ?limit : float, ?max : float, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?register_telnet : bool, ?resample : bool,
+ ?reset : bool, ?start : bool, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `averaging` (of type `float`, which defaults to `30.`): Length of the buffer averaging, in seconds (the time constant of the smoothing to be precise). The greater this is, the less reactive to local variations we are.
+- `buffer` (of type `float`, which defaults to `1.`): Amount of data to prebuffer, in seconds.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `limit` (of type `float`, which defaults to `1.25`): Maximum acceleration or deceleration factor, ie how fast or slow we can be compared to realtime.
+- `max` (of type `float`, which defaults to `10.`): Maximum amount of buffered data, in seconds.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `resample` (of type `bool`, which defaults to `true`): Use proper resampling instead of simply duplicating samples.
+- `reset` (of type `bool`, which defaults to `false`): Reset speed estimation to 1 when the source becomes available again (resuming from a buffer underflow).
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Current buffer duration, in seconds.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `estimated` (of type `() -> float`): Current smoothed buffer duration, in seconds.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `ratio` (of type `() -> float`): Get the current scaling ratio.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `source.drop`
+
+Animate the source as fast as possible, dropping its output.
+
+Type:
+
+```
+(source('a), ?ratio : float) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`): Source to animate.
+- `ratio` (of type `float`, which defaults to `50.`): Time ratio. A value of `50` means process data at `50x` real rate, when possible.
+
+This function is experimental.
+
+### `source.dump`
+
+Immediately encode the whole contents of a source into a file.
+
+Type:
+
+```
+(format('a), string, source('a), ?ratio : float) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `format('a)`): Encoding format.
+- `(unlabeled)` (of type `string`): Name of the file.
+- `(unlabeled)` (of type `source('a)`): Source to encode.
+- `ratio` (of type `float`, which defaults to `50.`): Time ratio. A value of `50` means process data at `50x` real rate, when possible.
+
+This function is experimental.
+
+### `source.duration`
+
+Estimation of the duration in the current track.
+
+Type:
+
+```
+(source('a)) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.elapsed`
+
+Elapsed time in the current track.
+
+Type:
+
+```
+(source('a)) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.fallible`
+
+Indicate if a source may fail, i.e. may not be ready to stream.
+
+Type:
+
+```
+(source('a)) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.id`
+
+Get the identifier of a source.
+
+Type:
+
+```
+(source('a)) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.init`
+
+Simultaneously initialize sources, return the sublist of sources that failed to initialize.
+
+Type:
+
+```
+([source('a)]) -> [source('a)]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[source('a)]`)
+
+This function is experimental.
+
+### `source.is_ready`
+
+Indicate if a source is ready to stream (we also say that it is available), or currently streaming.
+
+Type:
+
+```
+(source('a)) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.on_shutdown`
+
+Register a function to be called when source is not used anymore by another source.
+
+Type:
+
+```
+(source('a), (() -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `() -> unit`)
+
+### `source.remaining`
+
+Estimation of remaining time in the current track.
+
+Type:
+
+```
+(source('a)) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.seek`
+
+Seek forward, in seconds. Returns the amount of time effectively seeked.
+
+Type:
+
+```
+(source('a), float) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `float`)
+
+### `source.set_name`
+
+Set the name of an operator.
+
+Type:
+
+```
+(source('a), string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `string`)
+
+### `source.skip`
+
+Skip to the next track.
+
+Type:
+
+```
+(source('a)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+### `source.time`
+
+Get a source's time, based on its assigned clock
+
+Type:
+
+```
+(source('a)) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+## Source / MIDI processing
+
+### `midi.chord`
+
+Generate a chord.
+
+Type:
+
+```
+(?id : string?, ?metadata : string, source('a)) ->
+source(midi=midi(channels=1), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `metadata` (of type `string`, which defaults to `"chord"`): Name of the metadata containing the chords.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `midi.merge_all`
+
+Merge all MIDI tracks in one.
+
+Type:
+
+```
+(?id : string?, ?track_out : int, source(midi=midi('a), 'b)) ->
+source(midi=midi('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `track_out` (of type `int`, which defaults to `0`): Destination track.
+- `(unlabeled)` (of type `source(midi=midi('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `midi.remove`
+
+Remove MIDI tracks.
+
+Type:
+
+```
+(?id : string?, [int], source(midi=midi('a), 'b)) -> source(midi=midi('a),
+'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `[int]`): Tracks to remove.
+- `(unlabeled)` (of type `source(midi=midi('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Output
+
+### `ffmpeg.filter.audio_video.output`
+
+Return a source with audio and video from a filter's output.
+
+Type:
+
+```
+(?id : string?, ffmpeg.filter.graph, 'b
+ .{tracks : () -> 'a.{audio : ffmpeg.filter.audio}}, 'd
+ .{tracks : () -> 'c.{video : ffmpeg.filter.video}}) ->
+source(audio=ffmpeg.audio.raw('e), video=ffmpeg.video.raw('f))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `ffmpeg.filter.graph`): Force the value of the source ID.
+- `(unlabeled)` (of type `'b.{tracks : () -> 'a.{audio : ffmpeg.filter.audio}}`)
+- `(unlabeled)` (of type `'d.{tracks : () -> 'c.{video : ffmpeg.filter.video}}`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output`
+
+Output a stream using the default operator. The input source does not need to be infallible, blank will just be played during failures.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool, source(audio=pcm('A))) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `true`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If `true`, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `(unlabeled)` (of type `source(audio=pcm('A))`): Source to play.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.alsa`
+
+Output the source's stream to an ALSA output device.
+
+Type:
+
+```
+(?id : string?, ?bufferize : bool, ?clock_safe : bool, ?device : string,
+ ?fallible : bool, ?on_start : (() -> unit), ?on_stop : (() -> unit),
+ ?register_telnet : bool, ?start : bool, source(audio=pcm('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bufferize` (of type `bool`, which defaults to `true`): Bufferize output
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of the dedicated ALSA clock
+- `device` (of type `string`, which defaults to `"default"`): Alsa device to use
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.ao`
+
+Output stream to local sound card using libao.
+
+Type:
+
+```
+(?id : string?, ?buffer_size : int, ?channels_matrix : string,
+ ?clock_safe : bool, ?driver : string, ?fallible : bool,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit),
+ ?options : [string * string], ?register_telnet : bool, ?start : bool,
+ source(audio=pcm('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer_size` (of type `int`, which defaults to `2`): Set buffer size, in frames.
+- `channels_matrix` (of type `string`, which defaults to `""`): Output channels matrix, "" for AO's default.
+- `clock_safe` (of type `bool`, which defaults to `true`): Use the dedicated AO clock.
+- `driver` (of type `string`, which defaults to `""`): Driver to be used, "" for AO's default.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `options` (of type `[string * string]`, which defaults to `[]`): List of parameters, depends on the driver.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.audio_video`
+
+Output a stream with audio and video using the default operator. The input source does not need to be infallible, blank will just be played during failures.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool, source(audio=pcm('A),
+ video=canvas('a))) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `true`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If `true`, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `(unlabeled)` (of type `source(audio=pcm('A), video=canvas('a))`): Source to play.
+
+### `output.dummy`
+
+Dummy output: computes the stream, without actually using it.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?register_telnet : bool, ?start : bool, source('a)) ->
+unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.external`
+
+Send the stream to a process' standard input.
+
+Type:
+
+```
+(?id : string?, ?export_cover_metadata : bool, ?fallible : bool,
+ ?flush : bool, ?on_reopen : (() -> unit), ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?register_telnet : bool, ?reopen_delay : {float},
+ ?reopen_on_error : ((error
+                      .{
+                        kind : string,
+                        message : string,
+                        trace : [
+                                 {
+                                   position_end : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   position_start : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   to_string : (?prefix : string) -> string
+                                 }]
+                      }?) -> float?),
+ ?reopen_on_metadata : (([string * string]) -> bool),
+ ?reopen_when : (() -> bool), ?self_sync : bool, ?start : bool, format('a),
+ {string}, source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `export_cover_metadata` (of type `bool`, which defaults to `true`): Export cover metadata.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `flush` (of type `bool`, which defaults to `false`): Perform a flush after each write.
+- `on_reopen` (of type `() -> unit`, which defaults to `{()}`): Callback executed when the output is reopened.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `reopen_delay` (of type `{float}`, which defaults to `120.`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
+- `reopen_on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }?) -> float?`, which defaults to `<fun>`): Callback called when there is an error. Error is raised when returning `null`. Otherwise, the file is reopened after the returned value, in seconds.
+- `reopen_on_metadata` (of type `([string * string]) -> bool`, which defaults to `fun (_) -> false`): Callback called on metadata. If returned value is `true`, the file is reopened.
+- `reopen_when` (of type `() -> bool`, which defaults to `{false}`): Callback called on each frame. If returned value is `true`, the file is reopened.
+- `self_sync` (of type `bool`, which defaults to `false`): Set to `true` if the process is expected to control the output's latency. Typical example: `ffmpeg` with the `-re` command-line option.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `format('a)`): Process to pipe data to.
+- `(unlabeled)` (of type `{string}`): Encoding format.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reopen` (of type `() -> unit`): Reopen the output pipe. The actual reopening happens the next time the output has some data to output.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.file`
+
+Output the source stream to a file.
+
+Type:
+
+```
+(?id : string?, ?append : bool, ?dir_perm : int,
+ ?export_cover_metadata : bool, ?fallible : bool, ?flush : bool,
+ ?on_close : ((string) -> unit), ?on_reopen : (() -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?perm : int,
+ ?register_telnet : bool, ?reopen_delay : {float},
+ ?reopen_on_error : ((error
+                      .{
+                        kind : string,
+                        message : string,
+                        trace : [
+                                 {
+                                   position_end : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   position_start : 
+                                   {
+                                     character_offset : int,
+                                     filename : string,
+                                     line_number : int
+                                   },
+                                   to_string : (?prefix : string) -> string
+                                 }]
+                      }?) -> float?),
+ ?reopen_on_metadata : (([string * string]) -> bool),
+ ?reopen_when : (() -> bool), ?start : bool, format('a), {string},
+ source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `append` (of type `bool`, which defaults to `false`): Do not truncate but append in the file if it exists.
+- `dir_perm` (of type `int`, which defaults to `511`): Permission of the directories if some have to be created, up to umask. Although you can enter values in octal notation (0oXXX) they will be displayed in decimal (for instance, 0o777 = 7×8^2 + 7×8 + 7 = 511).
+- `export_cover_metadata` (of type `bool`, which defaults to `true`): Export cover metadata.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `flush` (of type `bool`, which defaults to `false`): Perform a flush after each write.
+- `on_close` (of type `(string) -> unit`, which defaults to `fun (_) -> ()`): This function will be called for each file, after that it is finished and closed. The filename will be passed as argument.
+- `on_reopen` (of type `() -> unit`, which defaults to `{()}`): Callback executed when the output is reopened.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `perm` (of type `int`, which defaults to `438`): Permission of the file if it has to be created, up to umask. You can and should write this number in octal notation: 0oXXX. The default value is however displayed in decimal (0o666 = 6×8^2 + 6×8 + 6 = 438).
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `reopen_delay` (of type `{float}`, which defaults to `120.`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
+- `reopen_on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }?) -> float?`, which defaults to `<fun>`): Callback called when there is an error. Error is raised when returning `null`. Otherwise, the file is reopened after the returned value, in seconds.
+- `reopen_on_metadata` (of type `([string * string]) -> bool`, which defaults to `fun (_) -> false`): Callback called on metadata. If returned value is `true`, the file is reopened.
+- `reopen_when` (of type `() -> bool`, which defaults to `{false}`): Callback called on each frame. If returned value is `true`, the file is reopened.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `format('a)`): Encoding format.
+- `(unlabeled)` (of type `{string}`): Filename where to output the stream.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `reopen` (of type `() -> unit`): Reopen the output pipe. The actual reopening happens the next time the output has some data to output.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.file.hls`
+
+Output the source stream to an HTTP live stream served from a local directory.
+
+Type:
+
+```
+(?id : string?, ?dir_perm : int, ?extra_tags : [string], ?fallible : bool,
+ ?on_file_change : ((state : string, string) -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?perm : int,
+ ?persist_at : string?, ?playlist : string, ?prefix : string,
+ ?register_telnet : bool, ?segment_duration : float,
+ ?segment_name : ((position : int, extname : string, string) -> string),
+ ?segments : int, ?segments_overhead : int, ?start : bool,
+ ?strict_persist : bool, ?temp_dir : string?, string,
+ [string * format('a)
+  .{
+    bandwidth? : int,
+    codecs? : string,
+    extname? : string,
+    extra_tags? : [string],
+    id3? : bool,
+    id3_version? : int,
+    replay_id3? : bool,
+    video_size? : int * int
+  }],
+ source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `dir_perm` (of type `int`, which defaults to `511`): Permission of the directories if some have to be created, up to umask. Although you can enter values in octal notation (0oXXX) they will be displayed in decimal (for instance, 0o777 = 7×8^2 + 7×8 + 7 = 511).
+- `extra_tags` (of type `[string]`, which defaults to `[]`): Extra tags to insert into the main playlist.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_file_change` (of type `(state : string, string) -> unit`, which defaults to `fun (~state=_,_) -> ()`): Callback executed when a file changes. `state` is one of: `"created"`, `"updated"` or `"deleted"`, second argument is file path. Typical use: sync file with a CDN
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `perm` (of type `int`, which defaults to `438`): Permission of the created files, up to umask. You can and should write this number in octal notation: 0oXXX. The default value is however displayed in decimal (0o666 = 6×8^2 + 4×8 + 4 = 412).
+- `persist_at` (of type `string?`, which defaults to `null`): Location of the configuration file used to restart the output. Relative paths are assumed to be with regard to the directory for generated file.
+- `playlist` (of type `string`, which defaults to `"stream.m3u8"`): Playlist name (m3u8 extension is recommended).
+- `prefix` (of type `string`, which defaults to `""`): Prefix for each files in playlists.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `segment_duration` (of type `float`, which defaults to `10.`): Segment duration (in seconds).
+- `segment_name` (of type `(position : int, extname : string, string) -> string`, which defaults to `<fun>`): Segment name. Default: `fun (~position,~extname,stream_name) -> "#{stream_name}_#{position}.#{extname}"`
+- `segments` (of type `int`, which defaults to `10`): Number of segments per playlist.
+- `segments_overhead` (of type `int`, which defaults to `5`): Number of segments to keep after they have been featured in the live playlist.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `strict_persist` (of type `bool`, which defaults to `false`): Fail if an invalid saved state exists.
+- `temp_dir` (of type `string?`, which defaults to `null`): Temporary directory used for writing files. This should be in the same partition or device as the final directory to guarantee atomic file operations. Use an system-specific value if `null`.
+- `(unlabeled)` (of type `string`): Directory for generated files.
+- `(unlabeled)` (of type `[string * format('a)
+ .{
+   bandwidth? : int,
+   codecs? : string,
+   extname? : string,
+   extra_tags? : [string],
+   id3? : bool,
+   id3_version? : int,
+   replay_id3? : bool,
+   video_size? : int * int
+ }]`): List of specifications for each stream: (name, format).
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `streams` (of type `() ->
+[
+ {
+   bandwidth : int,
+   codecs : string,
+   discontinuity_count : int,
+   encoder : format('A),
+   extname : string,
+   extra_tags : [string],
+   id3_enabled : bool,
+   insert_tag : (string) -> unit,
+   name : string,
+   replay_id3 : bool,
+   video_size : 
+   {height : int, width : int
+   }?
+ }]`): Output streams
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.harbor`
+
+Encode and output the stream using the harbor server.
+
+Type:
+
+```
+(?id : string?, ?auth : ((address : string, string, string) -> bool)?,
+ ?buffer : int, ?burst : int, ?chunk : int, ?dumpfile : string?,
+ ?encoding : string, ?fallible : bool, ?format : string,
+ ?headers : [string * string], ?metaint : int, mount : string,
+ ?on_connect : ((headers : [string * string], uri : string,
+                 protocol : string, string) -> unit),
+ ?on_disconnect : ((string) -> unit), ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?password : string?, ?port : int,
+ ?register_telnet : bool, ?start : bool, ?timeout : float,
+ ?transport : http_transport, ?url : string?, ?user : string?, format('a),
+ source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `auth` (of type `((address : string, string, string) -> bool)?`, which defaults to `null`): Authentication function. `f(~address,login,password)` returns `true` if the user should be granted access for this login. When defined, `user` and `password` arguments are not taken in account.
+- `buffer` (of type `int`, which defaults to `327675`): Maximum buffer per-client.
+- `burst` (of type `int`, which defaults to `65534`): Initial burst of data sent to the client.
+- `chunk` (of type `int`, which defaults to `4096`): Send data to clients using chunks of at least this length.
+- `dumpfile` (of type `string?`, which defaults to `null`): Dump stream to file, for debugging purpose. Disabled if null.
+- `encoding` (of type `string`, which defaults to `""`): Encoding used to send metadata. If empty, defaults to "UTF-8"
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `format` (of type `string`, which defaults to `""`): Format, e.g. "audio/ogg". When empty, the encoder is used to guess.
+- `headers` (of type `[string * string]`, which defaults to `[]`): Additional headers.
+- `metaint` (of type `int`, which defaults to `8192`): Interval used to send ICY metadata
+- `mount` (of type `string`)
+- `on_connect` (of type `(headers : [string * string], uri : string, protocol : string, string) ->
+unit`, which defaults to `fun (~headers=_,~uri=_,~protocol=_,_) -> ()`): Callback executed when connection is established (takes headers, connection uri, protocol and client's IP as arguments).
+- `on_disconnect` (of type `(string) -> unit`, which defaults to `fun (_) -> ()`): Callback executed when connection stops (takes client's IP as argument).
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `password` (of type `string?`, which defaults to `null`): Password for client connection. A `user` must also be set. We check for this password is checked unless an `auth` function is defined, which is used in this case.
+- `port` (of type `int`, which defaults to `8000`)
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `timeout` (of type `float`, which defaults to `30.`): Timeout for network operations (in seconds).
+- `transport` (of type `http_transport`, which defaults to `<unix_transport>`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `url` (of type `string?`, which defaults to `null`)
+- `user` (of type `string?`, which defaults to `null`): User for client connection. You also need to setup a `password`.
+- `(unlabeled)` (of type `format('a)`): Encoding format.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.harbor.hls`
+
+Output the source stream to an HTTP live stream served from the harbor HTTP server.
+
+Type:
+
+```
+(?id : string?, ?dir_perm : int, ?extra_tags : [string], ?fallible : bool,
+ ?on_file_change : ((state : string, string) -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?perm : int,
+ ?persist_at : string?, ?playlist : string, ?prefix : string,
+ ?register_telnet : bool, ?segment_duration : float, ?segments : int,
+ ?segments_overhead : int, ?start : bool, ?strict_persist : bool,
+ ?temp_dir : string?,
+ ?segment_name : ((position : int, extname : string, string) -> string),
+ ?headers : [string * string], ?port : int, ?path : string,
+ ?tmpdir : string?, ?transport : http_transport
+ .{default_port : int, name : string, protocol : string},
+ [string * format('a)], source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `dir_perm` (of type `int`, which defaults to `511`): Permission of the directories if some have to be created, up to umask. Although you can enter values in octal notation (0oXXX) they will be displayed in decimal (for instance, 0o777 = 7×8^2 + 7×8 + 7 = 511).
+- `extra_tags` (of type `[string]`, which defaults to `[]`): Extra tags to insert into the main playlist.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_file_change` (of type `(state : string, string) -> unit`, which defaults to `fun (~state=_,_) -> ()`): Callback executed when a file changes. `state` is one of: `"created"`, `"updated"` or `"deleted"`, second argument is file path. Typical use: sync file with a CDN
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `perm` (of type `int`, which defaults to `438`): Permission of the created files, up to umask. You can and should write this number in octal notation: 0oXXX. The default value is however displayed in decimal (0o666 = 6×8^2 + 4×8 + 4 = 412).
+- `persist_at` (of type `string?`, which defaults to `null`): Location of the configuration file used to restart the output. Relative paths are assumed to be with regard to the directory for generated file.
+- `playlist` (of type `string`, which defaults to `"stream.m3u8"`): Playlist name (m3u8 extension is recommended).
+- `prefix` (of type `string`, which defaults to `""`): Prefix for each files in playlists.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `segment_duration` (of type `float`, which defaults to `10.`): Segment duration (in seconds).
+- `segments` (of type `int`, which defaults to `10`): Number of segments per playlist.
+- `segments_overhead` (of type `int`, which defaults to `5`): Number of segments to keep after they have been featured in the live playlist.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `strict_persist` (of type `bool`, which defaults to `false`): Fail if an invalid saved state exists.
+- `temp_dir` (of type `string?`, which defaults to `null`): Temporary directory used for writing files. This should be in the same partition or device as the final directory to guarantee atomic file operations. Use an system-specific value if `null`.
+- `segment_name` (of type `(position : int, extname : string, string) -> string`, which defaults to `<fun>`): Segment name. Default: `fun (~position,~extname,stream_name) -> "#{stream_name}_#{position}.#{extname}"`
+- `headers` (of type `[string * string]`, which defaults to `[("Access-Control-Allow-Origin", "*")]`): Default response headers.
+- `port` (of type `int`, which defaults to `8000`): Port for incoming harbor (http) connections.
+- `path` (of type `string`, which defaults to `"/"`): Base path for hls URIs.
+- `tmpdir` (of type `string?`, which defaults to `null`): Directory for generated files.
+- `transport` (of type `http_transport.{default_port : int, name : string, protocol : string}`, which defaults to `<unix_transport>.{default_port=80, protocol="http", name="unix"}`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `(unlabeled)` (of type `[string * format('a)]`): List of specifications for each stream: (name, format).
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `streams` (of type `() ->
+[
+ {
+   bandwidth : int,
+   codecs : string,
+   discontinuity_count : int,
+   encoder : format('A),
+   extname : string,
+   extra_tags : [string],
+   id3_enabled : bool,
+   insert_tag : (string) -> unit,
+   name : string,
+   replay_id3 : bool,
+   video_size : 
+   {height : int, width : int
+   }?
+ }]`): Output streams
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.icecast`
+
+Encode and output the stream to an icecast server.
+
+Type:
+
+```
+(?id : string?, ?chunked : bool, ?connection_timeout : float,
+ ?description : string?, ?dumpfile : string?, ?encoding : string?,
+ ?fallible : bool, ?format : string, ?genre : string?,
+ ?headers : [string * string], ?host : string, ?icy_metadata : [string],
+ ?icy_song : (([string * string]) -> string?), ?method : string,
+ mount : string, ?name : string?, ?on_connect : (() -> unit),
+ ?on_disconnect : (() -> unit), ?on_error : ((string) -> float),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?password : string,
+ ?port : int, ?prefer_address : string?, ?public : bool,
+ ?register_telnet : bool, ?send_icy_metadata : bool?, ?start : bool,
+ ?timeout : float, ?transport : http_transport, ?url : string?,
+ ?user : string?, format('a), source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `chunked` (of type `bool`, which defaults to `false`): Used chunked transfer with the 'http(s)' protocol.
+- `connection_timeout` (of type `float`, which defaults to `5.`): Timeout for establishing network connections (disabled is negative).
+- `description` (of type `string?`, which defaults to `null`)
+- `dumpfile` (of type `string?`, which defaults to `null`): Dump stream to file, for debugging purpose. Disabled if null.
+- `encoding` (of type `string?`, which defaults to `null`): Encoding used to send metadata and stream info (name, genre and description). If null, defaults to "UTF-8".
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `format` (of type `string`, which defaults to `""`): Format, e.g. "audio/ogg". When empty, the encoder is used to guess.
+- `genre` (of type `string?`, which defaults to `null`)
+- `headers` (of type `[string * string]`, which defaults to `[("User-Agent", "Liquidsoap/2.2.5 (Unix; OCaml 4.14.1)")]`): Additional headers.
+- `host` (of type `string`, which defaults to `"localhost"`)
+- `icy_metadata` (of type `[string]`, which defaults to `["song", "title", "artist", "genre", "date", "album", "tracknum", "comment", "dj", "next"]`): List of metadata to send with ICY metadata update
+- `icy_song` (of type `([string * string]) -> string?`, which defaults to `<fun>`): Function used to generate the default icy "song" metadata. Metadata is not added when returning `null`. Default: `$(artist) - $(title)` if both are defined, otherwise `artist` or `title` if either is defined or `null`.
+- `method` (of type `string`, which defaults to `"source"`): Method to use with the 'http(s)' protocol. One of: 'source', 'put' or 'post'.
+- `mount` (of type `string`): Source mount point.
+- `name` (of type `string?`, which defaults to `null`)
+- `on_connect` (of type `() -> unit`, which defaults to `{()}`): Callback executed when connection is established.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Callback executed when connection stops.
+- `on_error` (of type `(string) -> float`, which defaults to `fun (_) -> 3.`): Callback executed when an error happens. The callback receives a string representation of the error that occurred and returns a float. If returned value is positive, connection will be tried again after this amount of time (in seconds).
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `password` (of type `string`, which defaults to `"hackme"`)
+- `port` (of type `int`, which defaults to `8000`)
+- `prefer_address` (of type `string?`, which defaults to `null`): Preferred address type when resolving hostnames. One of: `"ipv4"` or `"ipv6"`. Defaults to system default when `null`.
+- `public` (of type `bool`, which defaults to `true`)
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `send_icy_metadata` (of type `bool?`, which defaults to `null`): Send new metadata using the ICY protocol. Guessed when `null`
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `timeout` (of type `float`, which defaults to `30.`): Timeout for network read and write.
+- `transport` (of type `http_transport`, which defaults to `<unix_transport>`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `url` (of type `string?`, which defaults to `null`)
+- `user` (of type `string?`, which defaults to `null`): User for shout source connection. Defaults to "source" for icecast connections. Useful only in special cases, like with per-mountpoint users.
+- `(unlabeled)` (of type `format('a)`): Encoding format.
+- `(unlabeled)` (of type `source('a)`): The source to output
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.jack`
+
+Output stream to jack.
+
+Type:
+
+```
+(?id : string?, ?buffer_size : int, ?clock_safe : bool, ?fallible : bool,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?register_telnet : bool,
+ ?server : string, ?start : bool, source(audio=pcm('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buffer_size` (of type `int`, which defaults to `2`): Set buffer size, in frames.
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of the dedicated bjack clock.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `server` (of type `string`, which defaults to `""`): Jack server to connect to.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.oss`
+
+Output the source's stream to an OSS output device.
+
+Type:
+
+```
+(?id : string?, ?clock_safe : bool, ?device : string, ?fallible : bool,
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?register_telnet : bool,
+ ?start : bool, source(audio=pcm('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of the dedicated OSS clock.
+- `device` (of type `string`, which defaults to `"/dev/dsp"`): OSS device to use.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.portaudio`
+
+Output the source's stream to a portaudio output device.
+
+Type:
+
+```
+(?id : string?, ?buflen : int, ?clock_safe : bool, ?device_id : int?,
+ ?fallible : bool, ?latency : float?, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?register_telnet : bool, ?start : bool,
+ source(audio=pcm('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `buflen` (of type `int`, which defaults to `256`): Length of a buffer in samples.
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of the dedicated Portaudio clock.
+- `device_id` (of type `int?`, which defaults to `null`): Device ID. Uses default device if `null`.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `latency` (of type `float?`, which defaults to `null`): Device latency. Only used when specifying device ID.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.pulseaudio`
+
+Output the source's stream to a pulseaudio output device.
+
+Type:
+
+```
+(?id : string?, ?client : string, ?clock_safe : bool, ?device : string,
+ ?fallible : bool, ?on_start : (() -> unit), ?on_stop : (() -> unit),
+ ?register_telnet : bool, ?start : bool, source(audio=pcm('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `client` (of type `string`, which defaults to `"liquidsoap"`)
+- `clock_safe` (of type `bool`, which defaults to `true`): Force the use of the dedicated Pulseaudio clock.
+- `device` (of type `string`, which defaults to `""`): Device to use. Uses default if set to "".
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.sdl`
+
+Display a video using SDL.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?register_telnet : bool, ?start : bool,
+ source(video=canvas('a), 'b)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.sdl.has_video`
+
+Check whether video output is available with SDL.
+
+Type:
+
+```
+() -> bool
+```
+
+### `output.shoutcast`
+
+Encode and output the stream to a shoutcast server.
+
+Type:
+
+```
+(?id : string?, ?chunked : bool, ?connection_timeout : float,
+ ?dumpfile : string?, ?encoding : string?, ?fallible : bool,
+ ?format : string, ?genre : string?, ?headers : [string * string],
+ ?host : string, ?icy_id : int, ?icy_metadata : [string],
+ ?icy_song : (([string * string]) -> string?), ?name : string?,
+ ?on_connect : (() -> unit), ?on_disconnect : (() -> unit),
+ ?on_error : ((string) -> float), ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?password : string, ?port : int,
+ ?prefer_address : string?, ?public : bool, ?register_telnet : bool,
+ ?send_icy_metadata : bool?, ?start : bool, ?timeout : float,
+ ?transport : http_transport, ?url : string?, ?user : string?,
+ ?icy_reset : bool, ?dj : (() -> string), ?aim : string, ?icq : string,
+ ?irc : string, format('a), source('a)) -> unit
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `chunked` (of type `bool`, which defaults to `false`): Used chunked transfer with the 'http(s)' protocol.
+- `connection_timeout` (of type `float`, which defaults to `5.`): Timeout for establishing network connections (disabled is negative).
+- `dumpfile` (of type `string?`, which defaults to `null`): Dump stream to file, for debugging purpose. Disabled if null.
+- `encoding` (of type `string?`, which defaults to `null`): Encoding used to send metadata and stream info (name, genre and description). If null, defaults to "UTF-8".
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `format` (of type `string`, which defaults to `""`): Format, e.g. "audio/ogg". When empty, the encoder is used to guess.
+- `genre` (of type `string?`, which defaults to `null`)
+- `headers` (of type `[string * string]`, which defaults to `[("User-Agent", "Liquidsoap/2.2.5 (Unix; OCaml 4.14.1)")]`): Additional headers.
+- `host` (of type `string`, which defaults to `"localhost"`)
+- `icy_id` (of type `int`, which defaults to `1`): Shoutcast source ID.
+- `icy_metadata` (of type `[string]`, which defaults to `["song", "title", "artist", "genre", "date", "album", "tracknum", "comment", "dj", "next"]`): List of metadata to send with ICY metadata update
+- `icy_song` (of type `([string * string]) -> string?`, which defaults to `<fun>`): Function used to generate the default icy "song" metadata. Metadata is not added when returning `null`. Default: `$(artist) - $(title)` if both are defined, otherwise `artist` or `title` if either is defined or `null`.
+- `name` (of type `string?`, which defaults to `null`)
+- `on_connect` (of type `() -> unit`, which defaults to `{()}`): Callback executed when connection is established.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Callback executed when connection stops.
+- `on_error` (of type `(string) -> float`, which defaults to `fun (_) -> 3.`): Callback executed when an error happens. The callback receives a string representation of the error that occurred and returns a float. If returned value is positive, connection will be tried again after this amount of time (in seconds).
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `password` (of type `string`, which defaults to `"hackme"`)
+- `port` (of type `int`, which defaults to `8000`)
+- `prefer_address` (of type `string?`, which defaults to `null`): Preferred address type when resolving hostnames. One of: `"ipv4"` or `"ipv6"`. Defaults to system default when `null`.
+- `public` (of type `bool`, which defaults to `true`)
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `send_icy_metadata` (of type `bool?`, which defaults to `null`): Send new metadata using the ICY protocol. Guessed when `null`
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `timeout` (of type `float`, which defaults to `30.`): Timeout for network read and write.
+- `transport` (of type `http_transport`, which defaults to `<unix_transport>`): Http transport. Use `http.transport.ssl` or `http.transport.secure_transport`, when available, to enable HTTPS output
+- `url` (of type `string?`, which defaults to `null`)
+- `user` (of type `string?`, which defaults to `null`): User for shout source connection. Defaults to "source" for icecast connections. Useful only in special cases, like with per-mountpoint users.
+- `icy_reset` (of type `bool`, which defaults to `true`): Reset shoutcast source buffer upon connecting (necessary for NSV).
+- `dj` (of type `() -> string`, which defaults to `{""}`): Callback to set dj name.
+- `aim` (of type `string`, which defaults to `""`)
+- `icq` (of type `string`, which defaults to `""`)
+- `irc` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `format('a) where 'a is a set of tracks to be muxed into a source`): Encoding format. Should be mp3 or AAC(+).
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`): The source to output
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.srt`
+
+Send a SRT stream to a distant agent.
+
+Type:
+
+```
+(?id : string?, ?bind_address : string, ?connection_timeout : float?,
+ ?enforced_encryption : bool?, ?fallible : bool, ?host : string,
+ ?listen_callback : ((hs_version : int, peeraddr : string,
+                      streamid : string?, srt_socket
+                      .{
+                        bistats : (?clear : bool?, ?instantaneous : bool?) -> 
+                                  {
+                                    byteAvailRcvBuf : int,
+                                    byteAvailSndBuf : int,
+                                    byteMSS : int,
+                                    byteRcvBuf : int,
+                                    byteRcvDrop : int,
+                                    byteRcvDropTotal : int,
+                                    byteRcvUndecrypt : int,
+                                    byteRcvUndecryptTotal : int,
+                                    byteRecv : int,
+                                    byteRecvTotal : int,
+                                    byteRetrans : int,
+                                    byteRetransTotal : int,
+                                    byteSent : int,
+                                    byteSentTotal : int,
+                                    byteSndBuf : int,
+                                    byteSndDrop : int,
+                                    byteSndDropTotal : int,
+                                    mbpsBandwidth : float,
+                                    mbpsMaxBW : float,
+                                    mbpsRecvRate : float,
+                                    mbpsSendRate : float,
+                                    msRTT : float,
+                                    msRcvBuf : int,
+                                    msRcvTsbPdDelay : int,
+                                    msSndBuf : int,
+                                    msSndTsbPdDelay : int,
+                                    msTimeStamp : int,
+                                    pktCongestionWindow : int,
+                                    pktFlightSize : int,
+                                    pktFlowWindow : int,
+                                    pktRcvAvgBelatedTime : float,
+                                    pktRcvBelated : int,
+                                    pktRcvBuf : int,
+                                    pktRcvDrop : int,
+                                    pktRcvDropTotal : int,
+                                    pktRcvFilterExtra : int,
+                                    pktRcvFilterExtraTotal : int,
+                                    pktRcvFilterLoss : int,
+                                    pktRcvFilterLossTotal : int,
+                                    pktRcvFilterSupply : int,
+                                    pktRcvFilterSupplyTotal : int,
+                                    pktRcvLoss : int,
+                                    pktRcvLossTotal : int,
+                                    pktRcvRetrans : int,
+                                    pktRcvUndecrypt : int,
+                                    pktRcvUndecryptTotal : int,
+                                    pktRecv : int,
+                                    pktRecvACK : int,
+                                    pktRecvACKTotal : int,
+                                    pktRecvNAK : int,
+                                    pktRecvNAKTotal : int,
+                                    pktRecvTotal : int,
+                                    pktReorderDistance : int,
+                                    pktRetrans : int,
+                                    pktRetransTotal : int,
+                                    pktSent : int,
+                                    pktSentACK : int,
+                                    pktSentACKTotal : int,
+                                    pktSentNAK : int,
+                                    pktSentNAKTotal : int,
+                                    pktSentTotal : int,
+                                    pktSndBuf : int,
+                                    pktSndDrop : int,
+                                    pktSndDropTotal : int,
+                                    pktSndFilterExtra : int,
+                                    pktSndFilterExtraTotal : int,
+                                    pktSndLoss : int,
+                                    pktSndLossTotal : int,
+                                    usPktSndPeriod : float,
+                                    usSndDuration : int,
+                                    usSndDurationTotal : int},
+                        bstats : (?clear : bool?) -> 
+                                 {
+                                   byteAvailRcvBuf : int,
+                                   byteAvailSndBuf : int,
+                                   byteMSS : int,
+                                   byteRcvBuf : int,
+                                   byteRcvDrop : int,
+                                   byteRcvDropTotal : int,
+                                   byteRcvUndecrypt : int,
+                                   byteRcvUndecryptTotal : int,
+                                   byteRecv : int,
+                                   byteRecvTotal : int,
+                                   byteRetrans : int,
+                                   byteRetransTotal : int,
+                                   byteSent : int,
+                                   byteSentTotal : int,
+                                   byteSndBuf : int,
+                                   byteSndDrop : int,
+                                   byteSndDropTotal : int,
+                                   mbpsBandwidth : float,
+                                   mbpsMaxBW : float,
+                                   mbpsRecvRate : float,
+                                   mbpsSendRate : float,
+                                   msRTT : float,
+                                   msRcvBuf : int,
+                                   msRcvTsbPdDelay : int,
+                                   msSndBuf : int,
+                                   msSndTsbPdDelay : int,
+                                   msTimeStamp : int,
+                                   pktCongestionWindow : int,
+                                   pktFlightSize : int,
+                                   pktFlowWindow : int,
+                                   pktRcvAvgBelatedTime : float,
+                                   pktRcvBelated : int,
+                                   pktRcvBuf : int,
+                                   pktRcvDrop : int,
+                                   pktRcvDropTotal : int,
+                                   pktRcvFilterExtra : int,
+                                   pktRcvFilterExtraTotal : int,
+                                   pktRcvFilterLoss : int,
+                                   pktRcvFilterLossTotal : int,
+                                   pktRcvFilterSupply : int,
+                                   pktRcvFilterSupplyTotal : int,
+                                   pktRcvLoss : int,
+                                   pktRcvLossTotal : int,
+                                   pktRcvRetrans : int,
+                                   pktRcvUndecrypt : int,
+                                   pktRcvUndecryptTotal : int,
+                                   pktRecv : int,
+                                   pktRecvACK : int,
+                                   pktRecvACKTotal : int,
+                                   pktRecvNAK : int,
+                                   pktRecvNAKTotal : int,
+                                   pktRecvTotal : int,
+                                   pktReorderDistance : int,
+                                   pktRetrans : int,
+                                   pktRetransTotal : int,
+                                   pktSent : int,
+                                   pktSentACK : int,
+                                   pktSentACKTotal : int,
+                                   pktSentNAK : int,
+                                   pktSentNAKTotal : int,
+                                   pktSentTotal : int,
+                                   pktSndBuf : int,
+                                   pktSndDrop : int,
+                                   pktSndDropTotal : int,
+                                   pktSndFilterExtra : int,
+                                   pktSndFilterExtraTotal : int,
+                                   pktSndLoss : int,
+                                   pktSndLossTotal : int,
+                                   usPktSndPeriod : float,
+                                   usSndDuration : int,
+                                   usSndDurationTotal : int},
+                        close : () -> unit,
+                        pbkeylen : () -> int,
+                        read_data : () -> int,
+                        read_latency : () -> int,
+                        read_timeout : () -> int,
+                        status : () -> string,
+                        streamid : () -> string,
+                        write_timeout : () -> int
+                      }) -> bool)?,
+ ?max_clients : int?, ?messageapi : bool, ?mode : string,
+ ?on_connect : (() -> unit), ?on_disconnect : (() -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?passphrase : string?,
+ ?payload_size : int, ?pbkeylen : int?, ?polling_delay : float, ?port : int,
+ ?read_timeout : float?, ?register_telnet : bool, ?start : bool,
+ ?streamid : string?, ?write_timeout : float?, format('a), source('a)) ->
+unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bind_address` (of type `string`, which defaults to `"0.0.0.0"`): Address to bind on the local machine. Used only in listener mode
+- `connection_timeout` (of type `float?`, which defaults to `null`): Timeout, in seconds, after which initial connection operations are aborted if no data was received. Uses library's default if `nulll`. Used only in `client` mode.
+- `enforced_encryption` (of type `bool?`, which defaults to `null`): Enforces that both connection parties have the same passphrase set, or both do not set the passphrase, otherwise the connection is rejected.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `host` (of type `string`, which defaults to `"localhost"`): Address to connect to. Used only in caller mode.
+- `listen_callback` (of type `((hs_version : int, peeraddr : string, streamid : string?, srt_socket
+  .{
+    bistats : (?clear : bool?, ?instantaneous : bool?) -> 
+              {
+                byteAvailRcvBuf : int,
+                byteAvailSndBuf : int,
+                byteMSS : int,
+                byteRcvBuf : int,
+                byteRcvDrop : int,
+                byteRcvDropTotal : int,
+                byteRcvUndecrypt : int,
+                byteRcvUndecryptTotal : int,
+                byteRecv : int,
+                byteRecvTotal : int,
+                byteRetrans : int,
+                byteRetransTotal : int,
+                byteSent : int,
+                byteSentTotal : int,
+                byteSndBuf : int,
+                byteSndDrop : int,
+                byteSndDropTotal : int,
+                mbpsBandwidth : float,
+                mbpsMaxBW : float,
+                mbpsRecvRate : float,
+                mbpsSendRate : float,
+                msRTT : float,
+                msRcvBuf : int,
+                msRcvTsbPdDelay : int,
+                msSndBuf : int,
+                msSndTsbPdDelay : int,
+                msTimeStamp : int,
+                pktCongestionWindow : int,
+                pktFlightSize : int,
+                pktFlowWindow : int,
+                pktRcvAvgBelatedTime : float,
+                pktRcvBelated : int,
+                pktRcvBuf : int,
+                pktRcvDrop : int,
+                pktRcvDropTotal : int,
+                pktRcvFilterExtra : int,
+                pktRcvFilterExtraTotal : int,
+                pktRcvFilterLoss : int,
+                pktRcvFilterLossTotal : int,
+                pktRcvFilterSupply : int,
+                pktRcvFilterSupplyTotal : int,
+                pktRcvLoss : int,
+                pktRcvLossTotal : int,
+                pktRcvRetrans : int,
+                pktRcvUndecrypt : int,
+                pktRcvUndecryptTotal : int,
+                pktRecv : int,
+                pktRecvACK : int,
+                pktRecvACKTotal : int,
+                pktRecvNAK : int,
+                pktRecvNAKTotal : int,
+                pktRecvTotal : int,
+                pktReorderDistance : int,
+                pktRetrans : int,
+                pktRetransTotal : int,
+                pktSent : int,
+                pktSentACK : int,
+                pktSentACKTotal : int,
+                pktSentNAK : int,
+                pktSentNAKTotal : int,
+                pktSentTotal : int,
+                pktSndBuf : int,
+                pktSndDrop : int,
+                pktSndDropTotal : int,
+                pktSndFilterExtra : int,
+                pktSndFilterExtraTotal : int,
+                pktSndLoss : int,
+                pktSndLossTotal : int,
+                usPktSndPeriod : float,
+                usSndDuration : int,
+                usSndDurationTotal : int},
+    bstats : (?clear : bool?) -> 
+             {
+               byteAvailRcvBuf : int,
+               byteAvailSndBuf : int,
+               byteMSS : int,
+               byteRcvBuf : int,
+               byteRcvDrop : int,
+               byteRcvDropTotal : int,
+               byteRcvUndecrypt : int,
+               byteRcvUndecryptTotal : int,
+               byteRecv : int,
+               byteRecvTotal : int,
+               byteRetrans : int,
+               byteRetransTotal : int,
+               byteSent : int,
+               byteSentTotal : int,
+               byteSndBuf : int,
+               byteSndDrop : int,
+               byteSndDropTotal : int,
+               mbpsBandwidth : float,
+               mbpsMaxBW : float,
+               mbpsRecvRate : float,
+               mbpsSendRate : float,
+               msRTT : float,
+               msRcvBuf : int,
+               msRcvTsbPdDelay : int,
+               msSndBuf : int,
+               msSndTsbPdDelay : int,
+               msTimeStamp : int,
+               pktCongestionWindow : int,
+               pktFlightSize : int,
+               pktFlowWindow : int,
+               pktRcvAvgBelatedTime : float,
+               pktRcvBelated : int,
+               pktRcvBuf : int,
+               pktRcvDrop : int,
+               pktRcvDropTotal : int,
+               pktRcvFilterExtra : int,
+               pktRcvFilterExtraTotal : int,
+               pktRcvFilterLoss : int,
+               pktRcvFilterLossTotal : int,
+               pktRcvFilterSupply : int,
+               pktRcvFilterSupplyTotal : int,
+               pktRcvLoss : int,
+               pktRcvLossTotal : int,
+               pktRcvRetrans : int,
+               pktRcvUndecrypt : int,
+               pktRcvUndecryptTotal : int,
+               pktRecv : int,
+               pktRecvACK : int,
+               pktRecvACKTotal : int,
+               pktRecvNAK : int,
+               pktRecvNAKTotal : int,
+               pktRecvTotal : int,
+               pktReorderDistance : int,
+               pktRetrans : int,
+               pktRetransTotal : int,
+               pktSent : int,
+               pktSentACK : int,
+               pktSentACKTotal : int,
+               pktSentNAK : int,
+               pktSentNAKTotal : int,
+               pktSentTotal : int,
+               pktSndBuf : int,
+               pktSndDrop : int,
+               pktSndDropTotal : int,
+               pktSndFilterExtra : int,
+               pktSndFilterExtraTotal : int,
+               pktSndLoss : int,
+               pktSndLossTotal : int,
+               usPktSndPeriod : float,
+               usSndDuration : int,
+               usSndDurationTotal : int},
+    close : () -> unit,
+    pbkeylen : () -> int,
+    read_data : () -> int,
+    read_latency : () -> int,
+    read_timeout : () -> int,
+    status : () -> string,
+    streamid : () -> string,
+    write_timeout : () -> int
+  }) -> bool)?`, which defaults to `null`): Callback used to decide whether to accept new incoming connections. Used in listener mode only.
+- `max_clients` (of type `int?`, which defaults to `null`): Max number of connected clients (listener mode only)
+- `messageapi` (of type `bool`, which defaults to `true`): Use message api
+- `mode` (of type `string`, which defaults to `"caller"`): Mode to operate on. One of: `"listener"` (waits for connection to come in) or `"caller"` (initiate connection to a remote server)
+- `on_connect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when connected.
+- `on_disconnect` (of type `() -> unit`, which defaults to `{()}`): Function to execute when disconnected
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `passphrase` (of type `string?`, which defaults to `null`): When set to a non-empty string, this option enables encryption and sets the passphrase for it. See `libsrt` documentation for more details.
+- `payload_size` (of type `int`, which defaults to `1316`): Payload size.
+- `pbkeylen` (of type `int?`, which defaults to `null`): Set encryption key length. See `libsrt` documentation for more details.
+- `polling_delay` (of type `float`, which defaults to `2.`): Delay between connection attempts. Used only in caller mode.
+- `port` (of type `int`, which defaults to `8000`): Port to bind on the local machine (listener mode) or to connect to (caller mode). The term `port` as used in SRT is occasionally identical to the term `UDP port`. However SRT offers more flexibility than UDP because it manages ports as its own resources. For example, one port may be shared between various services.
+- `read_timeout` (of type `float?`, which defaults to `1.`): Timeout, in seconds, after which read operations are aborted if no data was received, indefinite if `null`.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `streamid` (of type `string?`, which defaults to `null`): Set `streamid`. This value can be retrieved by the listener side when connecting to it. Used in caller mode only.
+- `write_timeout` (of type `float?`, which defaults to `1.`): Timeout, in seconds, after which write operations are aborted if no data was received, indefinite if `null`.
+- `(unlabeled)` (of type `format('a)`): Encoding format.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `sockets` (of type `() ->
+[string * srt_socket
+ .{
+   bistats : (?clear : bool?, ?instantaneous : bool?) -> 
+             {
+               byteAvailRcvBuf : int,
+               byteAvailSndBuf : int,
+               byteMSS : int,
+               byteRcvBuf : int,
+               byteRcvDrop : int,
+               byteRcvDropTotal : int,
+               byteRcvUndecrypt : int,
+               byteRcvUndecryptTotal : int,
+               byteRecv : int,
+               byteRecvTotal : int,
+               byteRetrans : int,
+               byteRetransTotal : int,
+               byteSent : int,
+               byteSentTotal : int,
+               byteSndBuf : int,
+               byteSndDrop : int,
+               byteSndDropTotal : int,
+               mbpsBandwidth : float,
+               mbpsMaxBW : float,
+               mbpsRecvRate : float,
+               mbpsSendRate : float,
+               msRTT : float,
+               msRcvBuf : int,
+               msRcvTsbPdDelay : int,
+               msSndBuf : int,
+               msSndTsbPdDelay : int,
+               msTimeStamp : int,
+               pktCongestionWindow : int,
+               pktFlightSize : int,
+               pktFlowWindow : int,
+               pktRcvAvgBelatedTime : float,
+               pktRcvBelated : int,
+               pktRcvBuf : int,
+               pktRcvDrop : int,
+               pktRcvDropTotal : int,
+               pktRcvFilterExtra : int,
+               pktRcvFilterExtraTotal : int,
+               pktRcvFilterLoss : int,
+               pktRcvFilterLossTotal : int,
+               pktRcvFilterSupply : int,
+               pktRcvFilterSupplyTotal : int,
+               pktRcvLoss : int,
+               pktRcvLossTotal : int,
+               pktRcvRetrans : int,
+               pktRcvUndecrypt : int,
+               pktRcvUndecryptTotal : int,
+               pktRecv : int,
+               pktRecvACK : int,
+               pktRecvACKTotal : int,
+               pktRecvNAK : int,
+               pktRecvNAKTotal : int,
+               pktRecvTotal : int,
+               pktReorderDistance : int,
+               pktRetrans : int,
+               pktRetransTotal : int,
+               pktSent : int,
+               pktSentACK : int,
+               pktSentACKTotal : int,
+               pktSentNAK : int,
+               pktSentNAKTotal : int,
+               pktSentTotal : int,
+               pktSndBuf : int,
+               pktSndDrop : int,
+               pktSndDropTotal : int,
+               pktSndFilterExtra : int,
+               pktSndFilterExtraTotal : int,
+               pktSndLoss : int,
+               pktSndLossTotal : int,
+               usPktSndPeriod : float,
+               usSndDuration : int,
+               usSndDurationTotal : int},
+   bstats : (?clear : bool?) -> 
+            {
+              byteAvailRcvBuf : int,
+              byteAvailSndBuf : int,
+              byteMSS : int,
+              byteRcvBuf : int,
+              byteRcvDrop : int,
+              byteRcvDropTotal : int,
+              byteRcvUndecrypt : int,
+              byteRcvUndecryptTotal : int,
+              byteRecv : int,
+              byteRecvTotal : int,
+              byteRetrans : int,
+              byteRetransTotal : int,
+              byteSent : int,
+              byteSentTotal : int,
+              byteSndBuf : int,
+              byteSndDrop : int,
+              byteSndDropTotal : int,
+              mbpsBandwidth : float,
+              mbpsMaxBW : float,
+              mbpsRecvRate : float,
+              mbpsSendRate : float,
+              msRTT : float,
+              msRcvBuf : int,
+              msRcvTsbPdDelay : int,
+              msSndBuf : int,
+              msSndTsbPdDelay : int,
+              msTimeStamp : int,
+              pktCongestionWindow : int,
+              pktFlightSize : int,
+              pktFlowWindow : int,
+              pktRcvAvgBelatedTime : float,
+              pktRcvBelated : int,
+              pktRcvBuf : int,
+              pktRcvDrop : int,
+              pktRcvDropTotal : int,
+              pktRcvFilterExtra : int,
+              pktRcvFilterExtraTotal : int,
+              pktRcvFilterLoss : int,
+              pktRcvFilterLossTotal : int,
+              pktRcvFilterSupply : int,
+              pktRcvFilterSupplyTotal : int,
+              pktRcvLoss : int,
+              pktRcvLossTotal : int,
+              pktRcvRetrans : int,
+              pktRcvUndecrypt : int,
+              pktRcvUndecryptTotal : int,
+              pktRecv : int,
+              pktRecvACK : int,
+              pktRecvACKTotal : int,
+              pktRecvNAK : int,
+              pktRecvNAKTotal : int,
+              pktRecvTotal : int,
+              pktReorderDistance : int,
+              pktRetrans : int,
+              pktRetransTotal : int,
+              pktSent : int,
+              pktSentACK : int,
+              pktSentACKTotal : int,
+              pktSentNAK : int,
+              pktSentNAKTotal : int,
+              pktSentTotal : int,
+              pktSndBuf : int,
+              pktSndDrop : int,
+              pktSndDropTotal : int,
+              pktSndFilterExtra : int,
+              pktSndFilterExtraTotal : int,
+              pktSndLoss : int,
+              pktSndLossTotal : int,
+              usPktSndPeriod : float,
+              usSndDuration : int,
+              usSndDurationTotal : int},
+   close : () -> unit,
+   pbkeylen : () -> int,
+   read_data : () -> int,
+   read_latency : () -> int,
+   read_timeout : () -> int,
+   status : () -> string,
+   streamid : () -> string,
+   write_timeout : () -> int
+ }]`): List of `(connected_address, connected_socket)`
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.url`
+
+Encode and let encoder handle data output. Useful with encoder with no expected output or to encode to files that need full control from the encoder, e.g. `%ffmpeg` with `rtmp` output.
+
+Type:
+
+```
+(?id : string?, ?export_cover_metadata : bool, ?fallible : bool,
+ ?on_error : ((error
+               .{
+                 kind : string,
+                 message : string,
+                 trace : [
+                          {
+                            position_end : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            position_start : 
+                            {
+                              character_offset : int,
+                              filename : string,
+                              line_number : int
+                            },
+                            to_string : (?prefix : string) -> string
+                          }]
+               }) -> unit),
+ ?on_start : (() -> unit), ?on_stop : (() -> unit), ?register_telnet : bool,
+ ?restart_delay : float?, ?self_sync : bool, ?start : bool, url : string,
+ format('a), source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `export_cover_metadata` (of type `bool`, which defaults to `true`): Export cover metadata.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be stopped until the source is available again.
+- `on_error` (of type `(error
+ .{
+   kind : string,
+   message : string,
+   trace : [
+            {
+              position_end : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              position_start : 
+              {character_offset : int, filename : string, line_number : int
+              },
+              to_string : (?prefix : string) -> string
+            }]
+ }) -> unit`, which defaults to `<fun>`): Callback executed when an error occurs.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when output stops.
+- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
+- `restart_delay` (of type `float?`, which defaults to `2.`): If not `null`, restart output on errors after the given delay.
+- `self_sync` (of type `bool`, which defaults to `false`): Should the source control its own synchronization? Set to `true` for output to e.g. `rtmp` output using `%ffmpeg` and etc.
+- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
+- `url` (of type `string`): Url to output to.
+- `(unlabeled)` (of type `format('a)`): Encoding format.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.video`
+
+Output a video stream using the default operator. The input source does not need to be infallible, blank will just be played during failures.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool, source(video=canvas('a), 'b)) ->
+unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `true`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If `true`, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`): Source to play.
+
+### `output.youtube.live.hls`
+
+Stream to youtube using HLS.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?segment_duration : float, ?segments : int,
+ ?segments_overhead : int, ?start : bool, ?url : string, key : string,
+ encoder : format('a)
+ .{
+   bandwidth? : int,
+   codecs? : string,
+   extname? : string,
+   extra_tags? : [string],
+   id3? : bool,
+   id3_version? : int,
+   replay_id3? : bool,
+   video_size? : int * int
+ }, source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `segment_duration` (of type `float`, which defaults to `2.`): Segment duration (in seconds).
+- `segments` (of type `int`, which defaults to `4`): Number of segments per playlist.
+- `segments_overhead` (of type `int`, which defaults to `4`): Number of segments to keep after they have been featured in the live playlist.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If true, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `url` (of type `string`, which defaults to `"https://a.upload.youtube.com/http_upload_hls"`): HLS URL to stream to
+- `key` (of type `string`): Your secret youtube key
+- `encoder` (of type `format('a)
+.{
+  bandwidth? : int,
+  codecs? : string,
+  extname? : string,
+  extra_tags? : [string],
+  id3? : bool,
+  id3_version? : int,
+  replay_id3? : bool,
+  video_size? : int * int
+}`): Encoder to use (most likely a `%ffmpeg` encoder)
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `streams` (of type `() ->
+[
+ {
+   bandwidth : int,
+   codecs : string,
+   discontinuity_count : int,
+   encoder : format('A),
+   extname : string,
+   extra_tags : [string],
+   id3_enabled : bool,
+   insert_tag : (string) -> unit,
+   name : string,
+   replay_id3 : bool,
+   video_size : 
+   {height : int, width : int
+   }?
+ }]`): Output streams
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `output.youtube.live.rtmp`
+
+Stream to youtube using RTMP.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?on_start : (() -> unit),
+ ?on_stop : (() -> unit), ?start : bool, ?url : string, key : string,
+ encoder : format('a), source('a)) -> unit
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Allow the child source to fail, in which case the output will be (temporarily) stopped.
+- `on_start` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting starts.
+- `on_stop` (of type `() -> unit`, which defaults to `{()}`): Callback executed when outputting stops.
+- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If true, an infallible (normal) output will start outputting as soon as it is created, and a fallible output will (re)start as soon as its source becomes available for streaming.
+- `url` (of type `string`, which defaults to `"rtmp://a.rtmp.youtube.com/live2"`): RTMP URL to stream to
+- `key` (of type `string`): Your secret youtube key
+- `encoder` (of type `format('a)`): Encoder to use (most likely a `%ffmpeg` encoder)
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_started` (of type `() -> bool`): `true` if the output or source is started.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `shutdown` (of type `() -> unit`): Shutdown the output or source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `start` (of type `() -> unit`): Ask the source or output to start.
+- `stop` (of type `() -> unit`): Ask the source or output to stop.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Sound synthesis
+
+### `dssi.register`
+
+Register a DSSI plugin.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Path of the DSSI plugin file.
+
+### `synth.all.saw`
+
+Saw synthesizer. It creates one synthesizer for each channel.
+
+Type:
+
+```
+(?id : string?, ?attack : float, ?decay : float, ?envelope : bool,
+ ?release : float, ?sustain : float, source(midi=midi(channels=16), 'a)) ->
+source(midi=midi(channels=16), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `float`, which defaults to `0.02`): Envelope attack (in seconds).
+- `decay` (of type `float`, which defaults to `0.01`): Envelope decay (in seconds).
+- `envelope` (of type `bool`, which defaults to `true`): Use envelope.
+- `release` (of type `float`, which defaults to `0.01`): Envelope release (in seconds).
+- `sustain` (of type `float`, which defaults to `0.9`): Envelope sustain level.
+- `(unlabeled)` (of type `source(midi=midi(channels=16), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `synth.all.sine`
+
+Sine synthesizer. It creates one synthesizer for each channel.
+
+Type:
+
+```
+(?id : string?, ?attack : float, ?decay : float, ?envelope : bool,
+ ?release : float, ?sustain : float, source(midi=midi(channels=16), 'a)) ->
+source(midi=midi(channels=16), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `float`, which defaults to `0.02`): Envelope attack (in seconds).
+- `decay` (of type `float`, which defaults to `0.01`): Envelope decay (in seconds).
+- `envelope` (of type `bool`, which defaults to `true`): Use envelope.
+- `release` (of type `float`, which defaults to `0.01`): Envelope release (in seconds).
+- `sustain` (of type `float`, which defaults to `0.9`): Envelope sustain level.
+- `(unlabeled)` (of type `source(midi=midi(channels=16), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `synth.all.square`
+
+Square synthesizer. It creates one synthesizer for each channel.
+
+Type:
+
+```
+(?id : string?, ?attack : float, ?decay : float, ?envelope : bool,
+ ?release : float, ?sustain : float, source(midi=midi(channels=16), 'a)) ->
+source(midi=midi(channels=16), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `float`, which defaults to `0.02`): Envelope attack (in seconds).
+- `decay` (of type `float`, which defaults to `0.01`): Envelope decay (in seconds).
+- `envelope` (of type `bool`, which defaults to `true`): Use envelope.
+- `release` (of type `float`, which defaults to `0.01`): Envelope release (in seconds).
+- `sustain` (of type `float`, which defaults to `0.9`): Envelope sustain level.
+- `(unlabeled)` (of type `source(midi=midi(channels=16), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `synth.saw`
+
+Saw synthesizer.
+
+Type:
+
+```
+(?id : string?, ?attack : float, ?channel : int, ?decay : float,
+ ?envelope : bool, ?release : float, ?sustain : float, ?volume : float,
+ source(midi=midi(channels=1), 'a)) -> source(midi=midi(channels=1), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `float`, which defaults to `0.02`): Envelope attack (in seconds).
+- `channel` (of type `int`, which defaults to `0`): MIDI channel to handle.
+- `decay` (of type `float`, which defaults to `0.01`): Envelope decay (in seconds).
+- `envelope` (of type `bool`, which defaults to `true`): Use envelope.
+- `release` (of type `float`, which defaults to `0.05`): Envelope release (in seconds).
+- `sustain` (of type `float`, which defaults to `0.9`): Envelope sustain level.
+- `volume` (of type `float`, which defaults to `0.3`): Initial volume.
+- `(unlabeled)` (of type `source(midi=midi(channels=1), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `synth.sine`
+
+Sine synthesizer.
+
+Type:
+
+```
+(?id : string?, ?attack : float, ?channel : int, ?decay : float,
+ ?envelope : bool, ?release : float, ?sustain : float, ?volume : float,
+ source(midi=midi(channels=1), 'a)) -> source(midi=midi(channels=1), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `float`, which defaults to `0.02`): Envelope attack (in seconds).
+- `channel` (of type `int`, which defaults to `0`): MIDI channel to handle.
+- `decay` (of type `float`, which defaults to `0.01`): Envelope decay (in seconds).
+- `envelope` (of type `bool`, which defaults to `true`): Use envelope.
+- `release` (of type `float`, which defaults to `0.05`): Envelope release (in seconds).
+- `sustain` (of type `float`, which defaults to `0.9`): Envelope sustain level.
+- `volume` (of type `float`, which defaults to `0.3`): Initial volume.
+- `(unlabeled)` (of type `source(midi=midi(channels=1), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `synth.square`
+
+Square synthesizer.
+
+Type:
+
+```
+(?id : string?, ?attack : float, ?channel : int, ?decay : float,
+ ?envelope : bool, ?release : float, ?sustain : float, ?volume : float,
+ source(midi=midi(channels=1), 'a)) -> source(midi=midi(channels=1), 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `attack` (of type `float`, which defaults to `0.02`): Envelope attack (in seconds).
+- `channel` (of type `int`, which defaults to `0`): MIDI channel to handle.
+- `decay` (of type `float`, which defaults to `0.01`): Envelope decay (in seconds).
+- `envelope` (of type `bool`, which defaults to `true`): Use envelope.
+- `release` (of type `float`, which defaults to `0.05`): Envelope release (in seconds).
+- `sustain` (of type `float`, which defaults to `0.9`): Envelope sustain level.
+- `volume` (of type `float`, which defaults to `0.3`): Initial volume.
+- `(unlabeled)` (of type `source(midi=midi(channels=1), 'a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Testing
+
+### `sleeper`
+
+Sleep regularly, thus inducing delays in the sound production. This is mainly useful for emulating network delays or sources which are slow to produce data, and thus test bufferization and robustness of scripts.
+
+Type:
+
+```
+(?every : float, ?delay : float, ?delay_random : float,
+ ?on_delay : ((float) -> unit), source('a)) -> source('a)
+```
+
+Arguments:
+
+- `every` (of type `float`, which defaults to `1.`): How often we should sleep (in seconds, 0 means every frame).
+- `delay` (of type `float`, which defaults to `1.1`): Delay introduced (in seconds).
+- `delay_random` (of type `float`, which defaults to `0.`): Maximum amount of time randomly added to the delay (in seconds).
+- `on_delay` (of type `(float) -> unit`, which defaults to `fun (_) -> ()`): Function called when a delay is introduced, with the delay as argument.
+- `(unlabeled)` (of type `source('a)`): Source in which the delays should be introduced.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `frozen` (of type `(() -> bool).{set : (bool) -> unit}`): The stream production is frozen while set to `true`.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+## Source / Track processing
+
+### `append`
+
+Append an extra track to every track. Set the metadata 'liq_append' to 'false' to inhibit appending on one track.
+
+Type:
+
+```
+(?id : string?, ?insert_missing : bool, ?merge : bool, source('a),
+ (([string * string]) -> source('a))) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `insert_missing` (of type `bool`, which defaults to `true`): Treat track beginnings without metadata as having empty one.
+- `merge` (of type `bool`, which defaults to `false`): Merge the track with its appended track.
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `([string * string]) -> source('a)`): Given the metadata, build the source producing the track to append. This source is allowed to fail (produce nothing) if no relevant track is to be appended.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `cancel_pending` (of type `() -> unit`): Cancel any pending appended source.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `(?cancel_pending : bool) -> unit`): Skip the current track. Pending appended source are cancelled by default. Pass `cancel_pending=false` to keep it.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `blank.detect`
+
+Calls a given handler when detecting a blank.
+
+Type:
+
+```
+(?id : string?, ?max_blank : {float}, ?min_noise : {float},
+ ?on_noise : (() -> unit), ?start_blank : bool, ?threshold : {float},
+ ?track_sensitive : {bool}, (() -> unit), source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `max_blank` (of type `{float}`, which defaults to `20.`): Maximum duration of silence allowed, in seconds.
+- `min_noise` (of type `{float}`, which defaults to `0.`): Minimum duration of noise required to end silence, in seconds.
+- `on_noise` (of type `() -> unit`, which defaults to `{()}`): Handler called when noise is detected.
+- `start_blank` (of type `bool`, which defaults to `false`): Start assuming we have blank.
+- `threshold` (of type `{float}`, which defaults to `-40.`): Power in decibels under which the stream is considered silent.
+- `track_sensitive` (of type `{bool}`, which defaults to `true`): Reset blank counter at each track.
+- `(unlabeled)` (of type `() -> unit`): Handler called when blank is detected.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `blank.eat`
+
+Eat blanks, i.e., drop the contents of the stream until it is not blank anymore.
+
+Type:
+
+```
+(?id : string?, ?at_beginning : bool, ?max_blank : {float},
+ ?min_noise : {float}, ?start_blank : bool, ?threshold : {float},
+ ?track_sensitive : {bool}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `at_beginning` (of type `bool`, which defaults to `false`): Only eat at the beginning of a track.
+- `max_blank` (of type `{float}`, which defaults to `20.`): Maximum duration of silence allowed, in seconds.
+- `min_noise` (of type `{float}`, which defaults to `0.`): Minimum duration of noise required to end silence, in seconds.
+- `start_blank` (of type `bool`, which defaults to `false`): Start assuming we have blank.
+- `threshold` (of type `{float}`, which defaults to `-40.`): Power in decibels under which the stream is considered silent.
+- `track_sensitive` (of type `{bool}`, which defaults to `true`): Reset blank counter at each track.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `blank.skip`
+
+Skip track when detecting a blank.
+
+Type:
+
+```
+(?id : string?, ?threshold : float, ?max_blank : float, ?min_noise : float,
+ ?track_sensitive : bool, source(audio=pcm('a), 'b).{skip : () -> unit}) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"blank.skip"`): Force the value of the source ID.
+- `threshold` (of type `float`, which defaults to `-40.`): Power in decibels under which the stream is considered silent.
+- `max_blank` (of type `float`, which defaults to `20.`): Maximum silence length allowed, in seconds.
+- `min_noise` (of type `float`, which defaults to `0.`): Minimum duration of noise required to end silence, in seconds.
+- `track_sensitive` (of type `bool`, which defaults to `true`): Reset blank counter at each track.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b).{skip : () -> unit}`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `blank.strip`
+
+Make the source unavailable when it is streaming blank.
+
+Type:
+
+```
+(?id : string?, ?max_blank : {float}, ?min_noise : {float},
+ ?start_blank : bool, ?threshold : {float}, ?track_sensitive : {bool},
+ source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `max_blank` (of type `{float}`, which defaults to `20.`): Maximum duration of silence allowed, in seconds.
+- `min_noise` (of type `{float}`, which defaults to `0.`): Minimum duration of noise required to end silence, in seconds.
+- `start_blank` (of type `bool`, which defaults to `false`): Start assuming we have blank.
+- `threshold` (of type `{float}`, which defaults to `-40.`): Power in decibels under which the stream is considered silent.
+- `track_sensitive` (of type `{bool}`, which defaults to `true`): Reset blank counter at each track.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `dB_levels` (of type `() -> [float]?`): Return the detected dB level for each channel.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_blank` (of type `() -> bool`): Indicate whether blank was detected.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `delay`
+
+Make the source unavailable for a given time between tracks.
+
+Type:
+
+```
+(?id : string?, ?initial : bool, {float}, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `initial` (of type `bool`, which defaults to `false`): Start in unavailable state, as if a track had just finished.
+- `(unlabeled)` (of type `{float}`): The source won't be ready less than this amount of seconds after any end of track
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `fallback`
+
+At the beginning of each track, select the first ready child.
+
+Type:
+
+```
+(?id : string?, ?override : string, ?replay_metadata : bool,
+ ?track_sensitive : bool, ?transition_length : float,
+ ?transitions : [(source('a), source('a)) -> source('a)], [source('a)]) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `override` (of type `string`, which defaults to `"liq_transition_length"`): Metadata field which, if present and containing a float, overrides the `transition_length` parameter.
+- `replay_metadata` (of type `bool`, which defaults to `true`): Replay the last metadata of a child when switching to it in the middle of a track.
+- `track_sensitive` (of type `bool`, which defaults to `true`): Re-select only on end of tracks.
+- `transition_length` (of type `float`, which defaults to `5.`): Maximum transition duration.
+- `transitions` (of type `[(source('a), source('a)) -> source('a)]`, which defaults to `[]`): Transition functions, padded with `fun (x,y) -> y` functions.
+- `(unlabeled)` (of type `[source('a)]`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `insert_metadata`
+
+Dynamically insert metadata in a stream. Returns the source decorated with a method `insert_metadata` which is a function of type `(?new_track,metadata)->unit`, used to insert metadata in the source. This function also inserts a new track with the given metadata if passed `new_track=true`.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Insert metadata in the source. The `new_track` parameter indicates whether a track boundary should also be inserted (by default, no track is inserted).
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `max_duration`
+
+Limit source duration
+
+Type:
+
+```
+(?id : string?, ?override : string, float, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `override` (of type `string`, which defaults to `"liq_remaining"`): Metadata field which, if present and containing a float, overrides the remaining play time.
+- `(unlabeled)` (of type `float`): Maximum duration
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `metadata.map`
+
+Rewrite metadata on the fly using a function.
+
+Type:
+
+```
+(?id : string?, ?update : bool, ?strip : bool, ?insert_missing : bool,
+ (([string * string]) -> [string * string]), source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"metadata.map"`): Force the value of the track ID.
+- `update` (of type `bool`, which defaults to `true`): Update metadata. If false, existing metadata are cleared and only returned values are set as new metadata.
+- `strip` (of type `bool`, which defaults to `false`): Completely remove empty metadata. Operates on both empty values and empty metadata chunk.
+- `insert_missing` (of type `bool`, which defaults to `true`): Treat track beginnings without metadata as having empty ones. The operational order is: create empty if needed, map and strip if enabled.
+- `(unlabeled)` (of type `([string * string]) -> [string * string]`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `mksafe`
+
+Turn a source into an infaillible source by adding blank when the source is not available.
+
+Type:
+
+```
+(?id : string, source('a)) -> source('a) where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string`, which defaults to `"mksafe"`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of internal tracks`): the source to turn infaillible
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)? where 'A is a set of internal tracks`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `on_offset`
+
+Call a given handler when position in track is equal or more than a given amount of time.
+
+Type:
+
+```
+(?id : string?, ?force : bool, ?offset : float, ?override : string,
+ ((float, [string * string]) -> unit), source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `force` (of type `bool`, which defaults to `false`): Force execution of callback if track ends before 'offset' position has been reached.
+- `offset` (of type `float`, which defaults to `-1.`): Execute handler when position in track is equal or more than to this value.
+- `override` (of type `string`, which defaults to `"liq_on_offset"`): Metadata field which, if present and containing a float, overrides the 'offset' parameter.
+- `(unlabeled)` (of type `(float, [string * string]) -> unit`): Function to execute. First argument is the actual position within the current track, second is the latest metadata. That function should be fast because it is executed in the main streaming thread.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `once`
+
+Creates a source that plays only one track of the input source.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"once"`)
+- `(unlabeled)` (of type `source('a)`): The input source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `prepend`
+
+Prepend an extra track before every track. Set the metadata 'liq_prepend' to 'false' to inhibit prepending on one track.
+
+Type:
+
+```
+(?id : string?, ?merge : bool, source('a),
+ (([string * string]) -> source('a))) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `merge` (of type `bool`, which defaults to `false`): Merge the track with its appended track.
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `([string * string]) -> source('a)`): Given the metadata, build the source producing the track to prepend. This source is allowed to fail (produce nothing) if no relevant track is to be appended. However, success must be immediate or it will not be taken into account.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `random`
+
+At the beginning of every track, select a random ready child.
+
+Type:
+
+```
+(?id : string?, ?override : string, ?replay_metadata : bool,
+ ?transition_length : float,
+ ?transitions : [(source('a), source('a)) -> source('a)], ?weights : 
+ [{int}], [source('a)]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `override` (of type `string`, which defaults to `"liq_transition_length"`): Metadata field which, if present and containing a float, overrides the `transition_length` parameter.
+- `replay_metadata` (of type `bool`, which defaults to `true`): Replay the last metadata of a child when switching to it in the middle of a track.
+- `transition_length` (of type `float`, which defaults to `5.`): Maximum transition duration.
+- `transitions` (of type `[(source('a), source('a)) -> source('a)]`, which defaults to `[]`): Transition functions, padded with `fun (x,y) -> y` functions.
+- `weights` (of type `[{int}]`, which defaults to `[]`): Weights of the children (padded with 1), defining for each child the probability that it is selected.
+- `(unlabeled)` (of type `[source('a)]`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `request.player`
+
+Create a source on which plays immediately requests given with the `play` method.
+
+Type:
+
+```
+(?simultaneous : bool) -> source('a) where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `simultaneous` (of type `bool`, which defaults to `true`): Allow multiple requests to play simultaneously. If `false` a new request replaces the previous one.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `length` (of type `() -> int`): Number of currently playing requests.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `play` (of type `(request) -> unit`): Play a request.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(source('A)) -> unit where 'A is a set of internal tracks`): Set the source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `request.queue`
+
+Play a queue of requests (the first added request gets played first).
+
+Type:
+
+```
+(?id : string?, ?interactive : bool, ?prefetch : int?, ?native : bool,
+ ?queue : [request], ?timeout : float) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `interactive` (of type `bool`, which defaults to `true`): Should the queue be controllable via telnet?
+- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance.
+- `native` (of type `bool`, which defaults to `false`): Use native implementation, when available.
+- `queue` (of type `[request]`, which defaults to `[]`): Initial queue of requests.
+- `timeout` (of type `float`, which defaults to `20.`): Timeout (in sec.) for a single download.
+
+Methods:
+
+- `add` (of type `(request) -> bool`): This method is internal and should not be used. Consider using `push` instead.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `current` (of type `() -> request?`): Get the request currently being played.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fetch` (of type `() -> bool`): Try feeding the queue with a new request. Returns `true` if successful. This method can take long to return and should usually be run in a separate thread.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `length` (of type `() -> int`): Length of the queue.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `push` (of type `((request) -> unit).{uri : (string) -> unit}`): Push a request on the request queue.
+- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set_queue` (of type `([request]) -> unit`): 
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `rotate`
+
+Rotate between sources.
+
+Type:
+
+```
+(?id : string?, ?override : string, ?replay_metadata : bool,
+ ?transition_length : float,
+ ?transitions : [(source('a), source('a)) -> source('a)], ?weights : 
+ [{int}], [source('a)]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `override` (of type `string`, which defaults to `"liq_transition_length"`): Metadata field which, if present and containing a float, overrides the `transition_length` parameter.
+- `replay_metadata` (of type `bool`, which defaults to `true`): Replay the last metadata of a child when switching to it in the middle of a track.
+- `transition_length` (of type `float`, which defaults to `5.`): Maximum transition duration.
+- `transitions` (of type `[(source('a), source('a)) -> source('a)]`, which defaults to `[]`): Transition functions, padded with `fun (x,y) -> y` functions.
+- `weights` (of type `[{int}]`, which defaults to `[]`): Weights of the children (padded with 1), defining for each child how many tracks are played from it per round, if that many are actually available.
+- `(unlabeled)` (of type `[source('a)]`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `sequence`
+
+Play a sequence of sources. By default, play one track per source, except for the last one which is played as much as available.
+
+Type:
+
+```
+(?id : string?, ?merge : bool, ?single_track : bool, [source('a)]) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `merge` (of type `bool`, which defaults to `false`): Merge tracks when advancing from one source to the next one. This will NOT merge consecutive tracks from the last source; see merge_tracks() if you need that too.
+- `single_track` (of type `bool`, which defaults to `true`): Advance to the new track in the sequence on new track. Set to `false` to play each source until it becomes unavailable.
+- `(unlabeled)` (of type `[source('a)]`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.audio`
+
+Create an audio source from the given track, with metadata and track marks from that same track.
+
+Type:
+
+```
+(?id : string?, 'a) -> source(audio='a) where 'a is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"source.audio"`)
+- `(unlabeled)` (of type `anything that is a track`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.available`
+
+Change the availability of a source depending on a predicate.
+
+Type:
+
+```
+(?id : string?, ?override : bool, ?track_sensitive : {bool}, source('a),
+ {bool}) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `override` (of type `bool`, which defaults to `false`): Don't take availability of original source in account (this can be dangerous and should be avoided).
+- `track_sensitive` (of type `{bool}`, which defaults to `false`): Change availability only on end of tracks.
+- `(unlabeled)` (of type `source('a)`): Source of which the availability should be changed.
+- `(unlabeled)` (of type `{bool}`): Predicate indicating whether the source should be available or not.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.drop.audio`
+
+Remove the audio track of a source.
+
+Type:
+
+```
+(?id : string?, source(audio='a, 'b)) -> source('b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.drop.metadata`
+
+Remove the metadata track of a source.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source('a) where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.drop.midi`
+
+Remove the midi track of a source.
+
+Type:
+
+```
+(?id : string?, source(midi='a, 'b)) -> source('b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(midi='a, 'b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.drop.video`
+
+Remove the video track of a source.
+
+Type:
+
+```
+(?id : string?, source(video='a, 'b)) -> source('b)
+where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `(unlabeled)` (of type `source(video='a, 'b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.dynamic`
+
+Dynamically change the underlying source: it can either be changed by the function given as argument, which returns the source to be played, or by calling the `set` method.
+
+Type:
+
+```
+(?id : string?, ?infallible : bool, ?init : source('a)?,
+ ?resurection_time : float?, ?track_sensitive : bool, ?(() -> source('a)?)) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `infallible` (of type `bool`, which defaults to `false`): Whether the source is infallible or not (be careful when setting this, it will not be checked by the typing system).
+- `init` (of type `source('a)?`, which defaults to `null`): Initial value for the source
+- `resurection_time` (of type `float?`, which defaults to `1.`): When track sensitive and the source is unavailable, how long we should wait before trying to update source again (`null` means never).
+- `track_sensitive` (of type `bool`, which defaults to `false`): Whether the source should only be updated on track change.
+- `(unlabeled)` (of type `() -> source('a)?`, which defaults to `<fun>`): Function returning the source to be used, `null` means keep current source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(source('A)) -> unit`): Set the source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+This function is experimental.
+
+### `source.frame.duration`
+
+Compute the duration of the last frame.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source(frame_duration=float, 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `frame_duration` (of type `float`): Compute the duration of the last frame.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.frame.rms`
+
+Compute the rms of the last frame.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source(frame_rms=float, 'a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `frame_rms` (of type `float`): Compute the rms of the last frame.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.mux.audio`
+
+Replace the audio track of a source by the one of another source.
+
+Type:
+
+```
+(?id : string?, audio : source(audio='A, 'B), source('c)) -> source(audio='A,
+'c) where 'c is a set of tracks to be muxed into a source, 'A is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `audio` (of type `source(audio='B, 'A) where 'B is a track`): Source whose audio track is to be taken.
+- `(unlabeled)` (of type `source('c) where 'c is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.mux.midi`
+
+Replace the midi track of a source by the one of another source.
+
+Type:
+
+```
+(?id : string?, midi : source(midi='A, 'B), source('c)) -> source(midi='A,
+'c) where 'c is a set of tracks to be muxed into a source, 'A is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `midi` (of type `source(midi='B, 'A) where 'B is a track`): Source whose midi track is to be taken.
+- `(unlabeled)` (of type `source('c) where 'c is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.mux.track.audio`
+
+Replace the audio track of a source.
+
+Type:
+
+```
+(?id : string?, audio : 'a, source('b)) -> source(audio='a, 'b)
+where 'b is a set of tracks to be muxed into a source, 'a is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `audio` (of type `anything that is a track`)
+- `(unlabeled)` (of type `source('b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.mux.track.video`
+
+Replace the video track of a source.
+
+Type:
+
+```
+(?id : string?, video : 'a, source('b)) -> source(video='a, 'b)
+where 'b is a set of tracks to be muxed into a source, 'a is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `video` (of type `anything that is a track`)
+- `(unlabeled)` (of type `source('b) where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.mux.video`
+
+Replace the video track of a source by the one of another source.
+
+Type:
+
+```
+(?id : string?, video : source(video='A, 'B), source('c)) -> source(video='A,
+'c) where 'c is a set of tracks to be muxed into a source, 'A is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `video` (of type `source(video='B, 'A) where 'B is a track`)
+- `(unlabeled)` (of type `source('c) where 'c is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.on_end`
+
+Call a given handler when there is less than a given amount of time remaining before then end of track.
+
+Type:
+
+```
+(?id : string?, ?delay : {float}, source('a),
+ ((float, [string * string]) -> unit)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `delay` (of type `{float}`, which defaults to `5.`): Execute handler when remaining time is less or equal to this value.
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `(float, [string * string]) -> unit`): Function to execute. First argument is the remaining time, second is the latest metadata. That function should be fast because it is executed in the main streaming thread.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.on_frame`
+
+Call a given handler on every frame.
+
+Type:
+
+```
+(?id : string?, source('a), (() -> unit)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `() -> unit`): Function called on every frame. It should be fast because it is executed in the main streaming thread.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.on_metadata`
+
+Call a given handler on metadata packets.
+
+Type:
+
+```
+(?id : string?, source('a), (([string * string]) -> unit)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `([string * string]) -> unit`): Function called on every metadata packet in the stream. It should be fast because it is executed in the main streaming thread.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.on_track`
+
+Call a given handler on new tracks.
+
+Type:
+
+```
+(?id : string?, source('a), (([string * string]) -> unit)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+- `(unlabeled)` (of type `([string * string]) -> unit`): Function called on every beginning of track in the stream, with the corresponding metadata as argument. If there is no metadata at the beginning of track, the empty list is passed. That function should be fast because it is executed in the main streaming thread.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.run`
+
+Run a function regularly. This is similar to `thread.run` but based on a source internal time instead of the computer's time.
+
+Type:
+
+```
+(source('a), ?delay : float, ?every : float?, (() -> unit)) -> source('a)
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`): Source whose time is taken as reference.
+- `delay` (of type `float`, which defaults to `0.`): Time to wait before the first run (in seconds).
+- `every` (of type `float?`, which defaults to `null`): How often to run the function (in seconds). The function is run once if `null`.
+- `(unlabeled)` (of type `() -> unit`): Function to run.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `source.tracks`
+
+Return the tracks of a given source.
+
+Type:
+
+```
+(source('a)) -> 'a
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `metadata` (of type `metadata`)
+- `track_marks` (of type `track_marks`)
+
+### `source.video`
+
+Create a video source from the given track, with metadata and track marks from that same track.
+
+Type:
+
+```
+(?id : string?, 'a) -> source(video='a) where 'a is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"source.video"`)
+- `(unlabeled)` (of type `anything that is a track`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `switch`
+
+At the beginning of a track, select the first source whose predicate is true.
+
+Type:
+
+```
+(?id : string?, ?all_predicates : bool, ?override : string,
+ ?replay_metadata : bool, ?single : [bool], ?track_sensitive : {bool},
+ ?transition_length : float,
+ ?transitions : [(source('a), source('a)) -> source('a)],
+ [(() -> bool) * source('a)]) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `all_predicates` (of type `bool`, which defaults to `false`): Always evaluate all predicates when re-selecting.
+- `override` (of type `string`, which defaults to `"liq_transition_length"`): Metadata field which, if present and containing a float, overrides the `transition_length` parameter.
+- `replay_metadata` (of type `bool`, which defaults to `true`): Replay the last metadata of a child when switching to it in the middle of a track.
+- `single` (of type `[bool]`, which defaults to `[]`): Forbid the selection of a branch for two tracks in a row. The empty list stands for `[false,...,false]`.
+- `track_sensitive` (of type `{bool}`, which defaults to `true`): Re-select only on end of tracks.
+- `transition_length` (of type `float`, which defaults to `5.`): Maximum transition duration.
+- `transitions` (of type `[(source('a), source('a)) -> source('a)]`, which defaults to `[]`): Transition functions, padded with `fun (x,y) -> y` functions.
+- `(unlabeled)` (of type `[(() -> bool) * source('a)]`): Sources with the predicate telling when they can be played.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `selected` (of type `() -> source('A)?`): Currently selected source.
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Video processing
+
+### `image`
+
+Generate a source from a static image.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?width : {int}?, ?height : {int}?,
+ ?x : {int}, ?y : {int}, {string}) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Whether we are allowed to fail (in case the file is non-existent or invalid).
+- `width` (of type `{int}?`, which defaults to `null`): Scale to width
+- `height` (of type `{int}?`, which defaults to `null`): Scale to height
+- `x` (of type `{int}`, which defaults to `0`): x position.
+- `y` (of type `{int}`, which defaults to `0`): y position.
+- `(unlabeled)` (of type `{string}`): Path to the image.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(string) -> unit`): Change the image.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_image`
+
+Add a static image on the source video channel.
+
+Type:
+
+```
+(?id : string?, ?width : {int}?, ?height : {int}?, ?x : {int}, ?y : {int},
+ file : {string}, source(video=canvas('a), 'b)) -> source(video=canvas('a),
+'b) where 'b is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"video.add_image"`): Force the value of the source ID.
+- `width` (of type `{int}?`, which defaults to `null`): Scale to width
+- `height` (of type `{int}?`, which defaults to `null`): Scale to height
+- `x` (of type `{int}`, which defaults to `0`): x position.
+- `y` (of type `{int}`, which defaults to `0`): y position.
+- `file` (of type `{string}`): Path to the image file.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)
+where 'b is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_line`
+
+Draw a line on the video.
+
+Type:
+
+```
+(?id : string?, ?alpha : {float}, ?color : {int}, {int * int}, {int * int},
+ source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `alpha` (of type `{float}`, which defaults to `1.`): Transparency of the color between 0 and 1 (0 is fully transparent and 1 is fully opaque).
+- `color` (of type `{int}`, which defaults to `0`): Color to fill the image with (0xRRGGBB).
+- `(unlabeled)` (of type `{int * int}`): Start point.
+- `(unlabeled)` (of type `{int * int}`): End point.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_rectangle`
+
+Draw a rectangle.
+
+Type:
+
+```
+(?id : string?, ?alpha : {float}, ?color : {int}, height : {int},
+ width : {int}, ?x : {int}, ?y : {int}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `alpha` (of type `{float}`, which defaults to `1.`): Transparency of the color between 0 and 1 (0 is fully transparent and 1 is fully opaque).
+- `color` (of type `{int}`, which defaults to `0`): Color to fill the image with (0xRRGGBB).
+- `height` (of type `{int}`): Height.
+- `width` (of type `{int}`): Width.
+- `x` (of type `{int}`, which defaults to `0`): Horizontal offset.
+- `y` (of type `{int}`, which defaults to `0`): Vertical offset.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_subtitle`
+
+Add subtitle from metadata.
+
+Type:
+
+```
+(?override : string, ?size : int, ?color : int, ?offset : int,
+ source(video=canvas('A), 'a)) -> source(video=canvas('A), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `override` (of type `string`, which defaults to `"subtitle"`): Metadata where subtitle to display are located.
+- `size` (of type `int`, which defaults to `18`)
+- `color` (of type `int`, which defaults to `16777215`)
+- `offset` (of type `int`, which defaults to `20`): Offset in pixels.
+- `(unlabeled)` (of type `source(video=canvas('A), 'a)
+where 'a is a set of tracks to be muxed into a source`): Source.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_text`
+
+Add a text to a stream. Uses the first available operator in: camlimages, SDL, FFmpeg, GStreamer, gd or native.
+
+Type:
+
+```
+(?id : string?, ?duration : float?, ?color : int, ?cycle : bool,
+ ?font : {string}?, ?metadata : string?, ?size : int, ?speed : int,
+ ?x : {int}, ?y : {int}, ?on_cycle : (() -> unit), {string},
+ source(video=canvas('A), 'a).{is_ready : () -> bool}) ->
+source(video=canvas('A), 'a)
+where 'a is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float?`, which defaults to `null`)
+- `color` (of type `int`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file.
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `int`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `0`): Horizontal speed in pixels per second (`0` means no scrolling and update according to `x` and `y` in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `on_cycle` (of type `() -> unit`, which defaults to `{()}`): Function called when text is cycling.
+- `(unlabeled)` (of type `{string}`): d Text to display.
+- `(unlabeled)` (of type `source(video=canvas('A), 'a).{is_ready : () -> bool}
+where 'a is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_text.ffmpeg.internal`
+
+Display a text.
+
+Type:
+
+```
+(?id : string?, ?color : int, ?cycle : bool, ?font : string?,
+ ?duration : float?, ?metadata : string?, ?size : int, ?speed : int,
+ ?x : {int}, ?y : {int}, {string}, source(audio=pcm('b), video=canvas('a))) ->
+source(audio=pcm('c), video=canvas('d))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color` (of type `int`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `string?`, which defaults to `null`): Path to ttf font file.
+- `duration` (of type `float?`, which defaults to `null`)
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `int`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `70`): Horizontal speed in pixels per second (0 means no scrolling and update according to x and y in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `(unlabeled)` (of type `{string}`): d Text to display.
+- `(unlabeled)` (of type `source(audio=pcm('b), video=canvas('a))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_text.ffmpeg.raw`
+
+Display a text. Use this operator inside ffmpeg filters with a input source
+
+Type:
+
+```
+(?color : int, ?cycle : bool, ?font : string?, ?metadata : string?,
+ ?size : int, ?speed : int, ?x : {int}, ?y : {int},
+ graph : ffmpeg.filter.graph, ?{string}, source(video=ffmpeg.video.raw('a),
+ 'b)) -> ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `int`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `string?`, which defaults to `null`): Path to ttf font file.
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `int`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `70`): Horizontal speed in pixels per second (0 means no scrolling and update according to x and y in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `graph` (of type `ffmpeg.filter.graph`): a ffmpeg filter graph to attach this filter to.
+- `(unlabeled)` (of type `{string}`, which defaults to `""`): d Text to display.
+- `(unlabeled)` (of type `source(video=ffmpeg.video.raw('a), 'b)`)
+
+### `video.add_text.ffmpeg.raw.filter`
+
+Display a text. Use this operator inside ffmpeg filters with a ffmpeg video input Returns a ffmpeg video output with `on_change` and `on_metadata` methods to be used to update the output text.
+
+Type:
+
+```
+(?color : int, ?cycle : bool, ?font : string?, ?metadata : string?,
+ ?size : int, ?speed : int, ?x : {int}, ?y : {int},
+ graph : ffmpeg.filter.graph, ?{string}, ffmpeg.filter.video) ->
+ffmpeg.filter.video
+```
+
+Arguments:
+
+- `color` (of type `int`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `string?`, which defaults to `null`): Path to ttf font file.
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `int`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `70`): Horizontal speed in pixels per second (0 means no scrolling and update according to x and y in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `graph` (of type `ffmpeg.filter.graph`): a ffmpeg filter graph to attach this filter to.
+- `(unlabeled)` (of type `{string}`, which defaults to `""`): d Text to display.
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+Methods:
+
+- `on_change` (of type `() -> unit`): Method to call when parameters have changed to update the filter's rendered out, including when text changes.
+- `on_metadata` (of type `([string * string]) -> unit`): Method to call on new metadata.
+
+### `video.add_text.native`
+
+Add a text to a stream (native implementation).
+
+Type:
+
+```
+(?id : string?, ?duration : float?, ?color : {int}, ?cycle : bool,
+ ?font : {string}?, ?metadata : string?, ?size : {int}, ?speed : int,
+ ?x : {int}, ?y : {int}, ?on_cycle : (() -> unit), {string},
+ source(video=canvas('B), 'A).{is_ready : () -> bool}) ->
+source(video=canvas('B), 'A)
+where 'A is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float?`, which defaults to `null`)
+- `color` (of type `{int}`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file.
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `{int}`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `0`): Horizontal speed in pixels per second (`0` means no scrolling and update according to `x` and `y` in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `on_cycle` (of type `() -> unit`, which defaults to `{()}`)
+- `(unlabeled)` (of type `{string}`): d Text to display.
+- `(unlabeled)` (of type `source(video=canvas('B), 'A).{is_ready : () -> bool}
+where 'A is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.add_text.sdl`
+
+Add a text to a stream (SDL implementation).
+
+Type:
+
+```
+(?id : string?, ?duration : float?, ?color : {int}, ?cycle : bool,
+ ?font : {string}?, ?metadata : string?, ?size : {int}, ?speed : int,
+ ?x : {int}, ?y : {int}, ?on_cycle : (() -> unit), {string},
+ source(video=canvas('B), 'A).{is_ready : () -> bool}) ->
+source(video=canvas('B), 'A)
+where 'A is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float?`, which defaults to `null`)
+- `color` (of type `{int}`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file.
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `{int}`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `0`): Horizontal speed in pixels per second (`0` means no scrolling and update according to `x` and `y` in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `on_cycle` (of type `() -> unit`, which defaults to `{()}`)
+- `(unlabeled)` (of type `{string}`): d Text to display.
+- `(unlabeled)` (of type `source(video=canvas('B), 'A).{is_ready : () -> bool}
+where 'A is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.align`
+
+Translate the video so that it is aligned on boundaries.
+
+Type:
+
+```
+(?id : string?, ?bottom : bool, ?left : bool, ?right : bool, ?top : bool,
+ source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `bottom` (of type `bool`, which defaults to `false`): Align bottom.
+- `left` (of type `bool`, which defaults to `false`): Align left.
+- `right` (of type `bool`, which defaults to `false`): Align right.
+- `top` (of type `bool`, which defaults to `false`): Align top.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.alpha.movement`
+
+Make moving parts visible and non-moving parts transparent. A cheap way to have a bluescreen.
+
+Type:
+
+```
+(?id : string?, ?precision : float, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `precision` (of type `float`, which defaults to `0.2`): Precision when comparing pixels to those of previous image (between 0 and 1).
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.alpha.of_color`
+
+Set a color to be transparent.
+
+Type:
+
+```
+(?id : string?, ?color : int, ?precision : float, source(video=canvas('a),
+ 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color` (of type `int`, which defaults to `0`): Color which should be transparent (in 0xRRGGBB format).
+- `precision` (of type `float`, which defaults to `0.2`): Precision in color matching (0. means match precisely the color and 1. means match every color).
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.alpha.remove`
+
+Remove α channel.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.alpha.to_y`
+
+Convert the α channel to Y channel, thus converting opaque (resp. transparent) pixels to bright (resp. dark) ones. This is useful to observe the α channel.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.board`
+
+A plane where one can draw.
+
+Type:
+
+```
+(?id : string?, ?height : int?, ?width : int?) -> source('a)
+where 'a is a set of internal tracks
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `height` (of type `int?`, which defaults to `null`): Initial height of the video (defaults ot the same as frame).
+- `width` (of type `int?`, which defaults to `null`): Initial width of the video (defaults ot the same as frame).
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `clear` (of type `() -> unit`): Clear the board.
+- `clear_and_copy` (of type `(?x : int, ?y : int) -> unit`): Clear the board and copy the old board to the new one, translated.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `fill` (of type `(int) -> unit`): Fill with given color (0xRRGGBB).
+- `height` (of type `() -> int`): Current height of the board.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `line_to` (of type `(?color : int, int, int) -> unit`): Draw a line from the last point.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `pixel` (of type `(int, int) -> (() -> int).{set : (int) -> unit}`): Retrieve a pixel whose contents is a color (in 0xRRGGBB format).
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `width` (of type `() -> int`): Current width of the board.
+
+### `video.bounding_box`
+
+Retrieve the origin (methods `x` / `y`) and the dimensions (methods `width` / `height`) of the bounding box of the video.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `height` (of type `() -> int`): Height of video.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `width` (of type `() -> int`): Width of video.
+- `x` (of type `() -> int`): x offset of video.
+- `y` (of type `() -> int`): y offset of video.
+
+### `video.color`
+
+Generate a video filled with given color.
+
+Type:
+
+```
+({int}) -> source(video=canvas('a), 'b) where 'b is a set of internal tracks
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `{int}`): Color (in 0xRRGGBB format).
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.cover`
+
+Generate a video source containing cover-art for current track of input audio source.
+
+Type:
+
+```
+('b.{on_track : ((([string * string]) -> unit)) -> 'a}) ->
+source(video=canvas('c))
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `'b.{on_track : ((([string * string]) -> unit)) -> 'a}`): Audio source whose metadata contain cover-art.
+
+### `video.crop`
+
+Make the viewport of the current video match its bounding box.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.fade.in`
+
+Fade the beginning of tracks. Metadata 'liq_video_fade_in' can be used to set the duration for a specific track (float in seconds).
+
+Type:
+
+```
+(?id : string?, ?duration : float, ?override : string, ?transition : string,
+ ?type : string, source(video=canvas('a), 'b)) -> source(video=canvas('a),
+'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float`, which defaults to `3.`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override.
+- `override` (of type `string`, which defaults to `"liq_video_fade_in"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for current track.
+- `transition` (of type `string`, which defaults to `"fade"`): Kind of transition (fade|slide_left|slide_right|slide_up|slide_down|grow|disc|random).
+- `type` (of type `string`, which defaults to `"lin"`): Fader shape (lin|sin|log|exp): linear, sinusoidal, logarithmic or exponential.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.fade.out`
+
+Fade the end of tracks. Metadata 'liq_video_fade_out' can be used to set the duration for a specific track (float in seconds).
+
+Type:
+
+```
+(?id : string?, ?duration : float, ?override : string, ?transition : string,
+ ?type : string, source(video=canvas('a), 'b)) -> source(video=canvas('a),
+'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float`, which defaults to `3.`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override.
+- `override` (of type `string`, which defaults to `"liq_video_fade_out"`): Metadata field which, if present and containing a float, overrides the 'duration' parameter for current track.
+- `transition` (of type `string`, which defaults to `"fade"`): Kind of transition (fade|slide_left|slide_right|slide_up|slide_down|grow|disc|random).
+- `type` (of type `string`, which defaults to `"lin"`): Fader shape (lin|sin|log|exp): linear, sinusoidal, logarithmic or exponential.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.fill`
+
+Fill frame with a color.
+
+Type:
+
+```
+(?id : string?, ?alpha : {float}, ?color : {int}, source(video=canvas('a),
+ 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `alpha` (of type `{float}`, which defaults to `1.`): Transparency of the color between 0 and 1 (0 is fully transparent and 1 is fully opaque).
+- `color` (of type `{int}`, which defaults to `0`): Color to fill the image with (0xRRGGBB).
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.frame.height`
+
+Height for all video frames.
+
+Type:
+
+```
+() -> int
+```
+
+### `video.frame.rate`
+
+Framerate for all video frames.
+
+Type:
+
+```
+() -> int
+```
+
+### `video.frame.width`
+
+Width for all video frames.
+
+Type:
+
+```
+() -> int
+```
+
+### `video.greyscale`
+
+Convert video to greyscale.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.hmirror`
+
+Flip image horizontally.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.info`
+
+Compute various information about the video (dimension, size, etc.). Those are accessible through the methods attached to the source.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `height` (of type `() -> int`): Height of video.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `planes` (of type `() -> int`): Number of planes in a video frame.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `size` (of type `() -> int`): Size of a video frame (in bytes).
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+- `width` (of type `() -> int`): Width of video.
+
+### `video.invert`
+
+Invert video.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.lomo`
+
+Emulate the "Lomo effect".
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.opacity`
+
+Scale opacity of video.
+
+Type:
+
+```
+(?id : string?, {float}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `{float}`): Coefficient to scale opacity with.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.opacity.box`
+
+Set alpha value on a given box inside the image.
+
+Type:
+
+```
+(?id : string?, alpha : {float}, height : {int}, width : {int}, ?x : {int},
+ ?y : {int}, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `alpha` (of type `{float}`): alpha value.
+- `height` (of type `{int}`): Box height.
+- `width` (of type `{int}`): Box width.
+- `x` (of type `{int}`, which defaults to `0`): x offset.
+- `y` (of type `{int}`, which defaults to `0`): y offset.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.persistence`
+
+Make images of the video persistent.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `1.`): Persistence duration in seconds.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.plot`
+
+Plot a floating point value.
+
+Type:
+
+```
+(?lines : bool, ?min : float, ?max : float, ?speed : float, ?color : int,
+ (() -> float)) -> source(video=canvas('a), 'b)
+where 'b is a set of internal tracks
+```
+
+Arguments:
+
+- `lines` (of type `bool`, which defaults to `true`): Draw lines connecting plotted points.
+- `min` (of type `float`, which defaults to `0.`): Minimal value of the parameter.
+- `max` (of type `float`, which defaults to `1.`): Maximal value of the parameter.
+- `speed` (of type `float`, which defaults to `100.`): Speed in pixels per second.
+- `color` (of type `int`, which defaults to `16777215`): Color of the drawn point (in 0xRRGGBB format).
+- `(unlabeled)` (of type `() -> float`): Value to plot.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.render`
+
+Render the video by computing the result of its canvas images.
+
+Type:
+
+```
+(?id : string?, ?transparent : bool, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `transparent` (of type `bool`, which defaults to `true`): Make uncovered portions of the image transparent (they are black by default).
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.resize`
+
+Resize and translate video.
+
+Type:
+
+```
+(?id : string?, ?height : {int}?, ?proportional : bool, ?width : {int}?,
+ ?x : {int}, ?y : {int}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `height` (of type `{int}?`, which defaults to `null`): Target height (`null` means original height).
+- `proportional` (of type `bool`, which defaults to `true`): Keep original proportions.
+- `width` (of type `{int}?`, which defaults to `null`): Target width (`null` means original width).
+- `x` (of type `{int}`, which defaults to `0`): x offset.
+- `y` (of type `{int}`, which defaults to `0`): y offset.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.rotate`
+
+Rotate video.
+
+Type:
+
+```
+(?id : string?, ?angle : {float}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `angle` (of type `{float}`, which defaults to `0.`): Angle in radians.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.scale`
+
+Scale and translate video.
+
+Type:
+
+```
+(?id : string?, ?scale : {float}, ?x : {int}, ?xscale : {float}, ?y : {int},
+ ?yscale : {float}, source(video=canvas('a), 'b)) -> source(video=canvas('a),
+'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `scale` (of type `{float}`, which defaults to `1.`): Scaling coefficient in both directions.
+- `x` (of type `{int}`, which defaults to `0`): x offset.
+- `xscale` (of type `{float}`, which defaults to `1.`): x scaling.
+- `y` (of type `{int}`, which defaults to `0`): y offset.
+- `yscale` (of type `{float}`, which defaults to `1.`): y scaling.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.sepia`
+
+Convert video to sepia.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.slideshow`
+
+Display a slideshow (typically of pictures).
+
+Type:
+
+```
+(?id : string?, ?cyclic : {bool}, ?advance : {float}, ?[string]) ->
+source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `cyclic` (of type `{bool}`, which defaults to `true`): Go to the first picture after the last.
+- `advance` (of type `{float}`, which defaults to `-1.`): Skip to the next file after this amount of time in seconds (negative means never).
+- `(unlabeled)` (of type `[string]`, which defaults to `[]`): List of files to display.
+
+Methods:
+
+- `append` (of type `([string]) -> unit`): Append a list of files to the slideshow.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `clear` (of type `() -> unit`): Clear the list of files in the slideshow.
+- `current` (of type `() -> string`): Currently displayed file.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `next` (of type `() -> unit`): Go to next file.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `prev` (of type `() -> unit`): Go to previous file.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `set` (of type `(source('A)) -> unit`): Set the source.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.still_frame`
+
+Take still frames from a video source by calling the `save` method. For now only bitmap output is supported.
+
+Type:
+
+```
+(?id : string?, source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `save` (of type `(string) -> unit`): Save current image, argument is the file name to save to.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.testsrc.ffmpeg`
+
+A test video source, which generates various patterns.
+
+Type:
+
+```
+(?id : string?, ?pattern : string, ?max_buffer : float, ?duration : 'a?) ->
+source(video=canvas('b))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`)
+- `pattern` (of type `string`, which defaults to `"testsrc"`): Pattern drawn in the video: `"testsrc"`, `"testsrc2"`, `"smptebars"`, `"pal75bars"`, `"pal100bars"`, `"smptehdbars"`, `"yuvtestsrc"` or `"rgbtestsrc"` and more. Support any of the patterns supported by `ffmpeg`.
+- `max_buffer` (of type `float`, which defaults to `0.5`): Maximum data buffer in seconds
+- `duration` (of type `'a?`, which defaults to `null`): Duration of the source.
+
+### `video.text`
+
+Display a text using the first available operator in: camlimages, SDL, FFmpeg, GStreamer, gd or native.
+
+Type:
+
+```
+(?id : string?, ?color : {int}, ?duration : float?, ?font : {string}?,
+ ?size : {int}, {string}) -> source(video=canvas('A))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color` (of type `{int}`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file.
+- `size` (of type `{int}`, which defaults to `18`): Font size.
+- `(unlabeled)` (of type `{string}`): Text to display.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.text.gd`
+
+Add a text to a stream (GD implementation).
+
+Type:
+
+```
+(?id : string?, ?duration : float?, ?color : {int}, ?cycle : bool,
+ ?font : {string}?, ?metadata : string?, ?size : {int}, ?speed : int,
+ ?x : {int}, ?y : {int}, ?on_cycle : (() -> unit), {string},
+ source(video=canvas('B), 'A).{is_ready : () -> bool}) ->
+source(video=canvas('B), 'A)
+where 'A is a set of tracks to be muxed into a source
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `float?`, which defaults to `null`)
+- `color` (of type `{int}`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `cycle` (of type `bool`, which defaults to `true`): Cycle text when it reaches left boundary.
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file.
+- `metadata` (of type `string?`, which defaults to `null`): Change text on a particular metadata (empty string means disabled).
+- `size` (of type `{int}`, which defaults to `18`): Font size.
+- `speed` (of type `int`, which defaults to `0`): Horizontal speed in pixels per second (`0` means no scrolling and update according to `x` and `y` in case they are variable).
+- `x` (of type `{int}`, which defaults to `10`): x offset.
+- `y` (of type `{int}`, which defaults to `10`): y offset.
+- `on_cycle` (of type `() -> unit`, which defaults to `{()}`)
+- `(unlabeled)` (of type `{string}`): d Text to display.
+- `(unlabeled)` (of type `source(video=canvas('B), 'A).{is_ready : () -> bool}
+where 'A is a set of tracks to be muxed into a source`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.text.native`
+
+Display a text.
+
+Type:
+
+```
+(?id : string?, ?color : {int}, ?duration : float?, ?font : {string}?,
+ ?size : {int}, {string}) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color` (of type `{int}`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file (default is `"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"`).
+- `size` (of type `{int}`, which defaults to `18`): Font size.
+- `(unlabeled)` (of type `{string}`): Text to display.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.text.sdl`
+
+Display a text.
+
+Type:
+
+```
+(?id : string?, ?color : {int}, ?duration : float?, ?font : {string}?,
+ ?size : {int}, {string}) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `color` (of type `{int}`, which defaults to `16777215`): Text color (in 0xRRGGBB format).
+- `duration` (of type `float?`, which defaults to `null`): Duration in seconds (`null` means infinite).
+- `font` (of type `{string}?`, which defaults to `null`): Path to ttf font file (default is `"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"`).
+- `size` (of type `{int}`, which defaults to `18`): Font size.
+- `(unlabeled)` (of type `{string}`): Text to display.
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.tile`
+
+Tile sources
+
+Type:
+
+```
+(?id : string?, ?normalize : {bool}, ?power : {bool}, ?proportional : bool,
+ ?weights : [{float}], [source(?audio=pcm('b), video=canvas('a), 'c)]) ->
+source(?audio=pcm('b), video=canvas('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"video.tile"`): Force the value of the track ID.
+- `normalize` (of type `{bool}`, which defaults to `true`): Divide by the sum of weights of ready sources (or by the number of ready sources if weights are not specified).
+- `power` (of type `{bool}`, which defaults to `false`): Perform constant-power normalization.
+- `proportional` (of type `bool`, which defaults to `true`): Scale preserving the proportions.
+- `weights` (of type `[{float}]`, which defaults to `[]`)
+- `(unlabeled)` (of type `[source(?audio=pcm('b), video=canvas('a), 'c)]`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.translate`
+
+Translate video.
+
+Type:
+
+```
+(?id : string?, ?x : {int}, ?y : {int}, source(video=canvas('a), 'b)) ->
+source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `x` (of type `{int}`, which defaults to `0`): x offset.
+- `y` (of type `{int}`, which defaults to `0`): y offset.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.viewport`
+
+Set the viewport for the current video.
+
+Type:
+
+```
+(?id : string?, ?height : int?, ?width : int?, ?x : int, ?y : int,
+ source(video=canvas('a), 'b)) -> source(video=canvas('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `height` (of type `int?`, which defaults to `null`): height (default is frame height).
+- `width` (of type `int?`, which defaults to `null`): Width (default is frame width).
+- `x` (of type `int`, which defaults to `0`): Horizontal offset.
+- `y` (of type `int`, which defaults to `0`): Vertical offset.
+- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## Source / Visualization
+
+### `bpm`
+
+Detect the BPM (number of beats per minute). The returned source has a method `bpm`, which can be called to compute it.
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `bpm` (of type `() -> float`): Compute the current BPM.
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `lufs`
+
+Compute current LUFS of the source according to the EBU R128 standard. It returns the source with a method to compute the current value.
+
+Type:
+
+```
+(?id : string?, ?window : {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `window` (of type `{float}`, which defaults to `3.`): Duration of the window (in seconds) used to compute the LUFS.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `lufs` (of type `() -> float`): Current value for the LUFS (short-term value computed over the duration specified by the `window` parameter).
+- `lufs_momentary` (of type `() -> float`): Momentary LUFS (over a 400ms window).
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `midi.inspect`
+
+Display midi events on standard output.
+
+Type:
+
+```
+(?id : string?, source('a)) -> source('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source('a)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `rms.smooth`
+
+Compute the current RMS for the source, this varies more smoothly that `rms` and is updated more frequently. Returns the source with a method `rms`.
+
+Type:
+
+```
+(?id : string?, ?duration : {float}, source(audio=pcm('a), 'b)) ->
+source(audio=pcm('a), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `duration` (of type `{float}`, which defaults to `0.5`): Duration of the window in seconds (more precisely, this is the time constant of the low-pass filter).
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `rms` (of type `() -> float`): Current value for the RMS.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+### `video.volume`
+
+Graphical visualization of the sound.
+
+Type:
+
+```
+(?id : string?, source(audio=pcm('a), 'b)) -> source(audio=pcm('a),
+video=canvas('c), 'b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
+- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
+## String
+
+### `%`
+
+`pattern % [...,(k,v),...]` changes in the pattern occurrences of:
+
+- `$(k)` into `v`
+- `$(if $(k2),"a","b") into "a" if k2 is found in the list, "b" otherwise.
+
+Type:
+
+```
+(string, [string * string]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `[string * string]`)
+
+### `^`
+
+Concatenate strings.
+
+Type:
+
+```
+(string, string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+### `bool_of_string`
+
+Convert a string to a bool. Raises `error.failure("a string to a bool")` if conversion fails and default is `null`
+
+Type:
+
+```
+(string, ?default : bool?) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `default` (of type `bool?`, which defaults to `null`)
+
+### `file.metadata.flac.cover.decode`
+
+Decode a flac-encoded cover metadata string.
+
+Type:
+
+```
+(string) -> string
+.{
+  color_depth : int,
+  description : string,
+  height : int,
+  mime : string,
+  number_of_colors : int?,
+  picture_type : int,
+  width : int}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `file.metadata.flac.cover.encode`
+
+Encode cover metadata for embedding with flac files.
+
+Type:
+
+```
+(picture_type : int, mime : string, ?description : string, width : int,
+ height : int, color_depth : int, ?number_of_colors : int?, string) -> string
+```
+
+Arguments:
+
+- `picture_type` (of type `int`)
+- `mime` (of type `string`)
+- `description` (of type `string`, which defaults to `""`)
+- `width` (of type `int`)
+- `height` (of type `int`)
+- `color_depth` (of type `int`)
+- `number_of_colors` (of type `int?`, which defaults to `null`)
+- `(unlabeled)` (of type `string`)
+
+### `float_of_string`
+
+Convert a string to a float. Raises `error.failure("a string to a float")` if conversion fails and default is `null`
+
+Type:
+
+```
+(string, ?default : float?) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `default` (of type `float?`, which defaults to `null`)
+
+### `int_of_string`
+
+Convert a string to a int. Raises `error.failure("a string to a int")` if conversion fails and default is `null`
+
+Type:
+
+```
+(string, ?default : int?) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `default` (of type `int?`, which defaults to `null`)
+
+### `irc.channel`
+
+Contents of an IRC channel.
+
+Type:
+
+```
+(?server : string, ?port : int, ?channel : string, ?nick : string,
+ ?limit : int) -> () -> string
+```
+
+Example:
+
+```liquidsoap
+# Display messages in the #liquidsoap-test room over a video
+s = single("test.mp4")
+s = video.add_text.native(irc.channel(channel="#liquidsoap-test"), s)
+```
+
+Arguments:
+
+- `server` (of type `string`, which defaults to `"irc.libera.chat"`): IRC server.
+- `port` (of type `int`, which defaults to `6667`): Port for IRC server.
+- `channel` (of type `string`, which defaults to `"#liquidsoap"`): IRC chan to join.
+- `nick` (of type `string`, which defaults to `"liquidbot"`): Nickname.
+- `limit` (of type `int`, which defaults to `10`): Limit to n last messages
+
+### `json`
+
+Create a generic json object
+
+Type:
+
+```
+() -> json
+```
+
+Methods:
+
+- `add` (of type `(string, 'a) -> unit`): Add or replace a new `key`/`value` pair to the object.
+- `remove` (of type `(string) -> unit`): Remove a key from the object. Does not nothing if the key does not exist.
+- `stringify` (of type `(?compact : bool, ?json5 : bool) -> string`): Render object as json string.
+
+### `json.stringify`
+
+Convert a value to JSON. If the value cannot be represented as JSON (for instance a function), a `error.json` exception is raised.
+
+Type:
+
+```
+(?compact : bool, ?json5 : bool, 'a) -> string
+```
+
+Arguments:
+
+- `compact` (of type `bool`, which defaults to `false`): Output compact text.
+- `json5` (of type `bool`, which defaults to `false`): Use json5 extended spec.
+- `(unlabeled)` (of type `'a`)
+
+### `metadata.id3v2.render`
+
+Return a string representation of a id3v2 metadata tag
+
+Type:
+
+```
+([string * string], ?version : int) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`)
+- `version` (of type `int`, which defaults to `3`): Tag version. One of: 3 or 4
+
+### `regexp`
+
+Create a regular expression
+
+Type:
+
+```
+(?flags : [string], string) -> regexp
+```
+
+Arguments:
+
+- `flags` (of type `[string]`, which defaults to `[]`): List of flags. Valid flags: `"i"`, `"g"`, `"s"`, `"m"`.
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `exec` (of type `(string) -> [int * string].{groups : [string * string]}`): Extract substrings from a string. Returns a list of (index,value). If the list does not have a pair associated to some index, it means that the corresponding pattern was not found.
+- `replace` (of type `(((string) -> string), string) -> string`): Replace substrings matched by the regexp by another string returned by a function.
+- `split` (of type `(string) -> [string]`): Split a string on the given regular expression.
+- `test` (of type `(string) -> bool`): Match a string with the expressionn.
+
+### `runtime.mem_usage.prettify_bytes`
+
+Returns a human-redable description of an amount of bytes.
+
+Type:
+
+```
+(?float_printer : ((float) -> string)?, ?signed : bool?, ?bits : bool?,
+ ?binary : bool?, int) -> string
+```
+
+Arguments:
+
+- `float_printer` (of type `((float) -> string)?`, which defaults to `null`)
+- `signed` (of type `bool?`, which defaults to `null`)
+- `bits` (of type `bool?`, which defaults to `null`)
+- `binary` (of type `bool?`, which defaults to `null`)
+- `(unlabeled)` (of type `int`)
+
+### `string`
+
+Return the representation of a value.
+
+Type:
+
+```
+(?fields : bool, 'a) -> string
+```
+
+Arguments:
+
+- `fields` (of type `bool`, which defaults to `false`): Show toplevel fields around the value.
+- `(unlabeled)` (of type `'a`)
+
+### `string.annotate.parse`
+
+Parse a string of the form `<key>=<value>,...:<uri>` as given by the `annotate:` protocol
+
+Type:
+
+```
+(string) -> [string * string] * string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.base64.decode`
+
+Decode a Base64 encoded string.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.base64.encode`
+
+Encode a string in Base64.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.binary.of_int`
+
+Encode a positive (unsigned) integer using native memory representation.
+
+Type:
+
+```
+(?pad : int, ?little_endian : bool, int) -> string
+```
+
+Arguments:
+
+- `pad` (of type `int`, which defaults to `0`): Minimum length in digits (pad on the left with zeros in order to reach it)
+- `little_endian` (of type `bool`, which defaults to `true`): Whether the memory representation is little endian.
+- `(unlabeled)` (of type `int`): String containing the binary representation.
+
+### `string.binary.to_int`
+
+Value of a positive (unsigned) integer encoded using native memory representation.
+
+Type:
+
+```
+(?little_endian : bool, string) -> int
+```
+
+Arguments:
+
+- `little_endian` (of type `bool`, which defaults to `true`): Whether the memory representation is little endian.
+- `(unlabeled)` (of type `string`): String containing the binary representation.
+
+### `string.capitalize`
+
+Return a string with the first character set to upper case (capitalize), or to lower case (uncapitalize).
+
+Type:
+
+```
+(?capitalize : bool, ?space_sensitive : bool, string) -> string
+```
+
+Arguments:
+
+- `capitalize` (of type `bool`, which defaults to `true`): Capitalize if true, uncapitalize otherwise
+- `space_sensitive` (of type `bool`, which defaults to `true`): Capitalize each space separated sub-string.
+- `(unlabeled)` (of type `string`)
+
+### `string.case`
+
+Convert a string to lower or upper case.
+
+Type:
+
+```
+(?lower : bool, string) -> string
+```
+
+Arguments:
+
+- `lower` (of type `bool`, which defaults to `true`): Convert to lower case if true and uppercase otherwise.
+- `(unlabeled)` (of type `string`)
+
+### `string.char`
+
+Create a string with one character.
+
+Type:
+
+```
+(int) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Code of the character.
+
+### `string.char.ascii.random`
+
+Return a random ASCII character
+
+Type:
+
+```
+(?[int]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[int]`, which defaults to `[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]`)
+
+### `string.concat`
+
+Concatenate strings.
+
+Type:
+
+```
+(?separator : string, [string]) -> string
+```
+
+Arguments:
+
+- `separator` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `[string]`)
+
+### `string.contains`
+
+Test whether a string contains a given prefix, substring or suffix.
+
+Type:
+
+```
+(?prefix : string, ?substring : string, ?suffix : string, string) -> bool
+```
+
+Arguments:
+
+- `prefix` (of type `string`, which defaults to `""`): Prefix to look for.
+- `substring` (of type `string`, which defaults to `""`): Substring to look for.
+- `suffix` (of type `string`, which defaults to `""`): Suffix to look for.
+- `(unlabeled)` (of type `string`): The string to look into.
+
+### `string.data_uri.decode`
+
+Decode a string using the data uri format, i.e. `"data:<mime>[;base64],<data>"`.
+
+Type:
+
+```
+(string) -> string.{mime : string}?
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.data_uri.encode`
+
+Encode a string using the data uri format, i.e. `"data:<mime>[;base64],<data>"`.
+
+Type:
+
+```
+(?base64 : bool, mime : string, string) -> string
+```
+
+Arguments:
+
+- `base64` (of type `bool`, which defaults to `true`): Encode data using the base64 format
+- `mime` (of type `string`): Data mime type
+- `(unlabeled)` (of type `string`)
+
+### `string.escape`
+
+Escape special characters in an string. By default, the string is assumed to be `"utf8"` encoded and is escaped following JSON and javascript specification.
+
+Type:
+
+```
+(?special_char : ((encoding : string, string) -> bool)?,
+ ?escape_char : ((encoding : string, string) -> string)?,
+ ?encoding : string?, string) -> string
+```
+
+Arguments:
+
+- `special_char` (of type `((encoding : string, string) -> bool)?`, which defaults to `null`): Return `true` if the given character (passed as a string) should be escaped. Defaults to control characters for `"utf8"` and control characters and any character above `\x7E` (non-printable characters) for `"ascii"`.
+- `escape_char` (of type `((encoding : string, string) -> string)?`, which defaults to `null`): Function used to escape a character. Defaults to `\xxx` octal notation for `"ascii"` and `\uxxxx` hexadecimal notation for `"utf8"`.
+- `encoding` (of type `string?`, which defaults to `null`): One of: `"ascii"` or `"utf8"`. If `null`, `utf8` is tried first and `ascii` is used as a fallback if this fails.
+- `(unlabeled)` (of type `string`)
+
+### `string.escape.all`
+
+Escape each character in the given string using a specific escape sequence.
+
+Type:
+
+```
+(?format : string, string) -> string
+```
+
+Arguments:
+
+- `format` (of type `string`, which defaults to `"utf8"`): Escape format. One of: `"octal"`, `"hex"` or `"utf8"`.
+- `(unlabeled)` (of type `string`)
+
+### `string.escape.html`
+
+Escape HTML entities.
+
+Type:
+
+```
+(?encoding : string?, string) -> string
+```
+
+Arguments:
+
+- `encoding` (of type `string?`, which defaults to `null`): One of: `"ascii"` or `"utf8"`. If `null`, `utf8` is tried first and `ascii` is used as a fallback if this fails.
+- `(unlabeled)` (of type `string`)
+
+### `string.escape.special_char`
+
+Default function to detect characters to escape. See `string.escape` for more details.
+
+Type:
+
+```
+(?encoding : string, string) -> bool
+```
+
+Arguments:
+
+- `encoding` (of type `string`, which defaults to `"utf8"`): One of: `"ascii"` or `"utf8"`.
+- `(unlabeled)` (of type `string`)
+
+### `string.extract`
+
+Extract substrings from a string. Perl compatible regular expressions are recognized. Hence, special characters should be escaped. Returns a list of (index,value). If the list does not have a pair associated to some index, it means that the corresponding pattern was not found. Alter natively, one can use the `r/_/.exec(_)` syntax for regular expressions.
+
+Type:
+
+```
+(pattern : string, string) -> [int * string]
+```
+
+Arguments:
+
+- `pattern` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+Methods:
+
+- `groups` (of type `[string * string]`): Named captures
+
+### `string.float`
+
+String representation of a float.
+
+Type:
+
+```
+(?decimal_places : int?, float) -> string
+```
+
+Arguments:
+
+- `decimal_places` (of type `int?`, which defaults to `null`): Number of decimal places.
+- `(unlabeled)` (of type `float`)
+
+### `string.getter.concat`
+
+Combine a list of string getters `[g1, ...]` and return a single getter `g` such that: `string.getter.flush(separator=s, g) = string.concat(separator=s, list.filter(fun (s) -> s != "", [string.getter.flush(g1), ...]))`
+
+Type:
+
+```
+([{string}]) -> {string}
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[{string}]`)
+
+### `string.getter.flush`
+
+Flush all values from a string getter and return the concatenated result. If the getter is constant, return the constant string. Otherwise, call the getter repeatedly until it returns an empty string and return the concatenated result
+
+Type:
+
+```
+(?separator : string, {string}) -> string
+```
+
+Arguments:
+
+- `separator` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `{string}`)
+
+### `string.getter.single`
+
+Create a string getter which will return once the given string and then the empty string.
+
+Type:
+
+```
+(string) -> () -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.hex_of_int`
+
+Hexadecimal representation of an integer.
+
+Type:
+
+```
+(?pad : int, int) -> string
+```
+
+Arguments:
+
+- `pad` (of type `int`, which defaults to `0`): Minimum length in digits (pad on the left with zeros in order to reach it).
+- `(unlabeled)` (of type `int`)
+
+### `string.id`
+
+Generate an identifier with given operator name.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Operator name.
+
+### `string.id.default`
+
+Generate an identifier if no identifier was provided.
+
+Type:
+
+```
+(default : string, string?) -> string
+```
+
+Arguments:
+
+- `default` (of type `string`): Name from which identifier is generated if not present.
+- `(unlabeled)` (of type `string?`): Proposed identifier.
+
+### `string.index`
+
+Index where a substring occurs in a string. The function returns `-1` if the substring is not present
+
+Type:
+
+```
+(substring : string, string) -> int
+```
+
+Arguments:
+
+- `substring` (of type `string`): Substring to look for.
+- `(unlabeled)` (of type `string`): String in which to look.
+
+### `string.is_int`
+
+Test whether a string is a valid integer.
+
+Type:
+
+```
+(string) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.length`
+
+Get the length of a string.
+
+Type:
+
+```
+(string) -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.make`
+
+Create a string of a given length using the given character.
+
+Type:
+
+```
+(?char_code : int, int) -> string
+```
+
+Arguments:
+
+- `char_code` (of type `int`, which defaults to `32`): Character code.
+- `(unlabeled)` (of type `int`): String length.
+
+### `string.match`
+
+Match a string with an expression. Perl compatible regular expressions are recognized. Hence, special characters should be escaped. Alternatively, one can use the the `r/_/.test(_)` syntax for regular expressions.
+
+Type:
+
+```
+(pattern : string, string) -> bool
+```
+
+Arguments:
+
+- `pattern` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+### `string.nth`
+
+Retrieve a character in a string. Raises `error.not_found` if character does not exist.
+
+Type:
+
+```
+(string, int) -> int
+```
+
+Example:
+
+```liquidsoap
+c = string.nth("abcde", 2)
+print(c) # should print 99 which is the ascii code for "c"
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): String to look into.
+- `(unlabeled)` (of type `int`): Index of the character.
+
+### `string.null_terminated`
+
+Add a null character at the end of a string.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): String.
+
+### `string.quote`
+
+Return a quoted copy of the given string. By default, the string is assumed to be `"utf8"` encoded and is escaped following JSON and javascript specification.
+
+Type:
+
+```
+(?encoding : string?, string) -> string
+```
+
+Arguments:
+
+- `encoding` (of type `string?`, which defaults to `null`): One of: `"ascii"` or `"utf8"`. If `null`, `utf8` is tried first and `ascii` is used as a fallback if this fails.
+- `(unlabeled)` (of type `string`)
+
+### `string.recode`
+
+Convert a string. Effective only if Camomile is enabled.
+
+Type:
+
+```
+(?in_enc : string?, ?out_enc : string, string) -> string
+```
+
+Arguments:
+
+- `in_enc` (of type `string?`, which defaults to `null`): Input encoding. Autodetected if null.
+- `out_enc` (of type `string`, which defaults to `"UTF-8"`): Output encoding.
+- `(unlabeled)` (of type `string`)
+
+### `string.replace`
+
+Replace all substrings matched by a pattern by another string returned by a function. Alternatively, one can use the `r/_/g.replace(_)` syntax for regular expressions.
+
+Type:
+
+```
+(pattern : string, ((string) -> string), string) -> string
+```
+
+Arguments:
+
+- `pattern` (of type `string`): Pattern (regular expression) of substrings which should be replaced.
+- `(unlabeled)` (of type `(string) -> string`): Function getting a matched substring an returning the string to replace it with.
+- `(unlabeled)` (of type `string`): String whose substrings should be replaced.
+
+### `string.residual`
+
+What remains of a string after a given prefix.
+
+Type:
+
+```
+(prefix : string, string) -> string?
+```
+
+Arguments:
+
+- `prefix` (of type `string`): Requested prefix.
+- `(unlabeled)` (of type `string`)
+
+### `string.split`
+
+Split a string at "separator". Perl compatible regular expressions are recognized. Hence, special characters should be escaped. Alternatively, one can use the `r/_/.split(_)` syntax for regular expressions.
+
+Type:
+
+```
+(separator : string, string) -> [string]
+```
+
+Arguments:
+
+- `separator` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+### `string.split.first`
+
+Split a string in two at first "separator".
+
+Type:
+
+```
+(separator : string, string) -> string * string
+```
+
+Arguments:
+
+- `separator` (of type `string`)
+- `(unlabeled)` (of type `string`)
+
+### `string.sub`
+
+Get a substring of a string. Returns "" if no such substring exists.
+
+Type:
+
+```
+(string, start : int, length : int) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+- `start` (of type `int`): Return a sub string starting at this position. First position is 0.
+- `length` (of type `int`): Return a sub string of `length` characters.
+
+### `string.to_float`
+
+Convert a string to a float.
+
+Type:
+
+```
+(?default : float, string) -> float
+```
+
+Arguments:
+
+- `default` (of type `float`, which defaults to `0.`)
+- `(unlabeled)` (of type `string`)
+
+### `string.to_int`
+
+Convert a string to a int.
+
+Type:
+
+```
+(?default : int, string) -> int
+```
+
+Arguments:
+
+- `default` (of type `int`, which defaults to `0`)
+- `(unlabeled)` (of type `string`)
+
+### `string.trim`
+
+Return a string without leading and trailing whitespace.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.unescape`
+
+This function is the inverse of `string.escape`.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string.unquote`
+
+Return an unquoted copy of the given string. Quotes are removed by trying to parse the string following the JSON string escaping convention.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `string_of_metadata`
+
+Standard function for displaying metadata. Shows artist and title, using "Unknown" when a field is empty.
+
+Type:
+
+```
+([string * string]) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `[string * string]`): Metadata packet to be displayed.
+
+### `url.decode`
+
+Decode an encoded url (e.g. "%20" becomes " ").
+
+Type:
+
+```
+(?plus : bool, string) -> string
+```
+
+Arguments:
+
+- `plus` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+### `url.encode`
+
+Encode an url (e.g. " " becomes "%20").
+
+Type:
+
+```
+(?plus : bool, string) -> string
+```
+
+Arguments:
+
+- `plus` (of type `bool`, which defaults to `true`)
+- `(unlabeled)` (of type `string`)
+
+### `url.split`
+
+Split an url of the form `foo?arg=bar&arg2=bar2` into `("foo",[("arg","bar"),("arg2","bar2")])`. The returned strings are decoded (see `url.decode`).
+
+Type:
+
+```
+(string) -> string * [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Url to split.
+
+### `url.split_args`
+
+Split the arguments of an url of the form `arg=bar&arg2=bar2` into `[("arg","bar"),("arg2","bar2")]`. The returned strings are decoded (see `url.decode`).
+
+Type:
+
+```
+(string) -> [string * string]
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Argument string to split.
+
+### `yaml.stringify`
+
+Convert a value to YAML. If the value cannot be represented as YAML (for instance a function), a `error.yaml` exception is raised.
+
+Type:
+
+```
+(?scalar_style : string, ?layout_style : string, 'a) -> string
+```
+
+Arguments:
+
+- `scalar_style` (of type `string`, which defaults to `"any"`): Scalar style. One of: "any", "plain", "single_quoted", "double_quoted", "literal" or "folded".
+- `layout_style` (of type `string`, which defaults to `"any"`): Layout style. One of: "any", "block" or "flow".
+- `(unlabeled)` (of type `'a`)
+
+## System
+
+### `argv`
+
+Get command-line parameters. The parameters are numbered starting from 1, the zeroth parameter being the script name.
+
+Type:
+
+```
+(?default : string, int) -> string
+```
+
+Arguments:
+
+- `default` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `int`)
+
+### `environment`
+
+Return the process environment.
+
+Type:
+
+```
+() -> [string * string]
+```
+
+### `environment.get`
+
+Get the value of an environment variable. Returns `default` if the variable is not set.
+
+Type:
+
+```
+(?default : string, string) -> string
+```
+
+Arguments:
+
+- `default` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `string`)
+
+### `environment.set`
+
+Set the value associated to a variable in the process environment.
+
+Type:
+
+```
+(string, string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Variable to be set.
+- `(unlabeled)` (of type `string`): Value to set.
+
+### `exe_ext`
+
+Executable file extension.
+
+Type:
+
+```
+string
+```
+
+### `exit`
+
+Immediately stop the application. This should only be used in extreme cases or to specify an exit value. The recommended way of stopping Liquidsoap is to use shutdown.
+
+Type:
+
+```
+(int) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `int`): Exit value.
+
+### `getopt`
+
+Parse command line options:
+`getopt("-o")` returns "1" if "-o" was passed without any parameter, "0" otherwise.
+`getopt(default="X","-o")` returns "Y" if "-o Y" was passed, "X" otherwise.
+The result is removed from the list of arguments, affecting subsequent
+calls to `argv()` and `getopt()`.
+
+Type:
+
+```
+(?default : string, string) -> string
+```
+
+Arguments:
+
+- `default` (of type `string`, which defaults to `""`)
+- `(unlabeled)` (of type `string`)
+
+### `on_cleanup`
+
+Register a function to be called for the final cleanup.
+
+Type:
+
+```
+((() -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> unit`)
+
+### `on_shutdown`
+
+Register a function to be called when Liquidsoap shuts down.
+
+Type:
+
+```
+((() -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> unit`)
+
+### `on_start`
+
+Register a function to be called when Liquidsoap starts.
+
+Type:
+
+```
+((() -> unit)) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `() -> unit`)
+
+### `os.type`
+
+Type of OS running liquidsoap.
+
+Type:
+
+```
+string
+```
+
+### `process.pid`
+
+Get the process' pid.
+
+Type:
+
+```
+() -> int
+```
+
+### `process.quote`
+
+Return a quoted copy of the given string, suitable for use as one argument in a command line, escaping all meta-characters. Warning: under Windows, the output is only suitable for use with programs that follow the standard Windows quoting conventions.
+
+Type:
+
+```
+(string) -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): String to escape
+
+### `process.quote.command`
+
+Return a quoted command line, suitable for use as an argument to `process.run`.
+
+The optional arguments `stdin`, `stdout` and `stderr` are file names used to redirect the standard input, the standard output, or the standard error of the command.
+
+If `stdin=f` is given, a redirection `< f` is performed and the standard input of the command reads from file `f`.
+
+If `stdout=f` is given, a redirection `> f` is performed and the standard output of the command is written to file `f`.
+
+If `stderr=f` is given, a redirection `2> f` is performed and the standard error of the command is written to file `f`.
+
+If both `stdout=f` and `stderr=f` are given, with the exact same file name `f`, a `2>&1` redirection is performed so that the standard output and the standard error of the command are interleaved and redirected to the same file `f`.
+
+Type:
+
+```
+(?stdin : string?, ?stdout : string?, ?stderr : string?, ?args : [string],
+ string) -> string
+```
+
+Arguments:
+
+- `stdin` (of type `string?`, which defaults to `null`): command standard input
+- `stdout` (of type `string?`, which defaults to `null`): command standard output
+- `stderr` (of type `string?`, which defaults to `null`): command standard error
+- `args` (of type `[string]`, which defaults to `[]`): command arguments
+- `(unlabeled)` (of type `string`): Command to execute
+
+### `process.read`
+
+Perform a shell call and return its output.
+
+Type:
+
+```
+(?timeout : float, ?env : [string * string], ?inherit_env : bool,
+ ?log_errors : bool, string) -> string
+```
+
+Arguments:
+
+- `timeout` (of type `float`, which defaults to `-1.`): Cancel process after `timeout` has elapsed. Ignored if negative.
+- `env` (of type `[string * string]`, which defaults to `[]`): Process environment
+- `inherit_env` (of type `bool`, which defaults to `true`): Inherit calling process's environment when `env` parameter is empty.
+- `log_errors` (of type `bool`, which defaults to `true`): Log details if the command does not return 0.
+- `(unlabeled)` (of type `string`): Command to run
+
+### `process.read.lines`
+
+Perform a shell call and return the list of its output lines.
+
+Type:
+
+```
+(?timeout : float, ?env : [string * string], ?inherit_env : bool,
+ ?log_errors : bool, string) -> [string]
+```
+
+Arguments:
+
+- `timeout` (of type `float`, which defaults to `-1.`): Cancel process after `timeout` has elapsed. Ignored if negative.
+- `env` (of type `[string * string]`, which defaults to `[]`): Process environment
+- `inherit_env` (of type `bool`, which defaults to `true`): Inherit calling process's environment when `env` parameter is empty.
+- `log_errors` (of type `bool`, which defaults to `true`): Log details if the command does not return 0.
+- `(unlabeled)` (of type `string`): Command to run
+
+### `process.run`
+
+Run a process in a shell environment. Returns the standard output, as well as standard error and status as methods. The status can be "exit" (the status code is set), "killed" or "stopped" (the status code is the signal), or "exception" (the description is set) or "timeout" (the description is the run time).
+
+Type:
+
+```
+(?env : [string * string], ?inherit_env : bool, ?rwdirs : [string],
+ ?rodirs : [string], ?network : bool?, ?timeout : float?, string) -> unit
+```
+
+Arguments:
+
+- `env` (of type `[string * string]`, which defaults to `[]`): Process environment
+- `inherit_env` (of type `bool`, which defaults to `true`): Inherit calling process's environment when `env` parameter is empty.
+- `rwdirs` (of type `[string]`, which defaults to `["default"]`): Read/write directories for sandboxing. `"default"` expands to sandbox default.
+- `rodirs` (of type `[string]`, which defaults to `["default"]`): Read-only directories for sandboxing `"default"` expands to sandbox default.
+- `network` (of type `bool?`, which defaults to `null`): Enable or disable network inside sandboxed environment (sandbox default if not specified).
+- `timeout` (of type `float?`, which defaults to `null`): Cancel process after `timeout` has elapsed. Ignored if negative.
+- `(unlabeled)` (of type `string`): Command to run
+
+Methods:
+
+- `status` (of type `string.{code : int, description : string}`): Status when process ended, can be one of `"exit"` (the program exited, the `status` code is then relevant), `"killed"` (the program was killed by signal given in `status` code), `"stopped"` (the program was stopped by signal given in `status` code) or `"exception"` (the program raised and exception detailed in the `description`).
+- `stderr` (of type `string`): Messages written by process on standard error stream.
+- `stdout` (of type `string`): Messages written by process on standard output stream.
+
+### `process.stderr`
+
+The process' stderr
+
+Type:
+
+```
+socket
+.{
+  close : () -> unit,
+  non_blocking : (bool) -> unit,
+  read : ((?timeout : float?) -> string)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  },
+  type : string,
+  write : ((?timeout : float?, string) -> unit)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  }
+}
+```
+
+### `process.stdin`
+
+The process' stdin
+
+Type:
+
+```
+socket
+.{
+  close : () -> unit,
+  non_blocking : (bool) -> unit,
+  read : ((?timeout : float?) -> string)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  },
+  type : string,
+  write : ((?timeout : float?, string) -> unit)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  }
+}
+```
+
+### `process.stdout`
+
+The process' stdout
+
+Type:
+
+```
+socket
+.{
+  close : () -> unit,
+  non_blocking : (bool) -> unit,
+  read : ((?timeout : float?) -> string)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  },
+  type : string,
+  write : ((?timeout : float?, string) -> unit)
+  .{wait : (?timeout : float?, (() -> unit)) -> unit
+  }
+}
+```
+
+### `process.test`
+
+Return true if process exited with 0 code.
+
+Type:
+
+```
+(?timeout : float, ?env : [string * string], ?inherit_env : bool, string) ->
+bool
+```
+
+Arguments:
+
+- `timeout` (of type `float`, which defaults to `-1.`): Cancel process after `timeout` has elapsed. Ignored if negative.
+- `env` (of type `[string * string]`, which defaults to `[]`): Process environment
+- `inherit_env` (of type `bool`, which defaults to `true`): Inherit calling process's environment when `env` parameter is empty.
+- `(unlabeled)` (of type `string`): Command to test
+
+### `process.time`
+
+Get the execution time of the current liquidsoap process.
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `system` (of type `float`)
+- `user` (of type `float`)
+
+### `read`
+
+Read some value from standard input (console).
+
+Type:
+
+```
+(?hide : bool) -> string
+```
+
+Arguments:
+
+- `hide` (of type `bool`, which defaults to `false`): Hide typed characters (for passwords).
+
+### `reopen.stderr`
+
+Reopen standard error on the given file
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `reopen.stdin`
+
+Reopen standard input on the given file
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `reopen.stdout`
+
+Reopen standard output on the given file
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `restart`
+
+Restart the application.
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.gc.get`
+
+Return the current values of the GC parameters
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `allocation_policy` (of type `int`)
+- `custom_major_ratio` (of type `int`)
+- `custom_minor_max_size` (of type `int`)
+- `custom_minor_ratio` (of type `int`)
+- `major_heap_increment` (of type `int`)
+- `max_overhead` (of type `int`)
+- `minor_heap_size` (of type `int`)
+- `space_overhead` (of type `int`)
+- `stack_limit` (of type `int`)
+- `verbose` (of type `int`)
+- `window_size` (of type `int`)
+
+### `runtime.gc.print_stat`
+
+Print the current values of the memory management counters in human-readable form.
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.gc.quick_stat`
+
+Same as stat except that `live_words`, `live_blocks`, `free_words`, `free_blocks`, `largest_free`, and `fragments` are set to `0`. This function is much faster than `gc.stat` because it does not need to go through the heap.
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `compactions` (of type `int`)
+- `forced_major_collections` (of type `int`)
+- `fragments` (of type `int`)
+- `free_blocks` (of type `int`)
+- `free_words` (of type `int`)
+- `heap_chunks` (of type `int`)
+- `heap_words` (of type `int`)
+- `largest_free` (of type `int`)
+- `live_blocks` (of type `int`)
+- `live_words` (of type `int`)
+- `major_collections` (of type `int`)
+- `major_words` (of type `float`)
+- `minor_collections` (of type `int`)
+- `minor_words` (of type `float`)
+- `promoted_words` (of type `float`)
+- `stack_size` (of type `int`)
+- `top_heap_words` (of type `int`)
+
+### `runtime.gc.set`
+
+Set the GC parameters.
+
+Type:
+
+```
+(
+ {
+   allocation_policy : int,
+   custom_major_ratio : int,
+   custom_minor_max_size : int,
+   custom_minor_ratio : int,
+   major_heap_increment : int,
+   max_overhead : int,
+   minor_heap_size : int,
+   space_overhead : int,
+   stack_limit : int,
+   verbose : int,
+   window_size : int
+ }) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `
+{
+  allocation_policy : int,
+  custom_major_ratio : int,
+  custom_minor_max_size : int,
+  custom_minor_ratio : int,
+  major_heap_increment : int,
+  max_overhead : int,
+  minor_heap_size : int,
+  space_overhead : int,
+  stack_limit : int,
+  verbose : int,
+  window_size : int
+}`)
+
+### `runtime.gc.stat`
+
+Return the current values of the memory management counters. This function examines every heap block to get the statistics.
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `compactions` (of type `int`)
+- `forced_major_collections` (of type `int`)
+- `fragments` (of type `int`)
+- `free_blocks` (of type `int`)
+- `free_words` (of type `int`)
+- `heap_chunks` (of type `int`)
+- `heap_words` (of type `int`)
+- `largest_free` (of type `int`)
+- `live_blocks` (of type `int`)
+- `live_words` (of type `int`)
+- `major_collections` (of type `int`)
+- `major_words` (of type `float`)
+- `minor_collections` (of type `int`)
+- `minor_words` (of type `float`)
+- `promoted_words` (of type `float`)
+- `stack_size` (of type `int`)
+- `top_heap_words` (of type `int`)
+
+### `runtime.jemalloc.epoch`
+
+Refresh the epoch counter for statistics
+
+Type:
+
+```
+() -> unit
+```
+
+### `runtime.jemalloc.mallctl.bool`
+
+Get an option of type bool using mallctl. Returned value has the same type as a reference.
+
+Type:
+
+```
+(string) -> () -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Option name
+
+Methods:
+
+- `set` (of type `(bool) -> unit`): Set option value
+
+### `runtime.jemalloc.mallctl.flag`
+
+Set an option flag
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Flag name
+
+### `runtime.jemalloc.mallctl.int`
+
+Get an option of type int using mallctl. Returned value has the same type as a reference.
+
+Type:
+
+```
+(string) -> () -> int
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Option name
+
+Methods:
+
+- `set` (of type `(int) -> unit`): Set option value
+
+### `runtime.jemalloc.mallctl.string`
+
+Get an option of type string using mallctl. Returned value has the same type as a reference.
+
+Type:
+
+```
+(string) -> () -> string
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`): Option name
+
+Methods:
+
+- `set` (of type `(string) -> unit`): Set option value
+
+### `runtime.jemalloc.memory_stats`
+
+Return memory allocation stats from `jemalloc`.
+
+Type:
+
+```
+() -> unit
+```
+
+Methods:
+
+- `active` (of type `int`)
+- `allocated` (of type `int`)
+- `mapped` (of type `int`)
+- `resident` (of type `int`)
+
+### `runtime.jemalloc.version`
+
+Jemalloc version information
+
+Type:
+
+```
+() -> string
+```
+
+Methods:
+
+- `git_version` (of type `string`): Git version
+- `major` (of type `int`): Major version
+- `minor` (of type `int`): Minor version
+
+### `runtime.locale.set`
+
+Set the system's locale. This sets `LANG` and `LC_ALL` environment variables to the given value and then calls `setlocale`. This is set to `"C"` on startup, which defaults to the system's default locale. Keep in mind that changing this can potentially impact some functions such a `float_of_string`.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `runtime.sys.word_size`
+
+Size of one word on the machine currently executing the program, in bits. Either `32` or `64`.
+
+Type:
+
+```
+int
+```
+
+### `shutdown`
+
+Shutdown the application.
+
+Type:
+
+```
+(?code : int) -> unit
+```
+
+Arguments:
+
+- `code` (of type `int`, which defaults to `0`): Exit code. Default: `0`
+
+### `source.is_up`
+
+Check whether a source is up.
+
+Type:
+
+```
+(source('a)) -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `source('a)`)
+
+## Time
+
+### `time`
+
+Return the current time since 00:00:00 GMT, Jan. 1, 1970, in seconds.
+
+Type:
+
+```
+() -> float
+```
+
+### `time.local`
+
+Convert a time in seconds into a date in the local time zone (current time is used if no argument is provided).
+
+Type:
+
+```
+(?float?) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float?`, which defaults to `null`)
+
+Methods:
+
+- `day` (of type `int`): Day of month.
+- `dst` (of type `bool`): Daylight time savings in effect.
+- `hour` (of type `int`): Hours.
+- `min` (of type `int`): Minutes.
+- `month` (of type `int`): Month of year.
+- `sec` (of type `int`): Seconds.
+- `week_day` (of type `int`): Day of week (Sunday is 0 or 7, Saturday is 6).
+- `year` (of type `int`): Year.
+- `year_day` (of type `int`): Day of year, between `1` and `366`.
+
+### `time.make`
+
+Convert a date and time in the local timezone into a time, in seconds, since 00:00:00 GMT, Jan. 1, 1970.
+
+Type:
+
+```
+(
+ {
+   day : int,
+   dst : bool?,
+   hour : int,
+   min : int,
+   month : int,
+   sec : int,
+   year : int
+ }) -> float
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `
+{
+  day : int,
+  dst : bool?,
+  hour : int,
+  min : int,
+  month : int,
+  sec : int,
+  year : int
+}`)
+
+### `time.predicate`
+
+Parse a string as a time predicate
+
+Type:
+
+```
+(string) -> () -> bool
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+### `time.string`
+
+Obtain a string representation of the current time. It takes a string as argument where special strings are replaced roughly following [strftime](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes): %H is replaced by the current hour, %M minute, %S second, %A week day (%a week day abbreviated), %d month day, %B month name (%b month name abbreviated), %z timezone.
+
+Type:
+
+```
+(?time : float?, ?string?) -> string
+```
+
+Example:
+
+```liquidsoap
+s = time.string("Current time is %H:%M.")
+print(s)
+```
+
+Example:
+
+```liquidsoap
+# Backup a source naming the file based on time
+output.file({time.string("/path/to/file%H%M%S.wav")}, ...)
+```
+
+Arguments:
+
+- `time` (of type `float?`, which defaults to `null`): If specified convert the given time (in seconds since 00:00:00 GMT, Jan. 1, 1970) instead of the current time.
+- `(unlabeled)` (of type `string?`, which defaults to `null`): Description of the string to produce, e.g. `"Current time is %H:%M`"`.
+
+### `time.up`
+
+Current time, in seconds, since the script has started.
+
+Type:
+
+```
+() -> float
+```
+
+### `time.utc`
+
+Convert a time in seconds into a date in the UTC time zone (current time is used if no argument is provided).
+
+Type:
+
+```
+(?float?) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `float?`, which defaults to `null`)
+
+Methods:
+
+- `day` (of type `int`): Day of month.
+- `dst` (of type `bool`): Daylight time savings in effect.
+- `hour` (of type `int`): Hours.
+- `min` (of type `int`): Minutes.
+- `month` (of type `int`): Month of year.
+- `sec` (of type `int`): Seconds.
+- `week_day` (of type `int`): Day of week (Sunday is 0 or 7, Saturday is 6).
+- `year` (of type `int`): Year.
+- `year_day` (of type `int`): Day of year, between `1` and `366`.
+
+### `time.zone`
+
+Returns a description of the time zone set for the running process.
+
+Type:
+
+```
+() -> string
+```
+
+Methods:
+
+- `daylight` (of type `string`): Daylight Savings Time
+- `utc_diff` (of type `int`): Difference in seconds between the current timezone and UTC.
+
+### `time.zone.set`
+
+Set the current time zone. This is equivalent to setting the `TZ` environment variable.
+
+Type:
+
+```
+(string) -> unit
+```
+
+Arguments:
+
+- `(unlabeled)` (of type `string`)
+
+## Track / Audio processing
+
+### `track.audio.add`
+
+Mix audio tracks with optional normalization.
+
+Type:
+
+```
+(?id : string?, [pcm('a).{weight? : {float}}], ?normalize : {bool},
+ ?power : {bool}) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `[pcm('a).{weight? : {float}}]`)
+- `normalize` (of type `{bool}`, which defaults to `true`): Divide by the sum of weights of ready sources (or by the number of ready sources if weights are not specified).
+- `power` (of type `{bool}`, which defaults to `false`): Perform constant-power normalization.
+
+### `track.audio.amplify`
+
+Multiply the amplitude of the signal.
+
+Type:
+
+```
+(?id : string?, {float}, ?override : string?, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `{float}`): Multiplicative factor.
+- `override` (of type `string?`, which defaults to `"liq_amplify"`): Specify the name of a metadata field that, when present and well-formed, overrides the amplification factor for the current track. Well-formed values are floats in decimal notation (e.g. `0.7`) which are taken as normal/linear multiplicative factors; values can be passed in decibels with the suffix `dB` (e.g. `-8.2 dB`, but the spaces do not matter).
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.audio.clip`
+
+Clip samples, i.e. ensure that all values are between -1 and 1: values lower than -1 become -1 and values higher than 1 become 1. `nan` values become `0.`
+
+Type:
+
+```
+(?id : string?, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.audio.comb`
+
+Comb filter.
+
+Type:
+
+```
+(?id : string?, ?delay : float, ?feedback : {float}, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `delay` (of type `float`, which defaults to `0.001`): Delay in seconds.
+- `feedback` (of type `{float}`, which defaults to `-6.`): Feedback coefficient in dB.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.audio.compand`
+
+Compand the signal.
+
+Type:
+
+```
+(?id : string?, ?mu : float, source(pcm('a))) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `mu` (of type `float`, which defaults to `1.`)
+- `(unlabeled)` (of type `source(pcm('a))`)
+
+### `track.audio.compress`
+
+Compress the signal.
+
+Type:
+
+```
+(?id : string?, ?attack : {float}, ?release : {float}, ?lookahead : {float},
+ ?threshold : {float}, ?track_sensitive : bool, ?knee : {float},
+ ?pre_gain : {float}, ?gain : {float}, ?ratio : {float}, ?window : {float},
+ ?wet : {float}, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `attack` (of type `{float}`, which defaults to `50.`): Attack time (ms).
+- `release` (of type `{float}`, which defaults to `400.`): Release time (ms).
+- `lookahead` (of type `{float}`, which defaults to `0.`): Lookahead (ms).
+- `threshold` (of type `{float}`, which defaults to `-10.`): Threshold level (dB).
+- `track_sensitive` (of type `bool`, which defaults to `false`): Reset on every track.
+- `knee` (of type `{float}`, which defaults to `1.`): Knee width (dB).
+- `pre_gain` (of type `{float}`, which defaults to `0.`): Pre-amplification (dB).
+- `gain` (of type `{float}`, which defaults to `0.`): Post-amplification (dB).
+- `ratio` (of type `{float}`, which defaults to `2.`): Gain reduction ratio (reduction is ratio:1). Must be at least 1.
+- `window` (of type `{float}`, which defaults to `0.`): RMS window length (second). `0.` means peak mode.
+- `wet` (of type `{float}`, which defaults to `1.`): How much of input sound to output (between 0 and 1, 0 means only original sound, 1 means only compressed sound).
+- `(unlabeled)` (of type `pcm('a)`)
+
+Methods:
+
+- `gain` (of type `() -> float`): Gain (dB).
+- `rms` (of type `() -> float`): RMS or peak power (linear).
+
+### `track.audio.compress.exponential`
+
+Exponential compressor.
+
+Type:
+
+```
+(?id : string?, ?mu : float, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `mu` (of type `float`, which defaults to `2.`): Exponential compression factor, typically greater than 1.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.audio.map`
+
+Map a function to all audio samples. This is SLOW!
+
+Type:
+
+```
+(?id : string?, ((float) -> float), pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `(float) -> float`)
+- `(unlabeled)` (of type `pcm('a)`)
+
+This function is experimental.
+
+### `track.audio.stereo.ms.decode`
+
+Decode mid+side stereo (M/S) to left+right stereo.
+
+Type:
+
+```
+(?id : string?, ?width : float, pcm(stereo)) -> pcm(stereo)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `width` (of type `float`, which defaults to `1.`): Width of the stereo field.
+- `(unlabeled)` (of type `pcm(stereo)`)
+
+### `track.audio.stereo.ms.encode`
+
+Encode left+right stereo to mid+side stereo (M/S).
+
+Type:
+
+```
+(?id : string?, pcm(stereo)) -> pcm(stereo)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm(stereo)`)
+
+### `track.audio.stereo.pan`
+
+Pan a stereo sound.
+
+Type:
+
+```
+(?id : string?, ?pan : {float}, ?field : {float}, pcm(stereo)) -> pcm(stereo)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `pan` (of type `{float}`, which defaults to `0.`): Pan ranges between -1 and 1.
+- `field` (of type `{float}`, which defaults to `90.`): Field width in degrees (between 0 and 90).
+- `(unlabeled)` (of type `pcm(stereo)`)
+
+### `track.audio.stereo.width`
+
+Spacializer which allows controlling the width of the signal.
+
+Type:
+
+```
+(?id : string?, ?{float}, pcm(stereo)) -> pcm(stereo)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `{float}`, which defaults to `0.`): Width of the signal (-1: mono, 0.: original, 1.: wide stereo).
+- `(unlabeled)` (of type `pcm(stereo)`)
+
+### `track.audio.stereotool`
+
+Process the given audio track with StereoTool.
+
+Type:
+
+```
+(?id : string?, library_file : string, ?license_key : string?,
+ ?preset : string?, ?load_type : string, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `library_file` (of type `string`): Path to the shared library file.
+- `license_key` (of type `string?`, which defaults to `null`)
+- `preset` (of type `string?`, which defaults to `null`): Path to a preset file to load when initializing the operator.
+- `load_type` (of type `string`, which defaults to `"totalinit"`): Load type for preset. One of: "totalinit", "all_settings", "audiofm", "audio", "processing", "repair", "repair_no_pnr" or "sublevel_pnr".
+- `(unlabeled)` (of type `pcm('a)`)
+
+Methods:
+
+- `api_version` (of type `() -> int`): API version.
+- `latency` (of type `() -> float`): Get the operator's latency.
+- `software_version` (of type `() -> int`): Software version.
+- `unlincensed_used_features` (of type `() -> string?`): Check if the license is valid for the current settings.
+- `valid_license` (of type `() -> bool`): Check if the license is valid for the current settings.
+
+### `track.audio.stretch`
+
+Slow down or accelerate an audio stream by stretching (sounds lower) or squeezing it (sounds higher).
+
+Type:
+
+```
+(?id : string?, ratio : {float}, pcm('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `ratio` (of type `{float}`): A value higher than 1 means slowing down.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.decode.audio.pcm_f32`
+
+Decode an audio track using PCM signed 16 bit integers.
+
+Type:
+
+```
+(?id : string?, pcm_f32('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm_f32('a)`)
+
+### `track.decode.audio.pcm_s16`
+
+Decode an audio track using PCM signed 16 bit integers.
+
+Type:
+
+```
+(?id : string?, pcm_s16('a)) -> pcm('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm_s16('a)`)
+
+### `track.encode.audio.pcm_f32`
+
+Encode an audio track using PCM signed 16 bit integers.
+
+Type:
+
+```
+(?id : string?, pcm('a)) -> pcm_f32('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.encode.audio.pcm_s16`
+
+Encode an audio track using PCM signed 16 bit integers.
+
+Type:
+
+```
+(?id : string?, pcm('a)) -> pcm_s16('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm('a)`)
+
+## Track / Conversion
+
+### `track.audio.mean`
+
+Produce mono audio by taking the mean of all audio channels.
+
+Type:
+
+```
+(?id : string?, ?normalize : bool, pcm('a)) -> pcm(mono)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `normalize` (of type `bool`, which defaults to `true`): Divide the output volume by the number of channels.
+- `(unlabeled)` (of type `pcm('a)`): Track whose mean should be computed.
+
+### `track.audio.stereo`
+
+Convert any pcm audio track into a stereo track.
+
+Type:
+
+```
+(?id : string?, pcm('a)) -> pcm(stereo)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.audio.swap`
+
+Swap two channels of a stereo track.
+
+Type:
+
+```
+(?id : string?, pcm(stereo)) -> pcm(stereo)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `pcm(stereo)`)
+
+### `track.ffmpeg.decode.audio`
+
+Decode a track content
+
+Type:
+
+```
+(?id : string?, ffmpeg.copy('a)) -> pcm('b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `ffmpeg.copy('a)`)
+
+### `track.ffmpeg.decode.video`
+
+Decode a track content
+
+Type:
+
+```
+(?id : string?, ffmpeg.copy('a)) -> canvas('b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `ffmpeg.copy('a)`)
+
+### `track.ffmpeg.encode.audio`
+
+Convert a track's content
+
+Type:
+
+```
+(?id : string?, format(audio=pcm('a), 'b), pcm('a)) -> ffmpeg.copy('c)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `format(audio=pcm('a), 'b)`): Encoding format.
+- `(unlabeled)` (of type `pcm('a)`)
+
+### `track.ffmpeg.encode.video`
+
+Convert a track's content
+
+Type:
+
+```
+(?id : string?, format(video=canvas('a), 'b), canvas('a)) -> ffmpeg.copy('c)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `format(video=canvas('a), 'b)`): Encoding format.
+- `(unlabeled)` (of type `canvas('a)`)
+
+### `track.ffmpeg.raw.decode.audio`
+
+Decode a track content
+
+Type:
+
+```
+(?id : string?, ffmpeg.audio.raw('a)) -> pcm('b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `ffmpeg.audio.raw('a)`)
+
+### `track.ffmpeg.raw.decode.video`
+
+Decode a track content
+
+Type:
+
+```
+(?id : string?, ffmpeg.video.raw('a)) -> canvas('b)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `ffmpeg.video.raw('a)`)
+
+### `track.ffmpeg.raw.encode.audio`
+
+Convert a track's content
+
+Type:
+
+```
+(?id : string?, format(audio=ffmpeg.audio.raw('a), 'b), pcm('c)) ->
+ffmpeg.audio.raw('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `format(audio=ffmpeg.audio.raw('a), 'b)`): Encoding format.
+- `(unlabeled)` (of type `pcm('c)`)
+
+### `track.ffmpeg.raw.encode.video`
+
+Convert a track's content
+
+Type:
+
+```
+(?id : string?, format(video=ffmpeg.video.raw('a), 'b), canvas('c)) ->
+ffmpeg.video.raw('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `format(video=ffmpeg.video.raw('a), 'b)`): Encoding format.
+- `(unlabeled)` (of type `canvas('c)`)
+
+## Track / FFmpeg filter
+
+### `ffmpeg.filter.audio.output`
+
+Return an audio track from a filter's output
+
+Type:
+
+```
+(?id : string?, ?pass_metadata : bool, ffmpeg.filter.graph,
+ ffmpeg.filter.audio) -> ffmpeg.audio.raw('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `pass_metadata` (of type `bool`, which defaults to `true`): Pass ffmpeg stream metadata to liquidsoap
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.audio`)
+
+## Track / Track processing
+
+### `track.audio.defer`
+
+Defer an audio track by a given amount of time. Track will be available when the given `delay` has been fully buffered. Use this operator instead of `buffer` when buffering large amount of data as initial delay.
+
+Type:
+
+```
+(?id : string?, delay : float, ?overhead : float?, pcm_s16('a)) ->
+pcm_s16('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `delay` (of type `float`): Duration of the delay, in seconds.
+- `overhead` (of type `float?`, which defaults to `null`): Duration of the delay overhead, in seconds. Defaults to frame size.
+- `(unlabeled)` (of type `pcm_s16('a)`): Track to delay.
+
+### `track.metadata`
+
+Return the metadata associated with the given track
+
+Type:
+
+```
+(?id : string?, 'a) -> metadata where 'a is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `anything that is a track`)
+
+### `track.metadata.map`
+
+Rewrite metadata on the fly using a function.
+
+Type:
+
+```
+(?id : string?, (([string * string]) -> [string * string]), ?update : bool,
+ ?strip : bool, ?insert_missing : bool, metadata) -> metadata
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `([string * string]) -> [string * string]`): A function that returns new metadata.
+- `update` (of type `bool`, which defaults to `true`): Update metadata. If false, existing metadata are cleared and only returned values are set as new metadata.
+- `strip` (of type `bool`, which defaults to `false`): Completely remove empty metadata. Operates on both empty values and empty metadata chunk.
+- `insert_missing` (of type `bool`, which defaults to `true`): Treat track beginnings without metadata as having empty ones. The operational order is: create empty if needed, map and strip if enabled.
+- `(unlabeled)` (of type `metadata`)
+
+### `track.metadata.merge`
+
+Merge metadata from all given tracks. If two sources have metadata with the same label at the same time, the one from the last source in the list takes precedence.
+
+Type:
+
+```
+(?id : string?, [metadata]) -> metadata
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `[metadata]`)
+
+### `track.track_marks`
+
+Return the track marks associated with the given track
+
+Type:
+
+```
+(?id : string?, 'a) -> track_marks where 'a is a track
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `anything that is a track`)
+
+## Track / Video processing
+
+### `ffmpeg.filter.video.output`
+
+Return a video track from a filter's output
+
+Type:
+
+```
+(?id : string?, ?pass_metadata : bool, ffmpeg.filter.graph,
+ ffmpeg.filter.video) -> ffmpeg.video.raw('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `pass_metadata` (of type `bool`, which defaults to `true`): Pass ffmpeg stream metadata to liquidsoap
+- `(unlabeled)` (of type `ffmpeg.filter.graph`)
+- `(unlabeled)` (of type `ffmpeg.filter.video`)
+
+### `track.video.add`
+
+Merge video tracks.
+
+Type:
+
+```
+(?id : string?, [canvas('a)]) -> canvas('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `(unlabeled)` (of type `[canvas('a)]`)
+
+### `track.video.add_image`
+
+Add a static image on the given video track.
+
+Type:
+
+```
+(?id : string?, ?fallible : bool, ?width : {int}?, ?height : {int}?,
+ ?x : {int}, ?y : {int}, file : {string}, canvas('a)) -> canvas('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"track.video.add_image"`): Force the value of the source ID.
+- `fallible` (of type `bool`, which defaults to `false`): Whether we are allowed to fail (in case the file is non-existent or invalid).
+- `width` (of type `{int}?`, which defaults to `null`): Scale to width
+- `height` (of type `{int}?`, which defaults to `null`): Scale to height
+- `x` (of type `{int}`, which defaults to `0`): x position.
+- `y` (of type `{int}`, which defaults to `0`): y position.
+- `file` (of type `{string}`): Path to the image file.
+- `(unlabeled)` (of type `canvas('a)`)
+
+### `track.video.tile`
+
+Tile video tracks.
+
+Type:
+
+```
+(?id : string?, ?proportional : bool, [canvas('a)]) -> canvas('a)
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
+- `proportional` (of type `bool`, which defaults to `true`): Scale preserving the proportions.
+- `(unlabeled)` (of type `[canvas('a)]`)
+
+## Uncategorized
+
+### `defer`
+
+Defer the source's audio track by a given amount of time. Source will be available when the given `delay` has been fully buffered. Use this operator instead of `buffer` when buffering large amount of data as initial delay.
+
+Type:
+
+```
+(?id : string?, delay : float, ?overhead : float?, source(audio=pcm_s16('a))) ->
+source(audio=pcm_s16('a))
+```
+
+Arguments:
+
+- `id` (of type `string?`, which defaults to `"defer"`): Force the source's ID
+- `delay` (of type `float`): Duration of the delay, in seconds.
+- `overhead` (of type `float?`, which defaults to `null`): Duration of the delay overhead, in seconds. Defaults to frame size.
+- `(unlabeled)` (of type `source(audio=pcm_s16('a))`)
+
+Methods:
+
+- `buffered` (of type `() -> [string * float]`): Length of buffered data.
+- `duration` (of type `() -> float`): Estimation of the duration of the current track.
+- `elapsed` (of type `() -> float`): Elapsed time in the current track.
+- `fallible` (of type `bool`): Indicate if a source may fail, i.e. may not be ready to stream.
+- `id` (of type `() -> string`): Identifier of the source.
+- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
+- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
+- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
+- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
+- `log` (of type `{level : (() -> int?).{set : (int) -> unit}}`): Get or set the source's log level, from `1` to `5`.
+- `on_metadata` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on metadata packets.
+- `on_shutdown` (of type `((() -> unit)) -> unit`): Register a function to be called when source shuts down.
+- `on_track` (of type `((([string * string]) -> unit)) -> unit`): Call a given handler on new tracks.
+- `on_wake_up` (of type `((() -> unit)) -> unit`): Register a function to be called after the source is asked to get ready. This is when, for instance, the source's final ID is set.
+- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
+- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
+- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
+- `skip` (of type `() -> unit`): Skip to the next track.
+- `time` (of type `() -> float`): Get a source's time, based on its assigned clock.
+
diff --git a/website/content/doc-2.2.5/release-assets.md b/website/content/doc-2.2.5/release-assets.md
new file mode 100644
index 00000000..0b9dffbe
--- /dev/null
+++ b/website/content/doc-2.2.5/release-assets.md
@@ -0,0 +1,9 @@
+This release provides liquidsoap assets before they are published as a new versioned release.
+
+You can use it to install the latest stable code before it is published and test/prepare your production environment for it.
+
+Rolling releases can also be useful for us to quickly detect and report bugs before the final published release!
+
+Assets listed in this release will never be modified or deleted. Feel free to use them for packaging or distribution purposes.
+
+For more details about our release process, please checkout https://github.com/savonet/liquidsoap#release-details
diff --git a/website/content/doc-2.2.5/replay_gain.md b/website/content/doc-2.2.5/replay_gain.md
new file mode 100644
index 00000000..e279d39d
--- /dev/null
+++ b/website/content/doc-2.2.5/replay_gain.md
@@ -0,0 +1,85 @@
+# Normalization and ReplayGain
+
+## Normalization
+
+If you want to have a constant average volume on an audio stream, you can use the `normalize` operator. However, this operator cannot guess the volume of the whole stream, and can be "surprised" by rapid changes of the volume. This can lead to a volume that is too low, too high, oscillates. In some cases, dynamic normalization also creates saturation.
+
+To tweak the normalization, several parameters are available. These are listed and explained in the [reference](reference.html) and also visible by executing `liquidsoap -h normalize`. However, if the stream you want to normalize consist of audio files, using the replay gain technology might be a better choice.
+
+## Replay gain
+
+[ReplayGain](https://en.wikipedia.org/wiki/ReplayGain) is a proposed standard that is (more or less) respected by many open-source tools. It provides a way to obtain an overall uniform perceived loudness over a track or a set of tracks. The computation of the loudness is based on how the human ear actually perceives each range of frequency. Having computed the average perceived loudness on a track or an album, it is easy to renormalize the tracks when playing, ensuring a comfortable, consistent listening experience.
+
+Because it is track-based, replay gain does not suffer from the typical problems of stream-based, dynamic approaches. Namely, these distort the initial audio, since they constantly adapt the amplification factor. Sometimes it oscillates too quickly in a weird audible way. Sometimes it does not adapt quickly enough, leading to under or over-amplified sections.
+
+### Computing or retrieving replay gain information
+
+The first step in order to use replay gain is to fetch or compute the appropriate normalization level for a given file.
+
+Replay gain information can be found in various metadata fields depending on the audio format and the replay gain computation tool.
+Liquidsoap provides a script for extracting the replay gain value which requires the `ffmpeg` binary.
+
+There are two ways to use our replain gain script, one that works for _all_ files and one that can be enabled on a
+per-file basis, if you need finer grained control over replay gain.
+
+#### Using the replay gain metadata resolver
+
+The metadata solution is uniform: without changing anything, _all_ your
+files will have a new `replaygain_track_gain` metadata when the computation succeeded.
+
+However, keep in mind that this computation can be costly and will be done each time a remote file is
+downloaded to be prepared for streaming unless it already has the information pre-computed. For this
+reason, it is recommended to pre-compute replay gain information as much as possible, specially
+if you intent to stream large audio files.
+
+The replay gain metadata resolver is not enabled by default. You can do it
+by adding the following code to your script:
+
+```liquidsoap
+enable_replaygain_metadata()
+```
+
+#### Using the `replaygain:` protocol
+
+The `replaygain:` protocol triggers replay gain retrieval or computation on
+a per-file bases. To use it, you prefix your request URIs with it.
+
+For instance, replacing `/path/to/file.mp3` with `replaygain:/path/to/file.mp3`.
+
+When resolving such a request, a call to our script will be issued,
+resulting in your file having the extra `replaygain_track_gain` metadata.
+
+Prepending `replaygain:` is easy if you are using a script
+behind some `request.dynamic.list` operator. If you are using the
+`playlist` operator, you can use its `prefix` parameter.
+
+Protocols can be chained, for instance:
+
+```
+annotate:foo="bar":replaygain:/path/to/file.mp3
+```
+
+### Applying replay gain information
+
+After fetching or computing the replay gain information, the next step is to use it to correct the source's volume.
+
+The `amplify()` operator is used for that. This operator can be made to behave according to a given metadata, here the `replaygain` metadata. This is
+done using the `override` parameter.
+
+For replay gain implementation, the `amplify` operator would typically be added immediately on top of the basic tracks source, before transitions or other audio processing operators. Typically:
+
+```liquidsoap
+enable_replaygain_metadata()
+
+s = playlist("~/playlist")
+s = amplify(1.,override="replaygain_track_gain",s)
+```
+
+For convenience, we added the `replaygain` operator which performs the
+amplification on the right metadata so that this can further be simplified to
+
+```liquidsoap
+enable_replaygain_metadata()
+
+s = replaygain(playlist("~/playlist"))
+```
diff --git a/website/content/doc-2.2.5/request_sources.md b/website/content/doc-2.2.5/request_sources.md
new file mode 100644
index 00000000..d4e202f0
--- /dev/null
+++ b/website/content/doc-2.2.5/request_sources.md
@@ -0,0 +1,99 @@
+Playing files is the most common way to build an audio stream.
+In liquidsoap, files are accessed through [requests](requests.html),
+which combine the retrieval of a possibly remote file, and its
+decoding.
+
+Liquidsoap provides several operators for playing requests:
+`single`, `playlist` and `playlist.safe`,
+`request.dynamic.list`, `request.queue` and `request.equeue`.
+In a few cases (`single` with a local file,
+or `playlist.safe`) a request operator will know
+that it can always get a ready request instantaneously.
+It will then be [infallible](sources.html).
+Otherwise, it will have a queue of requests ready
+to be played (local files with a valid content), and will
+feed this queue in the background.
+This process is described here.
+
+## Common parameters
+
+Queued request sources maintain an _estimated remaining time_,
+and trigger a new request resolution when this remaining time
+goes below their `length` parameter.
+
+The estimation is based on the duration of files prepared in the queue,
+and the estimated remaining time in the currently playing file.
+Precise file durations being expensive to compute, they are not
+forced: if a duration is provided in the metadata it shall be used,
+otherwise the `default_length` is assumed.
+
+For example, with the default 10 seconds of wanted queue length,
+the operator will only prepare a new file 10 seconds before
+the end of the current one.
+
+Up to liquidsoap 0.9.1, the estimated remaining time
+in the current track was not taken into account.
+With this behavior, each request-based source would keep at least
+one song in queue, which was sometimes inconvenient.
+This behavior can be restored by passing `conservative=true`,
+which is useful in some cases:
+it helps to ensure that a song will be ready in case of skip;
+generally, it prepares things more in advance, which is good when
+resolution is long (_e.g._, heavily loaded server, remote files).
+
+## Request.dynamic
+
+This source takes a custom function for creating its new requests.
+This function, of type `()->request`,
+can for example call an external program.
+
+To create the request, the function will have
+to use the `request.create` function which has type
+`(string,?indicators:[string])`.
+The first string is the initial URI of the request,
+which is resolved to get an audio file.
+The second argument can be used to directly specify the first row of URIs
+(see the page about [requests](requests.html) for more details),
+in which case the initial URI is just here for naming,
+and the resolving process will try your list of indicators one by one
+until a valid audio file is obtained.
+
+An example that takes the output of an external script as an URI
+to create a new request can be:
+
+```liquidsoap
+def my_request_function() =
+  # Get the first line of my external process
+  result =
+    list.hd(default="", process.read.lines("my_script my_params"))
+  # Create and return a request using this result
+  [request.create(result)]
+end
+
+# Create the source
+s = request.dynamic.list(my_request_function)
+```
+
+## Queues
+
+Liquidsoap features two sources which provide request queues that
+can be directly manipulated by the user, via the server interface:
+`request.queue` and `request.equeue`.
+The former is a queued source where you can only push new requests,
+while the later can be edited.
+
+Both operators actually deal with two queues: _primary_ and _secondary_ queues.
+The secondary queue is user-controlled.
+The primary queue is the one that all queued request sources have,
+its behavior is the same as described above, and it cannot be changed
+in any way by the user.
+Requests added to the secondary queue sit there until
+the feeding process gets them and attempts to prepare them
+and put them in the primary queue.
+You can set how many requests will be in that primary queue
+by tweaking the common parameters of all queued request sources.
+
+The two sources are controlled via the [command server](advanced.html).
+They both feature commands for looking up the queues,
+queuing new requests, and the `equeue` operator also allows
+removal and exchange of requests in the secondary queue.
diff --git a/website/content/doc-2.2.5/requests.md b/website/content/doc-2.2.5/requests.md
new file mode 100644
index 00000000..1850128e
--- /dev/null
+++ b/website/content/doc-2.2.5/requests.md
@@ -0,0 +1,53 @@
+# An abstract notion of files: requests
+
+The request is an abstract notion of file which can be conveniently used for defining powerful sources. A request can denote a local file, a remote file, or even a dynamically generated file. They are resolved to a local file thanks to a set of _protocols_. Then, audio requests are transparently decoded thanks to a set of audio and metadata _formats_.
+
+The systematic use of requests to access files allows you to use remote URIs instead of local paths everywhere. It is perfectly OK to create a playlist for a remote list containing remote URIs: ` playlist("http://my/friends/playlist.pls")`
+.
+
+## The resolution process
+
+The nice thing about resolution is that it is recursive and supports backtracking. An URI can be changed into a list of new ones, which are in turn resolved. The process succeeds if some valid local file appears at some point. If it doesn't succeed on one branch then it goes back to another branch. A typical complex resolution would be:
+
+- `bubble:artist="bodom"` _ `ftp://no/where` _ `Error`
+
+- `ftp://some/valid.ogg` \* `/tmp/success.ogg`
+
+On top of that, metadata is extracted at every step in the branch. Usually, only the final local file yields interesting metadata (artist,album,...). But metadata can also be the nickname of the user who requested the song, set using the `annotate` protocol.
+
+At the end of the resolution process, in case of a media request,
+liquidsoap checks that the file is decodable,
+_i.e._, there should be a valid decoder for it.
+
+Each request gets assigned a request identifier (RID) which is used by
+various sources to identify which request(s) they are using. Knowing
+this number, you can monitor a request, even after it's been destroyed
+(see setting `request.grace_time`). Two [server](server.html)
+commands are available: `request.trace` shows a log of
+the resolution process and `request.metadata` shows the
+current request metadata. In addition, server commands are available
+to obtain the list of all requests, alive requests, currently resolving
+requests and currently playing requests (respectively
+`request.all`,
+`request.alive`,
+`request.resolving`,
+`request.on_air`).
+
+## Currently supported protocols
+
+- HTTP, HTTPS, FTP thanks to curl
+- SAY for speech synthesis (requires festival): `say:I am a robot` resolves to the WAV file resulting from the synthesis.
+- TIME for speech synthesis of the current time: ` time: It is exactly $(time), and you're still listening.`
+
+- ANNOTATE for manually setting metadata, typically used in ` annotate:nick="alice",message="for bob":/some/track/uri`
+
+The extra metadata can then be synthesized in the audio stream, or merged into the standard metadata fields, or used on a rich web interface...
+It is also possible to add a new protocol from the script, as it is done with [Beets](beets.html) for getting songs from a database query.
+
+## Currently supported formats
+
+- MPEG-1 Layer II (MP2) and Layer III (MP3) through libmad and `ocaml-mad`
+- Ogg Vorbis through libvorbis and `ocaml-vorbis`
+- WAV
+- AAC
+- and much more through external decoders!
diff --git a/website/content/doc-2.2.5/rolling-release.md b/website/content/doc-2.2.5/rolling-release.md
new file mode 100644
index 00000000..93a4ba27
--- /dev/null
+++ b/website/content/doc-2.2.5/rolling-release.md
@@ -0,0 +1,10 @@
+This release provides liquidsoap assets before they are published as a new versioned release.
+
+You can use it to install the latest stable code before it is published and test/prepare your production environment for it.
+
+Rolling releases can also be useful for us to quickly detect and report bugs before the final published release!
+
+⚠️ **Warning** ⚠️
+Assets in this release will be deleted. If you are looking for permanent links to release assets, please head over to https://github.com/savonet/liquidsoap-release-assets/releases
+
+For more details about our release process, please checkout https://github.com/savonet/liquidsoap#release-details
diff --git a/website/content/doc-2.2.5/script_loading.md b/website/content/doc-2.2.5/script_loading.md
new file mode 100644
index 00000000..b5a859d1
--- /dev/null
+++ b/website/content/doc-2.2.5/script_loading.md
@@ -0,0 +1,29 @@
+# Script loading
+
+When you run liquidsoap for streaming, the command line has the following form:
+
+```
+$ liquidsoap script_or_expr_1 ... script_or_expr_N
+```
+
+This allows you to ask liquidsoap to load definition and settings from
+some scripts so that the become available when processing the next ones.
+
+For example you can store your passwords by defined the variable `xxx`
+in `secret.liq`, and then refer to that variable in your main script
+`main.liq`. You would then run `liquidsoap secret.liq main.liq`. If you ever
+need to communicate `main.liq` there won't be any risk of divulgating your
+password.
+
+## The pervasive script library
+
+In fact, liquidsoap also implicitly loads scripts before those that you specify
+on the command-line. These scripts are meant to contain standard utilities.
+Liquidsoap finds them in `LIBDIR/liquidsoap/VERSION` where `LIBDIR` depends on
+your configuration (it is typically `/usr/local/lib` or `/usr/lib`) and
+`VERSION` is the version of liquidsoap (_e.g._ `0.3.8` or `svn`).
+
+Currently, liquidsoap loads `stdlib.liq` from the library directory,
+and this file includes some others.
+You can add your personal standard library in that directory
+if you find it useful.
diff --git a/website/content/doc-2.2.5/seek.md b/website/content/doc-2.2.5/seek.md
new file mode 100644
index 00000000..09c8a01a
--- /dev/null
+++ b/website/content/doc-2.2.5/seek.md
@@ -0,0 +1,67 @@
+# Seeking in liquidsoap
+
+Starting with Liquidsoap `1.0.0-beta2`, it is now possible to seek within sources!
+Not all sources support seeking though: currently, they are mostly file-based sources
+such as `request.queue`, `playlist`, `request.dynamic.list` etc..
+
+The basic function to seek within a source is `source.seek`. It has the following type:
+
+```
+(source('a),float)->float
+```
+
+The parameters are:
+
+- The source to seek.
+- The duration in seconds to seek from current position.
+
+The function returns the duration actually seeked.
+
+Please note that seeking is done to a position relative to the _current_
+position. For instance, `source.seek(s,3.)` will seek 3 seconds forward in
+source `s` and `source.seek(s,(-4.))` will seek 4 seconds backward.
+
+Since seeking is currently only supported by request-based sources, it is recommended
+to hook the function as close as possible to the original source. Here is an example
+that implements a server/telnet seek function:
+
+```liquidsoap
+# A playlist source
+s = playlist("/path/to/music")
+
+# The server seeking function
+def seek(t) =
+  t = float_of_string(default=0.,t)
+  log("Seeking #{t} sec")
+  ret = source.seek(s,t)
+  "Seeked #{ret} seconds."
+end
+
+# Register the function
+server.register(namespace=source.id(s),
+                description="Seek to a relative position \
+                             in source #{source.id(s)}",
+                usage="seek <duration>",
+                "seek",seek)
+```
+
+## Cue points
+
+File-based sources support cue-points to cut the beginning and end of tracks
+The values of cue-in and cue-out points are given in absolute
+position through the source's metadata. For instance, the following
+source will cue-in at 10 seconds and cue-out at 45 seconds on all its tracks:
+
+```liquidsoap
+s = playlist(prefix="annotate:liq_cue_in=\"10.\",liq_cue_out=\"45\":",
+             "/path/to/music")
+```
+
+As in the above example, you may use the `annotate` protocol to pass custom cue
+points along with the files passed to Liquidsoap. This is particularly useful
+in combination with `request.dymanic` as an external script can build-up
+the appropriate URI, including cue-points, based on information from your
+own scheduling back-end.
+
+Alternatively, you may use `metadata.map` to add those metadata. The operator
+`metadata.map` supports seeking and passes it to its underlying source.
diff --git a/website/content/doc-2.2.5/server.md b/website/content/doc-2.2.5/server.md
new file mode 100644
index 00000000..edb53fcf
--- /dev/null
+++ b/website/content/doc-2.2.5/server.md
@@ -0,0 +1,265 @@
+# Interaction with the server
+
+Liquidsoap starts with one or several scripts as its configuration, and then
+streams forever if everything goes well. Once started, you can still interact
+with it by means of the _server_. The server allows you to run commands. Some
+are general and always available, some belong to a specific operator. For
+example the `request.queue()` instances register commands to enqueue new
+requests, the outputs register commands to start or stop the outputting, display
+the last ten metadata chunks, etc.
+
+The protocol of the server is a simple human-readable one. Currently it does not
+have any kind of authentication and permissions. It is currently available via
+two media: TCP and Unix sockets. The TCP socket provides a simple telnet-like
+interface, available only on the local host by default. The Unix socket
+interface (_cf._ the `server.socket` setting) is through some sort of virtual
+file. This is more constraining, which allows one to restrict the use of the
+socket to some privileged users.
+
+You can find more details on how to configure the server in the
+[documentation](help.html#settings) of the settings key `server`, in particular
+`server.telnet` for the TCP interface and `server.socket` for the Unix
+interface. Liquidsoap also embeds some [documentation](help.html#server) about
+the available server commands.
+
+### Using telnet
+
+Now, we shall simply enable the Telnet interface to the server, by setting
+`settings.server.telnet := true` or simply passing the `-t` option on the
+command-line. In a [complete case analysis](complete_case.html) we set up a
+`request.queue()` instance to play user requests. It had the identifier
+`"queue"`. We are now going to interact via the server to push requests into
+that queue:
+
+```
+dbaelde@selassie:~$ telnet localhost 1234
+Trying 127.0.0.1...
+Connected to localhost.localdomain.
+Escape character is '^]'.
+queue.push /path/to/some/file.ogg
+5
+END
+request.metadata 5
+[...]
+END
+queue.push http://remote/audio.ogg
+6
+END
+request.trace 6
+[...see if the download started/succeeded...]
+END
+exit
+```
+
+Of course, the server isn't very user-friendly. But it is easy to write scripts
+to interact with Liquidsoap in that way, to implement a website or an IRC
+interface to your radio. However, this sort of tool is often bound to a specific
+usage, so we have not released any of ours.
+
+### Web interface
+
+Another simple way to test the telnet server consists in using the
+
+```liquidsoap
+server.harbor()
+```
+
+server.harbor api: https://www.liquidsoap.info/doc-2.0.0/reference-extras.html#server.harbor
+
+command which will start a web interface accessible at
+<http://localhost:8000/telnet> providing an emulation of a telnet.
+
+## Interactive variables
+
+Sometimes it is useful to control a variable using telnet. A simple way to
+achieve this is to use the `interactive.float` function. For instance, in order
+to dynamically the volume of a source:
+
+```liquidsoap
+# Register a telnet variable named volume with 1 as initial value
+v = interactive.float("volume", 1.)
+
+# Change the volume accordingly
+source = amplify(v, source)
+```
+
+The first line registers the variable volume on the telnet. Its value can be
+changed using the telnet command
+
+```liquidsoap
+var.set volume = 0.5
+```
+
+and it can be retrieved using
+
+```liquidsoap
+var.get volume
+```
+
+Similarly, we can switch between two tracks using `interactive.bool` and
+`switch` as follows:
+
+```liquidsoap
+# Activate the telnet server
+settings.server.telnet := true
+
+# The two sources
+s1 = playlist("~/Music")
+s2 = sine()
+
+# Create an interactive boolean
+b = interactive.bool("button", true)
+
+# Switch between the tracks depending on the boolean
+s = switch(track_sensitive=false,[(b,s1), ({true},s2)])
+
+# Output the result
+output.pulseaudio(s)
+```
+
+By default the source s1 is played. To switch to s2, you can connect on
+the telnet server and type `var.set button = false`.
+
+### Web interface
+
+A nice web interface can be obtained by running
+
+```liquidsoap
+interactive.harbor()
+```
+
+interactive.harbor api: https://www.liquidsoap.info/doc-2.0.0/reference.html#interactive.harbor
+
+after all interactive variables have been defined. This will start a web server
+accessible at <http://localhost:8000/interactive> on which you can easily change
+the values for the interactive variables.
+
+### Persistency
+
+By default, interactive variables are not _persistent_, which means that their
+values are lost if you restart the script. This can be changed by running the command
+
+```liquidsoap
+interactive.persistent("vars.json")
+```
+
+after all the interactive variables have been defined. This will store the
+values of all the interactive variables in the file `vars.json` (in JSON format)
+whenever you modify them, and reload them next time your run your script. This
+can be very handy for setting parameters for sound effects for instance.
+
+## Securing the server
+
+The command server provided by liquidsoap is very convenient for manipulating a
+running instance of Liquidsoap. However, no authentication mechanism is
+provided. The telnet server has no authentication and listens by default on the
+localhost (`127.0.0.1`) network interface, which means that it is accessible to
+any logged user on the machine.
+
+Many users have expressed interest into setting up a secured access to the
+command server, using for instance user and password information. While we
+understand and share this need, we do not believe this is a task that lies into
+Liquidsoap's scope. An authentication mechanism is not something that should be
+implemented naively. Being SSH, HTTP login or any other mechanism, all these
+methods have been, at some point, exposed to security issues. Thus, implementing
+our own secure access would require a constant care about possible security
+issues.
+
+Rather than doing our own home-made secure access, we believe that our users
+should be able to define their own secure access to the command server, taking
+advantage of a mainstream authentication mechanism, for instance HTTP or SSH
+login. In order to give an example of this approach, we show here how to create
+a SSH access to the command server: we create a SSH user that, when logging
+through SSH, has only access to the command server.
+
+First, we enable the unix socket for the command server in Liquidsoap:
+
+```liquidsoap
+settings.server.socket := true
+settings.server.socket.path := "/path/to/socket"
+```
+
+When started, liquidsoap will create a socket file `/path/to/socket`
+that can be used to interact with the command server. For instance,
+if your user has read and write rights on the socket file, you can do
+
+```liquidsoap
+socat /path/to/socket -
+```
+
+The interface is then exactly the same has for the telnet server.
+
+We define now a new ``shell''. This shell is in fact the invocation of the socat command. Thus, we create a `/usr/local/bin/liq_shell` file with the following
+content:
+
+```bash
+#!/bin/sh
+# We test if the file is a socket, readable and writable.
+if [ -S /path/to/socket ] && [ -w /path/to/socket ] && \
+   [ -r /path/to/socket ]; then
+  socat /path/to/socket -
+else
+# If not, we exit..
+  exit 1
+fi
+```
+
+We set this file as executable, and we add it in the list of shells in `/etc/shells`.
+
+Now, we create a user with the `liq_shell` as its shell:
+
+```
+adduser --shell /usr/local/bin/liq_shell liq-user
+```
+
+You also need to make sure that `liq-user` has read and write rights
+on the socket file.
+
+Finally, when logging through ssh with `liq-user`, we get:
+
+```
+11:27 toots@leonard % ssh liq-user@localhost
+liq-user@localhost's password:
+Linux leonard 2.6.32-4-amd64 #1 SMP Mon Apr 5 21:14:10 UTC 2010 x86_64
+
+The programs included with the Debian GNU/Linux system are free software;
+the exact distribution terms for each program are described in the
+individual files in /usr/share/doc/*/copyright.
+
+Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
+permitted by applicable law.
+Last login: Tue Oct  5 11:26:52 2010 from localhost
+help
+Available commands:
+(...)
+| exit
+| help [<command>]
+| list
+| quit
+| request.alive
+| request.all
+| request.metadata <rid>
+| request.on_air
+| request.resolving
+| request.trace <rid>
+| uptime
+| var.get <variable>
+| var.list
+| var.set <variable> = <value>
+| version
+
+Type "help <command>" for more information.
+END
+exit
+Bye!
+END
+Connection to localhost closed.
+```
+
+This is an example of how you can use an existing secure access to
+secure the access to liquidsoap's command server. This way, you make sure
+that you are using a mainstream secure application, here SSH.
+
+This example may be adapted similarly to use an online HTTP login
+mechanism, which is probably the most comment type of mechanism
+intended for the command line server.
diff --git a/website/content/doc-2.2.5/settings.md b/website/content/doc-2.2.5/settings.md
new file mode 100644
index 00000000..e07ac984
--- /dev/null
+++ b/website/content/doc-2.2.5/settings.md
@@ -0,0 +1,5624 @@
+
+# Liquidsoap configuration
+
+## ALSA configuration
+
+### Alsa internal buffer size
+
+This setting is only used in buffered alsa I/O, and affects latency.Set to 0 to disable this setting and use ALSA's default.
+
+```liquidsoap
+settings.alsa.alsa_buffer := 0
+```
+
+### Buffer size, in frames
+
+This is only used for buffered ALSA I/O, and affects latency.
+
+```liquidsoap
+settings.alsa.buffer_length := 1
+```
+
+### Number of periods
+
+Set to 0 to disable this setting and use ALSA's default.
+
+```liquidsoap
+settings.alsa.periods := 0
+```
+
+## Audio settings
+
+Options related to audio.
+
+### Conversion settings
+
+Options related to audio conversion.
+
+#### Channel layout conversion settings
+
+Options related to channel layout conversion.
+
+##### Preferred samplerate converters
+
+Preferred channel layout converter. The native converter is always available.
+
+```liquidsoap
+settings.audio.converter.channel_layout.converters := ["native"]
+```
+
+#### Samplerate conversion settings
+
+Options related to samplerate conversion.
+
+##### Preferred samplerate converters
+
+Preferred samplerate converter. The native converter is always available.
+
+```liquidsoap
+settings.audio.converter.samplerate.converters := ["libsamplerate", "ffmpeg", "native"]
+```
+
+##### Libsamplerate conversion settings
+
+Options related to libsamplerate conversion.
+
+###### Resampling quality
+
+Resampling quality, one of: `"best"`, `"medium"`, `"fast"`, `"zero_order"` or `"linear"`. Refer to ocaml-samplerate for details.
+
+```liquidsoap
+settings.audio.converter.samplerate.libsamplerate.quality := "fast"
+```
+
+##### Native samplerate conversion settings
+
+Options related to native samplerate conversion.
+
+###### Resampling quality
+
+Resampling quality: either "nearest" or "linear".
+
+```liquidsoap
+settings.audio.converter.samplerate.native.quality := "linear"
+```
+
+## Settings related to charset conversion.
+
+### List of encodings to try for automatic encoding detection.
+
+```liquidsoap
+settings.charset.encodings := ["UTF-8", "ISO-8859-1", "UTF-16"]
+```
+
+### Directory where charset files are to be found.
+
+```liquidsoap
+settings.charset.path := "/usr/share/liquidsoap/camomile"
+```
+
+## Clock settings
+
+### Handling of streaming errors
+
+Control the behaviour of clocks when an error occurs during streaming.This has no effect on errors occurring during source initializations.By default, any error will cause liquidsoap to shutdown. If errorsare allowed, faulty sources are simply removed and clocks keep running.Allowing errors can result in complex surprising situations;use at your own risk!
+
+```liquidsoap
+settings.clock.allow_streaming_errors := false
+```
+
+### How often (in seconds) we should indicate catchup errors.
+
+```liquidsoap
+settings.clock.log_delay := 1.
+```
+
+### Preferred clock implementation. One if: "posix" or "ocaml".
+
+```liquidsoap
+settings.clock.preferred := "posix"
+```
+
+## Console configuration
+
+### Use color in console output when available. One of: "always", "never" or "auto".
+
+```liquidsoap
+settings.console.colorize := "auto"
+```
+
+## Crossfade settings
+
+### Assume autocue when all 4 cue in/out and fade in/out metadata override are present.
+
+```liquidsoap
+settings.crossfade.assume_autocue := false
+```
+
+## Debug language features such as type inference and reduction.
+
+```liquidsoap
+settings.debug := false
+```
+
+## Debug errors by showing stacktraces instead of printing messages.
+
+```liquidsoap
+settings.debug_errors := false
+```
+
+## Encoder settings
+
+Settings for the encoder
+
+### Metadata settings
+
+Settings for the encoded metadata.
+
+#### Metadata labels that represent coverart
+
+```liquidsoap
+settings.encoder.metadata.cover := ["pic", "apic", "metadata_block_picture", "cover"]
+```
+
+#### Exported metadata
+
+The list of labels of exported metadata.
+
+```liquidsoap
+settings.encoder.metadata.export := ["artist", "title", "album", "genre", "date", "tracknumber", "comment", "track", "year", "dj", "next", "apic", "pic", "metadata_url", "metadata_block_picture", "coverart"]
+```
+
+## FFMPEG configuration
+
+### FFmpeg content configuration
+
+#### FFmpeg copy content configuration
+
+##### If `true`, relax content compatibility, e.g. allow audio tracks with different samplerate or video tracks with different resolution.
+
+```liquidsoap
+settings.ffmpeg.content.copy.relaxed_compatibility_check := false
+```
+
+### Log configuration
+
+#### Level
+
+```liquidsoap
+settings.ffmpeg.log.level := 3
+```
+
+#### Verbosity
+
+Set FFMPEG log level, one of: "quiet", "panic", "fatal", "error", "warning", "info", "verbose", "debug" or "trace".
+
+```liquidsoap
+settings.ffmpeg.log.verbosity := "warning"
+```
+
+### Scaling algorithm
+
+Set FFMPEG scaling algorithm. One of: "fast_bilinear","bilinear" or "bicubic".
+
+```liquidsoap
+settings.ffmpeg.scaling_algorithm := "bicubic"
+```
+
+## Frame format
+
+Settings for the data representation in frames, which are theelementary packets of which streams are made.
+
+### Audio (PCM) format
+
+#### Default number of channels
+
+```liquidsoap
+settings.frame.audio.channels := 2
+```
+
+#### Samplerate
+
+```liquidsoap
+settings.frame.audio.samplerate := 44100
+```
+
+#### Tentative frame duration in audio samples
+
+Audio samplerate and video frame rate constrain the possible frame durations.This setting is used as a hint for the duration, overriding'frame.duration'.Tweaking frame duration is tricky but needed when dealing with latencyor getting soundcard I/O correctly synchronized with liquidsoap.
+
+```liquidsoap
+settings.frame.audio.size := <value>
+```
+
+### Tentative frame duration in seconds
+
+Audio samplerate and video frame rate constrain the possible frame durations.This setting is used as a hint for the duration, when 'frame.audio.size'is not provided.Tweaking frame duration is tricky but needed when dealing with latencyor getting soundcard I/O correctly synchronized with liquidsoap.
+
+```liquidsoap
+settings.frame.duration := 0.04
+```
+
+### MIDI parameters
+
+#### Default number of channels
+
+```liquidsoap
+settings.frame.midi.channels := 0
+```
+
+### Video settings
+
+#### Set to `true` to force video content even when no video content is explicitly requested, for instance: `output.dummy(noise())`
+
+```liquidsoap
+settings.frame.video.default := false
+```
+
+#### Frame rate
+
+```liquidsoap
+settings.frame.video.framerate := 25
+```
+
+#### Image height
+
+```liquidsoap
+settings.frame.video.height := 720
+```
+
+#### Image width
+
+```liquidsoap
+settings.frame.video.width := 1280
+```
+
+## Harbor settings (Icecast/shoutcast stream receiver).
+
+### Timeout for network accept operations (in seconds).
+
+```liquidsoap
+settings.harbor.accept_timeout := 3.
+```
+
+### IP addresses on which the harbor should listen.
+
+```liquidsoap
+settings.harbor.bind_addrs := ["0.0.0.0"]
+```
+
+### Content-type (mime) of formats which allow shout metadata update.
+
+```liquidsoap
+settings.harbor.icy_formats := ["audio/mpeg", "audio/aacp", "audio/aac", "audio/x-aac", "audio/wav", "audio/wave", "audio/flac", "audio/x-flac"]
+```
+
+### Maximum of pending source requests per port.
+
+```liquidsoap
+settings.harbor.max_connections := 128
+```
+
+### Perform reverse DNS lookup to get the client's hostname from its IP.
+
+```liquidsoap
+settings.harbor.reverse_dns := false
+```
+
+### Timeout for network operations (in seconds).
+
+```liquidsoap
+settings.harbor.timeout := 120.
+```
+
+### Display passwords, for debugging.
+
+```liquidsoap
+settings.harbor.verbose := false
+```
+
+## Initialization configuration
+
+### Allow liquidsoap to run as root
+
+This should be reserved for advanced dynamic uses of liquidsoap such as running inside an isolated environment like docker.
+
+```liquidsoap
+settings.init.allow_root := false
+```
+
+### Catch exceptions, use false to backtrace exceptions
+
+```liquidsoap
+settings.init.catch_exn := true
+```
+
+### Run in daemon mode
+
+```liquidsoap
+settings.init.daemon := false
+```
+
+#### Changes the effective user (drops privileges).
+
+```liquidsoap
+settings.init.daemon.change_user := false
+```
+
+##### Group used to run the daemon.
+
+```liquidsoap
+settings.init.daemon.change_user.group := "daemon"
+```
+
+##### User used to run the daemon.
+
+```liquidsoap
+settings.init.daemon.change_user.user := "daemon"
+```
+
+#### Support for pidfile generation
+
+```liquidsoap
+settings.init.daemon.pidfile := true
+```
+
+##### Path to pidfile
+
+```liquidsoap
+settings.init.daemon.pidfile.path := "<sysrundir>/<script>.pid"
+```
+
+##### Unix file permissions for pidfile. Default: `0o640`.
+
+```liquidsoap
+settings.init.daemon.pidfile.perms := 416
+```
+
+### Start liquidsoap even without any active source
+
+This should be reserved for advanced dynamic uses of liquidsoap.
+
+```liquidsoap
+settings.init.force_start := false
+```
+
+### Dump an initialization trace
+
+```liquidsoap
+settings.init.trace := false
+```
+
+## Log configuration
+
+### Log to file
+
+```liquidsoap
+settings.log.file := false
+```
+
+#### Append log to the file
+
+```liquidsoap
+settings.log.file.append := true
+```
+
+#### Path to log file
+
+```liquidsoap
+settings.log.file.path := "<syslogdir>/<script>.log"
+```
+
+#### Log file permissions
+
+```liquidsoap
+settings.log.file.perms := 384
+```
+
+### General log level
+
+```liquidsoap
+settings.log.level := 3
+```
+
+### Recode log entries. Source encoding is set using `settings.charset.encodings`.
+
+```liquidsoap
+settings.log.recode := false
+```
+
+#### Encoding to recode log entries to.
+
+```liquidsoap
+settings.log.recode.encoding := "UTF-8"
+```
+
+### Log to stdout
+
+```liquidsoap
+settings.log.stdout := true
+```
+
+### Display unix timestamps (subsecond accuracy, timezone independant)
+
+```liquidsoap
+settings.log.unix_timestamps := false
+```
+
+## Parameters for the mpd protocol.
+
+### Debug communications with MPD server.
+
+```liquidsoap
+settings.mpd.debug := false
+```
+
+### MPD host.
+
+```liquidsoap
+settings.mpd.host := "127.0.0.1"
+```
+
+### Directory where MPD's music is located.
+
+```liquidsoap
+settings.mpd.path := "/var/lib/mpd/music"
+```
+
+### MPD port.
+
+```liquidsoap
+settings.mpd.port := 6600
+```
+
+### Randomize order of MPD's results.
+
+```liquidsoap
+settings.mpd.randomize := true
+```
+
+## Interactions through the OSC protocol.
+
+### Port for OSC server.
+
+```liquidsoap
+settings.osc.port := 7777
+```
+
+## Interactions through the OSC protocol.
+
+### Port for OSC server.
+
+```liquidsoap
+settings.oscnative.port := 7777
+```
+
+## Metric reporting using prometheus.
+
+### Enable the prometheus server.
+
+```liquidsoap
+settings.prometheus.server := false
+```
+
+#### Port to run the server on.
+
+```liquidsoap
+settings.prometheus.server.port := 9090
+```
+
+## Requests configuration
+
+### Number of requests at which a leak warning should be issued.
+
+```liquidsoap
+settings.request.leak_warning := 100
+```
+
+### Decoders and order used to decode files' metadata.
+
+```liquidsoap
+settings.request.metadata_decoders := ["video-metadata", "ogg_native", "image", "ID3", "ID3v1", "ID3v2", "flac_native", "mp4", "ffmpeg", "flac", "ogg", "taglib"]
+```
+
+#### Compute duration in the "duration" metadata, if the metadata is not already present. This can take a long time and the use of this option is not recommended: the proper way is to have a script precompute the "duration" metadata.
+
+```liquidsoap
+settings.request.metadata_decoders.duration := false
+```
+
+#### Priorities used for applying metadata decoders. Decoder with the highest priority take precedence.
+
+##### Priority for the ffmpeg metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.ffmpeg := 1
+```
+
+##### Priority for the flac metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.flac := 1
+```
+
+##### Priority for the flac native decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.flac_native := 1
+```
+
+##### Priority for the native ID3 metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.id3 := 1
+```
+
+##### Priority for the native ID3v1 metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.id3v1 := 1
+```
+
+##### Priority for the native ID3v2 metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.id3v2 := 1
+```
+
+##### Priority for the image metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.image_metadata := 1
+```
+
+##### Priority for the mp4 metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.mp4 := 1
+```
+
+##### Priority for the ogg metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.ogg := 1
+```
+
+##### Priority for the native ogg metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.ogg_metadata := 1
+```
+
+##### Priority for the request metadata. This include metadata set via `annotate`.
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.request_metadata := 5
+```
+
+##### Priority for the taglib metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.taglib := 1
+```
+
+##### Priority for the native video metadata decoder
+
+```liquidsoap
+settings.request.metadata_decoders.priorities.video_metadata := 1
+```
+
+#### Re-encode metadata strings in UTF-8
+
+```liquidsoap
+settings.request.metadata_decoders.recode := true
+```
+
+##### Exclude these metadata from automatic recording.
+
+```liquidsoap
+settings.request.metadata_decoders.recode.exclude := ["apic", "metadata_block_picture", "coverart"]
+```
+
+### Default prefetch
+
+```liquidsoap
+settings.request.prefetch := 1
+```
+
+## Streaming clock settings
+
+### Maximum latency in seconds
+
+If the latency gets higher than this value, the outputs will be reset,instead of trying to catch it up second by second.The reset is typically only useful to reconnect icecast mounts.
+
+```liquidsoap
+settings.root.max_latency := 60.
+```
+
+## Runtime configuration.
+
+### Strip runtime types whenever possible to optimize memory usage.
+
+```liquidsoap
+settings.runtime.strip_types := true
+```
+
+## Sandboxing for external processes.
+
+```liquidsoap
+settings.sandbox := false
+```
+
+### Sandbox binary to use.
+
+```liquidsoap
+settings.sandbox.binary := "bwrap"
+```
+
+### Enable network
+
+```liquidsoap
+settings.sandbox.network := true
+```
+
+### Read-only directories
+
+```liquidsoap
+settings.sandbox.ro := ["/"]
+```
+
+### Read/write directories. Default: `[$HOME;$TMPDIR]`.
+
+```liquidsoap
+settings.sandbox.rw := ["/usr/share/liquidsoap", "/tmp"]
+```
+
+### Additional default environment variables.
+
+```liquidsoap
+settings.sandbox.setenv := ["TEMPDIR=/tmp", "TEMP=/tmp", "TMPDIR=/tmp", "TMP=/tmp"]
+```
+
+### Run command inside shell.
+
+```liquidsoap
+settings.sandbox.shell := true
+```
+
+#### Patch to shell binary. Defaults to `$SHELL` if set and "/bin/sh" otherwise.
+
+```liquidsoap
+settings.sandbox.shell.path := "/bin/sh"
+```
+
+### Environment variables to unset.
+
+```liquidsoap
+settings.sandbox.unsetenv := []
+```
+
+## Internal scheduler
+
+The scheduler is used to process various tasks in liquidsoap.There are three kinds of tasks:"Non-blocking" ones are instantaneous to process, these are onlyinternal processes of liquidsoap like its server."Fast" tasks are those that can be long but are often not,such as request resolution (audio file downloading and checking).Finally, "slow" tasks are those that are always taking a long time,like last.fm submission, or user-defined tasks register via`thread.run`.The scheduler consists in a number of queues that process incomingtasks. Some queues might only process some kinds of tasks so thatthey are more responsive.Having more queues often do not make the program faster in average,but affect mostly the order in which tasks are processed.
+
+### Fast queues
+
+Number of queues that are dedicated to fast tasks.It might be useful to create some if your request resolutions,or some user defined tasks (cf `thread.run`), aredelayed too much because of slow tasks blocking the generic queues,such as last.fm submissions or slow `thread.run` handlers.
+
+```liquidsoap
+settings.scheduler.fast_queues := 0
+```
+
+### Generic queues
+
+Number of event queues accepting any kind of task.There should at least be one. Having more can be useful to make surethat trivial request resolutions (local files) are not delayedbecause of a stalled download. But N stalled download can blockN queues anyway.
+
+```liquidsoap
+settings.scheduler.generic_queues := 2
+```
+
+### Log scheduler messages
+
+```liquidsoap
+settings.scheduler.log := false
+```
+
+### Non-blocking queues
+
+Number of queues dedicated to internal non-blocking tasks.These are only started if such tasks are needed.There should be at least one.
+
+```liquidsoap
+settings.scheduler.non_blocking_queues := 2
+```
+
+## Server configuration
+
+The server is an abstract text-command-based communication protocol, which can be used through several interfaces.
+
+### Log configuration.
+
+#### Default log level for messages.
+
+```liquidsoap
+settings.server.log.level := 3
+```
+
+### Support for communication via a UNIX domain socket interface
+
+The main advantage of this method is that you can set very preciselythe access permissions for the socket, just like for any other file.A useful command to use this interface is: "socat stdin unix:<path>".
+
+```liquidsoap
+settings.server.socket := false
+```
+
+#### Path of the UNIX domain socket
+
+In this filename, `<pid>`, `<script>` and `<sysrundir>` are replaced by their respective values: PID of the instance of liquidsoap,base name of the .liq script (if any), default runtime data directory.
+
+```liquidsoap
+settings.server.socket.path := "<sysrundir>/<script>.sock"
+```
+
+#### Socket permissions, up to umask
+
+This parameter is better written in octal notation. Although you can write octal numbers like 0o660, they are not displayed back in octal. For example, the default value 384 is the decimal for 0o600.
+
+```liquidsoap
+settings.server.socket.permissions := 384
+```
+
+### Support for communication via a telnet interface
+
+This allows you to communicate with the server via a telnet interface,i.e., a simple text-based communication over TCP.The standard "telnet" command will allow you to communicate throughthat interface, as well as the telnet libraries available in mostscript languages.Since there is currently no authentication, you should be carefulabout who can access this interface: either restrict it to connectionsfrom localhost (using the bind_addr param) or set up a firewall.
+
+```liquidsoap
+settings.server.telnet := false
+```
+
+#### Network mask from which the telnet server should accept connections
+
+```liquidsoap
+settings.server.telnet.bind_addr := "127.0.0.1"
+```
+
+#### Port on which the telnet server should listen
+
+```liquidsoap
+settings.server.telnet.port := 1234
+```
+
+#### Perform reverse DNS lookup to get the client's hostname from its IP.
+
+```liquidsoap
+settings.server.telnet.revdns := false
+```
+
+### Timeout for read/write operations.
+
+A negative value disables timeout.
+
+```liquidsoap
+settings.server.timeout := 30.
+```
+
+## SRT configuration
+
+### Enforce consistent encryption settings on both end of any connection.
+
+```liquidsoap
+settings.srt.enforced_encryption := true
+```
+
+### Route srt logs through liquidsoap's logs
+
+```liquidsoap
+settings.srt.log := true
+```
+
+#### Level
+
+```liquidsoap
+settings.srt.log.level := 4
+```
+
+#### Verbosity
+
+Set SRT log level, one of: "critical", "error", "warning", "notice" or "debug"
+
+```liquidsoap
+settings.srt.log.verbosity := "warning"
+```
+
+### Poll configuration
+
+#### Timeout for polling loop, in seconda.
+
+```liquidsoap
+settings.srt.poll.timeout := 0.1
+```
+
+## Playlist formats
+
+### Cue in metadata for playlists with track index.
+
+Some playlists format, such as CUE files specify index points to starttracks playback. In this case, tracks are resolved to a annotate: request witha cue-in metadata containing the index. If you want to make use of this index,you should specify here what label you want for this metadata.
+
+```liquidsoap
+settings.playlist.cue_in_metadata := "liq_cue_in"
+```
+
+### Cue out metadata for playlists with track index.
+
+Some playlists format, such as CUE files specify index points to starttracks playback. In this case, tracks are resolved to a annotate: request witha cue-in metadata containing the index. If you want to make use of this index,you should specify here what label you want for this metadata.
+
+```liquidsoap
+settings.playlist.cue_out_metadata := "liq_cue_out"
+```
+
+### Mime-types used for guessing playlist formats.
+
+#### Mime-types used for guessing text-based playlists.
+
+```liquidsoap
+settings.playlist.mime_types.basic := [{mime="audio/x-scpls", strict=true, parser=<fun>}, {mime="application/x-cue", strict=true, parser=<fun>}, {mime="audio/x-mpegurl", strict=false, parser=<fun>}, {mime="audio/mpegurl", strict=false, parser=<fun>}, {mime="application/x-mpegURL", strict=false, parser=<fun>}]
+```
+
+#### Mime-types used for guessing xml-based playlists.
+
+```liquidsoap
+settings.playlist.mime_types.xml := [{mime="video/x-ms-asf", strict=true, parser=<fun>}, {mime="audio/x-ms-asx", strict=true, parser=<fun>}, {mime="text/xml", strict=true, parser=<fun>}, {mime="application/xml", strict=true, parser=<fun>}, {mime="application/smil", strict=true, parser=<fun>}, {mime="application/smil+xml", strict=true, parser=<fun>}, {mime="application/xspf+xml", strict=true, parser=<fun>}, {mime="application/rss+xml", strict=true, parser=<fun>}]
+```
+
+## 
+
+### All available autocue implementations
+
+```liquidsoap
+settings.autocue.implementations := [("internal", <fun>)]
+```
+
+### How much data should be buffer from each track when computing crossfade transitions. This will be shorter if one of the track is shorter than that.
+
+```liquidsoap
+settings.autocue.target_cross_duration := 3.
+```
+
+### 
+
+#### Priority for the autocue metadata resolver. Default value allows it to override both file and request metadata.
+
+```liquidsoap
+settings.autocue.metadata.priority := 10
+```
+
+### Preferred autocue
+
+```liquidsoap
+settings.autocue.preferred := "internal"
+```
+
+### How to proceed with amplify data when `"liq_amplify"` is set. One of: `"keep"` (prefer user-provided value), `"override"` (always override with computed value), `"ignore"` (ignore/suppress loudness adjustment).
+
+```liquidsoap
+settings.autocue.amplify_behavior := "keep"
+```
+
+### List of metadata to treat as amplify aliases when applying the `amplify_behavior` policy.
+
+```liquidsoap
+settings.autocue.amplify_aliases := ["replaygain_track_gain"]
+```
+
+### 
+
+#### Disable processing when one of these metadata is found
+
+```liquidsoap
+settings.autocue.internal.metadata_override := ["liq_cue_in", "liq_cue_out", "liq_cross_start_next", "liq_fade_in", "liq_fade_in_delay", "liq_fade_out", "liq_fade_out_delay"]
+```
+
+#### Loudness target
+
+```liquidsoap
+settings.autocue.internal.lufs_target := -16.
+```
+
+#### Cue in threshold
+
+```liquidsoap
+settings.autocue.internal.cue_in_threshold := -34.
+```
+
+#### Cue out threshold
+
+```liquidsoap
+settings.autocue.internal.cue_out_threshold := -42.
+```
+
+#### Crossfade start threshold
+
+```liquidsoap
+settings.autocue.internal.cross_threshold := -7.
+```
+
+#### Maximum allowed overlap/crossfade in seconds
+
+```liquidsoap
+settings.autocue.internal.max_overlap := 6.
+```
+
+#### Try to optimize crossfade point on sustained endings
+
+```liquidsoap
+settings.autocue.internal.sustained_endings_enabled := true
+```
+
+#### Max. loudness drop off immediately after crossfade point to consider it as relevant ending [percentage]
+
+```liquidsoap
+settings.autocue.internal.sustained_endings_dropoff := 15.
+```
+
+#### Max. loudness difference between crossfade point and cue out to consider it as relevant ending [percentage]
+
+```liquidsoap
+settings.autocue.internal.sustained_endings_slope := 20.
+```
+
+#### Minimum duration to consider it the ending as sustained [seconds]
+
+```liquidsoap
+settings.autocue.internal.sustained_endings_min_duration := 1.
+```
+
+#### Max reduction of dB thresholds compared to initial value [multiplying factor]
+
+```liquidsoap
+settings.autocue.internal.sustained_endings_threshold_limit := 2.
+```
+
+#### Maximum real time ratio to control speed of LUFS data analysis
+
+```liquidsoap
+settings.autocue.internal.ratio := 50.
+```
+
+#### Maximum allowed processing time (estimated)
+
+```liquidsoap
+settings.autocue.internal.timeout := 10.
+```
+
+## Settings for HTTP requests
+
+### MIME-related settings for HTTP requests
+
+#### MIME to file extension mappings
+
+```liquidsoap
+settings.http.mime.extnames := [("audio/mp3", ".mp3"), ("audio/mpeg", ".mp3"), ("application/ogg", ".ogg"), ("application/x-ogg", ".ogg"), ("audio/x-ogg", ".ogg"), ("audio/ogg", ".ogg"), ("video/ogg", ".ogg"), ("audio/flac", ".flac"), ("audio/x-flac", ".flac"), ("audio/mp4", ".mp4"), ("application/mp4", ".mp4"), ("video/mp4", ".mp4"), ("audio/vnd.wave", ".wav"), ("audio/wav", ".wav"), ("audio/wave", ".wav"), ("audio/x-wav", ".wav"), ("image/jpeg", ".jpg"), ("image/png", ".png"), ("application/pdf", ".pdf"), ("image/bmp", ".bmp")]
+```
+
+## Settings for registered protocols
+
+### Settings for the ReplayGain protocol
+
+#### Tag used to annotate ReplayGain
+
+```liquidsoap
+settings.protocol.replaygain.tag := "replaygain_track_gain"
+```
+
+### Settings for the process protocol
+
+#### List of environment variables passed down to the executed process.
+
+```liquidsoap
+settings.protocol.process.env := []
+```
+
+#### Inherit calling process's environment when `env` parameter is empty.
+
+```liquidsoap
+settings.protocol.process.inherit_env := true
+```
+
+### Settings for the youtube-dl protocol
+
+#### Path of the youtube-dl (or yt-dlp) binary.
+
+```liquidsoap
+settings.protocol.youtube_dl.path := "yt-dlp"
+```
+
+#### Timeout (in seconds) for youtube-dl executions.
+
+```liquidsoap
+settings.protocol.youtube_dl.timeout := 300.
+```
+
+### Settings for the FFmpeg protocol
+
+#### Path to the ffmpeg binary
+
+```liquidsoap
+settings.protocol.ffmpeg.path := "ffmpeg"
+```
+
+#### Should the protocol extract metadata
+
+```liquidsoap
+settings.protocol.ffmpeg.metadata := true
+```
+
+#### Should the protocol adjust ReplayGain
+
+```liquidsoap
+settings.protocol.ffmpeg.replaygain := false
+```
+
+### Settings for the text2wave protocol
+
+#### Path to the text2wave binary
+
+```liquidsoap
+settings.protocol.text2wave.path := "text2wave"
+```
+
+### Settings for the pico2wave protocol
+
+#### Path to the pico2wave binary
+
+```liquidsoap
+settings.protocol.pico2wave.path := "pico2wave"
+```
+
+#### Pico2wave language. One of: `"en-US"`, `"en-GB"`, `"es-ES"`, `"de-DE"`, `"fr-FR"` or `"it-IT"`.
+
+```liquidsoap
+settings.protocol.pico2wave.lang := "en-US"
+```
+
+### Settings for the gtts protocol
+
+#### Path to the gtts binary
+
+```liquidsoap
+settings.protocol.gtts.path := "gtts-cli"
+```
+
+#### Language to speak in.
+
+```liquidsoap
+settings.protocol.gtts.lang := "en"
+```
+
+#### Command line options.
+
+```liquidsoap
+settings.protocol.gtts.options := ""
+```
+
+### Settings for the AWS protocol
+
+#### Use a specific profile from your credential file.
+
+```liquidsoap
+settings.protocol.aws.profile := <value>
+```
+
+#### Alternative endpoint URL (useful for other S3 implementations).
+
+```liquidsoap
+settings.protocol.aws.endpoint := <value>
+```
+
+#### AWS Region
+
+```liquidsoap
+settings.protocol.aws.region := <value>
+```
+
+#### Path to aws CLI binary
+
+```liquidsoap
+settings.protocol.aws.path := "aws"
+```
+
+#### Settings for the polly protocol
+
+##### Output format
+
+```liquidsoap
+settings.protocol.aws.polly.format := "mp3"
+```
+
+##### Voice ID
+
+```liquidsoap
+settings.protocol.aws.polly.voice := "Joanna"
+```
+
+## Video settings
+
+Options related to video.
+
+### Video conversion
+
+Options related to video conversion.
+
+#### Preferred video converter
+
+```liquidsoap
+settings.video.converter.preferred := "ffmpeg"
+```
+
+### `video.text` implementation.
+
+```liquidsoap
+settings.video.text := "sdl"
+```
+
+## 
+
+```liquidsoap
+settings.make := <fun>
+```
+
+### 
+
+```liquidsoap
+settings.make.void := fun (~comments="",_) -> {comments=comments, description=description}
+```
+
+### 
+
+```liquidsoap
+settings.make.protocol := <fun>
+```
+
+### 
+
+```liquidsoap
+settings.make.external := <fun>
+```
+
+## Decoder settings
+
+### Maximum debugging information (dev only)
+
+WARNING: Do not enable unless a developer instructed you to do so!The debugging mode makes it easier to understand why decoding fails,but as a side effect it will crash liquidsoap at the end of everytrack.
+
+```liquidsoap
+settings.decoder.debug := false
+```
+
+### Media decoders.
+
+```liquidsoap
+settings.decoder.decoders := ["wav", "aiff", "pcm/basic", "srt", "raw audio", "midi", "image", "aac", "mp4", "ffmpeg", "flac", "ogg", "mad"]
+```
+
+### FFmpeg decoder configuration
+
+#### Codecs settings
+
+##### Preferred codec to decode 4xm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs._4xm := <value>
+```
+
+###### Available codecs to decode 4xm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs._4xm.available := ["4xm"]
+```
+
+##### Preferred codec to decode aac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aac := <value>
+```
+
+###### Available codecs to decode aac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aac.available := ["aac", "aac_fixed", "libfdk_aac"]
+```
+
+##### Preferred codec to decode aasc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aasc := <value>
+```
+
+###### Available codecs to decode aasc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aasc.available := ["aasc"]
+```
+
+##### Preferred codec to decode ac3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ac3 := <value>
+```
+
+###### Available codecs to decode ac3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ac3.available := ["ac3", "ac3_fixed"]
+```
+
+##### Preferred codec to decode acelp.kelvin
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.acelpkelvin := <value>
+```
+
+###### Available codecs to decode acelp.kelvin
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.acelpkelvin.available := ["acelp.kelvin"]
+```
+
+##### Preferred codec to decode adpcm_4xm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_4xm := <value>
+```
+
+###### Available codecs to decode adpcm_4xm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_4xm.available := ["adpcm_4xm"]
+```
+
+##### Preferred codec to decode adpcm_adx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_adx := <value>
+```
+
+###### Available codecs to decode adpcm_adx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_adx.available := ["adpcm_adx"]
+```
+
+##### Preferred codec to decode adpcm_afc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_afc := <value>
+```
+
+###### Available codecs to decode adpcm_afc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_afc.available := ["adpcm_afc"]
+```
+
+##### Preferred codec to decode adpcm_agm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_agm := <value>
+```
+
+###### Available codecs to decode adpcm_agm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_agm.available := ["adpcm_agm"]
+```
+
+##### Preferred codec to decode adpcm_dtk
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_dtk := <value>
+```
+
+###### Available codecs to decode adpcm_dtk
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_dtk.available := ["adpcm_dtk"]
+```
+
+##### Preferred codec to decode adpcm_ea_xas
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ea_xas := <value>
+```
+
+###### Available codecs to decode adpcm_ea_xas
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ea_xas.available := ["adpcm_ea_xas"]
+```
+
+##### Preferred codec to decode adpcm_g726le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_g726le := <value>
+```
+
+###### Available codecs to decode adpcm_g726le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_g726le.available := ["g726le"]
+```
+
+##### Preferred codec to decode adpcm_ima_ea_eacs
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_ea_eacs := <value>
+```
+
+###### Available codecs to decode adpcm_ima_ea_eacs
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_ea_eacs.available := ["adpcm_ima_ea_eacs"]
+```
+
+##### Preferred codec to decode adpcm_ima_ea_sead
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_ea_sead := <value>
+```
+
+###### Available codecs to decode adpcm_ima_ea_sead
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_ea_sead.available := ["adpcm_ima_ea_sead"]
+```
+
+##### Preferred codec to decode adpcm_ima_qt
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_qt := <value>
+```
+
+###### Available codecs to decode adpcm_ima_qt
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_qt.available := ["adpcm_ima_qt"]
+```
+
+##### Preferred codec to decode adpcm_ima_smjpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_smjpeg := <value>
+```
+
+###### Available codecs to decode adpcm_ima_smjpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_smjpeg.available := ["adpcm_ima_smjpeg"]
+```
+
+##### Preferred codec to decode adpcm_ima_ws
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_ws := <value>
+```
+
+###### Available codecs to decode adpcm_ima_ws
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_ima_ws.available := ["adpcm_ima_ws"]
+```
+
+##### Preferred codec to decode adpcm_psx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_psx := <value>
+```
+
+###### Available codecs to decode adpcm_psx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_psx.available := ["adpcm_psx"]
+```
+
+##### Preferred codec to decode adpcm_swf
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_swf := <value>
+```
+
+###### Available codecs to decode adpcm_swf
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_swf.available := ["adpcm_swf"]
+```
+
+##### Preferred codec to decode adpcm_thp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_thp := <value>
+```
+
+###### Available codecs to decode adpcm_thp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_thp.available := ["adpcm_thp"]
+```
+
+##### Preferred codec to decode adpcm_thp_le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_thp_le := <value>
+```
+
+###### Available codecs to decode adpcm_thp_le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_thp_le.available := ["adpcm_thp_le"]
+```
+
+##### Preferred codec to decode adpcm_xmd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_xmd := <value>
+```
+
+###### Available codecs to decode adpcm_xmd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_xmd.available := ["adpcm_xmd"]
+```
+
+##### Preferred codec to decode adpcm_yamaha
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_yamaha := <value>
+```
+
+###### Available codecs to decode adpcm_yamaha
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.adpcm_yamaha.available := ["adpcm_yamaha"]
+```
+
+##### Preferred codec to decode agm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.agm := <value>
+```
+
+###### Available codecs to decode agm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.agm.available := ["agm"]
+```
+
+##### Preferred codec to decode aic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aic := <value>
+```
+
+###### Available codecs to decode aic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aic.available := ["aic"]
+```
+
+##### Preferred codec to decode alac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.alac := <value>
+```
+
+###### Available codecs to decode alac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.alac.available := ["alac"]
+```
+
+##### Preferred codec to decode amr_nb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.amr_nb := <value>
+```
+
+###### Available codecs to decode amr_nb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.amr_nb.available := ["libopencore_amrnb"]
+```
+
+##### Preferred codec to decode amr_wb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.amr_wb := <value>
+```
+
+###### Available codecs to decode amr_wb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.amr_wb.available := ["amrwb", "libopencore_amrwb"]
+```
+
+##### Preferred codec to decode amv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.amv := <value>
+```
+
+###### Available codecs to decode amv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.amv.available := ["amv"]
+```
+
+##### Preferred codec to decode anm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.anm := <value>
+```
+
+###### Available codecs to decode anm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.anm.available := ["anm"]
+```
+
+##### Preferred codec to decode ansi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ansi := <value>
+```
+
+###### Available codecs to decode ansi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ansi.available := ["ansi"]
+```
+
+##### Preferred codec to decode apac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.apac := <value>
+```
+
+###### Available codecs to decode apac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.apac.available := ["apac"]
+```
+
+##### Preferred codec to decode ape
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ape := <value>
+```
+
+###### Available codecs to decode ape
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ape.available := ["ape"]
+```
+
+##### Preferred codec to decode apng
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.apng := <value>
+```
+
+###### Available codecs to decode apng
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.apng.available := ["apng"]
+```
+
+##### Preferred codec to decode aptx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aptx := <value>
+```
+
+###### Available codecs to decode aptx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aptx.available := ["aptx"]
+```
+
+##### Preferred codec to decode arbc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.arbc := <value>
+```
+
+###### Available codecs to decode arbc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.arbc.available := ["arbc"]
+```
+
+##### Preferred codec to decode argo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.argo := <value>
+```
+
+###### Available codecs to decode argo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.argo.available := ["argo"]
+```
+
+##### Preferred codec to decode asv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.asv1 := <value>
+```
+
+###### Available codecs to decode asv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.asv1.available := ["asv1"]
+```
+
+##### Preferred codec to decode asv2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.asv2 := <value>
+```
+
+###### Available codecs to decode asv2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.asv2.available := ["asv2"]
+```
+
+##### Preferred codec to decode atrac1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac1 := <value>
+```
+
+###### Available codecs to decode atrac1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac1.available := ["atrac1"]
+```
+
+##### Preferred codec to decode atrac3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac3 := <value>
+```
+
+###### Available codecs to decode atrac3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac3.available := ["atrac3"]
+```
+
+##### Preferred codec to decode atrac3al
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac3al := <value>
+```
+
+###### Available codecs to decode atrac3al
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac3al.available := ["atrac3al"]
+```
+
+##### Preferred codec to decode atrac9
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac9 := <value>
+```
+
+###### Available codecs to decode atrac9
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.atrac9.available := ["atrac9"]
+```
+
+##### Preferred codec to decode aura
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aura := <value>
+```
+
+###### Available codecs to decode aura
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aura.available := ["aura"]
+```
+
+##### Preferred codec to decode aura2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aura2 := <value>
+```
+
+###### Available codecs to decode aura2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.aura2.available := ["aura2"]
+```
+
+##### Preferred codec to decode av1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.av1 := <value>
+```
+
+###### Available codecs to decode av1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.av1.available := ["libdav1d", "libaom-av1", "av1", "av1_cuvid"]
+```
+
+##### Preferred codec to decode avc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avc := <value>
+```
+
+###### Available codecs to decode avc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avc.available := ["on2avc"]
+```
+
+##### Preferred codec to decode avrn
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avrn := <value>
+```
+
+###### Available codecs to decode avrn
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avrn.available := ["avrn"]
+```
+
+##### Preferred codec to decode avrp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avrp := <value>
+```
+
+###### Available codecs to decode avrp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avrp.available := ["avrp"]
+```
+
+##### Preferred codec to decode avs
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avs := <value>
+```
+
+###### Available codecs to decode avs
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avs.available := ["avs"]
+```
+
+##### Preferred codec to decode avs2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avs2 := <value>
+```
+
+###### Available codecs to decode avs2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avs2.available := ["libdavs2"]
+```
+
+##### Preferred codec to decode avui
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avui := <value>
+```
+
+###### Available codecs to decode avui
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.avui.available := ["avui"]
+```
+
+##### Preferred codec to decode ayuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ayuv := <value>
+```
+
+###### Available codecs to decode ayuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ayuv.available := ["ayuv"]
+```
+
+##### Preferred codec to decode bethsoftvid
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bethsoftvid := <value>
+```
+
+###### Available codecs to decode bethsoftvid
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bethsoftvid.available := ["bethsoftvid"]
+```
+
+##### Preferred codec to decode bfi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bfi := <value>
+```
+
+###### Available codecs to decode bfi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bfi.available := ["bfi"]
+```
+
+##### Preferred codec to decode binkaudio_dct
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.binkaudio_dct := <value>
+```
+
+###### Available codecs to decode binkaudio_dct
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.binkaudio_dct.available := ["binkaudio_dct"]
+```
+
+##### Preferred codec to decode binkvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.binkvideo := <value>
+```
+
+###### Available codecs to decode binkvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.binkvideo.available := ["binkvideo"]
+```
+
+##### Preferred codec to decode bitpacked
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bitpacked := <value>
+```
+
+###### Available codecs to decode bitpacked
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bitpacked.available := ["bitpacked"]
+```
+
+##### Preferred codec to decode bmp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bmp := <value>
+```
+
+###### Available codecs to decode bmp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bmp.available := ["bmp"]
+```
+
+##### Preferred codec to decode bmv_audio
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bmv_audio := <value>
+```
+
+###### Available codecs to decode bmv_audio
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bmv_audio.available := ["bmv_audio"]
+```
+
+##### Preferred codec to decode bmv_video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bmv_video := <value>
+```
+
+###### Available codecs to decode bmv_video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bmv_video.available := ["bmv_video"]
+```
+
+##### Preferred codec to decode bonk
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bonk := <value>
+```
+
+###### Available codecs to decode bonk
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.bonk.available := ["bonk"]
+```
+
+##### Preferred codec to decode brender_pix
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.brender_pix := <value>
+```
+
+###### Available codecs to decode brender_pix
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.brender_pix.available := ["brender_pix"]
+```
+
+##### Preferred codec to decode c93
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.c93 := <value>
+```
+
+###### Available codecs to decode c93
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.c93.available := ["c93"]
+```
+
+##### Preferred codec to decode cavs
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cavs := <value>
+```
+
+###### Available codecs to decode cavs
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cavs.available := ["cavs"]
+```
+
+##### Preferred codec to decode cdxl
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cdxl := <value>
+```
+
+###### Available codecs to decode cdxl
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cdxl.available := ["cdxl"]
+```
+
+##### Preferred codec to decode cfhd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cfhd := <value>
+```
+
+###### Available codecs to decode cfhd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cfhd.available := ["cfhd"]
+```
+
+##### Preferred codec to decode cljr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cljr := <value>
+```
+
+###### Available codecs to decode cljr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cljr.available := ["cljr"]
+```
+
+##### Preferred codec to decode cllc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cllc := <value>
+```
+
+###### Available codecs to decode cllc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cllc.available := ["cllc"]
+```
+
+##### Preferred codec to decode cmv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cmv := <value>
+```
+
+###### Available codecs to decode cmv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cmv.available := ["eacmv"]
+```
+
+##### Preferred codec to decode comfortnoise
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.comfortnoise := <value>
+```
+
+###### Available codecs to decode comfortnoise
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.comfortnoise.available := ["comfortnoise"]
+```
+
+##### Preferred codec to decode cook
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cook := <value>
+```
+
+###### Available codecs to decode cook
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cook.available := ["cook"]
+```
+
+##### Preferred codec to decode cpia
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cpia := <value>
+```
+
+###### Available codecs to decode cpia
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cpia.available := ["cpia"]
+```
+
+##### Preferred codec to decode cri
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cri := <value>
+```
+
+###### Available codecs to decode cri
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cri.available := ["cri"]
+```
+
+##### Preferred codec to decode cscd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cscd := <value>
+```
+
+###### Available codecs to decode cscd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cscd.available := ["camstudio"]
+```
+
+##### Preferred codec to decode cyuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cyuv := <value>
+```
+
+###### Available codecs to decode cyuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.cyuv.available := ["cyuv"]
+```
+
+##### Preferred codec to decode dds
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dds := <value>
+```
+
+###### Available codecs to decode dds
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dds.available := ["dds"]
+```
+
+##### Preferred codec to decode dfa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dfa := <value>
+```
+
+###### Available codecs to decode dfa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dfa.available := ["dfa"]
+```
+
+##### Preferred codec to decode dpx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dpx := <value>
+```
+
+###### Available codecs to decode dpx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dpx.available := ["dpx"]
+```
+
+##### Preferred codec to decode dsd_lsbf_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dsd_lsbf_planar := <value>
+```
+
+###### Available codecs to decode dsd_lsbf_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dsd_lsbf_planar.available := ["dsd_lsbf_planar"]
+```
+
+##### Preferred codec to decode dsd_msbf_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dsd_msbf_planar := <value>
+```
+
+###### Available codecs to decode dsd_msbf_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dsd_msbf_planar.available := ["dsd_msbf_planar"]
+```
+
+##### Preferred codec to decode dsicinvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dsicinvideo := <value>
+```
+
+###### Available codecs to decode dsicinvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dsicinvideo.available := ["dsicinvideo"]
+```
+
+##### Preferred codec to decode dss_sp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dss_sp := <value>
+```
+
+###### Available codecs to decode dss_sp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dss_sp.available := ["dss_sp"]
+```
+
+##### Preferred codec to decode dst
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dst := <value>
+```
+
+###### Available codecs to decode dst
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dst.available := ["dst"]
+```
+
+##### Preferred codec to decode dts
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dts := <value>
+```
+
+###### Available codecs to decode dts
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dts.available := ["dca"]
+```
+
+##### Preferred codec to decode dxa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dxa := <value>
+```
+
+###### Available codecs to decode dxa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dxa.available := ["dxa"]
+```
+
+##### Preferred codec to decode dxtory
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dxtory := <value>
+```
+
+###### Available codecs to decode dxtory
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dxtory.available := ["dxtory"]
+```
+
+##### Preferred codec to decode dxv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dxv := <value>
+```
+
+###### Available codecs to decode dxv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.dxv.available := ["dxv"]
+```
+
+##### Preferred codec to decode eac3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.eac3 := <value>
+```
+
+###### Available codecs to decode eac3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.eac3.available := ["eac3"]
+```
+
+##### Preferred codec to decode escape124
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.escape124 := <value>
+```
+
+###### Available codecs to decode escape124
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.escape124.available := ["escape124"]
+```
+
+##### Preferred codec to decode escape130
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.escape130 := <value>
+```
+
+###### Available codecs to decode escape130
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.escape130.available := ["escape130"]
+```
+
+##### Preferred codec to decode evrc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.evrc := <value>
+```
+
+###### Available codecs to decode evrc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.evrc.available := ["evrc"]
+```
+
+##### Preferred codec to decode exr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.exr := <value>
+```
+
+###### Available codecs to decode exr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.exr.available := ["exr"]
+```
+
+##### Preferred codec to decode fastaudio
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fastaudio := <value>
+```
+
+###### Available codecs to decode fastaudio
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fastaudio.available := ["fastaudio"]
+```
+
+##### Preferred codec to decode ffv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ffv1 := <value>
+```
+
+###### Available codecs to decode ffv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ffv1.available := ["ffv1"]
+```
+
+##### Preferred codec to decode fic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fic := <value>
+```
+
+###### Available codecs to decode fic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fic.available := ["fic"]
+```
+
+##### Preferred codec to decode fits
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fits := <value>
+```
+
+###### Available codecs to decode fits
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fits.available := ["fits"]
+```
+
+##### Preferred codec to decode flac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flac := <value>
+```
+
+###### Available codecs to decode flac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flac.available := ["flac"]
+```
+
+##### Preferred codec to decode flashsv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flashsv := <value>
+```
+
+###### Available codecs to decode flashsv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flashsv.available := ["flashsv"]
+```
+
+##### Preferred codec to decode flic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flic := <value>
+```
+
+###### Available codecs to decode flic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flic.available := ["flic"]
+```
+
+##### Preferred codec to decode flv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flv1 := <value>
+```
+
+###### Available codecs to decode flv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.flv1.available := ["flv"]
+```
+
+##### Preferred codec to decode fmvc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fmvc := <value>
+```
+
+###### Available codecs to decode fmvc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fmvc.available := ["fmvc"]
+```
+
+##### Preferred codec to decode fraps
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fraps := <value>
+```
+
+###### Available codecs to decode fraps
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.fraps.available := ["fraps"]
+```
+
+##### Preferred codec to decode frwu
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.frwu := <value>
+```
+
+###### Available codecs to decode frwu
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.frwu.available := ["frwu"]
+```
+
+##### Preferred codec to decode ftr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ftr := <value>
+```
+
+###### Available codecs to decode ftr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ftr.available := ["ftr"]
+```
+
+##### Preferred codec to decode g2m
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.g2m := <value>
+```
+
+###### Available codecs to decode g2m
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.g2m.available := ["g2m"]
+```
+
+##### Preferred codec to decode g723_1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.g723_1 := <value>
+```
+
+###### Available codecs to decode g723_1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.g723_1.available := ["g723_1"]
+```
+
+##### Preferred codec to decode g729
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.g729 := <value>
+```
+
+###### Available codecs to decode g729
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.g729.available := ["g729"]
+```
+
+##### Preferred codec to decode gdv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gdv := <value>
+```
+
+###### Available codecs to decode gdv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gdv.available := ["gdv"]
+```
+
+##### Preferred codec to decode gem
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gem := <value>
+```
+
+###### Available codecs to decode gem
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gem.available := ["gem"]
+```
+
+##### Preferred codec to decode gif
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gif := <value>
+```
+
+###### Available codecs to decode gif
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gif.available := ["gif"]
+```
+
+##### Preferred codec to decode gsm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gsm := <value>
+```
+
+###### Available codecs to decode gsm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.gsm.available := ["gsm", "libgsm"]
+```
+
+##### Preferred codec to decode h261
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h261 := <value>
+```
+
+###### Available codecs to decode h261
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h261.available := ["h261"]
+```
+
+##### Preferred codec to decode h263
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h263 := <value>
+```
+
+###### Available codecs to decode h263
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h263.available := ["h263", "h263_v4l2m2m"]
+```
+
+##### Preferred codec to decode h263i
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h263i := <value>
+```
+
+###### Available codecs to decode h263i
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h263i.available := ["h263i"]
+```
+
+##### Preferred codec to decode h263p
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h263p := <value>
+```
+
+###### Available codecs to decode h263p
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h263p.available := ["h263p"]
+```
+
+##### Preferred codec to decode h264
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h264 := <value>
+```
+
+###### Available codecs to decode h264
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.h264.available := ["h264", "h264_v4l2m2m", "libopenh264", "h264_cuvid"]
+```
+
+##### Preferred codec to decode hap
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hap := <value>
+```
+
+###### Available codecs to decode hap
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hap.available := ["hap"]
+```
+
+##### Preferred codec to decode hca
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hca := <value>
+```
+
+###### Available codecs to decode hca
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hca.available := ["hca"]
+```
+
+##### Preferred codec to decode hcom
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hcom := <value>
+```
+
+###### Available codecs to decode hcom
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hcom.available := ["hcom"]
+```
+
+##### Preferred codec to decode hdr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hdr := <value>
+```
+
+###### Available codecs to decode hdr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hdr.available := ["hdr"]
+```
+
+##### Preferred codec to decode hevc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hevc := <value>
+```
+
+###### Available codecs to decode hevc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hevc.available := ["hevc", "hevc_v4l2m2m", "hevc_cuvid"]
+```
+
+##### Preferred codec to decode hnm4video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hnm4video := <value>
+```
+
+###### Available codecs to decode hnm4video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hnm4video.available := ["hnm4video"]
+```
+
+##### Preferred codec to decode hq_hqa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hq_hqa := <value>
+```
+
+###### Available codecs to decode hq_hqa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hq_hqa.available := ["hq_hqa"]
+```
+
+##### Preferred codec to decode hqx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hqx := <value>
+```
+
+###### Available codecs to decode hqx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hqx.available := ["hqx"]
+```
+
+##### Preferred codec to decode hymt
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hymt := <value>
+```
+
+###### Available codecs to decode hymt
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.hymt.available := ["hymt"]
+```
+
+##### Preferred codec to decode iac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.iac := <value>
+```
+
+###### Available codecs to decode iac
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.iac.available := ["iac"]
+```
+
+##### Preferred codec to decode iff_ilbm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.iff_ilbm := <value>
+```
+
+###### Available codecs to decode iff_ilbm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.iff_ilbm.available := ["iff"]
+```
+
+##### Preferred codec to decode ilbc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ilbc := <value>
+```
+
+###### Available codecs to decode ilbc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ilbc.available := ["ilbc", "libilbc"]
+```
+
+##### Preferred codec to decode imc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.imc := <value>
+```
+
+###### Available codecs to decode imc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.imc.available := ["imc"]
+```
+
+##### Preferred codec to decode imm4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.imm4 := <value>
+```
+
+###### Available codecs to decode imm4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.imm4.available := ["imm4"]
+```
+
+##### Preferred codec to decode imm5
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.imm5 := <value>
+```
+
+###### Available codecs to decode imm5
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.imm5.available := ["imm5"]
+```
+
+##### Preferred codec to decode interplayacm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.interplayacm := <value>
+```
+
+###### Available codecs to decode interplayacm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.interplayacm.available := ["interplayacm"]
+```
+
+##### Preferred codec to decode interplayvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.interplayvideo := <value>
+```
+
+###### Available codecs to decode interplayvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.interplayvideo.available := ["interplayvideo"]
+```
+
+##### Preferred codec to decode ipu
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ipu := <value>
+```
+
+###### Available codecs to decode ipu
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ipu.available := ["ipu"]
+```
+
+##### Preferred codec to decode jpeg2000
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.jpeg2000 := <value>
+```
+
+###### Available codecs to decode jpeg2000
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.jpeg2000.available := ["jpeg2000"]
+```
+
+##### Preferred codec to decode jv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.jv := <value>
+```
+
+###### Available codecs to decode jv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.jv.available := ["jv"]
+```
+
+##### Preferred codec to decode kgv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.kgv1 := <value>
+```
+
+###### Available codecs to decode kgv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.kgv1.available := ["kgv1"]
+```
+
+##### Preferred codec to decode kmvc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.kmvc := <value>
+```
+
+###### Available codecs to decode kmvc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.kmvc.available := ["kmvc"]
+```
+
+##### Preferred codec to decode lagarith
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.lagarith := <value>
+```
+
+###### Available codecs to decode lagarith
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.lagarith.available := ["lagarith"]
+```
+
+##### Preferred codec to decode loco
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.loco := <value>
+```
+
+###### Available codecs to decode loco
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.loco.available := ["loco"]
+```
+
+##### Preferred codec to decode lscr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.lscr := <value>
+```
+
+###### Available codecs to decode lscr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.lscr.available := ["lscr"]
+```
+
+##### Preferred codec to decode m101
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.m101 := <value>
+```
+
+###### Available codecs to decode m101
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.m101.available := ["m101"]
+```
+
+##### Preferred codec to decode mace3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mace3 := <value>
+```
+
+###### Available codecs to decode mace3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mace3.available := ["mace3"]
+```
+
+##### Preferred codec to decode mace6
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mace6 := <value>
+```
+
+###### Available codecs to decode mace6
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mace6.available := ["mace6"]
+```
+
+##### Preferred codec to decode mad
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mad := <value>
+```
+
+###### Available codecs to decode mad
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mad.available := ["eamad"]
+```
+
+##### Preferred codec to decode mdec
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mdec := <value>
+```
+
+###### Available codecs to decode mdec
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mdec.available := ["mdec"]
+```
+
+##### Preferred codec to decode metasound
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.metasound := <value>
+```
+
+###### Available codecs to decode metasound
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.metasound.available := ["metasound"]
+```
+
+##### Preferred codec to decode mimic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mimic := <value>
+```
+
+###### Available codecs to decode mimic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mimic.available := ["mimic"]
+```
+
+##### Preferred codec to decode misc4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.misc4 := <value>
+```
+
+###### Available codecs to decode misc4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.misc4.available := ["misc4"]
+```
+
+##### Preferred codec to decode mjpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mjpeg := <value>
+```
+
+###### Available codecs to decode mjpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mjpeg.available := ["mjpeg", "mjpeg_cuvid"]
+```
+
+##### Preferred codec to decode mjpegb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mjpegb := <value>
+```
+
+###### Available codecs to decode mjpegb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mjpegb.available := ["mjpegb"]
+```
+
+##### Preferred codec to decode mlp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mlp := <value>
+```
+
+###### Available codecs to decode mlp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mlp.available := ["mlp"]
+```
+
+##### Preferred codec to decode mobiclip
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mobiclip := <value>
+```
+
+###### Available codecs to decode mobiclip
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mobiclip.available := ["mobiclip"]
+```
+
+##### Preferred codec to decode motionpixels
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.motionpixels := <value>
+```
+
+###### Available codecs to decode motionpixels
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.motionpixels.available := ["motionpixels"]
+```
+
+##### Preferred codec to decode mp1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mp1 := <value>
+```
+
+###### Available codecs to decode mp1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mp1.available := ["mp1", "mp1float"]
+```
+
+##### Preferred codec to decode mp2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mp2 := <value>
+```
+
+###### Available codecs to decode mp2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mp2.available := ["mp2", "mp2float"]
+```
+
+##### Preferred codec to decode mp3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mp3 := <value>
+```
+
+###### Available codecs to decode mp3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mp3.available := ["mp3float", "mp3"]
+```
+
+##### Preferred codec to decode mpeg1video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mpeg1video := <value>
+```
+
+###### Available codecs to decode mpeg1video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mpeg1video.available := ["mpeg1video", "mpeg1_v4l2m2m", "mpeg1_cuvid"]
+```
+
+##### Preferred codec to decode mpeg2video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mpeg2video := <value>
+```
+
+###### Available codecs to decode mpeg2video
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mpeg2video.available := ["mpeg2video", "mpegvideo", "mpeg2_v4l2m2m", "mpeg2_cuvid"]
+```
+
+##### Preferred codec to decode mpeg4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mpeg4 := <value>
+```
+
+###### Available codecs to decode mpeg4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mpeg4.available := ["mpeg4", "mpeg4_v4l2m2m", "mpeg4_cuvid"]
+```
+
+##### Preferred codec to decode msa1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msa1 := <value>
+```
+
+###### Available codecs to decode msa1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msa1.available := ["msa1"]
+```
+
+##### Preferred codec to decode mscc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mscc := <value>
+```
+
+###### Available codecs to decode mscc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mscc.available := ["mscc"]
+```
+
+##### Preferred codec to decode msmpeg4v1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msmpeg4v1 := <value>
+```
+
+###### Available codecs to decode msmpeg4v1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msmpeg4v1.available := ["msmpeg4v1"]
+```
+
+##### Preferred codec to decode msmpeg4v2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msmpeg4v2 := <value>
+```
+
+###### Available codecs to decode msmpeg4v2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msmpeg4v2.available := ["msmpeg4v2"]
+```
+
+##### Preferred codec to decode msmpeg4v3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msmpeg4v3 := <value>
+```
+
+###### Available codecs to decode msmpeg4v3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msmpeg4v3.available := ["msmpeg4"]
+```
+
+##### Preferred codec to decode msp2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msp2 := <value>
+```
+
+###### Available codecs to decode msp2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msp2.available := ["msp2"]
+```
+
+##### Preferred codec to decode msrle
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msrle := <value>
+```
+
+###### Available codecs to decode msrle
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.msrle.available := ["msrle"]
+```
+
+##### Preferred codec to decode mss1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mss1 := <value>
+```
+
+###### Available codecs to decode mss1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mss1.available := ["mss1"]
+```
+
+##### Preferred codec to decode mss2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mss2 := <value>
+```
+
+###### Available codecs to decode mss2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mss2.available := ["mss2"]
+```
+
+##### Preferred codec to decode mszh
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mszh := <value>
+```
+
+###### Available codecs to decode mszh
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mszh.available := ["mszh"]
+```
+
+##### Preferred codec to decode mts2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mts2 := <value>
+```
+
+###### Available codecs to decode mts2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mts2.available := ["mts2"]
+```
+
+##### Preferred codec to decode mv30
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mv30 := <value>
+```
+
+###### Available codecs to decode mv30
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mv30.available := ["mv30"]
+```
+
+##### Preferred codec to decode mvc1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvc1 := <value>
+```
+
+###### Available codecs to decode mvc1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvc1.available := ["mvc1"]
+```
+
+##### Preferred codec to decode mvc2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvc2 := <value>
+```
+
+###### Available codecs to decode mvc2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvc2.available := ["mvc2"]
+```
+
+##### Preferred codec to decode mvdv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvdv := <value>
+```
+
+###### Available codecs to decode mvdv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvdv.available := ["mvdv"]
+```
+
+##### Preferred codec to decode mvha
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvha := <value>
+```
+
+###### Available codecs to decode mvha
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mvha.available := ["mvha"]
+```
+
+##### Preferred codec to decode mwsc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mwsc := <value>
+```
+
+###### Available codecs to decode mwsc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mwsc.available := ["mwsc"]
+```
+
+##### Preferred codec to decode mxpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mxpeg := <value>
+```
+
+###### Available codecs to decode mxpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.mxpeg.available := ["mxpeg"]
+```
+
+##### Preferred codec to decode notchlc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.notchlc := <value>
+```
+
+###### Available codecs to decode notchlc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.notchlc.available := ["notchlc"]
+```
+
+##### Preferred codec to decode nuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.nuv := <value>
+```
+
+###### Available codecs to decode nuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.nuv.available := ["nuv"]
+```
+
+##### Preferred codec to decode opus
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.opus := <value>
+```
+
+###### Available codecs to decode opus
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.opus.available := ["opus", "libopus"]
+```
+
+##### Preferred codec to decode osq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.osq := <value>
+```
+
+###### Available codecs to decode osq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.osq.available := ["osq"]
+```
+
+##### Preferred codec to decode pam
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pam := <value>
+```
+
+###### Available codecs to decode pam
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pam.available := ["pam"]
+```
+
+##### Preferred codec to decode pbm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pbm := <value>
+```
+
+###### Available codecs to decode pbm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pbm.available := ["pbm"]
+```
+
+##### Preferred codec to decode pcm_bluray
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_bluray := <value>
+```
+
+###### Available codecs to decode pcm_bluray
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_bluray.available := ["pcm_bluray"]
+```
+
+##### Preferred codec to decode pcm_dvd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_dvd := <value>
+```
+
+###### Available codecs to decode pcm_dvd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_dvd.available := ["pcm_dvd"]
+```
+
+##### Preferred codec to decode pcm_f16le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f16le := <value>
+```
+
+###### Available codecs to decode pcm_f16le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f16le.available := ["pcm_f16le"]
+```
+
+##### Preferred codec to decode pcm_f24le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f24le := <value>
+```
+
+###### Available codecs to decode pcm_f24le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f24le.available := ["pcm_f24le"]
+```
+
+##### Preferred codec to decode pcm_f32be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f32be := <value>
+```
+
+###### Available codecs to decode pcm_f32be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f32be.available := ["pcm_f32be"]
+```
+
+##### Preferred codec to decode pcm_f32le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f32le := <value>
+```
+
+###### Available codecs to decode pcm_f32le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f32le.available := ["pcm_f32le"]
+```
+
+##### Preferred codec to decode pcm_f64be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f64be := <value>
+```
+
+###### Available codecs to decode pcm_f64be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f64be.available := ["pcm_f64be"]
+```
+
+##### Preferred codec to decode pcm_f64le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f64le := <value>
+```
+
+###### Available codecs to decode pcm_f64le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_f64le.available := ["pcm_f64le"]
+```
+
+##### Preferred codec to decode pcm_lxf
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_lxf := <value>
+```
+
+###### Available codecs to decode pcm_lxf
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_lxf.available := ["pcm_lxf"]
+```
+
+##### Preferred codec to decode pcm_s16be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s16be := <value>
+```
+
+###### Available codecs to decode pcm_s16be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s16be.available := ["pcm_s16be"]
+```
+
+##### Preferred codec to decode pcm_s16le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s16le := <value>
+```
+
+###### Available codecs to decode pcm_s16le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s16le.available := ["pcm_s16le"]
+```
+
+##### Preferred codec to decode pcm_s16le_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s16le_planar := <value>
+```
+
+###### Available codecs to decode pcm_s16le_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s16le_planar.available := ["pcm_s16le_planar"]
+```
+
+##### Preferred codec to decode pcm_s24be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24be := <value>
+```
+
+###### Available codecs to decode pcm_s24be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24be.available := ["pcm_s24be"]
+```
+
+##### Preferred codec to decode pcm_s24daud
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24daud := <value>
+```
+
+###### Available codecs to decode pcm_s24daud
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24daud.available := ["pcm_s24daud"]
+```
+
+##### Preferred codec to decode pcm_s24le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24le := <value>
+```
+
+###### Available codecs to decode pcm_s24le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24le.available := ["pcm_s24le"]
+```
+
+##### Preferred codec to decode pcm_s24le_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24le_planar := <value>
+```
+
+###### Available codecs to decode pcm_s24le_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s24le_planar.available := ["pcm_s24le_planar"]
+```
+
+##### Preferred codec to decode pcm_s32be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s32be := <value>
+```
+
+###### Available codecs to decode pcm_s32be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s32be.available := ["pcm_s32be"]
+```
+
+##### Preferred codec to decode pcm_s32le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s32le := <value>
+```
+
+###### Available codecs to decode pcm_s32le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s32le.available := ["pcm_s32le"]
+```
+
+##### Preferred codec to decode pcm_s32le_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s32le_planar := <value>
+```
+
+###### Available codecs to decode pcm_s32le_planar
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s32le_planar.available := ["pcm_s32le_planar"]
+```
+
+##### Preferred codec to decode pcm_s64be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s64be := <value>
+```
+
+###### Available codecs to decode pcm_s64be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s64be.available := ["pcm_s64be"]
+```
+
+##### Preferred codec to decode pcm_s64le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s64le := <value>
+```
+
+###### Available codecs to decode pcm_s64le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_s64le.available := ["pcm_s64le"]
+```
+
+##### Preferred codec to decode pcm_sga
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_sga := <value>
+```
+
+###### Available codecs to decode pcm_sga
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_sga.available := ["pcm_sga"]
+```
+
+##### Preferred codec to decode pcm_u16be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u16be := <value>
+```
+
+###### Available codecs to decode pcm_u16be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u16be.available := ["pcm_u16be"]
+```
+
+##### Preferred codec to decode pcm_u16le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u16le := <value>
+```
+
+###### Available codecs to decode pcm_u16le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u16le.available := ["pcm_u16le"]
+```
+
+##### Preferred codec to decode pcm_u24be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u24be := <value>
+```
+
+###### Available codecs to decode pcm_u24be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u24be.available := ["pcm_u24be"]
+```
+
+##### Preferred codec to decode pcm_u24le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u24le := <value>
+```
+
+###### Available codecs to decode pcm_u24le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u24le.available := ["pcm_u24le"]
+```
+
+##### Preferred codec to decode pcm_u32be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u32be := <value>
+```
+
+###### Available codecs to decode pcm_u32be
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u32be.available := ["pcm_u32be"]
+```
+
+##### Preferred codec to decode pcm_u32le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u32le := <value>
+```
+
+###### Available codecs to decode pcm_u32le
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_u32le.available := ["pcm_u32le"]
+```
+
+##### Preferred codec to decode pcm_vidc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_vidc := <value>
+```
+
+###### Available codecs to decode pcm_vidc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcm_vidc.available := ["pcm_vidc"]
+```
+
+##### Preferred codec to decode pcx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcx := <value>
+```
+
+###### Available codecs to decode pcx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pcx.available := ["pcx"]
+```
+
+##### Preferred codec to decode pdv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pdv := <value>
+```
+
+###### Available codecs to decode pdv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pdv.available := ["pdv"]
+```
+
+##### Preferred codec to decode pfm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pfm := <value>
+```
+
+###### Available codecs to decode pfm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pfm.available := ["pfm"]
+```
+
+##### Preferred codec to decode pgm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pgm := <value>
+```
+
+###### Available codecs to decode pgm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pgm.available := ["pgm"]
+```
+
+##### Preferred codec to decode pgmyuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pgmyuv := <value>
+```
+
+###### Available codecs to decode pgmyuv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pgmyuv.available := ["pgmyuv"]
+```
+
+##### Preferred codec to decode pgx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pgx := <value>
+```
+
+###### Available codecs to decode pgx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pgx.available := ["pgx"]
+```
+
+##### Preferred codec to decode phm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.phm := <value>
+```
+
+###### Available codecs to decode phm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.phm.available := ["phm"]
+```
+
+##### Preferred codec to decode pictor
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pictor := <value>
+```
+
+###### Available codecs to decode pictor
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.pictor.available := ["pictor"]
+```
+
+##### Preferred codec to decode png
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.png := <value>
+```
+
+###### Available codecs to decode png
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.png.available := ["png"]
+```
+
+##### Preferred codec to decode ppm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ppm := <value>
+```
+
+###### Available codecs to decode ppm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ppm.available := ["ppm"]
+```
+
+##### Preferred codec to decode psd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.psd := <value>
+```
+
+###### Available codecs to decode psd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.psd.available := ["psd"]
+```
+
+##### Preferred codec to decode ptx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ptx := <value>
+```
+
+###### Available codecs to decode ptx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ptx.available := ["ptx"]
+```
+
+##### Preferred codec to decode qdm2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qdm2 := <value>
+```
+
+###### Available codecs to decode qdm2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qdm2.available := ["qdm2"]
+```
+
+##### Preferred codec to decode qdmc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qdmc := <value>
+```
+
+###### Available codecs to decode qdmc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qdmc.available := ["qdmc"]
+```
+
+##### Preferred codec to decode qoi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qoi := <value>
+```
+
+###### Available codecs to decode qoi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qoi.available := ["qoi"]
+```
+
+##### Preferred codec to decode qpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qpeg := <value>
+```
+
+###### Available codecs to decode qpeg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.qpeg.available := ["qpeg"]
+```
+
+##### Preferred codec to decode r10k
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.r10k := <value>
+```
+
+###### Available codecs to decode r10k
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.r10k.available := ["r10k"]
+```
+
+##### Preferred codec to decode r210
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.r210 := <value>
+```
+
+###### Available codecs to decode r210
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.r210.available := ["r210"]
+```
+
+##### Preferred codec to decode ralf
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ralf := <value>
+```
+
+###### Available codecs to decode ralf
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ralf.available := ["ralf"]
+```
+
+##### Preferred codec to decode rasc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rasc := <value>
+```
+
+###### Available codecs to decode rasc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rasc.available := ["rasc"]
+```
+
+##### Preferred codec to decode rka
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rka := <value>
+```
+
+###### Available codecs to decode rka
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rka.available := ["rka"]
+```
+
+##### Preferred codec to decode rl2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rl2 := <value>
+```
+
+###### Available codecs to decode rl2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rl2.available := ["rl2"]
+```
+
+##### Preferred codec to decode roq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.roq := <value>
+```
+
+###### Available codecs to decode roq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.roq.available := ["roqvideo"]
+```
+
+##### Preferred codec to decode rpza
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rpza := <value>
+```
+
+###### Available codecs to decode rpza
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rpza.available := ["rpza"]
+```
+
+##### Preferred codec to decode rscc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rscc := <value>
+```
+
+###### Available codecs to decode rscc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rscc.available := ["rscc"]
+```
+
+##### Preferred codec to decode rtv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rtv1 := <value>
+```
+
+###### Available codecs to decode rtv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rtv1.available := ["rtv1"]
+```
+
+##### Preferred codec to decode rv10
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv10 := <value>
+```
+
+###### Available codecs to decode rv10
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv10.available := ["rv10"]
+```
+
+##### Preferred codec to decode rv20
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv20 := <value>
+```
+
+###### Available codecs to decode rv20
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv20.available := ["rv20"]
+```
+
+##### Preferred codec to decode rv30
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv30 := <value>
+```
+
+###### Available codecs to decode rv30
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv30.available := ["rv30"]
+```
+
+##### Preferred codec to decode rv40
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv40 := <value>
+```
+
+###### Available codecs to decode rv40
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.rv40.available := ["rv40"]
+```
+
+##### Preferred codec to decode sanm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sanm := <value>
+```
+
+###### Available codecs to decode sanm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sanm.available := ["sanm"]
+```
+
+##### Preferred codec to decode sbc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sbc := <value>
+```
+
+###### Available codecs to decode sbc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sbc.available := ["sbc"]
+```
+
+##### Preferred codec to decode scpr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.scpr := <value>
+```
+
+###### Available codecs to decode scpr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.scpr.available := ["scpr"]
+```
+
+##### Preferred codec to decode screenpresso
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.screenpresso := <value>
+```
+
+###### Available codecs to decode screenpresso
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.screenpresso.available := ["screenpresso"]
+```
+
+##### Preferred codec to decode sdx2_dpcm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sdx2_dpcm := <value>
+```
+
+###### Available codecs to decode sdx2_dpcm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sdx2_dpcm.available := ["sdx2_dpcm"]
+```
+
+##### Preferred codec to decode sgi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sgi := <value>
+```
+
+###### Available codecs to decode sgi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sgi.available := ["sgi"]
+```
+
+##### Preferred codec to decode simbiosis_imx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.simbiosis_imx := <value>
+```
+
+###### Available codecs to decode simbiosis_imx
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.simbiosis_imx.available := ["simbiosis_imx"]
+```
+
+##### Preferred codec to decode sipr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sipr := <value>
+```
+
+###### Available codecs to decode sipr
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sipr.available := ["sipr"]
+```
+
+##### Preferred codec to decode siren
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.siren := <value>
+```
+
+###### Available codecs to decode siren
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.siren.available := ["siren"]
+```
+
+##### Preferred codec to decode smc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.smc := <value>
+```
+
+###### Available codecs to decode smc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.smc.available := ["smc"]
+```
+
+##### Preferred codec to decode snow
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.snow := <value>
+```
+
+###### Available codecs to decode snow
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.snow.available := ["snow"]
+```
+
+##### Preferred codec to decode sol_dpcm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sol_dpcm := <value>
+```
+
+###### Available codecs to decode sol_dpcm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sol_dpcm.available := ["sol_dpcm"]
+```
+
+##### Preferred codec to decode sonic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sonic := <value>
+```
+
+###### Available codecs to decode sonic
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sonic.available := ["sonic"]
+```
+
+##### Preferred codec to decode sp5x
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sp5x := <value>
+```
+
+###### Available codecs to decode sp5x
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.sp5x.available := ["sp5x"]
+```
+
+##### Preferred codec to decode speedhq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.speedhq := <value>
+```
+
+###### Available codecs to decode speedhq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.speedhq.available := ["speedhq"]
+```
+
+##### Preferred codec to decode speex
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.speex := <value>
+```
+
+###### Available codecs to decode speex
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.speex.available := ["speex", "libspeex"]
+```
+
+##### Preferred codec to decode srgc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.srgc := <value>
+```
+
+###### Available codecs to decode srgc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.srgc.available := ["srgc"]
+```
+
+##### Preferred codec to decode svg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.svg := <value>
+```
+
+###### Available codecs to decode svg
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.svg.available := ["librsvg"]
+```
+
+##### Preferred codec to decode svq1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.svq1 := <value>
+```
+
+###### Available codecs to decode svq1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.svq1.available := ["svq1"]
+```
+
+##### Preferred codec to decode svq3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.svq3 := <value>
+```
+
+###### Available codecs to decode svq3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.svq3.available := ["svq3"]
+```
+
+##### Preferred codec to decode tak
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tak := <value>
+```
+
+###### Available codecs to decode tak
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tak.available := ["tak"]
+```
+
+##### Preferred codec to decode targa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.targa := <value>
+```
+
+###### Available codecs to decode targa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.targa.available := ["targa"]
+```
+
+##### Preferred codec to decode targa_y216
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.targa_y216 := <value>
+```
+
+###### Available codecs to decode targa_y216
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.targa_y216.available := ["targa_y216"]
+```
+
+##### Preferred codec to decode tdsc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tdsc := <value>
+```
+
+###### Available codecs to decode tdsc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tdsc.available := ["tdsc"]
+```
+
+##### Preferred codec to decode tgq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tgq := <value>
+```
+
+###### Available codecs to decode tgq
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tgq.available := ["eatgq"]
+```
+
+##### Preferred codec to decode tgv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tgv := <value>
+```
+
+###### Available codecs to decode tgv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tgv.available := ["eatgv"]
+```
+
+##### Preferred codec to decode theora
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.theora := <value>
+```
+
+###### Available codecs to decode theora
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.theora.available := ["theora"]
+```
+
+##### Preferred codec to decode thp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.thp := <value>
+```
+
+###### Available codecs to decode thp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.thp.available := ["thp"]
+```
+
+##### Preferred codec to decode tiertexseqvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tiertexseqvideo := <value>
+```
+
+###### Available codecs to decode tiertexseqvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tiertexseqvideo.available := ["tiertexseqvideo"]
+```
+
+##### Preferred codec to decode tiff
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tiff := <value>
+```
+
+###### Available codecs to decode tiff
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tiff.available := ["tiff"]
+```
+
+##### Preferred codec to decode tmv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tmv := <value>
+```
+
+###### Available codecs to decode tmv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tmv.available := ["tmv"]
+```
+
+##### Preferred codec to decode tqi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tqi := <value>
+```
+
+###### Available codecs to decode tqi
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tqi.available := ["eatqi"]
+```
+
+##### Preferred codec to decode truehd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truehd := <value>
+```
+
+###### Available codecs to decode truehd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truehd.available := ["truehd"]
+```
+
+##### Preferred codec to decode truemotion1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truemotion1 := <value>
+```
+
+###### Available codecs to decode truemotion1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truemotion1.available := ["truemotion1"]
+```
+
+##### Preferred codec to decode truemotion2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truemotion2 := <value>
+```
+
+###### Available codecs to decode truemotion2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truemotion2.available := ["truemotion2"]
+```
+
+##### Preferred codec to decode truemotion2rt
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truemotion2rt := <value>
+```
+
+###### Available codecs to decode truemotion2rt
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.truemotion2rt.available := ["truemotion2rt"]
+```
+
+##### Preferred codec to decode tscc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tscc := <value>
+```
+
+###### Available codecs to decode tscc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tscc.available := ["camtasia"]
+```
+
+##### Preferred codec to decode tscc2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tscc2 := <value>
+```
+
+###### Available codecs to decode tscc2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tscc2.available := ["tscc2"]
+```
+
+##### Preferred codec to decode tta
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tta := <value>
+```
+
+###### Available codecs to decode tta
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.tta.available := ["tta"]
+```
+
+##### Preferred codec to decode txd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.txd := <value>
+```
+
+###### Available codecs to decode txd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.txd.available := ["txd"]
+```
+
+##### Preferred codec to decode ulti
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ulti := <value>
+```
+
+###### Available codecs to decode ulti
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ulti.available := ["ultimotion"]
+```
+
+##### Preferred codec to decode v210
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v210 := <value>
+```
+
+###### Available codecs to decode v210
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v210.available := ["v210"]
+```
+
+##### Preferred codec to decode v210x
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v210x := <value>
+```
+
+###### Available codecs to decode v210x
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v210x.available := ["v210x"]
+```
+
+##### Preferred codec to decode v308
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v308 := <value>
+```
+
+###### Available codecs to decode v308
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v308.available := ["v308"]
+```
+
+##### Preferred codec to decode v408
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v408 := <value>
+```
+
+###### Available codecs to decode v408
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v408.available := ["v408"]
+```
+
+##### Preferred codec to decode v410
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v410 := <value>
+```
+
+###### Available codecs to decode v410
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.v410.available := ["v410"]
+```
+
+##### Preferred codec to decode vb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vb := <value>
+```
+
+###### Available codecs to decode vb
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vb.available := ["vb"]
+```
+
+##### Preferred codec to decode vble
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vble := <value>
+```
+
+###### Available codecs to decode vble
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vble.available := ["vble"]
+```
+
+##### Preferred codec to decode vbn
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vbn := <value>
+```
+
+###### Available codecs to decode vbn
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vbn.available := ["vbn"]
+```
+
+##### Preferred codec to decode vc1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vc1 := <value>
+```
+
+###### Available codecs to decode vc1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vc1.available := ["vc1", "vc1_v4l2m2m", "vc1_cuvid"]
+```
+
+##### Preferred codec to decode vc1image
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vc1image := <value>
+```
+
+###### Available codecs to decode vc1image
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vc1image.available := ["vc1image"]
+```
+
+##### Preferred codec to decode vcr1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vcr1 := <value>
+```
+
+###### Available codecs to decode vcr1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vcr1.available := ["vcr1"]
+```
+
+##### Preferred codec to decode vixl
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vixl := <value>
+```
+
+###### Available codecs to decode vixl
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vixl.available := ["xl"]
+```
+
+##### Preferred codec to decode vmdaudio
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmdaudio := <value>
+```
+
+###### Available codecs to decode vmdaudio
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmdaudio.available := ["vmdaudio"]
+```
+
+##### Preferred codec to decode vmdvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmdvideo := <value>
+```
+
+###### Available codecs to decode vmdvideo
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmdvideo.available := ["vmdvideo"]
+```
+
+##### Preferred codec to decode vmix
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmix := <value>
+```
+
+###### Available codecs to decode vmix
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmix.available := ["vmix"]
+```
+
+##### Preferred codec to decode vmnc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmnc := <value>
+```
+
+###### Available codecs to decode vmnc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vmnc.available := ["vmnc"]
+```
+
+##### Preferred codec to decode vorbis
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vorbis := <value>
+```
+
+###### Available codecs to decode vorbis
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vorbis.available := ["vorbis", "libvorbis"]
+```
+
+##### Preferred codec to decode vp3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp3 := <value>
+```
+
+###### Available codecs to decode vp3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp3.available := ["vp3"]
+```
+
+##### Preferred codec to decode vp4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp4 := <value>
+```
+
+###### Available codecs to decode vp4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp4.available := ["vp4"]
+```
+
+##### Preferred codec to decode vp5
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp5 := <value>
+```
+
+###### Available codecs to decode vp5
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp5.available := ["vp5"]
+```
+
+##### Preferred codec to decode vp6
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp6 := <value>
+```
+
+###### Available codecs to decode vp6
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp6.available := ["vp6"]
+```
+
+##### Preferred codec to decode vp6a
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp6a := <value>
+```
+
+###### Available codecs to decode vp6a
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp6a.available := ["vp6a"]
+```
+
+##### Preferred codec to decode vp6f
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp6f := <value>
+```
+
+###### Available codecs to decode vp6f
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp6f.available := ["vp6f"]
+```
+
+##### Preferred codec to decode vp7
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp7 := <value>
+```
+
+###### Available codecs to decode vp7
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp7.available := ["vp7"]
+```
+
+##### Preferred codec to decode vp8
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp8 := <value>
+```
+
+###### Available codecs to decode vp8
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp8.available := ["vp8", "vp8_v4l2m2m", "libvpx", "vp8_cuvid"]
+```
+
+##### Preferred codec to decode vp9
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp9 := <value>
+```
+
+###### Available codecs to decode vp9
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vp9.available := ["vp9", "vp9_v4l2m2m", "libvpx-vp9", "vp9_cuvid"]
+```
+
+##### Preferred codec to decode vqc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vqc := <value>
+```
+
+###### Available codecs to decode vqc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.vqc.available := ["vqc"]
+```
+
+##### Preferred codec to decode wavesynth
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wavesynth := <value>
+```
+
+###### Available codecs to decode wavesynth
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wavesynth.available := ["wavesynth"]
+```
+
+##### Preferred codec to decode wavpack
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wavpack := <value>
+```
+
+###### Available codecs to decode wavpack
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wavpack.available := ["wavpack"]
+```
+
+##### Preferred codec to decode wbmp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wbmp := <value>
+```
+
+###### Available codecs to decode wbmp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wbmp.available := ["wbmp"]
+```
+
+##### Preferred codec to decode wcmv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wcmv := <value>
+```
+
+###### Available codecs to decode wcmv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wcmv.available := ["wcmv"]
+```
+
+##### Preferred codec to decode webp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.webp := <value>
+```
+
+###### Available codecs to decode webp
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.webp.available := ["webp"]
+```
+
+##### Preferred codec to decode westwood_snd1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.westwood_snd1 := <value>
+```
+
+###### Available codecs to decode westwood_snd1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.westwood_snd1.available := ["ws_snd1"]
+```
+
+##### Preferred codec to decode wmalossless
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmalossless := <value>
+```
+
+###### Available codecs to decode wmalossless
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmalossless.available := ["wmalossless"]
+```
+
+##### Preferred codec to decode wmavoice
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmavoice := <value>
+```
+
+###### Available codecs to decode wmavoice
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmavoice.available := ["wmavoice"]
+```
+
+##### Preferred codec to decode wmv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmv1 := <value>
+```
+
+###### Available codecs to decode wmv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmv1.available := ["wmv1"]
+```
+
+##### Preferred codec to decode wmv2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmv2 := <value>
+```
+
+###### Available codecs to decode wmv2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmv2.available := ["wmv2"]
+```
+
+##### Preferred codec to decode wmv3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmv3 := <value>
+```
+
+###### Available codecs to decode wmv3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wmv3.available := ["wmv3"]
+```
+
+##### Preferred codec to decode wnv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wnv1 := <value>
+```
+
+###### Available codecs to decode wnv1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.wnv1.available := ["wnv1"]
+```
+
+##### Preferred codec to decode ws_vqa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ws_vqa := <value>
+```
+
+###### Available codecs to decode ws_vqa
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ws_vqa.available := ["vqavideo"]
+```
+
+##### Preferred codec to decode xan_wc3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xan_wc3 := <value>
+```
+
+###### Available codecs to decode xan_wc3
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xan_wc3.available := ["xan_wc3"]
+```
+
+##### Preferred codec to decode xan_wc4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xan_wc4 := <value>
+```
+
+###### Available codecs to decode xan_wc4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xan_wc4.available := ["xan_wc4"]
+```
+
+##### Preferred codec to decode xbm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xbm := <value>
+```
+
+###### Available codecs to decode xbm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xbm.available := ["xbm"]
+```
+
+##### Preferred codec to decode xma1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xma1 := <value>
+```
+
+###### Available codecs to decode xma1
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xma1.available := ["xma1"]
+```
+
+##### Preferred codec to decode xma2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xma2 := <value>
+```
+
+###### Available codecs to decode xma2
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xma2.available := ["xma2"]
+```
+
+##### Preferred codec to decode xpm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xpm := <value>
+```
+
+###### Available codecs to decode xpm
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xpm.available := ["xpm"]
+```
+
+##### Preferred codec to decode xwd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xwd := <value>
+```
+
+###### Available codecs to decode xwd
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.xwd.available := ["xwd"]
+```
+
+##### Preferred codec to decode y41p
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.y41p := <value>
+```
+
+###### Available codecs to decode y41p
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.y41p.available := ["y41p"]
+```
+
+##### Preferred codec to decode ylc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ylc := <value>
+```
+
+###### Available codecs to decode ylc
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.ylc.available := ["ylc"]
+```
+
+##### Preferred codec to decode yop
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.yop := <value>
+```
+
+###### Available codecs to decode yop
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.yop.available := ["yop"]
+```
+
+##### Preferred codec to decode yuv4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.yuv4 := <value>
+```
+
+###### Available codecs to decode yuv4
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.yuv4.available := ["yuv4"]
+```
+
+##### Preferred codec to decode zlib
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.zlib := <value>
+```
+
+###### Available codecs to decode zlib
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.zlib.available := ["zlib"]
+```
+
+##### Preferred codec to decode zmbv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.zmbv := <value>
+```
+
+###### Available codecs to decode zmbv
+
+```liquidsoap
+settings.decoder.ffmpeg.codecs.zmbv.available := ["zmbv"]
+```
+
+#### Maximum delay between interleaved streams.
+
+```liquidsoap
+settings.decoder.ffmpeg.max_interleave_delta := 0.04
+```
+
+#### Maximum data buffered while waiting for all streams.
+
+```liquidsoap
+settings.decoder.ffmpeg.max_interleave_duration := 5.
+```
+
+### File extensions used for guessing audio formats
+
+#### File extensions used for guessing AAC format
+
+```liquidsoap
+settings.decoder.file_extensions.aac := ["aac"]
+```
+
+#### File extensions used for guessing AIFF format
+
+```liquidsoap
+settings.decoder.file_extensions.aiff := ["aiff", "aif", "aifc"]
+```
+
+#### File extensions used for decoding media files (except images) with ffmpeg
+
+```liquidsoap
+settings.decoder.file_extensions.ffmpeg := ["264", "265", "302", "3g2", "3gp", "669", "722", "A64", "a64", "aa", "aa3", "aac", "aax", "ac3", "acm", "adf", "adp", "ads", "adts", "adx", "aea", "afc", "aif", "aifc", "aiff", "aix", "amf", "amr", "ams", "amv", "ape", "apl", "apm", "apng", "aptx", "aptxhd", "aqt", "asf", "ass", "ast", "au", "aud", "avi", "avr", "avs", "avs2", "bcstm", "bfstm", "binka", "bit", "bmv", "brstm", "c2", "calf", "cavs", "cdata", "cdg", "cdxl", "cgi", "chk", "cif", "cpk", "cvg", "dat", "daud", "dav", "dbm", "dif", "digi", "dmf", "dnxhd", "dnxhr", "drc", "dsm", "dss", "dtk", "dtm", "dts", "dtshd", "dv", "dvd", "eac3", "f4v", "fap", "far", "ffmeta", "fits", "flac", "flm", "flv", "fsb", "fwse", "g722", "g723_1", "g729", "gdm", "genh", "gif", "gsm", "gxf", "h261", "h263", "h264", "h265", "hca", "hevc", "ice", "ico", "idf", "idx", "ifv", "imf", "imx", "ipu", "ircam", "ism", "isma", "ismv", "it", "ivf", "ivr", "j2b", "jss", "kux", "latm", "lbc", "loas", "lrc", "lvf", "m15", "m1v", "m2a", "m2t", "m2ts", "m2v", "m3u8", "m4a", "m4b", "m4v", "mac", "mca", "mcc", "mdl", "med", "mj2", "mjpeg", "mjpg", "mk3d", "mka", "mks", "mkv", "mlp", "mmcmp", "mmf", "mms", "mo3", "mod", "mods", "moflex", "mov", "mp2", "mp3", "mp4", "mpa", "mpc", "mpd", "mpeg", "mpg", "mpl2", "mptm", "msbc", "msf", "mt2", "mtaf", "mtm", "mts", "musx", "mvi", "mxf", "mxg", "nist", "nsp", "nst", "nut", "obu", "oga", "ogg", "ogv", "okt", "oma", "omg", "opus", "paf", "pcm", "pjs", "plm", "psm", "psp", "pt36", "ptm", "pvf", "qcif", "ra", "rco", "rcv", "rgb", "rm", "roq", "rsd", "rso", "rt", "s3m", "sami", "sbc", "sbg", "scc", "sdr2", "sds", "sdx", "ser", "sf", "sfx", "sfx2", "sga", "shn", "sln", "smi", "son", "sox", "spdif", "sph", "spx", "srt", "ss2", "ssa", "st26", "stk", "stl", "stm", "stp", "str", "sub", "sup", "svag", "svs", "swf", "tak", "tco", "thd", "ts", "tta", "ttml", "tun", "txt", "ty", "ty+", "ult", "umx", "v", "v210", "vag", "vb", "vc1", "vc2", "viv", "vob", "voc", "vpk", "vqe", "vqf", "vql", "vtt", "w64", "wav", "webm", "wma", "wmv", "wow", "wsd", "wtv", "wv", "xl", "xm", "xml", "xmv", "xpk", "xvag", "y4m", "yop", "yuv"]
+```
+
+##### File extensions used for decoding images with ffmpeg
+
+```liquidsoap
+settings.decoder.file_extensions.ffmpeg.images := ["bmp", "cri", "dds", "dng", "dpx", "exr", "im1", "im24", "im32", "im8", "j2c", "j2k", "jls", "jp2", "jpc", "jpeg", "jpg", "jps", "ljpg", "mng", "mpg1-img", "mpg2-img", "mpg4-img", "mpo", "pam", "pbm", "pcd", "pct", "pcx", "pfm", "pgm", "pgmyuv", "pic", "pict", "pix", "png", "pnm", "pns", "ppm", "ptx", "ras", "raw", "rs", "sgi", "sun", "sunras", "svg", "svgz", "tga", "tif", "tiff", "webp", "xbm", "xface", "xpm", "xwd", "y", "yuv10"]
+```
+
+#### File extensions used for guessing FLAC format
+
+```liquidsoap
+settings.decoder.file_extensions.flac := ["flac"]
+```
+
+#### File extensions used for decoding metadata using native FLAC parser.
+
+```liquidsoap
+settings.decoder.file_extensions.flac_metadata := ["flac"]
+```
+
+#### File extensions used for decoding metadata using native ID3v1 and ID3v2 parser
+
+```liquidsoap
+settings.decoder.file_extensions.id3 := ["mp3", "wav"]
+```
+
+#### File extensions used for decoding metadata using native parser.
+
+```liquidsoap
+settings.decoder.file_extensions.image_metadata := ["png", "jpg", "jpeg"]
+```
+
+#### File extensions used for guessing mpeg audio format
+
+```liquidsoap
+settings.decoder.file_extensions.mad := ["mp3", "mp2", "mp1"]
+```
+
+#### File extensions used for guessing MP3 format (DEPRECATED, use *.mad configuration keys!)
+
+```liquidsoap
+settings.decoder.file_extensions.mp3 := ["mp3", "mp2", "mp1"]
+```
+
+#### File extensions used for guessing MP4 format
+
+```liquidsoap
+settings.decoder.file_extensions.mp4 := ["m4a", "m4b", "m4p", "m4v", "m4r", "3gp", "mp4"]
+```
+
+#### File extensions used for guessing OGG format
+
+```liquidsoap
+settings.decoder.file_extensions.ogg := ["ogv", "oga", "ogx", "ogg", "opus"]
+```
+
+#### File extensions used for decoding metadata using native ogg parser.
+
+```liquidsoap
+settings.decoder.file_extensions.ogg_metadata := ["ogg"]
+```
+
+#### File extensions used for guessing SRT format
+
+```liquidsoap
+settings.decoder.file_extensions.srt := ["srt"]
+```
+
+#### File extensions used for decoding metadata using TAGLIB
+
+```liquidsoap
+settings.decoder.file_extensions.taglib := ["mp3", "ogg", "mkv", "wav", "flac", "mp4", "m4a"]
+```
+
+#### File extensions used for decoding metadata using native parser.
+
+```liquidsoap
+settings.decoder.file_extensions.video_metadata := ["avi", "mp4"]
+```
+
+#### File extensions used for guessing WAV format
+
+```liquidsoap
+settings.decoder.file_extensions.wav := ["wav", "wave"]
+```
+
+### Native FLAC metadata parser settings.
+
+### Native ID3 parser settings
+
+### Decoders and order used to decode image files.
+
+```liquidsoap
+settings.decoder.image_file_decoders := ["ppm", "ffmpeg", "sdl"]
+```
+
+### Native image metadata parser settings.
+
+### Mime-types used for choosing audio and video file decoders
+
+When a mime-type is available (e.g. with input.http), it can be used to guess which audio stream format is used.This section contains the listings used for that detection, which you might want to tweak if you encounter a new mime-type.If you feel that new mime-types should be permanently added, please contact the developers.
+
+#### Mime-types used for guessing AAC format
+
+```liquidsoap
+settings.decoder.mime_types.aac := ["audio/aac", "audio/aacp", "audio/x-hx-aac-adts"]
+```
+
+#### Mime-types used for guessing AIFF format
+
+```liquidsoap
+settings.decoder.mime_types.aiff := ["audio/x-aiff", "audio/aiff"]
+```
+
+#### Mime-types used for guessing PCM/BASIC format
+
+```liquidsoap
+settings.decoder.mime_types.basic := ["audio/basic"]
+```
+
+#### Mime-types used for decoding with ffmpeg
+
+```liquidsoap
+settings.decoder.mime_types.ffmpeg := ["application/f4v", "application/ffmpeg", "application/mp4", "application/mxf", "application/octet-stream", "application/octet-stream", "application/ogg", "application/vnd.pg.format", "application/vnd.rn-realmedia", "application/vnd.smaf", "application/x-mpegURL", "application/x-ogg", "application/x-pgs", "application/x-shockwave-flash", "application/x-subrip", "application/xml", "audio/G722", "audio/MP4A-LATM", "audio/MPA", "audio/aac", "audio/aacp", "audio/aiff", "audio/amr", "audio/basic", "audio/bit", "audio/flac", "audio/g723", "audio/iLBC", "audio/mp4", "audio/mpeg", "audio/ogg", "audio/vnd.wave", "audio/wav", "audio/wave", "audio/webm", "audio/x-ac3", "audio/x-adpcm", "audio/x-caf", "audio/x-dca", "audio/x-eac3", "audio/x-flac", "audio/x-gsm", "audio/x-hx-aac-adts", "audio/x-ogg", "audio/x-oma", "audio/x-tta", "audio/x-voc", "audio/x-wav", "audio/x-wavpack", "multipart/x-mixed-replace;boundary=ffserver", "text/vtt", "text/x-ass", "text/x-jacosub", "text/x-microdvd", "video/3gpp", "video/3gpp2", "video/MP2T", "video/mp2t", "video/mp4", "video/mpeg", "video/ogg", "video/webm", "video/x-flv", "video/x-h261", "video/x-h263", "video/x-m4v", "video/x-matroska", "video/x-mjpeg", "video/x-ms-asf", "video/x-msvideo", "video/x-nut"]
+```
+
+##### Mime-types used for decoding images with ffmpeg
+
+```liquidsoap
+settings.decoder.mime_types.ffmpeg.images := ["image/gif", "image/jpeg", "image/png", "image/vnd.microsoft.icon", "image/webp"]
+```
+
+#### Mime-types used for guessing FLAC format
+
+```liquidsoap
+settings.decoder.mime_types.flac := ["audio/flac", "audio/x-flac"]
+```
+
+#### Mime-types used for decoding metadata using native FLAC metadata parser.
+
+```liquidsoap
+settings.decoder.mime_types.flac_metadata := ["audio/flac"]
+```
+
+#### Mime-types used for decoding metadata using native ID3v1 and ID3v2 parser
+
+```liquidsoap
+settings.decoder.mime_types.id3 := ["audio/mpeg", "audio/x-wav"]
+```
+
+#### Mime-types used for decoding metadata using native parser.
+
+```liquidsoap
+settings.decoder.mime_types.image_metadata := ["image/png", "image/jpeg"]
+```
+
+#### Mime-types used for guessing mpeg audio format
+
+```liquidsoap
+settings.decoder.mime_types.mad := ["audio/mpeg", "audio/MPA"]
+```
+
+#### Mime-types used for guessing MP3 format (DEPRECATED, use *.mad configuration keys!)
+
+```liquidsoap
+settings.decoder.mime_types.mp3 := ["audio/mpeg", "audio/MPA"]
+```
+
+#### Mime-types used for guessing MP4 format
+
+```liquidsoap
+settings.decoder.mime_types.mp4 := ["audio/mp4", "application/mp4"]
+```
+
+#### Mime-types used for guessing OGG format.
+
+```liquidsoap
+settings.decoder.mime_types.ogg := ["audio/opus", "application/ogg", "application/x-ogg", "audio/x-ogg", "audio/ogg", "video/ogg"]
+```
+
+#### Mime-types used for decoding metadata using native ogg metadata parser.
+
+```liquidsoap
+settings.decoder.mime_types.ogg_metadata := ["audio/ogg"]
+```
+
+#### Mime-types used for guessing SRT format
+
+```liquidsoap
+settings.decoder.mime_types.srt := ["application/x-subrip"]
+```
+
+#### Mime-types used for decoding metadata using TAGLIB
+
+```liquidsoap
+settings.decoder.mime_types.taglib := ["audio/mpeg", "audio/ogg", "video/ogg", "audio/wav", "audio/wave", "audio/flac", "audio/mp4", "video/mp4"]
+```
+
+#### Mime-types used for decoding metadata using native parser.
+
+```liquidsoap
+settings.decoder.mime_types.video_metadata := ["video/x-msvideo", "video/mp4"]
+```
+
+#### Mime-types used for guessing WAV format
+
+```liquidsoap
+settings.decoder.mime_types.wav := ["audio/vnd.wave", "audio/wav", "audio/wave", "audio/x-wav"]
+```
+
+### Native ogg metadata parser settings.
+
+### Priorities used for choosing audio and video file decoders
+
+#### Priority for the AAC decoder
+
+```liquidsoap
+settings.decoder.priorities.aac := 1
+```
+
+#### Priority for the AIFF decoder
+
+```liquidsoap
+settings.decoder.priorities.aiff := 1
+```
+
+#### Priority for the PCM/BASIC decoder
+
+```liquidsoap
+settings.decoder.priorities.basic := 1
+```
+
+#### Priority for the ffmpeg decoder
+
+```liquidsoap
+settings.decoder.priorities.ffmpeg := 10
+```
+
+#### Priority for the flac decoder
+
+```liquidsoap
+settings.decoder.priorities.flac := 1
+```
+
+#### Priority for the mpeg audio decoder
+
+```liquidsoap
+settings.decoder.priorities.mad := 1
+```
+
+#### Priority for the MP4 decoder
+
+```liquidsoap
+settings.decoder.priorities.mp4 := 1
+```
+
+#### Priority for the OGG decoder
+
+```liquidsoap
+settings.decoder.priorities.ogg := 15
+```
+
+#### Priority for the SRT decoder
+
+```liquidsoap
+settings.decoder.priorities.srt := 1
+```
+
+#### Priority for the WAV decoder
+
+```liquidsoap
+settings.decoder.priorities.wav := 1
+```
+
+### Taglib settings
+
+### Native video metadata parser settings.
+
+### External decoders settings
+
+#### Settings for the FFprobe external decoder
+
+##### Path to ffprobe binary
+
+```liquidsoap
+settings.decoder.external.ffprobe.path := "ffprobe"
+```
+
+#### Settings for the FFmpeg external decoder
+
+##### Path to ffmpeg binary
+
+```liquidsoap
+settings.decoder.external.ffmpeg.path := "ffmpeg"
+```
+
+##### Mime types supported by the external ffmpeg stream decoder
+
+```liquidsoap
+settings.decoder.external.ffmpeg.mime_types := []
+```
+
+#### Settings for the mpcdec external decoder
+
+##### Path to mpcdec binary
+
+```liquidsoap
+settings.decoder.external.mpcdec.path := "mpcdec"
+```
+
+#### Settings for the flac external decoder
+
+##### Path to flac binary
+
+```liquidsoap
+settings.decoder.external.flac.path := "flac"
+```
+
+#### Settings for the metaflac external decoder
+
+##### Path to metaflac binary
+
+```liquidsoap
+settings.decoder.external.metaflac.path := "metaflac"
+```
+
+#### Settings for the faad external decoder
+
+##### Path to faad binary
+
+```liquidsoap
+settings.decoder.external.faad.path := "faad"
+```
diff --git a/website/content/doc-2.2.5/shoutcast.md b/website/content/doc-2.2.5/shoutcast.md
new file mode 100644
index 00000000..7d18c678
--- /dev/null
+++ b/website/content/doc-2.2.5/shoutcast.md
@@ -0,0 +1,39 @@
+# Streaming to Shoutcast
+
+Although Liquidsoap is primarily aimed at streaming to Icecast servers (that provide
+much more features than Shoutcast), it is also able to stream to Shoutcast.
+
+## Shoutcast output
+
+Shoutcast server accept streams encoded with the MP3 or AAC/AAC+ codec. You to compile Liquidsoap with
+`lame` support, so it can encode in MP3. Liquidsoap also has support for AAC+ encoding
+using FDK-AAC or using an [external encoder](external_encoders.html). The recommended format is MP3.
+
+Shoutcast output are done using the `output.shoutcast` operator with the appropriate parameters.
+An example is:
+
+```liquidsoap
+source = single("audiofile.ogg")
+
+output.shoutcast(%mp3, host="shoutcast.example.org",
+                     port=8000, password="changeme",
+                     source)
+```
+
+As usual, `liquidsoap -h output.shoutcast` gives you the full list of options for this operator.
+
+## Shoutcast as relay
+
+A side note for those of you who feel they ``need'' to use Shoutcast for non-technical reasons (such as their stream
+directory service...): you can still benefit from Icecast's power by streaming to an Icecast server, and then relaying
+it through a shoutcast server.
+
+In order to do that, you have to alias the root mountpoint ("`/`") to your MP3 mountpoint in your icecast server
+configuration, like this:
+
+```
+<alias source="/" dest="/mystream.mp3" />
+```
+
+Be careful that icecast often aliases the status page (`/status.xsl`) with the `/`. In this case, comment
+out the status page alias before inserting yours.
diff --git a/website/content/doc-2.2.5/sources.md b/website/content/doc-2.2.5/sources.md
new file mode 100644
index 00000000..01f92114
--- /dev/null
+++ b/website/content/doc-2.2.5/sources.md
@@ -0,0 +1,138 @@
+# Sources
+
+Using liquidsoap is about writing a script describing how to build what you
+want. It is about building a stream using elementary streams and stream
+combinators, etc. Actually, it's a bit more than streams, we call them
+_sources_.
+
+A source is a stream with metadata and track annotations. It is discretized as
+a stream of fixed-length buffers of media samples, the frames. Every frame may
+have metadata inserted at any point, independently of track boundaries. At
+every instant, a source can be asked to fill a frame of data.
+
+The liquidsoap API provides plenty of functions for building sources.
+Some of those functions build elementary sources from scratch, others are
+operators that combine sources into more complex ones. An important class of
+sources is that of _active sources_, they are the sources that actively
+trigger the computation of your stream. Typically, active sources are built
+from output functions, because outputting a stream is the only reason why you
+want to compute it.
+
+All sources, operators and outputs are listed in the
+[scripting API reference](reference.html).
+
+## How does it work?
+
+To clarify the picture let's study in more details an example:
+
+```liquidsoap
+radio =
+  output.icecast(
+    %vorbis,mount="test.ogg",
+    random(
+      [ jingle ,
+        fallback([ playlist1,playlist2,playlist3 ]) ]))
+```
+
+At every cycle of the [clock](clocks.html), the output asks the `random` node for data,
+until it gets a full frame of raw audio.
+Then, it encodes the frame and sends it to the Icecast server.
+Suppose `random` has chosen the `fallback` node,
+and that only `playlist2` is available, and thus played.
+At every cycle, the buffer is passed from `random` to
+`fallback` and then to `playlist2` which fills it,
+returns it to `fallback` which returns it to `random`
+which returns it to the output.
+
+At some point, `playlist2` ends a track.
+The fallback detects that on the returned buffer,
+and selects a new child for the next filling,
+depending on who's available.
+But it doesn't change the buffer, and returns it to `random`,
+which also (randomly) selects a new child at this point,
+before returning the buffer to the output.
+On next filling, the route of the frame can be different.
+
+Note that it is also possible to have the route changed inside a track,
+for example using the `track_sensitive` option of fallback,
+which is typically done for instant switches to live shows when they start.
+
+The important point here is that **all of the above steps are local**.
+Everything takes place between one operator and its immediate children source;
+operators do not see beyond that point.
+
+## Fallibility
+
+By default, liquidsoap outputs are meant to emit a stream without
+discontinuing. Since this stream is provided by the source passed to the
+output operator, it is the source responsibility to never fail.
+Liquidsoap has a mechanism to verify this, which helps you think of
+all possible failures, and prevent them.
+Elementary sources are either _fallible_ or _infallible_, and this
+_liveness type_ is propagated through operators to finally
+compute the type of any source.
+For example,
+a `fallback` or `random` source is infallible
+if an only if at least one of its children is infallible,
+and a `switch` is infallible if and only if it has one infallible
+child guarded by the trivial predicate `{ true }`.
+
+On startup, each output checks the liveness type of its input source,
+and issues an error if it is fallible. The typical fix for such problems
+is to add one fallback to play a default file (`single()`)
+or a checked playlist (`playlist.safe()`) if the normal source
+fails.
+One can also use the `mksafe` operator that will insert silence
+during failures.
+
+If you do not care about failures, you can pass the parameter
+`fallible=true` to most outputs. In that case, the output
+will accept a fallible source, and stop whenever the source fails,
+to restart when it is ready to emit a stream again.
+
+## Caching mode
+
+In some situations, a source must take care of the consistency of its
+output. If it is asked twice to fill buffers during the same cycle, it
+should fill them with the same data. Suppose for example that a playlist is
+used by two outputs, and that it gives the first frame to the first
+output, the second frame to the second output: it would give the third frame
+to the first output during the second cycle,
+and the output will have missed one frame.
+
+It is sometimes useful to keep this is mind to understand the behaviour
+of some complex scripts. The high-level picture is enough for users,
+more details follow for developers and curious readers.
+
+The sources detect if they need to remember (cache) their previous output in
+order to replay it. To do that, clients of the source must register in
+advance. If two clients have registered, then caching should be enabled.
+Actually that's a bit more complicated, because of transitions. Obviously the
+sources which use a transition involving some other source must register to
+it, because they may eventually use it. But a jingle used in two transitions
+by the same switching operator doesn't need caching. The solution involves two
+kinds of registering: _dynamic_ and _static activations_. Activations are
+associated with a path in the graph of sources' nesting. The dynamic
+activation is a pre-registration allowing a single real _static activation_
+to come later, possibly in the middle of a cycle.
+Two static activations trigger caching. The other reason for enabling caching
+is when there is one static activation and one dynamic activation which
+doesn't come from a prefix of the static activation's path. It means that the
+dynamic activation can yield at any moment to a static activation and that the
+source will be used by two sources at the same time.
+
+## Execution model
+
+In your script you define a bunch of sources interacting together. Each
+source belongs to a [clock](clocks.html), but clocks only have direct access
+to _active sources_, which are mostly outputs.
+At every cycle of the clock, active sources are animated: a chunk of stream
+(frame) is computed, and potentially outputted one way or another.
+
+This streaming task is the most important and shouldn't be disturbed.
+Thus, other tasks are done in auxiliary threads:
+file download, audio validity checking, http polling, playlist reloading...
+No blocking or expensive call should be done in streaming threads.
+Remote files are completely downloaded to a local temporary file
+before use by the root thread. It also means that you shouldn't access NFS
+or any kind of falsely local files.
diff --git a/website/content/doc-2.2.5/split-cue.md b/website/content/doc-2.2.5/split-cue.md
new file mode 100644
index 00000000..344d411a
--- /dev/null
+++ b/website/content/doc-2.2.5/split-cue.md
@@ -0,0 +1,32 @@
+# Split and re-encode a CUE sheet.
+
+CUE sheets are sometimes distributed along with a single audio file containing a whole CD.
+Liquidsoap can parse CUE sheets as playlists and use them in your request-based sources.
+
+Here's for instance an example of a simple code to split a CUE sheet into several mp3 files
+with `id3v2` tags:
+
+```liquidsoap
+ # Log to stdout
+ log.file.set(false)
+ log.stdout.set(true)
+ log.level.set(4)
+
+ # Initial playlist
+ cue = "/path/to/sheet.cue"
+
+ # Create a reloadable playlist with this CUE sheet.
+ # Tell liquidsoap to shutdown when we are done.
+ x = playlist.reloadable(cue, on_done=shutdown)
+
+ # We will never reload this playlist so we drop the first
+ # returned value:
+ s = snd(x)
+
+ # Shove all that to a output.file operator.
+ output.file(%mp3(id3v2=true,bitrate=320),
+             fallible=true,
+             reopen_on_metadata=true,
+             "/path/to/$(track) - $(title).mp3",
+             s)
+```
diff --git a/website/content/doc-2.2.5/stereotool.md b/website/content/doc-2.2.5/stereotool.md
new file mode 100644
index 00000000..3690b4c9
--- /dev/null
+++ b/website/content/doc-2.2.5/stereotool.md
@@ -0,0 +1,54 @@
+# Stereotool support
+
+Starting with version `2.2.0`, liquidsoap supports the shared library distributed by [Thimeo Audio Technology](https://www.thimeo.com/stereo-tool/)
+using the `stereotool` operator (and `track.audio.stereotool` for the low-level, track-specific equivalent).
+
+This feature is enabled in all release builds of liquidsoap starting with `rolling-release-v2.2.x` and should be enabled if you compile liquidsoap
+with the optional `ctypes-foreign` opam module installed.
+
+The operator can replace the use of the stereotool binary in your script and offers multiple benefits. In particular, it has a **very low latency**
+compared to using the binary and also operates synchronously.
+
+The operator should be quite easy to use. Here's an example:
+
+```liquidsoap
+# Define a source
+s = ...
+
+# Apply stereotool to it:
+s = stereotool(
+  library_file="/path/to/stereotool/shared/lib",
+  license_key="my_license_key",
+  preset="/path/to/preset/file",
+  s
+)
+```
+
+That's it! You can apply as many `stereotool` operators as you wish and at any stage in the script, thanks
+to its synchronous nature. However, a current limitation is that **the processed audio signal is slightly delayed**.
+
+This is because the operator has an internal processing buffer. We do plan on delaying metadata and track marks
+to match this latency but this has not yet been implemented and will probably have to wait for the `2.3.x` release cycle.
+
+This means that, until then, track switches and metadata updates might happen slightly earlier than the corresponding
+signal. We're talking about `50ms` to `100ms` earlier, though, so that might not be a super big deal.
+
+For the same reason, the source returned by `stereotool` is an _audio-only_ source. Otherwise, other concurrent tracks
+such as video and etc would be slightly out of sync. If you need to use the operator in this kind of situation, you
+might want to use a `ffmpeg` filter to e.g. adjust the video's PTS to match the audio delay.
+
+In such case, you can refer to the `latency` method that is available on the source returned by the operator which
+should indicate the delay to compensate from the processed audio signal.
+
+The operator's `preset` parameter has a companion `load_type` parameter that can optionally be used to only load a subset of
+the preset. You might refer to the upstream documentation if you need to use it.
+
+Lastly, `stereotool` is a **proprietary software**. While we actively promote open source, we also want to meet
+our users where they are and, for a lot of them, this means supporting the sound processing provided by the tool.
+
+However, to use it, you will need a license. Using the operator without the proper license will _not_ result in an
+error in your script but the audio signal might have spoken text and/or beeps added to it.
+
+Using the operator with an invalid license will be reported in the logs. You might also use the `valid_license`
+method available on the source returned by the operator, which returns `false` if the license is invalid. In this case, the `unlincensed_used_features`
+method returns a string indicating which unlicensed features are being used.
diff --git a/website/content/doc-2.2.5/stream_content.md b/website/content/doc-2.2.5/stream_content.md
new file mode 100644
index 00000000..33613115
--- /dev/null
+++ b/website/content/doc-2.2.5/stream_content.md
@@ -0,0 +1,208 @@
+# Stream contents
+
+In liquidsoap, a stream may contain any number of audio, video and
+event MIDI channels (though this has not been tested in a while!).
+As part of the type checking of your script,
+liquidsoap checks that you make a consistent use of stream contents,
+and also guesses what kind of stream your script is intended to
+work on. As with other inferred parameters, you do not necessarily
+need to read about stream contents typing if you're still learning
+the ropes of liquidsoap, but you might eventually need to know a
+little about it.
+
+In liquidsoap script language, there are three sorts of objects
+that rely on stream types: sources, requests and encoding formats.
+A [source](sources.html) produces a stream,
+and it is important what kind of stream
+it produces when composing it with other sources.
+A [request](requests.html) is an abstract notion of file,
+often meant to be decoded, and it is useful to know into what
+kind of stream it is meant to be decoded.
+Finally, a [format](encoding_formats.html) describes how a stream
+should be encoded (_e.g._, before output in a file or via icecast),
+and the stream content is also useful here for the format
+to make sense.
+
+In this page, we explain how liquidsoap uses stream types
+to guess and check what you're doing.
+
+## Content types
+
+Liquidsoap supports various type of content to be produced as the
+script runs.
+
+### Internal content
+
+_internal_ content generally refers to content that the liquidsoap application
+can produce and manipulate.
+
+For audio, the default internal content is `pcm` floats
+using OCaml native 64-bits float array representations. This is the format that allows the
+fastest manipulation.
+
+For video, the default is a C in-memory arrays of plannar YUV420 data.
+
+For users concerned with memory consumption, we also support two additional audio formats,
+`pcm_s16` and `pcm_f32` using, resp., signed 16-bit integers and 32-bit floating point numbers.
+These formats may increase CPU usage, however, as we do need to convert back and forth when
+using them in audio manipulation operators such as `amplify`, `crossfade` and etc. See [this
+link](memory.html#audio-data-format) for more details.
+
+### Opaque content
+
+Liquidsoap also supports content type that are opaque to the application, provided by the `ffmpeg` decoder. There
+are two:
+
+- FFmpeg raw frames, which are decoded plain FFmpeg frames
+- FFmpeg packets, also referred to as FFmpeg copy content. These are packets of encoded content
+
+These type of content are consumed by FFmpeg specific operators and it is possible to convert back and
+forth if you want to use them with our internal operators. However, their best use-case is to keep them as-is end-to-end
+to optimize for memory and/or CPU usage.
+
+See the [FFmpeg support](ffmpeg.html) doc for more information.
+
+## Global parameters
+
+You might have noticed that our description of internal stream contents is
+missing some information, such as sample rate, video size, etc.
+Indeed, that information is not part of the stream types, which is
+local to each source/request/format, but global in liquidsoap.
+You can change it using the `frame.audio/video.*`
+settings, shown here with their default values:
+
+```liquidsoap
+audio.samplerate := 44100
+video.frame.width := 320
+video.frame.height := 240
+video.frame.rate := 25
+```
+
+## Checking stream contents
+
+Checking the consistency of use of stream contents is done as part
+of type checking. There is not so much to say here, except that you
+have to read type errors. We present a few examples.
+
+For example, if you try to send an ALSA input to a SDL input using
+`output.sdl(input.alsa())`, you'll get the following:
+
+```
+At line 1, char 22-23:
+  this value has type
+    source(audio=pcm('a))
+  but it should be a subtype of
+    source(video=canvas)
+```
+
+It means that a source with a video channel was expected
+by the SDL output, but the ALSA output can only offer sources
+producing audio.
+
+## Conversions
+
+get a type error on seemingly meaningful code, and you'll wonder how
+to fix it. Often, it suffices to perform a few explicit conversions.
+
+Consider another example involving the SDL output, where we also try
+to use AO to output the audio content of a video:
+
+```liquidsoap
+s = single("file.mp4")
+
+# Output video here
+output.file(
+  %ffmpeg(%video(codec="libx264"),
+  "/path/to/video.flv",
+  s
+)
+
+# Output audio here
+output.file(
+  %ffmpeg(%audio(codec="aac"))
+  "/path/to/video.aac",
+  s
+)
+```
+
+This won't work because the first output expects a video-only
+stream while the second one expected an audio-only stream
+
+The solution is to split the stream in two, dropping the irrelevant content:
+
+```liquidsoap
+s = single("file.mp4")
+
+# Output video here
+output.file(
+  %ffmpeg(%video(codec="libx264"),
+  "/path/to/video.flv",
+  source.drop.audio(s)
+)
+
+# Output audio here
+output.file(
+  %ffmpeg(%audio(codec="aac"))
+  "/path/to/video.aac",
+  source.drop.video(s)
+)
+```
+
+Another conversion is muxing.
+It is useful to add audio/video channels to a pure video/audio stream.
+For this, see `source.mux.video` and `source.mux.audio`.
+
+## Type annotations
+
+You now have all the tools to write a correct script.
+But you might still be surprised by what stream content liquidsoap
+guesses you want to use.
+This is very important, because even if liquidsoap finds a type
+for which it accepts to run, it might not run as you intend:
+a different type might mean a different behavior
+(not the intended number of audio channels, no video, etc).
+
+Before reading on how liquidsoap performs this inference,
+you can already work your way to the intended type by using type
+annotations.
+
+For example, with `output.alsa(input.alsa())`,
+you'll see that liquidsoap decides that stereo audio should be used,
+and consequently the ALSA I/O will be initialized with two channels.
+If you want to use a different number of channels,
+for example mono, you can explicitly specify it using:
+
+```liquidsoap
+output.alsa((input.alsa():source(audio=pcm(mono))))
+```
+
+## Guessing stream contents
+
+When all other methods fail, you might need to understand a little more
+how liquidsoap guesses what stream contents should be used for
+each source.
+
+First, liquidsoap guesses as much as possible
+(without making unnecessary assumption) from what's been given in the
+script.
+Usually, the outputs pretty much determine what sources should contain.
+A critical ingredient here is often the
+[encoding format](encoding_formats.html). For example, in
+
+```liquidsoap
+output.icecast(%vorbis,mount="some.ogg",s)
+```
+
+`%vorbis` has type `format(audio=pcm(stereo))`, hence `s`
+should have type `source(audio=pcm(stereo))`. This works in more complex
+examples, when the types are guessed successively for several intermediate
+operators.
+
+After this first phase, it is possible that some contents are still
+undetermined. For example in `output.alsa(input.alsa())`,
+any number of audio channels could work, and nothing helps us determine
+what is intended. At this point, the default numbers of channels are
+used. They are given by the setting
+`frame.audio/video/midi.channels` (whose defaults are respectively
+`2`, `0` and `0`). In our example,
+stereo audio would be chosen.
diff --git a/website/content/doc-2.2.5/strings_encoding.md b/website/content/doc-2.2.5/strings_encoding.md
new file mode 100644
index 00000000..d5c04d64
--- /dev/null
+++ b/website/content/doc-2.2.5/strings_encoding.md
@@ -0,0 +1,18 @@
+# Strings encoding
+
+Liquidsoap operates internally using the UTF-8 string encoding. Most strings inside the application are converted
+to UTF-8 whenever possible. Conversion is done using [camomile](https://github.com/ocaml-community/camomile) automatic
+string encoding detection. If the conversion fails, the string is kept as-is. The list of encodings used for automatic
+detection is set via [settings.charset.encodings](settings.html#list-of-encodings-to-try-for-automatic-encoding-detection.)
+
+There are some exceptions, however. For instance, filenames and paths are not converted: if your system expects paths
+to be in a different encoding than UTF-8 then we do need to keep strings representing files and paths in this encoding
+to prevent errors.
+
+In general, you are advised to set the string encoding to UTF-8 on all systems running liquidsoap scripts for consistency
+and clarity.
+
+However, if for some reasons you need to tweak string encoding, these settings can be of use:
+
+- `settings.log.recode` and `settings.log.recode.encoding`: set the first one to `true` and the second one to the string encoding you would like log entries to be converted into.
+- `settings.metadata.recode`: set to `false` to prevent metadata from being converted to UTF-8.
diff --git a/website/content/doc-2.2.5/video-static.md b/website/content/doc-2.2.5/video-static.md
new file mode 100644
index 00000000..31a3aff6
--- /dev/null
+++ b/website/content/doc-2.2.5/video-static.md
@@ -0,0 +1,35 @@
+# A simple video script
+
+The other day, I wanted to prepare some videos of my favorite reggae and soul
+tunes for uploading them to YouTube.
+My goal was very simple: prepare a video with the music,
+and a static image.
+
+After briefly digging for a simple software to do that,
+which I could not find, I said ``hey, why not doing it with liquidsoap''?
+Well, that is fairly easy!
+
+Here is the code:
+
+```liquidsoap
+log.level := 4
+
+audio = once(single("/tmp/bla.mp3"))
+video = single("/tmp/bla.jpg")
+
+# Mux audio and video
+source = source.mux.video(video=video,audio)
+
+# Disable real-time processing, to process with the maximum speed
+clock.assign_new(sync='none',[source])
+
+# Encode video and copy audio:
+encoder = %ffmpeg(format="mp4",
+                  %audio.copy,
+                  %video(codec="libx264"))
+
+ # Output to a theora file, shutdown on stop
+ output.file(fallible=true,on_stop=shutdown,
+             encoder, "/tmp/encoded-video.mp4",
+             source)
+```
diff --git a/website/content/doc-2.2.5/video.md b/website/content/doc-2.2.5/video.md
new file mode 100644
index 00000000..4b5bc889
--- /dev/null
+++ b/website/content/doc-2.2.5/video.md
@@ -0,0 +1,269 @@
+---
+header-includes: |
+  \DeclareUnicodeCharacter{03C0}{$\pi$}
+...
+
+Basically streaming videos does not change anything compared to streaming audio:
+you just have to use video files instead of sound files! For instance, if you
+want to stream a single file to an icecast server in ogg format (with theora and
+vorbis as codecs for audio and video) you can simply type:
+
+```liquidsoap
+source = single("video.mp4")
+
+output.icecast(
+        %ffmpeg(format="ogg",
+          %audio(codec="libvorbis"),
+          %video(codec="libtheora")
+        ),
+        host="localhost",
+        port=8000,
+        password="hackme",
+        mount="/videostream",
+        source)
+```
+
+And of course you could have used a `playlist` instead of `single` to have
+multiple files, or used other [formats](encoding_formats.html) for the stream.
+
+In order to test a video stream, it is often convenient to use the `output.sdl`
+operator (or `output.graphics`) which will open a window and display the video
+stream inside. These can handle streams with video only, you can use the
+`drop_audio` operator to remove the sound part of a stream if needed.
+
+You should be expecting much higher resource needs (in cpu time in particular)
+for video than for audio. So, be prepared to hear the fan of your computer! The
+size of videos have a great impact on computations; if your machine cannot
+handle a stream (i.e. it's always catching up) you can try to encode to smaller
+videos for a start.
+
+### Encoding with FFmpeg
+
+The `%ffmpeg` encoder is the recommended encoder when working with video. Not only does it support a wide range
+of audio and video formats but it can also send and receive data to many different places, using `input.ffmpeg.`
+and `output.url`. On top of that, it also supports all the [FFmpeg filters](https://ffmpeg.org/ffmpeg-filters.html)
+and passing encoded data, if your script does not need re-encoding.
+
+The syntax for the encoder is detailed in the [encoders page](encoding_formats.html). Here are some examples:
+
+```liquidsoap
+# AC3 audio and H264 video encapsulated in a MPEG-TS bitstream
+%ffmpeg(format="mpegts",
+  %audio(codec="ac3",channel_coupling=0),
+  %video(codec="libx264",b="2600k",
+         "x264-params"="scenecut=0:open_gop=0:min-keyint=150:keyint=150",
+         preset="ultrafast"))
+
+# AAC audio and H264 video encapsulated in a mp4 file (to use with
+# `output.file` only, mp4 container cannot be streamed!
+%ffmpeg(format="mp4",
+  %audio(codec="aac"),
+  %video(codec="libx264",b="2600k"))
+
+# Ogg opus and theora encappsulated in an ogg bitstream
+%ffmpeg(format="ogg",
+  %audio(codec="libopus"),
+  %video(codec="libtheora"))
+
+# Ogg opus and VP8 video encapsulated in a webm bitstream
+%ffmpeg(format="webm",
+  %audio(codec="libopus"),
+  %video(codec="libvpx"))
+```
+
+### Streaming with FFmpeg
+
+The main input to take advantage of FFmpeg is `input.ffmpeg`. It should be able to decode pretty much any url and file that the `ffmpeg` command-line
+can take as input. This is, in particular, how `input.rtmp` is defined.
+
+For outputting, one can use the regular outputs but some of them have special features when used with `%ffmpeg`:
+
+- `output.file` is able to properly close a file after it is done encoding it. This makes it possible to encode in formats that need a proper header after encoding is done, such as `mp4`.
+- `output.url` will only work with the `%ffmpeg` encoder. It delegates data output to FFmpeg and can support any url that the `ffmpeg` command-line supports.
+- `output.file.hls` and `output.harbor.hls` should only be used with `%ffmpeg`. The other encoders do work but `%ffmpeg` is the only encoder able to generate valid `MPEG-TS` and `MP4` data segments for the HLS specifications.
+
+## Useful tips & tricks
+
+Video is a really exciting world where there are lots of cool stuff to do.
+
+### Transitions
+
+Transitions at the beginning or at the end of video can be achieved using
+`video.fade.in` and `video.fade.out`. For instance, fading at the beginning of
+videos is done by
+
+```liquidsoap
+source = video.fade.in(transition="fade",duration=3.,source)
+```
+
+### Adding a logo
+
+You can add a logo (any image) using the `video.add_image` operator, as follows:
+
+```liquidsoap
+source = video.add_image(
+       width=30,height=30,
+       x=10,y=10,
+       file="logo.jpg",
+       source)
+```
+
+### Inputting from a webcam
+
+If your computer has a webcam, it can be used as a source thanks to the
+`input.v4l2` operator. For instance:
+
+```liquidsoap
+output.sdl(input.v4l2())
+```
+
+### Video in video
+
+Suppose that you have two video sources `source` and `source2` and you want to
+display a small copy of `source2` on top of `source`. This can be achieved by
+
+```liquidsoap
+source2 = video.scale(scale=0.2,x=10,y=10,source2)
+source = add([source,source2])
+```
+
+### Scrolling text
+
+Adding scrolling text at the bottom of your video is as easy as
+
+```liquidsoap
+source = video.add_text.sdl(
+       font="/usr/share/fonts/truetype/ttf-dejavu/DejaVuSans.ttf",
+       "Hello world!", source)
+```
+
+You might need to change the `font` parameter so that it matches a font file
+present on your system.
+
+### Effects
+
+There are many of effects that you can use to add some fun to your videos:
+`video.greyscale`, `video.sepia`, `video.lomo`, etc. [Read the
+documentation](reference.html) to find out about them. If you have compiled
+Liquidsoap with [frei0r](http://www.piksel.org/frei0r/) support, and have
+installed frei0r plugins, they will be named `video.frei0r.*`. You can have a
+list of those supported on your installation as usual, using `liquidsoap --list-plugins`.
+
+### Presenting weather forecast
+
+You can say that a specific color should be transparent using
+`video.transparent`. For instance, you can put yourself in front of a blue
+screen (whose RGB color should be around 0x0000ff) and replace the blue screen
+by an image of the weather using
+
+```liquidsoap
+img = single("weather.jpg")
+cam = input.v4l2()
+cam = video.transparent(color=0x0000ff,precision=0.2,cam)
+source = add([img,cam])
+```
+
+## Detailed examples
+
+### The anonymizer
+
+Let's design an ``anonymizer'' effect: I want to blur my face and change my voice
+so that nobody will recognise me in the street after seeing the youtube
+video. Here is what we are going to achieve:
+
+<center><iframe width="560" height="315" src="//www.youtube.com/embed/E7Fb0wV3h5Q" frameborder="0" allowfullscreen></iframe></center>This video was produced thanks to the following script:
+
+```liquidsoap
+# Input from webcam
+cam = input.v4l2()
+
+# Detect faces (this generates a white disk over faces)
+mask = video.frei0r.opencvfacedetect(cam)
+# Pixellize the video
+censored = video.frei0r.pixeliz0r(blocksizex=0.1,blocksizey=0.1,cam)
+# Generate a mask for video without the face
+unmask = video.frei0r.invert0r(mask)
+# Put the pixellized face over the video
+s = video.frei0r.addition(
+  video.frei0r.multiply(mask,censored),
+  video.frei0r.multiply(unmask,cam))
+# We have to bufferize the source because its clock it GStreamer's clock
+s = buffer(buffer=0.1,mksafe(s))
+
+# Input audio from microphone
+mic = input.pulseaudio(clock_safe=false)
+# Transpose sound to generate a funny voice
+mic = soundtouch(pitch=1.5,mic)
+# Add sound to video
+s = source.mux.audio(audio=mic,s)
+
+# Let's hear the sound
+output.pulseaudio(fallible=true,s)
+# Let's see the video
+output.sdl(fallible=true,drop_audio(s))
+
+s = mksafe(s)
+# Output the video/sound into a file in theora/vorbis format
+output.file(%ogg(%theora(quality=63),%vorbis), "anonymous.ogv", s)
+```
+
+### Controlling with OSC
+
+In this example we are going to use OSC integration in order to modify the
+parameters in realtime. There are many OSC clients around, for instance I used
+[TouchOSC](http://hexler.net/software/touchosc) :
+
+<center><iframe width="560" height="315" src="//www.youtube.com/embed/EX1PTjiuuXY" frameborder="0" allowfullscreen></iframe></center>Here is how the video was made:
+
+```liquidsoap
+# Set the OSC port to match TouchOSC's default port
+settings.osc.port := 8000
+
+# Input from the webcam
+s = input.v4l2_with_audio()
+s = mksafe(s)
+
+# We get the angle from fader 3
+angle = osc.float("/1/fader3", 0.)
+# we rescale the position of fader 3 so that it corresponds to a 2π rotation
+angle = fun() -> angle() * 3.1416 * 2.
+# ...and we rotate the video according to the angle
+s = video.rotate(speed=0.,angle=angle,s)
+# Change brightness according to fader 1
+s = video.frei0r.brightness(brightness=osc.float("/1/fader1",0.5),s)
+# Change contrast according to fader 2
+s = video.frei0r.contrast0r(contrast=osc.float("/1/fader2",0.5),s)
+
+# We have to buffer here otherwise we get clocks problems
+s = buffer(s)
+
+# Output sound and video
+output.pulseaudio(fallible=true,s)
+output.sdl(fallible=true,drop_audio(s))
+```
+
+### Blue screen
+
+You want to show yourself in front of a video of a bunny, as in
+
+<center><iframe width="640" height="360" src="//www.youtube.com/embed/zHikXRNMQu4?feature=player_detailpage" frameborder="0" allowfullscreen></iframe></center>The idea is to film yourself in front of a blue screen, make this blue screen
+transparent and put the resulting video in front of the bunny video (actually, I
+don't have a blue screen at home, only a white wall but it still kinda works).
+
+```liquidsoap
+# The video of the bunny
+s = single("big_buck_bunny_720p_stereo.ogg")
+# Input from the webcam
+cam = input.v4l2()
+# Flip the video around a vertical axis so that it is easier
+# to position yourself
+cam = video.frei0r.flippo(x_axis=true,cam)
+# Make the white background transparent
+# I had to tweak the precision parameter so that I will be seen
+# but not the wall
+cam = video.transparent(color=0xffffff,precision=0.64,cam)
+# Superpose the two videos
+s = add([s,cam])
+# Output to SDL
+output.sdl(fallible=true,drop_audio(s))
+```
diff --git a/website/content/doc-2.2.5/yaml.md b/website/content/doc-2.2.5/yaml.md
new file mode 100644
index 00000000..95f6c152
--- /dev/null
+++ b/website/content/doc-2.2.5/yaml.md
@@ -0,0 +1,29 @@
+## Importing/exporting YAML values
+
+Support for YAML parsing and rendering was first added in liquidsoap `2.2.0`. This support follows the same pattern as [JSON parsing/rendering](json.html) but using
+yaml-based syntax, i.e.:
+
+```liquidsoap
+let yaml.parse ({
+  name,
+  version,
+  scripts,
+} : {
+  name: string,
+  version: string,
+  scripts: {
+    test: string?
+  }?
+}) = file.contents("/path/to/file.yaml")
+```
+
+and
+
+```liquidsoap
+r = {artist = "Bla", title = "Blo"}
+print(yaml.stringify(r))
+```
+
+The only major difference being that, in YAML, all numbers are parsed and rendered as _floats_.
+
+Please refer to the [JSON parsing and rendering](json.html) documentation for more details.
diff --git a/website/template-2.2.5.html b/website/template-2.2.5.html
new file mode 100644
index 00000000..484d3b3d
--- /dev/null
+++ b/website/template-2.2.5.html
@@ -0,0 +1,423 @@
+<!DOCTYPE html>
+<html lang="en">
+
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" type="image/png" href="/assets/img/favicon.ico">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+    <title>Liquidsoap</title>
+    <meta content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0, shrink-to-fit=no' name='viewport' />
+    <!-- Extra details for Live View on GitHub Pages -->
+    <!-- Canonical SEO -->
+    <link rel="canonical" href="https://www.liquidsoap.info/" />
+    <!--  Social tags      -->
+    <meta name="keywords" content="radio, audio, video, streaming, icecast, shoutcast">
+    <meta name="description" content="Swiss-army knife for multimedia streaming">
+    <!-- Schema.org markup for Google+ -->
+    <meta itemprop="name" content="Liquidsoap Streaming Language">
+    <meta itemprop="description" content="Swiss-army knife for multimedia streaming">
+    <!-- Twitter Card data -->
+    <meta name="twitter:card" content="product">
+    <meta name="twitter:site" content="@LiquidsoapMedia">
+    <meta name="twitter:title" content="Liquidsoap Streaming Language">
+    <meta name="twitter:description" content="Swiss-army knife for multimedia streaming">
+    <meta name="twitter:creator" content="@LiquidsoapMedia">
+    <meta name="twitter:image" content="https://www.liquidsoap.info//assets/img/bottle_invert.png">
+    <!--     Fonts and icons     -->
+    <link rel="stylesheet" type="text/css" href="https://fonts.googleapis.com/css?family=Roboto:300,400,500,700|Roboto+Slab:400,700|Material+Icons" />
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/latest/css/font-awesome.min.css">
+    <!-- CSS Files -->
+    <link href="/assets/css/custom.css" rel="stylesheet" />
+    <link href="/assets/css/material-kit.min.css" rel="stylesheet" />
+    <link rel="stylesheet" href="https://ajax.googleapis.com/ajax/libs/jqueryui/1.12.1/themes/smoothness/jquery-ui.css">
+    <!-- Documentation extras -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/docsearch.js/2/docsearch.min.css" />
+    <link rel="stylesheet" href="/assets/demo/docs.min.css">
+    <style>
+    .navbar-absolute-logo {
+      padding-left: 45px;
+    }
+
+    .navbar-absolute-logo img {
+      position: absolute;
+      left: 15px;
+      margin-top: -6px;
+    }
+
+    body {
+      background: white;
+    }
+
+    p {
+        font-size: 16px;
+        text-align: justify;
+    }
+    </style>
+$if(highlighting-css)$
+    <style type="text/css">
+$highlighting-css$
+    </style>
+$endif$
+$for(css)$
+    <link rel="stylesheet" href="$css$" />
+$endfor$
+$if(math)$
+  $math$
+$endif$
+$for(header-includes)$
+  $header-includes$
+$endfor$
+  </head>
+
+  <body class="bd-docs" data-spy="scroll" data-target=".bd-sidenav-active">
+    <a id="skippy" class="sr-only sr-only-focusable" href="#content">
+      <div class="container">
+        <span class="skiplink-text">Skip to main content</span>
+      </div>
+    </a>
+    <header class="navbar navbar-expand navbar-dark bg-primary flex-column flex-md-row bd-navbar">
+      <a class="navbar-brand mr-0 mr-md-2 navbar-absolute-logo" href="/doc-$version$">
+        <svg class="navbar-nav-svg" xmlns="http://www.w3.org/2000/svg" viewbox="0 0 600 600" focusable="false" style="width: 25px; height: 25px;">
+          <title>Liquidsoap</title>
+          <style type="text/css">
+.st0{fill:#FFFFFF;}
+          </style>
+          <g>
+          <path class="st0" d="M102.4,593.8c-0.7-2.8-3.4-2.5-5.3-3.3c-24.6-10.2-37.2-28.7-37.2-55.6c-0.1-72.1,0-144.2,0-216.3
+          c0-52.3,0-104.6,0-156.9c0-37.6,23.1-60.9,60.6-61.1c12-0.1,23.9-0.2,35.9,0c15.7,0.3,26.7,10.1,26.3,23
+          c-0.4,12.5-11.1,21.5-26.3,21.8c-12,0.2-23.9-0.1-35.9,0.1c-11.8,0.1-15.6,3.7-15.6,15.3c-0.1,124.4,0,248.8-0.1,373.2
+          c0,10.3,4.5,15.1,14.8,15.1c69.1-0.1,138.2,0,207.3-0.1c12.3,0,15.5-3.7,15.5-17.7c0-74.7,0-149.4,0-224.2c0-47.8,0-95.6,0-143.5
+          c0-15.2-3-18.1-18.4-18.2c-10.8,0-21.7,0.1-32.5,0c-16-0.2-26.7-9.4-26.6-22.5c0.1-13,10.9-22.1,26.9-22.3
+          c13.4-0.2,26.9-0.3,40.3,0.1c30.8,1,54.9,24.5,55,55.2c0.3,127.4,0.3,254.8,0.1,382.2c0,25.5-15.8,45.7-40.2,53.3
+          c-1.7,0.5-3.8,0-4.5,2.4C262.3,593.8,182.4,593.8,102.4,593.8z"/>
+          <path class="st0" d="M537.4,212.6c-16.8,23-56.5,16.5-68.6-9.5c-8-17.2-12.4-32.7-12-54.5c4.6,4.1,8.3,7.5,12.1,10.7
+          c10.3,8.6,21,14,35.5,11.8c12.5-1.9,21.5,6,28.2,16.3c2,3,1.3,7.3,4.8,9.5C537.4,202.2,537.4,207.4,537.4,212.6z"/>
+          <path class="st0" d="M200.6,230.4c0-55.3,0-110.5,0-165.8c0-40.7,22.3-62.7,63.2-62.7c50.4,0,100.8,0,151.3,0
+          c36.1,0,59.1,21.9,60.4,57.7c0.5,13.1,0.4,26.1,0,39.2c-0.4,15.1-10.1,25.8-22.5,25.7c-12-0.1-21.6-10.1-22.3-24.8
+          c-0.6-12.7-0.4-25.4-0.1-38.1c0.2-10.4-4.5-14.9-14.9-14.9c-51.5,0.1-103.1,0-154.6,0.1c-12.7,0-15.5,3.2-15.5,17.5
+          c0,105.3,0,210.6,0,316c0,7.8,0.1,15.7,0,23.5c-0.2,17.5-9.4,28.9-23,28.6c-13.5-0.3-21.9-10.9-21.9-28.3
+          C200.6,346.2,200.6,288.3,200.6,230.4z"/>
+          </g>
+        </svg>
+        Liquidsoap
+      </a>
+      <ul class="navbar-nav flex-row d-none d-md-flex">
+        <li class="nav-item dropdown">
+          <a data-versions="$versions$" data-version="$version$" class="nav-item nav-link dropdown-toggle mr-md-2" href="#" id="liq-version" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
+            $version$
+          </a>
+          <div class="dropdown-menu dropdown-menu-right" aria-labelledby="liq-version" id="liq-versions">
+          </div>
+        </li>
+        <li class="nav-item">
+          <a class="nav-link p-2" href="https://github.com/savonet/liquidsoap" target="_blank" rel="noopener" aria-label="GitHub">
+            <svg class="navbar-nav-svg" xmlns="http://www.w3.org/2000/svg" viewbox="0 0 512 499.36" focusable="false">
+              <title>GitHub</title>
+              <path d="M256 0C114.64 0 0 114.61 0 256c0 113.09 73.34 209 175.08 242.9 12.8 2.35 17.47-5.56 17.47-12.34 0-6.08-.22-22.18-.35-43.54-71.2 15.49-86.2-34.34-86.2-34.34-11.64-29.57-28.42-37.45-28.42-37.45-23.27-15.84 1.73-15.55 1.73-15.55 25.69 1.81 39.21 26.38 39.21 26.38 22.84 39.12 59.92 27.82 74.5 21.27 2.33-16.54 8.94-27.82 16.25-34.22-56.84-6.43-116.6-28.43-116.6-126.49 0-27.95 10-50.8 26.35-68.69-2.63-6.48-11.42-32.5 2.51-67.75 0 0 21.49-6.88 70.4 26.24a242.65 242.65 0 0 1 128.18 0c48.87-33.13 70.33-26.24 70.33-26.24 14 35.25 5.18 61.27 2.55 67.75 16.41 17.9 26.31 40.75 26.31 68.69 0 98.35-59.85 120-116.88 126.32 9.19 7.9 17.38 23.53 17.38 47.41 0 34.22-.31 61.83-.31 70.23 0 6.85 4.61 14.81 17.6 12.31C438.72 464.97 512 369.08 512 256.02 512 114.62 397.37 0 256 0z" fill="currentColor" fill-rule="evenodd" />
+            </svg>
+          </a>
+        </li>
+        <li class="nav-item">
+          <a class="nav-link p-2" href="https://twitter.com/liquidsoapmedia" target="_blank" rel="noopener" aria-label="Twitter">
+            <svg class="navbar-nav-svg" xmlns="http://www.w3.org/2000/svg" viewbox="0 0 512 416.32" focusable="false">
+              <title>Twitter</title>
+              <path d="M160.83 416.32c193.2 0 298.92-160.22 298.92-298.92 0-4.51 0-9-.2-13.52A214 214 0 0 0 512 49.38a212.93 212.93 0 0 1-60.44 16.6 105.7 105.7 0 0 0 46.3-58.19 209 209 0 0 1-66.79 25.37 105.09 105.09 0 0 0-181.73 71.91 116.12 116.12 0 0 0 2.66 24c-87.28-4.3-164.73-46.3-216.56-109.82A105.48 105.48 0 0 0 68 159.6a106.27 106.27 0 0 1-47.53-13.11v1.43a105.28 105.28 0 0 0 84.21 103.06 105.67 105.67 0 0 1-47.33 1.84 105.06 105.06 0 0 0 98.14 72.94A210.72 210.72 0 0 1 25 370.84a202.17 202.17 0 0 1-25-1.43 298.85 298.85 0 0 0 160.83 46.92" fill="currentColor" />
+            </svg>
+          </a>
+        </li>
+      </ul>
+      <div class="navbar-nav-scroll ml-md-auto ">
+        <ul class="navbar-nav bd-navbar-nav flex-row">
+          <!--
+            <li class="nav-item">
+            <a class="nav-link" href=""> <i class="material-icons">card_membership</i> PRO Services </a>
+            </li>
+            -->
+          <li class="nav-item">
+            <script async src="https://cse.google.com/cse.js?cx=24f50f6f088994c53"></script>
+            <style>
+.cse .gsc-control-cse, .gsc-control-cse {
+  background-color: transparent;
+  border: none;
+  width: 300px;
+}
+            </style>
+            <div class="gcse-search"></div>
+          </li>
+          <li class="nav-item">
+            <a class="nav-link" href="https://github.com/savonet/liquidsoap/issues" target="_blank" rel="noopener"><i class="material-icons">star</i> Get Help</a>
+          </li>
+          <li class="nav-item">
+            <a class="nav-link" href="" target="_blank" rel="noopener"></a>
+          </li>
+          <li class="nav-item">
+            <a class="nav-link" href="" target="_blank" rel="noopener"></a>
+          </li>
+        </ul>
+      </div>
+      <a href="https://github.com/savonet/liquidsoap" class="github-corner" aria-label="View source on Github">
+        <svg width="80" height="80" viewBox="0 0 250 250" style="fill:#fff; color:#9c27b0; position: absolute; top: 0; border: 0; right: 0;" aria-hidden="true">
+          <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
+          <path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path>
+          <path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path>
+        </svg>
+      </a>
+      <style>
+.github-corner:hover .octo-arm {
+  animation: octocat-wave 560ms ease-in-out
+}
+
+        @keyframes octocat-wave {
+          0%,
+          100% {
+            transform: rotate(0)
+          }
+          20%,
+          60% {
+            transform: rotate(-25deg)
+          }
+          40%,
+          80% {
+            transform: rotate(10deg)
+          }
+        }
+
+        @media (max-width:500px) {
+          .github-corner:hover .octo-arm {
+            animation: none
+          }
+          .github-corner .octo-arm {
+            animation: octocat-wave 560ms ease-in-out
+          }
+        }
+      </style>
+    </header>
+    <div class="container-fluid">
+      <div class="row flex-xl-nowrap">
+        <div class="col-12 col-md-3 col-xl-2 bd-sidebar">
+          <nav class="collapse bd-links" id="bd-docs-nav">
+            <div class="bd-toc-item active">
+              <ul class="nav bd-sidenav">
+                <li class="active bd-sidenav-active">
+                  <a class="bd-toc-link" href="/doc-$version$/install.html">
+                    Install
+                  </a>
+                </li>
+                <li>
+                  <a href="/doc-$version$/migrating.html">
+                    Migrating from previous versions
+                  </a>
+                </li>
+                <li class="active bd-sidenav-active">
+                  <a class="bd-toc-link" href="#">
+                    Starters
+                  </a>
+                </li>
+                <li><a href="/doc-$version$/book.html">The book</a></li>
+                <li>
+                  <a href="/doc-$version$/presentations.html">Video Presentations</a>
+                </li>
+                <li>
+                  <a href="/doc-$version$/help.html">How to find help</a>
+                </li>
+                <li>
+                  <a href="/doc-$version$/faq.html">Frequently Asked Questions</a>
+                </li>
+                <li><a href="/doc-$version$/quick_start.html">Quickstart</a></li>
+                <li>
+                  <a href="/doc-$version$/complete_case.html">Complete case analysis</a>
+                </li>
+                <li>
+                  <a href="/doc-$version$/cookbook.html">Cookbook</a>
+                </li>
+              </ul>
+            </div>
+            <div class="bd-toc-item active">
+              <a class="bd-toc-link" href="#">
+                Reference
+              </a>
+              <ul class="nav bd-sidenav">
+                <li>
+                  <a href="/doc-$version$/language.html">Script language</a></li>
+                <li>
+                  <a href="/doc-$version$/reference.html">Core API</a></li>
+                <li>
+                  <a href="/doc-$version$/reference-extras.html">Extra API</a></li>
+                <li>
+                  <a href="/doc-$version$/reference-deprecated.html">Deprecated API</a></li>
+                <li>
+                  <a href="/doc-$version$/multitrack.html">Multitrack</a></li>
+                <li>
+                  <a href="/doc-$version$/protocols.html">Protocols</a></li>
+                <li>
+                  <a href="/doc-$version$/settings.html">Settings</a></li>
+                <li>
+                  <a href="/doc-$version$/ffmpeg.html">FFmpeg support</a></li>
+                <li>
+                  <a href="/doc-$version$/encoding_formats.html">Encoding formats</a></li>
+                <li>
+                  <a href="/doc-$version$/video.html">Videos streams</a></li>
+                <li>
+                  <a href="/doc-$version$/memory.html">Memory management</a></li>
+                <li>
+                  <a href="/doc-$version$/json.html">JSON import/export</a></li>
+                <li>
+                  <a href="/doc-$version$/yaml.html">YAML import/export</a></li>
+                <li>
+                  <a href="/doc-$version$/ladspa.html">LADSPA plugins</a></li>
+                <li>
+                  <a href="/doc-$version$/playlist_parsers.html">Playlist parsers</a></li>
+              </ul>
+            </div>
+            <div class="bd-toc-item active">
+              <a class="bd-toc-link" href="#">
+                Core
+              </a>
+              <ul class="nav bd-sidenav">
+                <li>
+                  <a href="/doc-$version$/sources.html">Sources</a></li>
+                <li>
+                  <a href="/doc-$version$/clocks.html">Clocks</a></li>
+                <li>
+                  <a href="/doc-$version$/requests.html">Requests</a></li>
+                <li>
+                  <a href="/doc-$version$/protocols-presentation.html">Protocols</a></li>
+                <li>
+                  <a href="/doc-$version$/stream_content.html">Stream contents</a></li>
+                <li>
+                  <a href="/doc-$version$/strings_encoding.html">Strings encoding</a></li>
+                <li>
+                  <a href="/doc-$version$/script_loading.html">Script loading</a></li>
+                <li><a href="/doc-$version$/phases.html">Execution phases</a></li>
+              </ul>
+            </div>
+            <div class="bd-toc-item active">
+              <a class="bd-toc-link" href="#">
+                Specific tutorials
+              </a>
+              <ul class="nav bd-sidenav">
+                <li>
+                  <a href="/doc-$version$/harbor_http.html">Using the HTTP server</a></li>
+                <li>
+                  <a href="/doc-$version$/blank.html">Blank detection</a></li>
+                <li>
+                  <a href="/doc-$version$/metadata.html">Customize metadata</a></li>
+                <li>
+                  <a href="/doc-$version$/seek.html">Seek and cue support</a></li>
+                <li>
+                  <a href="/doc-$version$/external_decoders.html">External decoders</a></li>
+                <li>
+                  <a href="/doc-$version$/external_streams.html">External streams</a></li>
+                <li>
+                  <a href="/doc-$version$/external_encoders.html">External encoders</a></li>
+                <li>
+                  <a href="/doc-$version$/hls_output.html">HLS output</a></li>
+                <li>
+                  <a href="/doc-$version$/http_input.html">HTTP input</a></li>
+                <li>
+                  <a href="/doc-$version$/harbor.html">Harbor input</a></li>
+                <li>
+                  <a href="/doc-$version$/stereotool.html">Stereotool</a></li>
+                <li>
+                  <a href="/doc-$version$/server.html">Using the telnet server</a></li>
+                <li>
+                  <a href="/doc-$version$/icy_metadata.html">ICY metadata update</a></li>
+                <li>
+                  <a href="/doc-$version$/replay_gain.html">Normalization and replay gain</a></li>
+                <li>
+                  <a href="/doc-$version$/request_sources.html">Requests-based sources</a></li>
+                <li>
+                  <a href="/doc-$version$/shoutcast.html">Shoutcast output</a></li>
+                <li>
+                  <a href="/doc-$version$/dynamic_sources.html">Dynamic source creation</a></li>
+                <li>
+                  <a href="/doc-$version$/crossfade.html">Crossfading</a></li>
+                <li>
+                  <a href="/doc-$version$/in_production.html">Using in production</a></li>
+              </ul>
+              <ul class="nav bd-sidenav">
+                <li>
+                  <a class="bd-toc-link" href="#">
+                    User scripts
+                  </a>
+                </li>
+                <li>
+                  <a href="/doc-$version$/beets.html">Beets</a></li>
+                <li>
+                  <a href="/doc-$version$/geekradio.html">Geekradio</a></li>
+                <li>
+                  <a href="/doc-$version$/radiopi.html">RadioPi</a></li>
+                <li>
+                  <a href="/doc-$version$/dolebrai.html">Dolebraï</a></li>
+                <li>
+                  <a href="/doc-$version$/kube.html">Kube</a></li>
+                <li>
+                  <a href="/doc-$version$/frequence3.html">Frequence3</a></li>
+                <li>
+                  <a href="/doc-$version$/video-static.html">Video with a single static image</a></li>
+                <li>
+                  <a href="/doc-$version$/split-cue.html">Split a CUE sheet</a></li>
+              </ul>
+              <ul class="nav bd-sidenav">
+                <li>
+                  <a class="bd-toc-link" href="#">
+                    Behind the curtains
+                  </a>
+                </li>
+                <li>
+                  <a href="/doc-$version$/publications.html">Some presentations and publications</a></li>
+                <li>
+                  <a href="https://github.com/savonet">OCaml libraries</a></li>
+                <li class="active bd-sidenav-active">
+                  <a class="bd-toc-link" href="/legacy">
+                    Legacy website
+                  </a>
+                </li>
+              </ul>
+            </div>
+          </nav>
+        </div>
+        <!--
+          <div class="d-none d-xl-block col-xl-2 bd-toc">
+          <ul class="section-nav">
+          <li class="toc-entry toc-h2">
+          <a href="#quick-start">Quick start</a>
+          <ul>
+          <li class="toc-entry toc-h3">
+          <a href="#css">CSS</a>
+          </li>
+          <li class="toc-entry toc-h3">
+          <a href="#js">JS</a>
+          </li>
+          <li class="toc-entry toc-h3">
+          <a href="#fonts-and-icons">Fonts and Icons</a>
+          </li>
+          </ul>
+          </li>
+          <li class="toc-entry toc-h2">
+          <a href="#starter-template">Starter template</a>
+          </li>
+          </ul>
+          </div>
+        -->
+          <main class="col-12 col-md-9 col-xl-8 py-md-3 pl-md-5 bd-content" role="main">
+          $if(toc)$
+          <nav id="$idprefix$TOC">
+            $table-of-contents$
+          </nav>
+          $endif$
+$body$
+          <div id="footer"></div>
+        </main>
+      </div>
+    </div>
+    <!--   Core JS Files   -->
+
+    <script src="/assets/js/core/jquery.min.js" type="text/javascript"></script>
+    <script src="/assets/js/core/popper.min.js" type="text/javascript"></script>
+    <script src="/assets/js/core/bootstrap-material-design.min.js" type="text/javascript"></script>
+    <script src="https://ajax.googleapis.com/ajax/libs/jqueryui/1.12.1/jquery-ui.min.js" type="text/javascript"></script>
+    <script src="/assets/js/liq-jquery.js" type="text/javascript"></script>
+  </body>
+
+</html>