# 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
- Configuration
- File
- Getter
- Interaction
- Internet
- Liquidsoap
- List
- Math
- Metadata
- Programming
- Settings
- Source / Audio processing
- Source / Conversion
- Source / FFmpeg filter
- Source / Fade
- Source / Input
- Source / Liquidsoap
- Source / MIDI processing
- Source / Output
- Source / Sound synthesis
- Source / Testing
- Source / Track processing
- Source / Video processing
- Source / Visualization
- String
- System
- Time
- Track / Audio processing
- Track / Conversion
- Track / FFmpeg filter
- Track / Track processing
- Track / Video processing
- 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.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.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.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.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.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.cache`

Liquidsoap cache directory.

Type:

    (mode : string) -> string?

Arguments:

- `mode` (of type `string`): Cache mode, one of: “user” or “system”

### `liquidsoap.cache.maintenance`

Execute cache maintenance routine.

Type:

    (mode : string) -> unit

Arguments:

- `mode` (of type `string`): Cache mode, one of: “user” or “system”

### `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 `true`): 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.0`): 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.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.lufs`

Get the LUFS for a file (in dB).

Type:

    (?id : string?, ?compute : bool, ?ratio : float?, string) -> float?

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
- `compute` (of type `bool`, which defaults to `true`): Compute LUFS if metadata tag is empty.
- `ratio` (of type `float?`, which defaults to `null`): 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 lufs tags. Defaults to `settings.lufs.decoding_ratio` when `null`.
- `(unlabeled)` (of type `string`): File name.

### `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.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:

    (?parents : bool, ?perms : int, string) -> unit

Arguments:

- `parents` (of type `bool`, which defaults to `false`): Also create parent directories if they do not exist.
- `perms` (of type `int`, which defaults to `0o755`): Default file rights if created.
- `(unlabeled)` (of type `string`)

### `file.move`

Move a file

Type:

    (?force : bool, ?atomic : bool, string, string) -> unit

Arguments:

- `force` (of type `bool`, which defaults to `false`): Do not prompt for confirmation if the destination path exists.
- `atomic` (of type `bool`, which defaults to `false`): Move the file atomically. Implies `force` and raises `error.file.cross_device` if atomic move fails because the source and destination files are not on the same partition.
- `(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 `0o644`): Default file rights if created.
- `(unlabeled)` (of type `string`)

Methods:

- `close` (of type `() -> unit`): Close the socket.
- `closed` (of type `() -> bool`): `true` if the socket is already closed.
- `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`

Get the ReplayGain for a file (in dB). Use this setting to lower CPU peaks when computing replaygain tags.

Type:

    (?id : string?, ?compute : bool, ?ratio : float, string) -> float?

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
- `compute` (of type `bool`, which defaults to `true`): Compute ReplayGain if metadata tag is empty.
- `ratio` (of type `float`, which defaults to `50.0`): Decoding ratio. A value of `50` means try to decode the file `50x` faster than real time, if possible.
- `(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, ?directory : string?, string, string) -> string

Arguments:

- `cleanup` (of type `bool`, which defaults to `false`): Delete the file on shutdown
- `directory` (of type `string?`, which defaults to `null`): Directory where to create the file.
- `(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 `0o644`)
- `(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, ?atomic : bool,
     ?temp_dir : string?, 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 `0o644`): Default file rights if created. Default: `0o644`.
- `append` (of type `bool`, which defaults to `false`): Append data if file exists.
- `atomic` (of type `bool`, which defaults to `false`): Make the write atomic by writing to a temporary file and moving the file to destination once writing has succeeded.
- `temp_dir` (of type `string?`, which defaults to `null`): Temporary directory for atomic write.
- `(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, ?atomic : bool, ?temp_dir : string?, string) ->
    (string?) -> unit

Arguments:

- `perms` (of type `int`, which defaults to `0o644`): Default file rights if created. Default: `0o644`.
- `append` (of type `bool`, which defaults to `false`): Append data if file exists.
- `atomic` (of type `bool`, which defaults to `false`): Make the write atomic by writing to a temporary file and moving the file to destination once writing has succeeded.
- `temp_dir` (of type `string?`, which defaults to `null`): Temporary directory for atomic write.
- `(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?, ?bpm_lt : 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?, 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 `null`): Timeout for resolving the playlist
- `(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.api.track.scrobble`

Submit a track to the audioscrobbler `track.scrobble` API.

Type:

    (username : string, password : string, ?session_key : string?,
     ?api_key : string?, ?api_secret : string?, artist : string, track : string,
     ?timestamp : float?, ?album : string?, ?context : string?,
     ?streamId : string?, ?chosenByUser : bool, ?trackNumber : int?,
     ?mbid : string?, ?albumArtist : string?, ?duration : int?) -> unit

Arguments:

- `username` (of type `string`)
- `password` (of type `string`)
- `session_key` (of type `string?`, which defaults to `null`)
- `api_key` (of type `string?`, which defaults to `null`)
- `api_secret` (of type `string?`, which defaults to `null`)
- `artist` (of type `string`)
- `track` (of type `string`)
- `timestamp` (of type `float?`, which defaults to `null`)
- `album` (of type `string?`, which defaults to `null`)
- `context` (of type `string?`, which defaults to `null`)
- `streamId` (of type `string?`, which defaults to `null`)
- `chosenByUser` (of type `bool`, which defaults to `true`)
- `trackNumber` (of type `int?`, which defaults to `null`)
- `mbid` (of type `string?`, which defaults to `null`)
- `albumArtist` (of type `string?`, which defaults to `null`)
- `duration` (of type `int?`, which defaults to `null`)

Methods:

- `lfm` (of type `{ scrobbles : { scrobble : { album : string? .{xml_params : {corrected : int} }, albumArtist : string? .{xml_params : {corrected : int} }, artist : string .{xml_params : {corrected : int} }, ignoredMessage : {xml_params : {code : int} }, timestamp : float, track : string .{xml_params : {corrected : int} } }, xml_params : {accepted : int, ignored : int } }, xml_params : {status : string } }`):

### `audioscrobbler.api.track.scrobble.metadata`

Submit a track to the audioscrobbler `track.scrobble` API using its metadata.

Type:

    (username : string, password : string, ?session_key : string?,
     ?api_key : string?, ?api_secret : string?, [string * string]) -> unit

Arguments:

- `username` (of type `string`)
- `password` (of type `string`)
- `session_key` (of type `string?`, which defaults to `null`)
- `api_key` (of type `string?`, which defaults to `null`)
- `api_secret` (of type `string?`, which defaults to `null`)
- `(unlabeled)` (of type `[string * string]`)

### `audioscrobbler.api.track.updateNowPlaying`

Submit a track to the audioscrobbler `track.updateNowPlaying` API.

Type:

    (username : string, password : string, ?session_key : string?,
     ?api_key : string?, ?api_secret : string?, artist : string, track : string,
     ?album : string?, ?context : string?, ?trackNumber : int?, ?mbid : string?,
     ?albumArtist : string?, ?duration : int?) -> unit

Arguments:

- `username` (of type `string`)
- `password` (of type `string`)
- `session_key` (of type `string?`, which defaults to `null`)
- `api_key` (of type `string?`, which defaults to `null`)
- `api_secret` (of type `string?`, which defaults to `null`)
- `artist` (of type `string`)
- `track` (of type `string`)
- `album` (of type `string?`, which defaults to `null`)
- `context` (of type `string?`, which defaults to `null`)
- `trackNumber` (of type `int?`, which defaults to `null`)
- `mbid` (of type `string?`, which defaults to `null`)
- `albumArtist` (of type `string?`, which defaults to `null`)
- `duration` (of type `int?`, which defaults to `null`)

Methods:

- `lfm` (of type `{ nowplaying : { album : string? .{xml_params : {corrected : int} }, albumArtist : string? .{xml_params : {corrected : int} }, artist : string .{xml_params : {corrected : int} }, ignoredMessage : {xml_params : {code : int} }, track : string .{xml_params : {corrected : int} } }, xml_params : {status : string } }`):

### `audioscrobbler.api.track.updateNowPlaying.metadata`

Submit a track using its metadata to the audioscrobbler `track.updateNowPlaying` API.

Type:

    (username : string, password : string, ?session_key : string?,
     ?api_key : string?, ?api_secret : string?, [string * string]) -> unit

Arguments:

- `username` (of type `string`)
- `password` (of type `string`)
- `session_key` (of type `string?`, which defaults to `null`)
- `api_key` (of type `string?`, which defaults to `null`)
- `api_secret` (of type `string?`, which defaults to `null`)
- `(unlabeled)` (of type `[string * string]`)

### `http.codes`

List of HTTP response codes and statuses.

Type:

    [int * 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.4.0+dev (Unix; OCaml 5.4.0)")]`): 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.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.

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

    ((('a, 'b, (('a, 'b) -> 'c)) -> 'c)) -> unit

Arguments:

- `(unlabeled)` (of type `('a, 'b, (('a, 'b) -> 'c)) -> 'c`)

### `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, '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 : (socket
                        .{
                          close : () -> unit,
                          closed : () -> bool,
                          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, '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 : (socket .{ close : () -> unit, closed : () -> bool, 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,
           closed : () -> bool,
           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, closed : () -> bool, 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,
           closed : () -> bool,
           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, closed : () -> bool, 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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.0`): Timeout for network operations in seconds.
- `normalize_url` (of type `bool?`, which defaults to `null`): Normalize url, replacing spaces with `%20` and more. Defaults to `settings.http.normalize_url` when `null`.
- `(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.unix`

Http unencrypted transport

Type:

    http_transport.{default_port : int, name : string, protocol : string}

### `http.user_agent`

Default user-agent

Type:

    string

### `http.www_form_urlencoded`

Prepare a list of `(string, string)` arguments for sending as `"application/x-www-form-urlencoded"` content

Type:

    ([string * string]) -> string

Arguments:

- `(unlabeled)` (of type `[string * 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.
- `closed` (of type `() -> bool`): `true` if the socket is already closed.
- `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, closed : () -> bool, 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.
- `closed` (of type `() -> bool`): `true` if the socket is already closed.
- `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`

Decorate a clock with all its methods.

Type:

    (clock) -> clock

Arguments:

- `(unlabeled)` (of type `clock`)

Methods:

- `id` (of type `(() -> string).{set : (string) -> unit}`): The clock’s id
- `self_sync` (of type `() -> bool`): `true` if the clock is in control of its latency.
- `start` (of type `(?force : bool) -> unit`): Start the clock.
- `stop` (of type `() -> unit`): Stop the clock. Does nothing if the clock is stopping or stopped.
- `sync` (of type `() -> string`): The clock’s current sync mode. One of: `"stopped"`, `"stopping"`, `"auto"`, `"CPU"`, `"unsynced"` or `"passive"`.
- `tick` (of type `() -> unit`): Animate the clock and run one tick
- `ticks` (of type `() -> int`): The total number of times the clock has ticked.
- `unify` (of type `(clock) -> unit`): Unify the clock with another one. One of the two clocks should be in `"stopped"` sync mode.

### `clock.active`

Return the list of clocks currently in use.

Type:

    () ->
    [clock
     .{
       id : (() -> string)
       .{set : (string) -> unit
       },
       self_sync : () -> bool,
       start : (?force : bool) -> unit,
       stop : () -> unit,
       sync : () -> string,
       tick : () -> unit,
       ticks : () -> int,
       unify : (clock) -> unit
     }]

### `clock.assign_new`

Create a new clock and assign it to a list of sources.

Type:

    (?sync : string, ?id : string?, ?on_error : ((error) -> unit)?,
     ['a.{clock : clock}]) -> unit

Arguments:

- `sync` (of type `string`, which defaults to `"auto"`): Synchronization mode. One of: `"auto"`, `"cpu"`, `"passive"` 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`)
- `on_error` (of type `((error) -> 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.
- `(unlabeled)` (of type `['a.{clock : clock}]`)

### `clock.create`

Create a new clock

Type:

    (?id : string?, ?on_error : ((error) -> unit)?, ?sync : string) -> clock

Arguments:

- `id` (of type `string?`, which defaults to `null`): Identifier for the new clock.
- `on_error` (of type `((error) -> 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"`): Clock sync mode. Should be one of: `"auto"`, `"CPU"`, `"unsynced"` or `"passive"`. Defaults to `"auto"`. Defaults to: “auto”

Methods:

- `id` (of type `(() -> string).{set : (string) -> unit}`): The clock’s id
- `self_sync` (of type `() -> bool`): `true` if the clock is in control of its latency.
- `start` (of type `(?force : bool) -> unit`): Start the clock.
- `stop` (of type `() -> unit`): Stop the clock. Does nothing if the clock is stopping or stopped.
- `sync` (of type `() -> string`): The clock’s current sync mode. One of: `"stopped"`, `"stopping"`, `"auto"`, `"CPU"`, `"unsynced"` or `"passive"`.
- `tick` (of type `() -> unit`): Animate the clock and run one tick
- `ticks` (of type `() -> int`): The total number of times the clock has ticked.
- `unify` (of type `(clock) -> unit`): Unify the clock with another one. One of the two clocks should be in `"stopped"` sync mode.

### `decoder.add`

Register an external decoder. The decoder receives a local file and produces another local file. Produced file can be any format decodable by liquidsoap and can also be a request uri. Recommended returned value is: `annotate:metadata="value",..:/path/to/file.wav`. File decoders are applied during the request resolution process.

Type:

    (name : string, description : string, ?static : ((string) -> bool),
     ?mimes : [string], file_extensions : [string],
     ((rlog : ((string) -> unit), maxtime : float, string) -> string
      .{temporary? : bool}?)) -> unit

Arguments:

- `name` (of type `string`)
- `description` (of type `string`): Description of the decoder.
- `static` (of type `(string) -> bool`, which defaults to `fun (_) -> true`): Return `true`, then requests can be resolved once and for all. Typically, static decoders can be used to create infallible sources.
- `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]`): List of file extensions. Should not be empty.
- `(unlabeled)` (of type `(rlog : ((string) -> unit), maxtime : float, string) -> string .{temporary? : bool}?`): Resolution function. Returns `null` if no file could be decoded.

### `decoder.metadata.add`

Register an external file metadata decoder.

Type:

    (?priority : {int}, ?mime_types : [string]?, ?file_extensions : [string]?,
     ?reentrant : bool, string,
     ((metadata : [string * string], string) -> [string * string])) -> unit

Arguments:

- `priority` (of type `{int}`, which defaults to `1`): Resolver’s priority.
- `mime_types` (of type `[string]?`, which defaults to `null`): Decode files that match the mime types in this list. Accept any file if `null`.
- `file_extensions` (of type `[string]?`, which defaults to `null`): Decode files that have the file extensions in this list. Accept any file if `null`.
- `reentrant` (of type `bool`, which defaults to `false`): Set to `true` to indicate that the decoder needs to resolve a request. Such decoders need to be mutually exclusive to avoid request resolution loops!
- `(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.metadata.reentrant`

Return the list of reentrant decoders.

Type:

    () -> [string]

### `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. For a finer-grained processing, use the `autocue:` protocol.

Type:

    () -> unit

### `enable_external_ffmpeg_decoder`

Enable the external ffmpeg decoder.

Type:

    (?binary : string, mimes : [string], file_extensions : [string]) -> unit

Arguments:

- `binary` (of type `string`, which defaults to `"ffmpeg"`): Path to the `ffmpeg` binary.
- `mimes` (of type `[string]`): Mime types to decode. Empty list means any type.
- `file_extensions` (of type `[string]`): File extensions to decode. Should not be empty

### `enable_external_openmpt123_decoder`

Enable the external openmpt123 decoder

Type:

    (?binary : string, ?mimes : [string], ?file_extensions : [string],
     ?options : string) -> unit

Arguments:

- `binary` (of type `string`, which defaults to `"openmpt123"`): Path to the `ffmpeg` binary.
- `mimes` (of type `[string]`, which defaults to `["audio/it", "audio/xm", "audio/s3m", "audio/x-mod", "audio/mod", "audio/module-xm", "audio/x-mod", "application/playerpro", "audio/x-s3m", "application/soundapp", "audio/med", "audio/x-xm"]`): Mime types to decode. Empty list means any type.
- `file_extensions` (of type `[string]`, which defaults to `["xm", "mtm", "amf", "stm", "ult", "wow", "dmf", "it", "s3m", "far", "mod", "mt2", "okt", "med", "669"]`): File extensions to decode.
- `options` (of type `string`, which defaults to `""`): Extra options.

### `enable_lufs_track_gain_metadata`

Enable LUFS metadata resolver. This resolver will process any file decoded by Liquidsoap and add a `lufs_track_gain` metadata when this value could be computed. For a finer-grained replay gain processing, use the `lufs_track_gain:` protocol.

Type:

    (?compute : bool, ?ratio : float?) -> unit

Arguments:

- `compute` (of type `bool`, which defaults to `true`): Compute lufs if metadata tag is empty.
- `ratio` (of type `float?`, which defaults to `null`): 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 lufs tags. Defaults to `settings.lufs.decoding_ratio` when `null`

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

    (?compute : bool, ?ratio : float) -> unit

Arguments:

- `compute` (of type `bool`, which defaults to `true`): Compute replaygain if metadata tag is empty.
- `ratio` (of type `float`, which defaults to `50.0`): 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)`)

### `error.methods`

Decorate an error with all its methods

Type:

    (error) -> error

Arguments:

- `(unlabeled)` (of type `error`)

Methods:

- `kind` (of type `string`): Error kind.
- `message` (of type `string`): Error message.
- `trace` (of type `[ { cstart : int, cstop : int, filename : string, lstart : int, lstop : int, to_string : (?prefix : string) -> string }]`): Error stacktrace.

### `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.functions.count`

Number of functions registered in the standard library.

Type:

    () -> int

### `liquidsoap.script.path`

Path to the current script, if available

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 a cue file and return a value suitable for playlist parser registration.

Type:

    (?pwd : string?, string) -> [[string * string] * string]

Arguments:

- `pwd` (of type `string?`, which defaults to `null`): Path to use for relative path resolution
- `(unlabeled)` (of type `string`)

### `playlist.parse.cue.full`

Parse a cue file

Type:

    (?pwd : string?, string) -> unit

Arguments:

- `pwd` (of type `string?`, which defaults to `null`): Path to use for relative path resolution
- `(unlabeled)` (of type `string`)

Methods:

- `catalog` (of type `string`):
- `performer` (of type `string`):
- `rem` (of type `[string * string]`):
- `title` (of type `string`):
- `tracks` (of type `[ { album? : string, indexes : [int * { file_type? : string, filename? : string, frames : int, minutes : int, seconds : int }], isrc? : string, performer? : string, position : int, postgap? : {frames : int, minutes : int, seconds : int }, pregap? : {frames : int, minutes : int, seconds : int }, title? : string, track_type? : string }]`):

### `playlist.parse.get_file`

Resolve a uri relative to a given pwd.

Type:

    (?pwd : string?, string) -> string

Arguments:

- `pwd` (of type `string?`, which defaults to `null`): Current directory to use for relative file path.
- `(unlabeled)` (of type `string`): URI

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

    (name : string, mimes : [string], strict : bool,
     ((?pwd : string, string) -> [[string * string] * string])) -> unit

Arguments:

- `name` (of type `string`): User-friendly format name
- `mimes` (of type `[string]`): Supported mime formats.
- `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

### `protocol.add`

Register a new protocol.

Type:

    (?temporary : bool, ?static : ((string) -> 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 `(string) -> bool`, which defaults to `fun (_) -> false`): When given an uri for the protocol, if it returns `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.

### `protocol.count`

Number of registered protocols.

Type:

    () -> int

### `request.all`

Return all the requests currently available.

Type:

    () -> [request]

### `request.create`

Create a request from an URI.

Type:

    (?cue_in_metadata : string?, ?cue_out_metadata : string?, ?persistent : bool,
     ?resolve_metadata : bool, ?excluded_metadata_resolvers : [string],
     ?temporary : bool, string) -> request

Arguments:

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

    (?resolvers : [string]?, ?resolve_metadata : bool,
     ?metadata : [string * string], ?timeout : float?, string) -> float?

Arguments:

- `resolvers` (of type `[string]?`, which defaults to `null`): Set to a list of resolvers to only resolve duration using a specific decoder.
- `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 `null`): Limit in seconds to the duration of request resolution. Defaults to `settings.request.timeout` when `null`.
- `(unlabeled)` (of type `string`)

### `request.duration.ffmpeg`

Compute the duration in seconds of audio data contained in a request using the ffmpeg decoder. 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 `null`): Limit in seconds to the duration of request resolution. Defaults to `settings.request.timeout` when `null`.
- `(unlabeled)` (of type `string`)

### `request.duration.flac`

Compute the duration in seconds of audio data contained in a request using the flac decoder. 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 `null`): Limit in seconds to the duration of request resolution. Defaults to `settings.request.timeout` when `null`.
- `(unlabeled)` (of type `string`)

### `request.duration.mad`

Compute the duration in seconds of audio data contained in a request using the mad decoder. 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 `null`): Limit in seconds to the duration of request resolution. Defaults to `settings.request.timeout` when `null`.
- `(unlabeled)` (of type `string`)

### `request.duration.ogg_flac`

Compute the duration in seconds of audio data contained in a request using the ogg_flac decoder. 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 `null`): Limit in seconds to the duration of request resolution. Defaults to `settings.request.timeout` when `null`.
- `(unlabeled)` (of type `string`)

### `request.duration.wav/aiff`

Compute the duration in seconds of audio data contained in a request using the wav/aiff decoder. 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 `null`): Limit in seconds to the duration of request resolution. Defaults to `settings.request.timeout` when `null`.
- `(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.is_static`

`true` if the given URI is assumed to be static, e.g. a file.

Type:

    (string) -> bool

Arguments:

- `(unlabeled)` (of type `string`)

### `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.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).

Type:

    (?timeout : float?, ?content_type : source('a)?, request) -> bool

Arguments:

- `timeout` (of type `float?`, which defaults to `null`): Limit in seconds to the duration of the request resolution. Defaults to `settings.request.timeout` when `null`.
- `content_type` (of type `source('a)?`, which defaults to `null`): Check that the request can decode content suitable for the given source.
- `(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

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

### `track.clock`

Return the clock associated with the given track.

Type:

    ('a) -> clock where 'a is a track

Arguments:

- `(unlabeled)` (of type `anything that is a track`)

## 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.nullable`

Associate a value to a key in an association list. This functions is similar to `list.assoc` excepting that it returns `null` if no value exists for the key.

Type:

    ('a, ['a * 'b?]) -> 'b? 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`)

### `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.slice`

Return the sublist of length `length` starting with the element at index `offset`.

Type:

    (?offset : int, ?length : int?, ['a]) -> ['a]

Arguments:

- `offset` (of type `int`, which defaults to `0`): Index of the first element.
- `length` (of type `int?`, which defaults to `null`): Length of the returned list. Include all elements from `offset` if `null`.
- `(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`)

### `ceil`

Round above to an integer value. `ceil(x)` returns the least integer whose value is greater than or equal to `x`. The result is returned as a float.

Type:

    (float) -> float

Arguments:

- `(unlabeled)` (of type `float`)

### `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.is_infinite`

Return `true` if the floating point number is infinite.

Type:

    (float) -> bool

Arguments:

- `(unlabeled)` (of type `float`)

### `float.is_nan`

Return `true` if the floating point number is `NaN`.

Type:

    (float) -> bool

Arguments:

- `(unlabeled)` (of type `float`)

### `float_of_int`

Convert an int to a float.

Type:

    (int) -> float

Arguments:

- `(unlabeled)` (of type `int`)

### `floor`

Round below to an integer value. `floor(x)` returns the greatest integer whose value is less than or equal to `x`. The result is returned as a float.

Type:

    (float) -> float

Arguments:

- `(unlabeled)` (of type `float`)

### `infinity`

Float representation of infinity.

Type:

    float

### `int`

Convert a number to an integer.

Type:

    ('a, ?raise : bool) -> int where 'a is a number type

Arguments:

- `(unlabeled)` (of type `anything that is a number type`)
- `raise` (of type `bool`, which defaults to `false`): Raise `error.invalid` if number is `NaN` or `+/-infinity`.

### `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.0`)
- `max` (of type `float`, which defaults to `1.0`)

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

### `round`

Rounds `x` to the nearest integer with ties (fractional values of `0.5`) rounded away from zero, regardless of the current rounding direction. If `x` is an integer, `+0.`, `-0.`, `nan`, or `infinite`, `x` itself is returned.

Type:

    (float) -> float

Arguments:

- `(unlabeled)` (of type `float`)

### `sign`

Return `1.` if the argument is positive and `-1.` otherwise.

Type:

    (float) -> float

Arguments:

- `(unlabeled)` (of type `float`)

### `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?, ?using : [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
- `using` (of type `[string]?`, which defaults to `null`): Labels to use to compare the metadata. Defaults to all of them when `null`.
- `(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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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 : (synchronous : bool, ((['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 : (synchronous : bool, ((['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 : (synchronous : bool, ((['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 : (synchronous : bool, ((['a * string]) -> unit)) -> 'b} where 'a is an orderable type`): Source containing the metadata.

### `metadata.getter.source.float`

Create a float getter from a metadata: this is a float, whose value can be changed with a metadata. This function also returns the source.

Type:

    (float, 'a, 'c
     .{on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> 'b}) ->
    'c.{on_metadata : (synchronous : bool, ((['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 : (synchronous : bool, ((['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.lufs`

Extract the LUFS from the metadata (in dB).

Type:

    ([string * string]) -> float?

Arguments:

- `(unlabeled)` (of type `[string * string]`): Metadata from which the LUFS should be extracted.

### `metadata.replaygain`

Extract the ReplayGain from the metadata (in dB).

Type:

    ([string * string]) -> float?

Arguments:

- `(unlabeled)` (of type `[string * string]`): Metadata from which the ReplayGain should be extracted.

### `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?, ?using : [string]?, metadata) -> metadata

Arguments:

- `id` (of type `string?`, which defaults to `"track.metadata.deduplicate"`)
- `using` (of type `[string]?`, which defaults to `null`): Labels to use to compare the metadata. Defaults to all of them when `null`.
- `(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.

### `cron.add`

Add an entry to the cron tab.

Type:

    (?id : string?, string, (() -> unit)) -> unit

Arguments:

- `id` (of type `string?`, which defaults to `null`): Optional task ID.
- `(unlabeled)` (of type `string`): Cron entry
- `(unlabeled)` (of type `() -> unit`): Function to execute

Methods:

- `id` (of type `string`): ID to be used to remove the task.

### `cron.remove`

Remove a cron tab entry. ID is returned during the task’s registration

Type:

    (string) -> unit

Arguments:

- `(unlabeled)` (of type `string`)

### `error.kind`

Return error kind

Type:

    (error) -> string

Arguments:

- `(unlabeled)` (of type `error`)

### `error.message`

Return error message

Type:

    (error) -> string

Arguments:

- `(unlabeled)` (of type `error`)

### `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. The callback passed to this function is called on every errors, not just uncaught errors.

Type:

    (((error
       .{
         kind : string,
         message : string,
         trace : [
                  {
                    cstart : int,
                    cstop : int,
                    filename : string,
                    lstart : int,
                    lstop : int,
                    to_string : (?prefix : string) -> string
                  }]
       }) -> unit)) -> unit

Arguments:

- `(unlabeled)` (of type `(error .{ kind : string, message : string, trace : [ { cstart : int, cstop : int, filename : string, lstart : int, lstop : 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 `[ { cstart : int, cstop : int, filename : string, lstart : int, lstop : 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:

- `cstart` (of type `int`): Starting character
- `cstop` (of type `int`): Stopping character
- `filename` (of type `string`): Filename
- `lstart` (of type `int`): Starting line
- `lstop` (of type `int`): Stopping line
- `to_string` (of type `(?prefix : string) -> string`): Render as string

### `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) -> unit}) -> unit

Arguments:

- `(unlabeled)` (of type `(() -> int).{set : (int) -> unit}`)

### `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.delay`

Delay the current thread by the given duration in seconds.

Type:

    (float) -> unit

Arguments:

- `(unlabeled)` (of type `float`)

### `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?, ((backtrace : string, error) -> unit)) -> unit

Arguments:

- `(unlabeled)` (of type `error?`)
- `(unlabeled)` (of type `(backtrace : string, error) -> unit`)

### `thread.pause`

Pause execution for a given amount of seconds. This puts the calling thread to sleep 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, ?on_error : ((error) -> unit)?,
     ?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.0`): Delay (in seconds) after which the thread should be launched.
- `on_error` (of type `((error) -> unit)?`, which defaults to `null`): Error callback executed when an error occurred while running the given function. When passed, all raised errors are silenced unless re-raised by the callback.
- `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, ?on_error : ((error) -> 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.0`): Delay (in sec.) after which the thread should be launched.
- `on_error` (of type `((error) -> float)?`, which defaults to `null`): Error callback executed when an error occurred while running the given function. When passed, all raised errors are silenced unless re-raised by the callback.
- `(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,
     ?on_error : ((error) -> float)?, (() -> 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.
- `on_error` (of type `((error) -> float)?`, which defaults to `null`): Error callback executed when an error occurred while running the given function. When passed, all raised errors are silenced unless re-raised by the callback.
- `(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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `amplify`

Multiply the amplitude of the signal.

Type:

    (?id : string?, ?override : {string?}, {float}, source(audio='a, 'b)) ->
    source(audio='a, 'b)
    where 'b is a set of tracks to be muxed into a source,
      'a is a track and a track of type: pcm, pcm_s16 or pcm_f32

Arguments:

- `id` (of type `string?`, which defaults to `"amplify"`): Force the value of the track ID.
- `override` (of type `{string?}`, which defaults to `<fun>`): 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). Defaults to `settings.amplify.metadata`. Set to `null` to disable.
- `(unlabeled)` (of type `{float}`): Multiplicative factor.
- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source, 'a is a track and a track of type: pcm, pcm_s16 or pcm_f32`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `file.autocue.metadata`

Return the file’s autocue values as metadata suitable for metadata override.

Type:

    (request_metadata : [string * string], string) -> [string * string]

Arguments:

- `request_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.0`)
- `wetness` (of type `{float}`, which defaults to `1.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Q
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Q
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Shelf slope (in dB/octave)
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Q
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Shelf slope (dB/octave)
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Q
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Gain (in dB)
- `q` (of type `{float}`, which defaults to `1.0`): Q
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Quality factor
- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Quality factor
- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Quality factor
- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.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.0`): Phase difference between channels in radians.
- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Time to fully open the gate (ms).
- `hold` (of type `{float}`, which defaults to `1000.0`): Minimum amount of time the gate stays open (ms).
- `range` (of type `{float}`, which defaults to `-30.0`): Difference between closed and open level (dB).
- `release` (of type `{float}`, which defaults to `2000.0`): Time to fully close the gate (ms).
- `threshold` (of type `{float}`, which defaults to `-30.0`): Threshold at which the gate will open (dB).
- `window` (of type `{float}`, which defaults to `1.0`): Duration for computing peak (ms).
- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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,
     ?enabled : {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.0`): Desired RMS (dB).
- `up` (of type `{float}`, which defaults to `10.0`): 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.0`): Minimal gain value (dB).
- `gain_max` (of type `float`, which defaults to `12.0`): 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.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.0`): Minimal RMS for activaing gain control (dB).
- `track_sensitive` (of type `bool`, which defaults to `true`)
- `enabled` (of type `{bool}`, which defaults to `true`): Whether normalization is enabled or not.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Maximal gain value (dB).
- `gain_min` (of type `{float}`, which defaults to `-6.0`): 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.0`): Desired RMS (dB).
- `threshold` (of type `{float}`, which defaults to `-40.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `normalize_track_gain`

Amplify source tracks according to track gain normalization metadata. This operator does not compute that value. You can use integrated LUFS track gain or ReplayGain to compute it.

Type:

    (?id : string?, source(audio='a, 'b)) -> source(audio='a, 'b)
    where 'b is a set of tracks to be muxed into a source,
      'a is a track and a track of type: pcm, pcm_s16 or pcm_f32

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source, 'a is a track and a track of type: pcm, pcm_s16 or pcm_f32`): Source to be amplified.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `peak` (of type `() -> float`): Current value for the peak volume.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `peak` (of type `() -> float * float`): Current value for the peak volume.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`)
- `rate` (of type `{float}`, which defaults to `1.0`)
- `tempo` (of type `{float}`, which defaults to `1.0`)
- `(unlabeled)` (of type `source(audio=pcm('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `peak` (of type `() -> float`): Peak sample.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset` (of type `() -> unit`): Reset ReplayGain computation.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `stereo.pan`

Pan a stereo sound.

Type:

    (?id : string?, ?field : {float}, {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.
- `field` (of type `{float}`, which defaults to `90.0`): Field width in degrees (between 0 and 90).
- `(unlabeled)` (of type `{float}`): Pan value. Should be between `-1` (left side) and `1` (right side).
- `(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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `ffmpeg.decode.audio_video`

Decode a source’s audio and video content

Type:

    (?id : string?, source(audio=ffmpeg.copy('a), video=ffmpeg.copy('b), 'c)) ->
    source(audio=pcm('d), video=canvas('e))

Arguments:

- `id` (of type `string?`, which defaults to `"ffmpeg.decode.audio_video"`)
- `(unlabeled)` (of type `source(audio=ffmpeg.copy('a), video=ffmpeg.copy('b), 'c)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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), 'd)) ->
    source(audio=ffmpeg.copy('e), video=ffmpeg.copy('f))

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), 'd)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `ffmpeg.raw.decode.audio_video`

Decode a source’s audio and video content

Type:

    (?id : string?, source(audio=ffmpeg.audio.raw('a),
     video=ffmpeg.video.raw('b), 'c)) -> source(audio=pcm('d), video=canvas('e))

Arguments:

- `id` (of type `string?`, which defaults to `"ffmpeg.raw.decode.audio_video"`)
- `(unlabeled)` (of type `source(audio=ffmpeg.audio.raw('a), video=ffmpeg.video.raw('b), 'c)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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('d), video=canvas('e),
     'f)) -> 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('d), video=canvas('e), 'f)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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?, ?duration : {float},
     ?end_duration : {float}?, ?override_duration : string,
     ?override_end_duration : string, ?override_max_start_duration : string,
     ?override_start_duration : string, ?persist_override : bool,
     ?start_duration : {float}?, ?width : float, ?deduplicate : bool,
     ((
       {
         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)
    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.
- `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`.
- `duration` (of type `{float}`, which defaults to `5.0`): Duration (in seconds) of buffered data from the end and start of each track that is used to compute the transition between tracks.
- `end_duration` (of type `{float}?`, which defaults to `null`): Duration (in seconds) of buffered data from the end of 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.
- `override_end_duration` (of type `string`, which defaults to `"liq_cross_end_duration"`): Metadata field which, if present and containing a float, overrides the ‘end_duration’ parameter for current track.
- `override_max_start_duration` (of type `string`, which defaults to `"liq_cross_max_start_duration"`): Metadata field which, if present and containing a float, informs the crossfade of the maximum start duration. When not present, it is assumed to be `0.`.
- `override_start_duration` (of type `string`, which defaults to `"liq_cross_start_duration"`): Metadata field which, if present and containing a float, overrides the ‘start_duration’ parameter for current track.
- `persist_override` (of type `bool`, which defaults to `false`): Keep duration override on track change.
- `start_duration` (of type `{float}?`, which defaults to `null`): Duration (in seconds) of buffered data from the start of each track that is used to compute the transition between tracks.
- `width` (of type `float`, which defaults to `2.0`): Width of the power computation window.
- `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.
- `(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) where 'b is a set of tracks to be muxed into a source`): 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) where 'b is a set of tracks to be muxed into a source`)

Methods:

- `buffered` (of type `() -> [string * float]`):
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`):
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `end_duration` (of type `() -> float`):
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `start_duration` (of type `() -> float`):
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `cross.simple`

Simple transition for crossfade

Type:

    (?log : ((string) -> unit), ?fade_in : float, ?fade_out : float,
     ?initial_fade_in_metadata : [string * string],
     ?initial_fade_out_metadata : [string * string],
     ?ending_map : ((source(audio='a, 'b)) -> source(audio='a, 'b)),
     ?starting_map : ((source(audio='a, 'b)) -> source(audio='a, 'b)),
     source(audio='a, 'b), source(audio='a, 'b)) -> source(audio='a, 'b)
    where
      'b is a set of tracks to be muxed into a source and a set of internal tracks,
      'a is a track of type: pcm, pcm_s16 or pcm_f32 and a track and a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks

Arguments:

- `log` (of type `(string) -> unit`, which defaults to `<fun>`): Logging utility
- `fade_in` (of type `float`, which defaults to `3.0`): Fade-in duration, if any.
- `fade_out` (of type `float`, which defaults to `3.0`): 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
- `ending_map` (of type `(source(audio='a, 'b)) -> source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source and a set of internal tracks, 'a is a track of type: pcm, pcm_s16 or pcm_f32 and a track and a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks`, which defaults to `<fun>`): Optional mapping for the ending track
- `starting_map` (of type `(source(audio='a, 'b)) -> source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source and a set of internal tracks, 'a is a track of type: pcm, pcm_s16 or pcm_f32 and a track and a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks`, which defaults to `<fun>`): Optional mapping for the starting track
- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source and a set of internal tracks, 'a is a track of type: pcm, pcm_s16 or pcm_f32 and a track and a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks`): Ending track
- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source and a set of internal tracks, 'a is a track of type: pcm, pcm_s16 or pcm_f32 and a track and a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks`): Starting track

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `crossfade`

Crossfade between tracks, taking the respective volume levels into account in the choice of the transition.

Type:

    (?id : string?, ?start_duration : {float}?, ?end_duration : {float}?,
     ?duration : {float}, ?override_start_duration : string,
     ?override_end_duration : string, ?override_duration : string,
     ?persist_override : bool, ?width : float, ?fade_in : float,
     ?fade_out : float, ?deduplicate : 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.
- `start_duration` (of type `{float}?`, which defaults to `null`): Duration (in seconds) of buffered data from the start of each track that is used to compute the transition between tracks.
- `end_duration` (of type `{float}?`, which defaults to `null`): Duration (in seconds) of buffered data from the end of each track that is used to compute the transition between tracks.
- `duration` (of type `{float}`, which defaults to `5.0`): Duration (in seconds) of buffered data from the end and start of each track that is used to compute the transition between tracks.
- `override_start_duration` (of type `string`, which defaults to `"liq_cross_start_duration"`): Metadata field which, if present and containing a float, overrides the ‘start_duration’ parameter for current track.
- `override_end_duration` (of type `string`, which defaults to `"liq_cross_end_duration"`): Metadata field which, if present and containing a float, overrides the ‘end_duration’ parameter for current track.
- `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.0`): Width of the power computation window.
- `fade_in` (of type `float`, which defaults to `3.0`)
- `fade_out` (of type `float`, which defaults to `3.0`)
- `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.
- `(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]`):
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`):
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `end_duration` (of type `() -> float`):
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `start_duration` (of type `() -> float`):
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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='a,
     'b)) -> source(audio='a, 'b)
    where
      'b is a set of internal tracks and a set of tracks to be muxed into a source,
      'a is a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks and a track and a track of type: pcm, pcm_s16 or pcm_f32

Arguments:

- `id` (of type `string`, which defaults to `"fade.in"`): Force the value of the source ID.
- `duration` (of type `float?`, which defaults to `null`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override. Defaults to `settings.fade.in.duration` if `null`.
- `delay` (of type `float`, which defaults to `0.0`): Initial delay before starting fade.
- `curve` (of type `float?`, which defaults to `null`): Fade curve. Defaults to `settings.fade.in.curve` 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 `null`): Fader shape. One of: “lin”“,”sin”, “log” or “exp”. Defaults to `settings.fade.in.type` if `null`.
- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of internal tracks and a set of tracks to be muxed into a source, 'a is a track of type: pcm, pcm_s16, pcm_f32, canvas, metadata or track_marks and a track and a track of type: pcm, pcm_s16 or pcm_f32`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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='a,
     'b)) -> source(audio='a, 'b)
    where 'b is a set of tracks to be muxed into a source,
      'a is a track and a track of type: pcm, pcm_s16 or pcm_f32

Arguments:

- `id` (of type `string`, which defaults to `"fade.out"`): Force the value of the source ID.
- `duration` (of type `float?`, which defaults to `null`): Duration of the fading. This value can be set on a per-file basis using the metadata field passed as override. Defaults to `settings.fade.out.curve` if `null`.
- `delay` (of type `float`, which defaults to `0.0`): Initial delay before starting fade. Defaults to `settings.fade.out.delay` if `null`.
- `curve` (of type `float?`, which defaults to `null`): Fade curve. Defaults to `settings.fade.out.curve` 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 `null`): Fader shape. One of: “lin”“,”sin”, “log” or “exp”. Defaults to `settings.fade.out.type` if `null`.
- `(unlabeled)` (of type `source(audio='a, 'b) where 'b is a set of tracks to be muxed into a source, 'a is a track and a track of type: pcm, pcm_s16 or pcm_f32`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Start value.
- `stop` (of type `float`, which defaults to `1.0`): Stop value.
- `delay` (of type `float`, which defaults to `0.0`): Initial delay before starting fade.
- `duration` (of type `float`, which defaults to `3.0`): 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.0`): Duration of blank tracks in seconds, Negative value means forever.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `debug.is_ready`

A source that always produces an empty frame when the underlying source is not ready, used for testing and debugging.

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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

This function is experimental.

### `input`

Input an audio stream using the default operator.

Type:

    (?id : string?, ?start : bool, ?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.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `input.alsa`

Stream from an ALSA input device.

Type:

    (?id : string?, ?buffer_size : float?, ?device : string, ?fallible : bool,
     ?self_sync : bool, ?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 `float?`, which defaults to `null`): ALSA buffer size in seconds. Defaults to frame duration when `null`.
- `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.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the ALSA driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Duration of the pre-buffered data.
- `max` (of type `float`, which defaults to `10.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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.0`): 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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Duration of the pre-buffered data.
- `max` (of type `float`, which defaults to `10.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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.0`): Duration of the pre-buffered data.
- `max` (of type `float`, which defaults to `10.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `input.ffmpeg`

Create a stream using ffmpeg

Type:

    (?id : string?, ?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, ?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.
- `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.0`): 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.
- `poll_delay` (of type `float`, which defaults to `2.0`): 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:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler Function to execute when a source is connected.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when a source is disconnected.
- `on_error` (of type `(synchronous : bool, ((error) -> unit)) -> unit`): Call a given handler when an error occurs.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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?, ?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.0`): 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.0`): 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.
- `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler when a source is connected. Its receives the list of headers, of the form: (,<value>). All labels are lowercase.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when a source is disconnected.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler Function to execute when a source is connected.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when a source is disconnected.
- `on_error` (of type `(synchronous : bool, ((error) -> unit)) -> unit`): Call a given handler when an error occurs.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

This function is experimental.

### `input.http`

Create a http stream using ffmpeg

Type:

    (?id : string?, ?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, ?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.
- `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.0`): 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.
- `poll_delay` (of type `float`, which defaults to `2.0`): 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.0`): 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.4.0+dev (Unix; OCaml 5.4.0)"`): User agent.
- `(unlabeled)` (of type `{string}`): URL to decode.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler when a source is connected. Its receives the list of ICY-specific headers, if available.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when a source is disconnected.
- `on_error` (of type `(synchronous : bool, ((error) -> unit)) -> unit`): Call a given handler when an error occurs.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `input.jack`

Get stream from jack.

Type:

    (?id : string?, ?fallible : bool, ?self_sync : bool, ?server : string,
     ?start : bool) -> source(audio=pcm('a))

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 source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the jack server.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `input.oss`

Stream from an OSS input device.

Type:

    (?id : string?, ?device : string, ?fallible : bool, ?self_sync : bool,
     ?start : bool) -> source(audio=pcm('a))

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
- `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.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the OSS driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `input.portaudio`

Stream from a portaudio input device.

Type:

    (?id : string?, ?buflen : int, ?device_id : int?, ?fallible : bool,
     ?latency : float?, ?self_sync : bool, ?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.
- `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.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the portaudio driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `input.pulseaudio`

Stream from a pulseaudio input device.

Type:

    (?id : string?, ?client : string, ?device : string?, ?fallible : bool,
     ?on_error : ((string) -> unit), ?retry_delay : float, ?self_sync : bool,
     ?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"`)
- `device` (of type `string?`, which defaults to `null`): Device to use. Uses default if set to `null`.
- `fallible` (of type `bool`, which defaults to `true`): Allow the source to fail. If set to `false`, `start` must be `true` and `stop` method raises an error.
- `on_error` (of type `(string) -> unit`, which defaults to `fun (_) -> ()`): Function executed when an operation with the pulseaudio server returns an error.
- `retry_delay` (of type `float`, which defaults to `1.0`): When fallible, time to wait before trying to connect again.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the pulseaudio driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler Function to execute when a source is connected.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when a source is disconnected.
- `on_error` (of type `(synchronous : bool, ((error) -> unit)) -> unit`): Call a given handler when an error occurs.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when source stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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}, ?synchronous : bool, ?timeout : float?,
     ?native : bool, (() -> 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.
- `retry_delay` (of type `{float}`, which defaults to `0.1`): Retry after a given time (in seconds) when callback returns `null` or an error occurs while resolving a returned request.
- `synchronous` (of type `bool`, which defaults to `false`): If `true`, new requests are prepared as needed instead of using an asynchronous queue.
- `timeout` (of type `float?`, which defaults to `null`): Timeout (in sec.) to resolve the request. Defaults to `settings.request.timeout` when `null`.
- `native` (of type `bool`, which defaults to `false`)
- `(unlabeled)` (of type `() -> request?`)

Methods:

- `add` (of type `(request) -> bool`):
- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `current` (of type `() -> request?`):
- `current_source` (of type `() -> source('A)?`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `prepare` (of type `(source('A)) -> unit`): Prepare a source that will be returned later.
- `queue` (of type `() -> [request]`):
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `playlist`

Read a playlist or a directory and play all files.

Type:

    (?id : string?, ?check_next : ((request) -> bool)?, ?prefetch : int?,
     ?loop : bool, ?max_fail : int, ?mime_type : string?, ?mode : string,
     ?native : bool, ?on_done : (() -> unit), ?on_fail : (() -> [string])?,
     ?on_reload : ((string) -> unit), ?prefix : string, ?reload : int,
     ?reload_mode : string, ?timeout : float?, ?cue_in_metadata : string?,
     ?cue_out_metadata : string?, ?register_server_commands : bool, 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.
- `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.
- `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_done` (of type `() -> unit`, which defaults to `{()}`): Function executed when the playlist is finished.
- `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 `null`): Timeout (in sec.) to resolve the request. Defaults to `settings.request.timeout` when `null`.
- `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`.
- `register_server_commands` (of type `bool`, which defaults to `true`): Register corresponding server commands
- `(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.
- `clock` (of type `clock`): The source’s clock
- `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 `() -> unit`): Notify the source to queue a new request. If `synchronous` is `false` (the default), this method returns immediately and a new request is fetched in the background. If `synchronous` is `true`, can take long to return and should usually be run in a separate thread.
- `id` (of type `() -> string`): Identifier of the source.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could 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`.
- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `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.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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, ?on_fail : (() -> [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.
- `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.
- `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 `null`): Timeout (in sec.) to resolve the request. Defaults to `settings.request.timeout` when `null`.
- `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.

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.
- `clock` (of type `clock`): The source’s clock
- `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 `() -> unit`): Notify the source to queue a new request. If `synchronous` is `false` (the default), this method returns immediately and a new request is fetched in the background. If `synchronous` is `true`, can take long to return and should usually be run in a separate thread.
- `id` (of type `() -> string`): Identifier of the source.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `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.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `request.dynamic`

Play request dynamically created by a given function.

Type:

    (?id : string?, ?available : {bool}, ?prefetch : int?,
     ?retry_delay : {float}, ?synchronous : bool, ?timeout : float?,
     ?native : bool, (() -> 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.
- `retry_delay` (of type `{float}`, which defaults to `0.1`): Retry after a given time (in seconds) when callback returns `null` or an error occurs while resolving a returned request.
- `synchronous` (of type `bool`, which defaults to `false`): If `true`, new requests are prepared as needed instead of using an asynchronous queue.
- `timeout` (of type `float?`, which defaults to `null`): Timeout (in sec.) to resolve the request. Defaults to `settings.request.timeout` when `null`.
- `native` (of type `bool`, which defaults to `false`)
- `(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.
- `clock` (of type `clock`): The source’s clock
- `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 `() -> unit`): Notify the source to queue a new request. If `synchronous` is `false` (the default), this method returns immediately and a new request is fetched in the background. If `synchronous` is `true`, can take long to return and should usually be run in a separate thread.
- `id` (of type `() -> string`): Identifier of the source.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `queue` (of type `() -> [request]`): Get the requests currently in the queue.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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 `"request.once"`)
- `timeout` (of type `float?`, which defaults to `null`): Timeout in seconds for resolving the request.
- `(unlabeled)` (of type `request`): Request to play.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `request` (of type `request`):
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `resolve` (of type `() -> bool`):
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `request.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?, ?prefetch : int?, ?timeout : float?, ?fallible : bool?,
     {request}) -> source('a)

Arguments:

- `id` (of type `string?`, which defaults to `"request.single"`)
- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance.
- `timeout` (of type `float?`, which defaults to `null`): Timeout (in sec.) to resolve the request.
- `fallible` (of type `bool?`, which defaults to `null`): Enforce fallibility of the request.
- `(unlabeled)` (of type `{request}`): Request

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.0`): Frequency of the saw.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.0`): Frequency of the sine.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `single`

Loop on a URI. 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:

    (?prefetch : int?, ?timeout : float?, ?id : string?, ?fallible : bool,
     ?cue_in_metadata : string?, ?cue_out_metadata : string?, string) ->
    source('a)

Arguments:

- `prefetch` (of type `int?`, which defaults to `null`): How many requests should be queued in advance.
- `timeout` (of type `float?`, which defaults to `null`): Timeout (in sec.) to resolve the request.
- `id` (of type `string?`, which defaults to `"single"`)
- `fallible` (of type `bool`, which defaults to `false`): Enforce fallibility of the request.
- `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`): URI where to find the file

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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.0`): 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.0`): Frequency of the square.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## Source / Liquidsoap

### `buffer`

Create a buffer between two different clocks.

Type:

    (?id : string?, ?buffer : float, ?fallible : bool, ?max : float,
     ?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.0`): 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.0`): Maximum amount of buffered data, in seconds.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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, ?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.0`): 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.0`): 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.0`): Maximum amount of buffered data, in seconds.
- `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.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `ratio` (of type `() -> float`): Get the current scaling ratio.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

This function is experimental.

### `request.dump`

Immediately encode the whole contents of a request into a file.

Type:

    (format('a), string, request, ?ratio : float, ?timeout : float,
     ?sleep_latency : float) -> unit

Arguments:

- `(unlabeled)` (of type `format('a)`): Encoding format.
- `(unlabeled)` (of type `string`): Name of the file.
- `(unlabeled)` (of type `request`): Request to encode.
- `ratio` (of type `float`, which defaults to `50.0`): Time ratio. A value of `50` means process data at `50x` real rate, when possible.
- `timeout` (of type `float`, which defaults to `1.0`): Stop processing the source if it has not started after the given timeout.
- `sleep_latency` (of type `float`, which defaults to `0.1`): How much time ahead, in seconds, should we should be before pausing the processing.

This function is experimental.

### `request.process`

Given a request and an optional function to process this request, animate the source as fast as possible until the request is fully processed.

Type:

    (request, ?process : ((source('a)) -> source('b)), ?ratio : float,
     ?timeout : float, ?sleep_latency : float) -> unit

Arguments:

- `(unlabeled)` (of type `request`): Request to process
- `process` (of type `(source('a)) -> source('b)`, which defaults to `<fun>`): Callback to create the source to animate.
- `ratio` (of type `float`, which defaults to `50.0`): Time ratio. A value of `50` means process data at `50x` real rate, when possible.
- `timeout` (of type `float`, which defaults to `1.0`): Stop processing the source if it has not started after the given timeout.
- `sleep_latency` (of type `float`, which defaults to `0.1`): How much time ahead, in seconds, should we should be before pausing the processing.

### `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.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.methods`

Returns the given source decorated with all its methods.

Type:

    (source('a)) -> source('a)

Arguments:

- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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

Set the id 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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, ?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.
- `start` (of type `bool`, which defaults to `true`): Automatically start outputting whenever possible. If `true`, an infallible (normal) output will start 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.alsa`

Output the source’s stream to an ALSA output device.

Type:

    (?id : string?, ?buffer_size : float?, ?device : string, ?fallible : bool,
     ?register_telnet : bool, ?self_sync : 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 `float?`, which defaults to `null`): ALSA buffer size in seconds. Defaults to frame duration when `null`.
- `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.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the ALSA driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.ao`

Output stream to local sound card using libao.

Type:

    (?id : string?, ?channels_matrix : string, ?driver : string,
     ?fallible : bool, ?options : [string * string], ?register_telnet : bool,
     ?self_sync : 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.
- `channels_matrix` (of type `string`, which defaults to `""`): Output channels matrix, “” for AO’s default.
- `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.
- `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.
- `self_sync` (of type `bool`, which defaults to `true`): Use the dedicated AO clock.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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, ?start : bool, source(audio=pcm('B),
     video=canvas('A), '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.
- `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('B), video=canvas('A), 'a)`): Source to play.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.dummy`

Dummy output: computes the stream, without actually using it.

Type:

    (?id : string?, ?fallible : bool, ?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.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.external`

Send the stream to a process’ standard input.

Type:

    (?id : string?, ?export_cover_metadata : bool, ?fallible : bool,
     ?flush : bool, ?register_telnet : bool, ?reopen_delay : {float},
     ?reopen_on_error : ((error?) -> 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.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `reopen_delay` (of type `{float}`, which defaults to `120.0`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
- `reopen_on_error` (of type `(error?) -> float?`, which defaults to `fun (_) -> null`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `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.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_reopen` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when the output is reopened.
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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), ?perm : int, ?register_telnet : bool,
     ?reopen_delay : {float}, ?reopen_on_error : ((error?) -> 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.
- `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.0`): Prevent re-opening within that delay, in seconds. Only applies to `reopen_when`.
- `reopen_on_error` (of type `(error?) -> float?`, which defaults to `fun (_) -> null`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `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.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_reopen` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when the output is reopened.
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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,
     ?perm : int, ?persist_at : string?, ?playlist : string, ?prefix : string,
     ?register_telnet : bool, ?segment_duration : float,
     ?segment_name : ((
                       {
                         duration : float,
                         extname : string,
                         position : int,
                         stream_name : string,
                         ticks : int
                       }) -> string),
     ?segments : int, ?segments_overhead : int?, ?start : bool,
     ?strict_persist : bool, ?temp_dir : string?,
     ?main_playlist_writer : ((extra_tags : [string], prefix : string,
                               version : int,
                               [string
                                .{
                                  bandwidth : int,
                                  codecs : string,
                                  video_size? : int * int
                                }]) -> 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.
- `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.
- `perm` (of type `int`, which defaults to `438`): Permission of the created files, up to umask.
- `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.0`): Segment duration (in seconds).
- `segment_name` (of type `( { duration : float, extname : string, position : int, stream_name : string, ticks : int }) -> string`, which defaults to `<fun>`): Segment name. Default: `fun (metadata) -> "#{metadata.stream_name}_#{metadata.position}.#{metadata.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. Set to `null` to disable.
- `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 the same directory as the HLS files if `null`.
- `main_playlist_writer` (of type `((extra_tags : [string], prefix : string, version : int, [string.{bandwidth : int, codecs : string, video_size? : int * int}]) -> string?)?`, which defaults to `<fun>`): Main playlist writer. Main playlist writing is disabled when `null` or when returning `null`.
- `(unlabeled)` (of type `string`): List of specifications for each stream: (name, format).
- `(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 }]`): Directory for generated files.
- `(unlabeled)` (of type `source('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `insert_tag` (of type `(string) -> unit`): Insert the same tag into all the streams
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_file_change` (of type `(synchronous : bool, (({path : string, state : string}) -> unit)) -> unit`): Call a given handler when a file changes. `state` is one of: `"created"`, `"updated"` or `"deleted"`, `path` is the full file path. Typical use: sync file with a CDN
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.graphics`

Display video stream using the Graphics library.

Type:

    (?id : string?, ?fallible : bool, ?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.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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,
     ?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`)
- `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (({headers : [string * string], ip : string, protocol : string, uri : string }) -> unit)) -> unit`): Call a given handler when connection is established (takes headers, connection uri, protocol and client’s IP as arguments).
- `on_disconnect` (of type `(synchronous : bool, ((string) -> unit)) -> unit`): Call a given handler when a source is disconnected.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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,
     ?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?,
     ?main_playlist_writer : ((extra_tags : [string], prefix : string,
                               version : int,
                               [string
                                .{
                                  bandwidth : int,
                                  codecs : string,
                                  video_size? : int * int
                                }]) -> string?)?,
     ?segment_name : ((
                       {
                         duration : float,
                         extname : string,
                         position : int,
                         stream_name : string,
                         ticks : int
                       }) -> 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.
- `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.
- `perm` (of type `int`, which defaults to `438`): Permission of the created files, up to umask.
- `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.0`): 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. Set to `null` to disable.
- `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 the same directory as the HLS files if `null`.
- `main_playlist_writer` (of type `((extra_tags : [string], prefix : string, version : int, [string.{bandwidth : int, codecs : string, video_size? : int * int}]) -> string?)?`, which defaults to `<fun>`): Main playlist writer. Main playlist writing is disabled when `null` or when returning `null`.
- `segment_name` (of type `( { duration : float, extname : string, position : int, stream_name : string, ticks : int }) -> string`, which defaults to `<fun>`): Segment name. Default: `fun (metadata) -> "#{metadata.stream_name}_#{metadata.position}.#{metadata.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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `insert_tag` (of type `(string) -> unit`): Insert the same tag into all the streams
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_file_change` (of type `(synchronous : bool, (({path : string, state : string}) -> unit)) -> unit`): Call a given handler when a file changes. `state` is one of: `"created"`, `"updated"` or `"deleted"`, `path` is the full file path. Typical use: sync file with a CDN
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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?, ?password : string, ?port : int,
     ?prefer_address : string?, ?public : bool, ?register_telnet : bool,
     ?send_icy_metadata : bool?, ?send_last_metadata_on_connect : 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.0`): 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.4.0+dev (Unix; OCaml 5.4.0)")]`): 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`)
- `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: `"system"`, `"ipv4"` or `"ipv6"`. Defaults to `settings.icecast.prefer_address` 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`
- `send_last_metadata_on_connect` (of type `bool`, which defaults to `true`): Send the source’s last metadata when connecting to the remote icecast server.
- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
- `timeout` (of type `float`, which defaults to `30.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when connection is established.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when connection stops.
- `on_error` (of type `(synchronous : bool, ((restart_in : ((float?) -> unit), error) -> unit)) -> unit`): Call a given handler when an error happens. The callback receives the error that occurred and a restart callback. If restart callback is executed with a positive float value, connection will be tried again after this amount of time (in seconds). If executed with a negative value, an error is raised. If executed with `null`, connection is not attempted again and no errors are raised. There can only be one single callback registered for this at a time. Every secondary registration replaces the previous one.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.jack`

Output stream to jack.

Type:

    (?id : string?, ?fallible : bool, ?register_telnet : bool, ?self_sync : 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.
- `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.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `self_sync` (of type `bool`, which defaults to `true`): Force the use of the dedicated bjack clock.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.oss`

Output the source’s stream to an OSS output device.

Type:

    (?id : string?, ?device : string, ?fallible : bool, ?register_telnet : bool,
     ?self_sync : 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.
- `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.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the OSS driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.portaudio`

Output the source’s stream to a portaudio output device.

Type:

    (?id : string?, ?buflen : int, ?device_id : int?, ?fallible : bool,
     ?latency : float?, ?register_telnet : bool, ?self_sync : 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.
- `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.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the portaudio driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.pulseaudio`

Output the source’s stream to a pulseaudio output device.

Type:

    (?id : string?, ?client : string, ?device : string?, ?fallible : bool,
     ?on_error : ((string) -> unit), ?register_telnet : bool,
     ?retry_delay : float, ?self_sync : 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"`)
- `device` (of type `string?`, which defaults to `null`): Device to use. Uses default if set to `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.
- `on_error` (of type `(string) -> unit`, which defaults to `fun (_) -> ()`): Function executed when an operation with the pulseaudio server returns an error.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `retry_delay` (of type `float`, which defaults to `1.0`): When fallible, time to wait before trying to connect again.
- `self_sync` (of type `bool`, which defaults to `true`): Mark the source as being synchronized by the pulseaudio driver.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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?,
     ?password : string, ?port : int, ?prefer_address : string?, ?public : bool,
     ?register_telnet : bool, ?send_icy_metadata : bool?,
     ?send_last_metadata_on_connect : 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.0`): 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.4.0+dev (Unix; OCaml 5.4.0)")]`): 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`)
- `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: `"system"`, `"ipv4"` or `"ipv6"`. Defaults to `settings.icecast.prefer_address` 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`
- `send_last_metadata_on_connect` (of type `bool`, which defaults to `true`): Send the source’s last metadata when connecting to the remote icecast server.
- `start` (of type `bool`, which defaults to `true`): Start output as soon as it is available.
- `timeout` (of type `float`, which defaults to `30.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_connect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when connection is established.
- `on_disconnect` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when connection stops.
- `on_error` (of type `(synchronous : bool, ((restart_in : ((float?) -> unit), error) -> unit)) -> unit`): Call a given handler when an error happens. The callback receives the error that occurred and a restart callback. If restart callback is executed with a positive float value, connection will be tried again after this amount of time (in seconds). If executed with a negative value, an error is raised. If executed with `null`, connection is not attempted again and no errors are raised. There can only be one single callback registered for this at a time. Every secondary registration replaces the previous one.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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,
     ?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.
- `register_telnet` (of type `bool`, which defaults to `true`): Register telnet commands for this output.
- `restart_delay` (of type `float?`, which defaults to `2.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_error` (of type `(synchronous : bool, ((error) -> unit)) -> unit`): Call a given handler when an error occurs.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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, ?start : bool, source(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.
- `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))`): Source to play.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.youtube.live.hls`

Stream to youtube using HLS.

Type:

    (?id : string?, ?fallible : bool, ?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.
- `segment_duration` (of type `float`, which defaults to `2.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `insert_tag` (of type `(string) -> unit`): Insert the same tag into all the streams
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_file_change` (of type `(synchronous : bool, (({path : string, state : string}) -> unit)) -> unit`): Call a given handler when a file changes. `state` is one of: `"created"`, `"updated"` or `"deleted"`, `path` is the full file path. Typical use: sync file with a CDN
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `output.youtube.live.rtmp`

Stream to youtube using RTMP.

Type:

    (?id : string?, ?fallible : bool, ?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.
- `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a 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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.
- `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.

Callbacks:

- `on_error` (of type `(synchronous : bool, ((error) -> unit)) -> unit`): Call a given handler when an error occurs.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_start` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output starts
- `on_stop` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when output stops
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## 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.0`): 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.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:

- `frozen` (of type `(() -> bool).{set : (bool) -> unit}`): The stream production is frozen while set to `true`.

This function is experimental.

## Source / Track processing

### `blank.detect`

Calls a given handler when detecting a 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.0`): Maximum duration of silence allowed, in seconds.
- `min_noise` (of type `{float}`, which defaults to `0.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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_blank` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when detecting a blank.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_noise` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when noise is detected.
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Maximum duration of silence allowed, in seconds.
- `min_noise` (of type `{float}`, which defaults to `0.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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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)) -> 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.0`): Power in decibels under which the stream is considered silent.
- `max_blank` (of type `float`, which defaults to `20.0`): Maximum silence length allowed, in seconds.
- `min_noise` (of type `float`, which defaults to `0.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)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_blank` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when detecting a blank.
- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_noise` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler when noise is detected.
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `blank.strip`

Make the source unavailable when it is streaming blank. This is an active operator, meaning that the source used in this operator will be consumed continuously, even when it is not actively used.

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.0`): Maximum duration of silence allowed, in seconds.
- `min_noise` (of type `{float}`, which defaults to `0.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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.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`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `delay_line`

Delay the source by a given amount of time.

Type:

    (?id : string?, {float}, source('a)) -> source('a)

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('a)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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 `null`): Completely remove empty metadata. Operates on both empty values and empty metadata chunk. Defaults to `settings.metadata.map.strip` when `null`.
- `insert_missing` (of type `bool?`, which defaults to `null`): Treat track beginnings without metadata as having empty ones. The operational order is: create empty if needed, map and strip if enabled. Defaults to `settings.metadata.map.insert_missing` when `null`.
- `(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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `queue` (of type `() -> [source('A)]`): Return the current sequence of source
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `current_source` (of type `() -> source('A)? where 'A is a set of internal tracks`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could 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`.
- `play` (of type `(request) -> unit`): Play a request.
- `prepare` (of type `(source('A)) -> unit where 'A is a set of internal tracks`): Prepare a source that will be returned later.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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 `null`): Timeout (in sec.) to resolve the request.

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.
- `clock` (of type `clock`): The source’s clock
- `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 `() -> unit`): Notify the source to queue a new request. If `synchronous` is `false` (the default), this method returns immediately and a new request is fetched in the background. If `synchronous` is `true`, can take long to return and should usually be run in a separate thread.
- `id` (of type `() -> string`): Identifier of the source.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could 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`.
- `push` (of type `((request) -> unit).{uri : (string) -> unit}`): Push a request on the request queue.
- `queue` (of type `() -> [request]`):
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `queue` (of type `() -> [source('A)]`): Return the current sequence of source
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `source.drop.audio`

Remove the audio track of a source.

Type:

    (?id : string?, source(audio='a, 'b)) -> source(audio='a, '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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `source.drop.metadata_track_marks`

Remove the metadata and track marks 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `source.drop.midi`

Remove the midi track of a source.

Type:

    (?id : string?, source(midi='a, 'b)) -> source(midi='a, '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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `source.drop.track_marks`

Remove the track marks 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `source.drop.video`

Remove the video track of a source.

Type:

    (?id : string?, source(video='a, 'b)) -> source(video='a, '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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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)?, ?merge : {bool},
     ?self_sync : bool?, ?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
- `merge` (of type `{bool}`, which defaults to `false`): Set or return `true` to merge subsequent tracks.
- `self_sync` (of type `bool?`, which defaults to `null`): For the source’s `self_sync` property.
- `track_sensitive` (of type `{bool}`, which defaults to `false`): Whether the source should only be updated on track change.
- `(unlabeled)` (of type `() -> source('a)?`): Function returning the source to be used, `null` means keep current source.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `current_source` (of type `() -> source('A)?`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `prepare` (of type `(source('A)) -> unit`): Prepare a source that will be returned later.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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='a, 'b) where 'a 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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='a, 'b) where 'a 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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='a, 'b) where 'a 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## Source / Video processing

### `image`

Generate a source from an image file.

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.
- `clock` (of type `clock`): The source’s clock
- `current_source` (of type `() -> source(video=canvas('B), 'A)?`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `prepare` (of type `(source(video=canvas('B), 'A)) -> unit`): Prepare a source that will be returned later.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `request.image`

Generate a source from an image request.

Type:

    (?id : string?, ?fallible : bool, ?width : {int}?, ?height : {int}?,
     ?x : {int}, ?y : {int}, {request}) -> 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 `{request}`): Image request

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `current_source` (of type `() -> source(video=canvas('B), 'A)?`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `prepare` (of type `(source(video=canvas('B), 'A)) -> unit`): Prepare a source that will be returned later.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.add_image`

Add a static image on the source video channel.

Type:

    (?id : string?, ?fallible : bool, ?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.
- `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 `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.add_request`

Add a static request on the source video channel.

Type:

    (?id : string?, ?fallible : bool, ?width : {int}?, ?height : {int}?,
     ?x : {int}, ?y : {int}, request : {request}, 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_request"`): 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.
- `request` (of type `{request}`): Request to add to the video channel
- `(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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.add_subtitle`

Add subtitle from metadata.

Type:

    (?override : string, ?size : int, ?color : int, ?offset : int,
     source(video=canvas('A), 'b)
     .{on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> 'a}) ->
    source(video=canvas('A), 'b)
    where 'b 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 `0xffffff`)
- `offset` (of type `int`, which defaults to `20`): Offset in pixels.
- `(unlabeled)` (of type `source(video=canvas('A), 'b) .{on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> 'a} where 'b is a set of tracks to be muxed into a source`): Source.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.add_text`

Add a text to a stream. Uses the first available operator in: camlimages, SDL, FFmpeg, gd or native.

Type:

    (?id : string?, ?duration : float?, ?color : int, ?cycle : bool,
     ?font : {string}?, ?metadata : 'a?, ?size : int, ?speed : int, ?x : {int},
     ?y : {int}, ?on_cycle : (() -> unit), {string}, source(video=canvas('A), 'b)
     .{
       is_ready : {bool},
       on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> unit
     }) -> source(video=canvas('A), 'b)
    where 'b is a set of tracks to be muxed into a source,
      'a is an orderable type

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 `0xffffff`): 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 `'a? where 'a is an orderable type`, 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), 'b) .{ is_ready : {bool}, on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> unit } where 'b is a set of tracks to be muxed into a source, 'a is an orderable type`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.add_text.ffmpeg`

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('a), video=canvas('b),
     'c)) -> source(audio=pcm('d), video=canvas('e))

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
- `color` (of type `int`, which defaults to `0xffffff`): 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}`): Text to display.
- `(unlabeled)` (of type `source(audio=pcm('a), video=canvas('b), 'c)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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('d),
     'e)
     .{
       on_frame : (synchronous : bool, (() -> unit)) -> 'c,
       on_metadata : (synchronous : bool, (('a) -> unit)) -> 'b
     }) -> ffmpeg.filter.video

Arguments:

- `color` (of type `int`, which defaults to `0xffffff`): 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 `""`): Text to display.
- `(unlabeled)` (of type `source(video=ffmpeg.video.raw('d), 'e) .{ on_frame : (synchronous : bool, (() -> unit)) -> 'c, on_metadata : (synchronous : bool, (('a) -> unit)) -> '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 `0xffffff`): 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 `""`): 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.gd`

Add a text to a stream (GD implementation).

Type:

    (?id : string?, ?duration : float?, ?color : {int}, ?cycle : bool,
     ?font : {string}?, ?metadata : 'a?, ?size : {int}, ?speed : int, ?x : {int},
     ?y : {int}, ?on_cycle : (() -> unit), {string}, source(video=canvas('b), 'c)
     .{
       is_ready : {bool},
       on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> unit
     }) -> source(video=canvas('b), 'c)
    where 'c is a set of tracks to be muxed into a source,
      'a is an orderable type

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 `0xffffff`): 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 `'a? where 'a is an orderable type`, 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), 'c) .{ is_ready : {bool}, on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> unit } where 'c is a set of tracks to be muxed into a source, 'a is an orderable type`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.add_text.native`

Add a text to a stream (native implementation).

Type:

    (?id : string?, ?duration : float?, ?color : {int}, ?cycle : bool,
     ?font : {string}?, ?metadata : 'a?, ?size : {int}, ?speed : int, ?x : {int},
     ?y : {int}, ?on_cycle : (() -> unit), {string}, source(video=canvas('b), 'c)
     .{
       is_ready : {bool},
       on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> unit
     }) -> source(video=canvas('b), 'c)
    where 'c is a set of tracks to be muxed into a source,
      'a is an orderable type

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 `0xffffff`): 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 `'a? where 'a is an orderable type`, 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), 'c) .{ is_ready : {bool}, on_metadata : (synchronous : bool, ((['a * string]) -> unit)) -> unit } where 'c is a set of tracks to be muxed into a source, 'a is an orderable type`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could 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`.
- `pixel` (of type `(int, int) -> (() -> int).{set : (int) -> unit}`): Retrieve a pixel whose contents is a color (in 0xRRGGBB format).
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.canvas.make`

Create a virtual canvas that can be used to return video position and sizes that are independent of the frame’s dimensions. of the canvas height of the canvas width

Type:

    (virtual_width : 'a, actual_size : 'd.{height : 'b, width : 'c},
     font_size : 'e) -> unit
    where 'a, 'b, 'c, 'e is a number type

Arguments:

- `virtual_width` (of type `anything that is a number type`): Virtual height, in pixels, of the canvas
- `actual_size` (of type `'d.{height : 'b, width : 'c} where 'b, 'c is a number type`): Actual size, in pixels, of the canvas
- `font_size` (of type `anything that is a number type`): Font size, in virtual pixels.

Methods:

- `height` (of type `something that is a number type`):
- `px` (of type `(int) -> int`):
- `rem` (of type `(float) -> int`):
- `vh` (of type `(float) -> int`):
- `vw` (of type `(float) -> int`):
- `width` (of type `something that is a number type`):

### `video.canvas.virtual_10k`

Standard video canvas based off a `10k` virtual canvas.

Type:

    unit

Methods:

- `actual_1080p` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):
- `actual_1440p` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):
- `actual_360p` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):
- `actual_480p` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):
- `actual_4k` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):
- `actual_720p` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):
- `actual_8k` (of type `{ height : int, px : (int) -> int, rem : (float) -> int, vh : (float) -> int, vw : (float) -> int, width : int }`):

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.cover`

Generate a video source containing cover-art for current track of input audio source.

Type:

    (source('a)?) -> source('a)

Arguments:

- `(unlabeled)` (of type `source('a)?`): Audio source whose metadata contain cover-art.

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `current_source` (of type `() -> source('A)?`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `prepare` (of type `(source('A)) -> unit`): Prepare a source that will be returned later.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): 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.
- `insert_metadata` (of type `(?new_track : bool, [string * string]) -> unit`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `planes` (of type `() -> int`): Number of planes in a video frame.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, 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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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: from 0 (fully transparent) to 1 (fully opaque).
- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Persistence duration in seconds.
- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Minimal value of the parameter.
- `max` (of type `float`, which defaults to `1.0`): Maximal value of the parameter.
- `speed` (of type `float`, which defaults to `100.0`): Speed in pixels per second.
- `color` (of type `int`, which defaults to `0xffffff`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Angle in radians.
- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): Scaling coefficient in both directions.
- `x` (of type `{int}`, which defaults to `0`): x offset.
- `xscale` (of type `{float}`, which defaults to `1.0`): x scaling.
- `y` (of type `{int}`, which defaults to `0`): y offset.
- `yscale` (of type `{float}`, which defaults to `1.0`): y scaling.
- `(unlabeled)` (of type `source(video=canvas('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `current` (of type `() -> string`): Currently displayed file.
- `current_source` (of type `() -> source('A)?`): Return the source currently selected.
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last 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.
- `prepare` (of type `(source('A)) -> unit`): Prepare a source that will be returned later.
- `prev` (of type `() -> unit`): Go to previous file.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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, gd or native.

Type:

    (?id : string?, ?color : {int}, ?duration : float?, ?font : {string}?,
     ?size : {int}, {string}) -> source(video=canvas('B), 'A)

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the source ID.
- `color` (of type `{int}`, which defaults to `0xffffff`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `video.text.gd`

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 `0xffffff`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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 `0xffffff`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

## 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.0`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last 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_integrated` (of type `() -> float`): Average LUFS value over the current track.
- `lufs_momentary` (of type `() -> float`): Momentary LUFS (over a 400ms window).
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `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.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

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

### `hls.playlist.main`

Generate a main HLS playlist

Type:

    (?extra_tags : [string], ?prefix : string, ?version : int,
     [string.{bandwidth : int, codecs : string, video_size? : int * int}]) ->
    string

Arguments:

- `extra_tags` (of type `[string]`, which defaults to `[]`)
- `prefix` (of type `string`, which defaults to `""`)
- `version` (of type `int`, which defaults to `7`)
- `(unlabeled)` (of type `[string.{bandwidth : int, codecs : string, video_size? : int * int}]`)

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

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

### `metadata.parse.amplify`

Parse an amplify metadata. Parsing is the same as in the `amplify` operator. Metadata can be of the form: “<db> dB” for a decibel-based value or “<float>” for a linear-based value. Returns a decibel value.

Type:

    (string) -> float

Arguments:

- `(unlabeled)` (of type `string`)

### `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"`, `"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.memory.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.bytes`

Return an array of the string’s bytes.

Type:

    (string) -> [string]

Arguments:

- `(unlabeled)` (of type `string`)

### `string.bytes.length`

Return the length of the string in bytes.

Type:

    (string) -> int

Arguments:

- `(unlabeled)` (of type `string`)

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

All ASCII characters code

Type:

    [int]

### `string.char.ascii.alphabet`

All ASCII alphabet character codes

Type:

    [int]

### `string.char.ascii.control`

All ASCII control character codes

Type:

    [int]

### `string.char.ascii.number`

All ASCII number character codes

Type:

    [int]

### `string.char.ascii.printable`

All ASCII printable character codes

Type:

    [int]

### `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.chars`

Split string into characters. Raises `error.invalid` on errors.

Type:

    (?encoding : string?, string) -> [string]

Arguments:

- `encoding` (of type `string?`, which defaults to `null`): Encoding used to split characters. Should be one of: `"utf8"` or `"ascii"`
- `(unlabeled)` (of type `string`)

### `string.compare`

Compare strings in lexicographical order.

Type:

    (string, string) -> int

Arguments:

- `(unlabeled)` (of type `string`)
- `(unlabeled)` (of type `string`)

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

    (?encoding : string?, ?prefix : string, ?substring : string,
     ?suffix : string, string) -> bool

Arguments:

- `encoding` (of type `string?`, which defaults to `null`): Encoding used to split characters. Should be one of: `"utf8"` or `"ascii"`
- `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.digest`

Return an MD5 digest for the given string.

Type:

    (string) -> string

Arguments:

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

    (?category : string, string) -> string

Arguments:

- `category` (of type `string`, which defaults to `""`): Category
- `(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`

Return the string’s length using the given encoding. Raises `error.invalid` on errors.

Type:

    (?encoding : string?, string) -> int

Arguments:

- `encoding` (of type `string?`, which defaults to `null`): Encoding used to split characters. Should be one of: `"utf8"` or `"ascii"`
- `(unlabeled)` (of type `string`)

### `string.lowercase`

Convert a string to lowercase.

Type:

    (string) -> string

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:

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

Convert an int to string.

Type:

    (?digits : int, 'a) -> string

Arguments:

- `digits` (of type `int`, which defaults to `0`): Minimal number of digits (pad with 0s on the left if necessary).
- `(unlabeled)` (of type `'a`)

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

    (?encoding : string?, prefix : string, string) -> string?

Arguments:

- `encoding` (of type `string?`, which defaults to `null`): Encoding used to split characters. Should be one of: `"utf8"` or `"ascii"`
- `prefix` (of type `string`): Requested prefix.
- `(unlabeled)` (of type `string`)

### `string.spaces`

Generate a given number of spaces (this can be useful for indenting).

Type:

    (int) -> string

Arguments:

- `(unlabeled)` (of type `int`): Number of spaces.

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

    (?encoding : string?, separator : string, string) -> string * string

Arguments:

- `encoding` (of type `string?`, which defaults to `null`)
- `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, ?encoding : string?, length : int) -> string

Arguments:

- `(unlabeled)` (of type `string`)
- `start` (of type `int`): Return a sub string starting at this position. First position is 0.
- `encoding` (of type `string?`, which defaults to `null`): Encoding used to split characters. Should be one of: `"utf8"` or `"ascii"`
- `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.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.uppercase`

Convert a string to uppercase.

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.

### `xml.stringify`

Convert a value to XML. If the value cannot be represented as XML (for instance a function), a `error.xml` exception is raised.

Type:

    (?compact : bool, 'a) -> string

Arguments:

- `compact` (of type `bool`, which defaults to `false`): Output compact text.
- `(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.0`): 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.0`): 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, ?stdin : string,
     ?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.
- `stdin` (of type `string`, which defaults to `""`): Data to write to the process’ standard input.
- `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,
      closed : () -> bool,
      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,
      closed : () -> bool,
      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,
      closed : () -> bool,
      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.0`): 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.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.memory`

Returns information about the system and process’ memory.

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

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

### `cron.parse`

Parse a cron entry. Format is the posix crontab format with linux extensions (named months and week days and @yearly,annyally,monthly,weeklydaily,hourly.

Type:

    (string) -> unit

Arguments:

- `(unlabeled)` (of type `string`)

Methods:

- `hour` (of type `string`)
- `minute` (of type `string`)
- `month` (of type `string`)
- `month_day` (of type `string`)
- `test` (of type `(?time : float?) -> bool`)
- `week_day` (of type `string`)

### `duration.split`

Convert a duration in seconds to hour/minutes/seconds

Type:

    (int) -> unit

Arguments:

- `(unlabeled)` (of type `int`)

Methods:

- `hours` (of type `int`):
- `minutes` (of type `int`):
- `seconds` (of type `int`):

### `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: %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:

    s = time.string("Current time is %H:%M.")
    print(s)

Example:

    # 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?, ?override : {string?}, {float}, pcm*) -> pcm*

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
- `override` (of type `{string?}`, which defaults to `<fun>`): 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). Defaults to `settings.amplify.metadata`. Set to `null` to disable.
- `(unlabeled)` (of type `{float}`): Multiplicative factor.
- `(unlabeled)` (of type `anything that is a track of type: pcm, pcm_s16 or pcm_f32`)

### `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.0`): 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.0`)
- `(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.0`): Attack time (ms).
- `release` (of type `{float}`, which defaults to `400.0`): Release time (ms).
- `lookahead` (of type `{float}`, which defaults to `0.0`): Lookahead (ms).
- `threshold` (of type `{float}`, which defaults to `-10.0`): Threshold level (dB).
- `track_sensitive` (of type `bool`, which defaults to `false`): Reset on every track.
- `knee` (of type `{float}`, which defaults to `1.0`): Knee width (dB).
- `pre_gain` (of type `{float}`, which defaults to `0.0`): Pre-amplification (dB).
- `gain` (of type `{float}`, which defaults to `0.0`): Post-amplification (dB).
- `ratio` (of type `{float}`, which defaults to `2.0`): Gain reduction ratio (reduction is ratio:1). Must be at least 1.
- `window` (of type `{float}`, which defaults to `0.0`): RMS window length (second). `0.` means peak mode.
- `wet` (of type `{float}`, which defaults to `1.0`): 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.0`): 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.0`): 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?, ?field : {float}, {float}, pcm(stereo)) -> pcm(stereo)

Arguments:

- `id` (of type `string?`, which defaults to `null`): Force the value of the track ID.
- `field` (of type `{float}`, which defaults to `90.0`): Field width in degrees (between 0 and 90).
- `(unlabeled)` (of type `{float}`): Pan value. Should be between `-1` (left side) and `1` (right side).
- `(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.0`): Width of the signal (-1: mono, 0.: original, 1.: wide stereo).
- `(unlabeled)` (of type `pcm(stereo)`)

### `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 `null`): Completely remove empty metadata. Operates on both empty values and empty metadata chunk. Defaults to `settings.metadata.map.strip` when `null`.
- `insert_missing` (of type `bool?`, which defaults to `null`): Treat track beginnings without metadata as having empty ones. The operational order is: create empty if needed, map and strip if enabled. Defaults to `settings.metadata.map.insert_missing` when `null`.
- `(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.add_request`

Add a static request on the given video track.

Type:

    (?id : string?, ?fallible : bool, ?width : {int}?, ?height : {int}?,
     ?x : {int}, ?y : {int}, request : {request}, canvas('a)) -> canvas('a)

Arguments:

- `id` (of type `string?`, which defaults to `"track.video.add_request"`): 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.
- `request` (of type `{request}`): Request to add to the video track
- `(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.

This operator encodes and decodes the audio content. See `defer.pcm_s16` for a low-level operator using directly the `pcm_s16` format.

Type:

    (?id : string?, delay : float, ?overhead : float?, source(audio=pcm('a), 'b)) ->
    source(audio=pcm('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('a), 'b)`)

Methods:

- `buffered` (of type `() -> [string * float]`): Length of buffered data.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `defer.pcm_s16`

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.

This operator uses a source already using `pcm_s16` audio data. It can be used to prevent unneeded data copy. Typically, decoders that know how to decode to `pcm_s16` (like `ffmpeg`) will decode directly into the format and encoders who support it (also `%ffmpeg`) will encoder directly from the `pcm_s16` data. Use `defer` if you prefer a more user-friendly operator.

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.pcm_s16"`): 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.
- `clock` (of type `clock`): The source’s clock
- `duration` (of type `() -> float`): Estimation of the duration of the current track.
- `elapsed` (of type `() -> float`): Elapsed time in the current track.
- `fallible` (of 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`): Dynamically insert metadata in a stream. Inserts a new track with the given metadata if `new_track` is `true`.
- `is_active` (of type `() -> bool`): `true` if the source is active, i.e. it is continuously animated by its own clock whenever it is ready. Typically, `true` for outputs and sources such as `input.http`.
- `is_ready` (of type `() -> bool`): Indicate if a source is ready to stream. This does not mean that the source is currently streaming, just that its resources are all properly initialized.
- `is_up` (of type `() -> bool`): Indicate that the source can be asked to produce some data at any time. This is `true` when the source is currently being used or if it could be used at any time, typically inside a `switch` or `fallback`.
- `last_metadata` (of type `() -> [string * string]?`): Return the last metadata from the source.
- `log` (of type `{level : (() -> int).{set : (int) -> unit}}`): Get or set the source’s log level, from `1` to `5`.
- `register_command` (of type `(?usage : string?, description : string, string, ((string) -> string)) -> unit`): Register a server command for this source. Command is registered under the source’s id namespace when it gets up and de-registered when it gets down.
- `remaining` (of type `() -> float`): Estimation of remaining time in the current track.
- `reset_last_metadata_on_track` (of type `(() -> bool).{set : (bool) -> unit}`): If `true`, the source’s `last_metadata` is reset on each new track. If a metadata is present along with the track mark, then it becomes the new `last_metadata`, otherwise, `last_metadata becomes`null`.
- `seek` (of type `(float) -> float`): Seek forward, in seconds (returns the amount of time effectively seeked).
- `self_sync` (of type `() -> bool`): Is the source currently controlling its own real-time loop.
- `skip` (of type `() -> unit`): Skip to the next track.
- `time` (of type `() -> float`): Get a source’s time, based on its assigned clock.

Callbacks:

- `on_frame` (of type `(?before : bool, synchronous : bool, (() -> unit)) -> unit`): Call a given handler on frame. When `before` is `true`, callback is executed before computing the frame and after otherwise
- `on_metadata` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler to execute on each metadata
- `on_position` (of type `(position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit`): Call a given handler on track position. If `remaining` is `false`, callback is executed when position in track is more or equal to `position`. If `remaining` is `true`, callback is executed when remaining time in the current track is less or equal to `position`. Keep in mind that elapsed time is exact while remaining time is always estimated. Remaining time is usually more accurate for file-based sources. When `allow_partial` is `true`, if the current track ends before the `offset` position is reached, callback is still executed
- `on_shutdown` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called when source shuts down
- `on_track` (of type `(synchronous : bool, (([string * string]) -> unit)) -> unit`): Call a given handler on track marks
- `on_wake_up` (of type `(synchronous : bool, (() -> unit)) -> unit`): Call a given handler to be called after the source is asked to get ready

### `interactive.persistency`

Function called to ensure persistency of data.

Type:

    () -> () -> unit

### `native`

Native reimplementation of track functions.

Type:

    unit

### `native.request`

This allows doing `open native`

Type:

    unit

Methods:

- `all` (of type `() -> [request]`):
- `create` (of type `(?cue_in_metadata : string?, ?cue_out_metadata : string?, ?persistent : bool, ?resolve_metadata : bool, ?excluded_metadata_resolvers : [string], ?temporary : bool, string) -> request`):
- `destroy` (of type `(?force : bool, request) -> unit`):
- `dump` (of type `(format('a), string, request, ?ratio : float, ?timeout : float, ?sleep_latency : float) -> unit`):
- `duration` (of type `((?resolvers : [string]?, ?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float?, string) -> float?) .{ ffmpeg : (?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float?, string) -> float?, flac : (?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float?, string) -> float?, mad : (?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float?, string) -> float?, ogg_flac : (?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float?, string) -> float?, wav/aiff : (?resolve_metadata : bool, ?metadata : [string * string], ?timeout : float?, string) -> float? }`):
- `dynamic` (of type `(?id : string?, ?available : {bool}, ?prefetch : int?, ?retry_delay : {float}, ?synchronous : bool, ?timeout : float?, ?native : bool, (() -> request?)) -> source('a) .{ add : (request) -> bool, buffered : () -> [string * float], clock : clock, current : () -> request?, duration : () -> float, elapsed : () -> float, fallible : bool, fetch : () -> unit, id : () -> string, insert_metadata : (?new_track : bool, [string * string]) -> unit, is_active : () -> bool, is_ready : () -> bool, is_up : () -> bool, last_metadata : () -> [string * string]?, log : {level : (() -> int).{set : (int) -> unit} }, on_frame : (?before : bool, synchronous : bool, (() -> unit)) -> unit, on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_position : (position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit, on_shutdown : (synchronous : bool, (() -> unit)) -> unit, on_track : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_wake_up : (synchronous : bool, (() -> unit)) -> unit, queue : () -> [request], register_command : (?usage : string?, description : string, string, ((string) -> string)) -> unit, remaining : () -> float, reset_last_metadata_on_track : (() -> bool) .{set : (bool) -> unit }, seek : (float) -> float, self_sync : () -> bool, set_queue : ([request]) -> unit, skip : () -> unit, time : () -> float}`):
- `filename` (of type `(request) -> string`):
- `id` (of type `(request) -> int`):
- `image` (of type `(?id : string?, ?fallible : bool, ?width : {int}?, ?height : {int}?, ?x : {int}, ?y : {int}, {request}) -> source(video=canvas('a), 'b) .{ buffered : () -> [string * float], clock : clock, current_source : () -> source(video=canvas('a), 'b)?, duration : () -> float, elapsed : () -> float, fallible : bool, id : () -> string, insert_metadata : (?new_track : bool, [string * string]) -> unit, is_active : () -> bool, is_ready : () -> bool, is_up : () -> bool, last_metadata : () -> [string * string]?, log : {level : (() -> int).{set : (int) -> unit} }, on_frame : (?before : bool, synchronous : bool, (() -> unit)) -> unit, on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_position : (position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit, on_shutdown : (synchronous : bool, (() -> unit)) -> unit, on_track : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_wake_up : (synchronous : bool, (() -> unit)) -> unit, prepare : (source(video=canvas('a), 'b)) -> unit, register_command : (?usage : string?, description : string, string, ((string) -> string)) -> unit, remaining : () -> float, reset_last_metadata_on_track : (() -> bool) .{set : (bool) -> unit }, seek : (float) -> float, self_sync : () -> bool, skip : () -> unit, time : () -> float}`):
- `is_static` (of type `(string) -> bool`):
- `log` (of type `(request) -> string`):
- `metadata` (of type `(request) -> [string * string]`):
- `once` (of type `(?id : string?, ?timeout : float?, request) -> source('a) .{ buffered : () -> [string * float], clock : clock, duration : () -> float, elapsed : () -> float, fallible : bool, id : () -> string, insert_metadata : (?new_track : bool, [string * string]) -> unit, is_active : () -> bool, is_ready : () -> bool, is_up : () -> bool, last_metadata : () -> [string * string]?, log : {level : (() -> int).{set : (int) -> unit} }, on_frame : (?before : bool, synchronous : bool, (() -> unit)) -> unit, on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_position : (position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit, on_shutdown : (synchronous : bool, (() -> unit)) -> unit, on_track : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_wake_up : (synchronous : bool, (() -> unit)) -> unit, register_command : (?usage : string?, description : string, string, ((string) -> string)) -> unit, remaining : () -> float, request : request, reset_last_metadata_on_track : (() -> bool) .{set : (bool) -> unit }, resolve : () -> bool, seek : (float) -> float, self_sync : () -> bool, skip : () -> unit, time : () -> float}`):
- `player` (of type `(?simultaneous : bool) -> source('a) .{ buffered : () -> [string * float], clock : clock, current_source : () -> source('a)?, duration : () -> float, elapsed : () -> float, fallible : bool, id : () -> string, insert_metadata : (?new_track : bool, [string * string]) -> unit, is_active : () -> bool, is_ready : () -> bool, is_up : () -> bool, last_metadata : () -> [string * string]?, length : () -> int, log : {level : (() -> int).{set : (int) -> unit} }, on_frame : (?before : bool, synchronous : bool, (() -> unit)) -> unit, on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_position : (position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit, on_shutdown : (synchronous : bool, (() -> unit)) -> unit, on_track : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_wake_up : (synchronous : bool, (() -> unit)) -> unit, play : (request) -> unit, prepare : (source('a)) -> unit, register_command : (?usage : string?, description : string, string, ((string) -> string)) -> unit, remaining : () -> float, reset_last_metadata_on_track : (() -> bool) .{set : (bool) -> unit }, seek : (float) -> float, self_sync : () -> bool, skip : () -> unit, time : () -> float} where 'a is a set of internal tracks`):
- `process` (of type `(request, ?process : ((source('a)) -> source('b)), ?ratio : float, ?timeout : float, ?sleep_latency : float) -> unit`):
- `queue` (of type `(?id : string?, ?interactive : bool, ?prefetch : int?, ?native : bool, ?queue : [request], ?timeout : float?) -> source('a) .{ add : (request) -> bool, buffered : () -> [string * float], clock : clock, current : () -> request?, duration : () -> float, elapsed : () -> float, fallible : bool, fetch : () -> unit, id : () -> string, insert_metadata : (?new_track : bool, [string * string]) -> unit, is_active : () -> bool, is_ready : () -> bool, is_up : () -> bool, last_metadata : () -> [string * string]?, length : () -> int, log : {level : (() -> int).{set : (int) -> unit} }, on_frame : (?before : bool, synchronous : bool, (() -> unit)) -> unit, on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_position : (position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit, on_shutdown : (synchronous : bool, (() -> unit)) -> unit, on_track : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_wake_up : (synchronous : bool, (() -> unit)) -> unit, push : ((request) -> unit) .{uri : (string) -> unit }, queue : () -> [request], register_command : (?usage : string?, description : string, string, ((string) -> string)) -> unit, remaining : () -> float, reset_last_metadata_on_track : (() -> bool) .{set : (bool) -> unit }, seek : (float) -> float, self_sync : () -> bool, set_queue : ([request]) -> unit, skip : () -> unit, time : () -> float}`):
- `resolve` (of type `(?timeout : float?, ?content_type : source('a)?, request) -> bool`):
- `resolved` (of type `(request) -> bool`):
- `single` (of type `(?id : string?, ?prefetch : int?, ?timeout : float?, ?fallible : bool?, {request}) -> source('a) .{ buffered : () -> [string * float], clock : clock, duration : () -> float, elapsed : () -> float, fallible : bool, id : () -> string, insert_metadata : (?new_track : bool, [string * string]) -> unit, is_active : () -> bool, is_ready : () -> bool, is_up : () -> bool, last_metadata : () -> [string * string]?, log : {level : (() -> int).{set : (int) -> unit} }, on_frame : (?before : bool, synchronous : bool, (() -> unit)) -> unit, on_metadata : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_position : (position : {float}, ?remaining : bool, ?allow_partial : bool, synchronous : bool, ((float, [string * string]) -> unit)) -> unit, on_shutdown : (synchronous : bool, (() -> unit)) -> unit, on_track : (synchronous : bool, (([string * string]) -> unit)) -> unit, on_wake_up : (synchronous : bool, (() -> unit)) -> unit, register_command : (?usage : string?, description : string, string, ((string) -> string)) -> unit, remaining : () -> float, reset_last_metadata_on_track : (() -> bool) .{set : (bool) -> unit }, seek : (float) -> float, self_sync : () -> bool, skip : () -> unit, time : () -> float}`):
- `status` (of type `(request) -> string`):
- `uri` (of type `(request) -> string`):

### `settings.autocue`

Initialize settings for autocue

Type:

    unit

Methods:

- `internal` (of type `unit`):

### `settings.protocol.gtts`

GTTS

Type:

    unit

Methods:

- `comments` (of type `string`):
- `description` (of type `string`):

### `settings.protocol.macos_say`

MacOS say

Type:

    unit

Methods:

- `comments` (of type `string`):
- `description` (of type `string`):

### `settings.protocol.pico2wave`

Pico2wave

Type:

    unit

Methods:

- `comments` (of type `string`):
- `description` (of type `string`):

### `settings.protocol.say`

Say

Type:

    unit

Methods:

- `comments` (of type `string`):
- `description` (of type `string`):

### `settings.protocol.text2wave`

Text2wave

Type:

    unit

Methods:

- `comments` (of type `string`):
- `description` (of type `string`):

### `variables`

Information about all variables

Type:

    () -> [string * {description : string, type : string}]

### `variables_bool`

Bool variables

Type:

    () -> [string * {ref : (() -> bool).{set : (bool) -> unit}}]

### `variables_float`

Float variables

Type:

    () ->
    [string *
     {
       max : float,
       min : float,
       ref : (() -> float)
       .{set : (float) -> unit
       },
       step : float,
       unit : string
     }]

### `variables_int`

Int variables

Type:

    () -> [string * {ref : (() -> int).{set : (int) -> unit}}]

### `variables_string`

String variables

Type:

    () -> [string * {ref : (() -> string).{set : (string) -> unit}}]

### `variables_unit`

Unit variables: those are not references but handler functions

Type:

    () -> [string * {handler : () -> unit}]