| (<:) [Lang_values] | |
| (<:) [Lang_types] | |
| (>:) [Lang_values] | |
| (>:) [Lang_types] | |
A | |
| add [Server] | add ~ns ~descr command f adds a new command command in a given namespace ~ns.
|
| add [AFrame] |
Add two portions of frames of same length.
|
| add_break [VFrame] |
Add a break at given video position.
|
| add_break [MFrame] |
Add a break.
|
| add_break [Generator.S_Asio] | |
| add_break [Generator.From_audio_video_plus] | |
| add_break [Generator.From_audio_video] |
Add a track limit.
|
| add_break [Generator.From_frames] | |
| add_break [Frame] |
Add a break to a frame (which should be past its current end position).
|
| add_break [AFrame] |
Add a break.
|
| add_builtin [Lang] |
Add an builtin to the language, high-level version for functions.
|
| add_builtin_base [Lang] |
Add an builtin to the language, more rudimentary version.
|
| add_log [Request] | |
| add_metadata [Generator.S_Asio] | |
| add_metadata [Generator.S] |
Add metadata.
|
| add_metadata [Generator.From_audio_video_plus] | |
| add_metadata [Generator.From_audio_video] |
Add metadata at the minimum position of audio and video.
|
| add_metadata [Generator.From_frames] | |
| add_mul [Frame] | |
| add_operator [Lang] |
Add an operator to the language and to the documentation.
|
| add_t [Lang_values] | |
| add_t [Lang] | |
| advance [Frame] |
Same as
clear but leaves the last metadata at position -1.
|
| advance [AFrame] |
Reset breaks and metadata, but leaves the last metadata at position -1.
|
| alive_requests [Request] | |
| all_requests [Request] | |
| allow_lazy_config_eval [Frame] |
Prevent forcing the value of a lazy configuration value before the user gets
a chance to override the default.
|
| any_fixed [Lang] | |
| any_fixed_with [Lang] | |
| apply [Lang_values] | |
| apply [Lang] |
Multiapply a value to arguments.
|
| args_split [Http] |
split arg=value&arg2=value2 into (arg, value) Hashtbl.t
|
| assoc [Lang] | assoc x n l returns the n-th y such that (x,y) is in the list l.
|
| audio_any [Lang] | |
| audio_channels [Frame] |
Default number of audio channels.
|
| audio_channels [Encoder.GStreamer] | |
| audio_conf [Audio_converter] | |
| audio_length [Generator.S_Asio] | |
| audio_length [Generator.From_audio_video_plus] | |
| audio_length [Generator.From_audio_video] |
Audio length, in ticks.
|
| audio_mono [Lang] | |
| audio_n [Lang] | |
| audio_of_master [Frame] |
Duration of given number of samples in ticks.
|
| audio_of_seconds [Frame] | |
| audio_rate [Frame] |
Rate of audio (in samples per second).
|
| audio_stereo [Lang] | |
| audio_variable [Lang] | |
| audio_video_any [Lang] | |
B | |
| big_endian [Configure] |
Is the architecture big endian?
|
| bind [Lang_types] | |
| bit_ctl_to_string [Encoder.Theora] | |
| blankify [AFrame] | blankify frame off len blanks the frame at offset off for length len (in samples).
|
| blit_content [Frame] | blit_content c1 o1 c2 o2 l copies l data from c1 starting at offset
o1 into c2 starting at offset o2.
|
| bool [Lang] | |
| bool_t [Lang] | |
| breaks [Frame] |
List of breaks in a frame.
|
| breaks [AFrame] |
Breaks in frame.
|
| builtins [Lang_values] | |
C | |
| can_ignore [Lang_values] | |
| channels [Wav] |
Parameters of the output PCM format.
|
| check [Lang_values] | |
| check_unused [Lang_values] | |
| clean [Request] |
Called at exit, for cleaning temporary files
and destroying all the requests, even persistent ones.
|
| clear [Generator.S_Asio] | |
| clear [Generator.S] |
Clear the generator.
|
| clear [Generator.From_audio_video_plus] | |
| clear [Generator.From_audio_video] | |
| clear [Generator.From_frames] | |
| clear [Generator.Generator] | |
| clear [Frame] |
Make the frame empty.
|
| clear [AFrame] |
Reset breaks.
|
| clear_from [Frame] |
Same as
clear from a given position.
|
| close [Wav] | close w close the wav descriptor w
|
| collect_after [Clock] | |
| common [Switch] | |
| conf [Server] |
The configuration of the server.
|
| conf [Encoder] | |
| conf [Configure] |
Liquidsoap configuration root
|
| conf_cue_in_metadata [Playlist_parser] | |
| conf_cue_out_metadata [Playlist_parser] | |
| conf_decoder [Decoder] | |
| conf_export_metadata [Encoder] |
The list of metadata fields that should be exported when encoding.
|
| conf_file_extensions [Decoder] | |
| conf_meta [Encoder] | |
| conf_mime_types [Playlist_parser] | |
| conf_mime_types [Decoder] | |
| conf_playlists [Playlist_parser] | |
| conf_socket [Server] |
Should a socket server be created?
|
| conf_socket_path [Server] |
Path of the socket.
|
| conf_socket_perms [Server] |
Permissions of the socket.
|
| conf_telnet [Server] |
Should a telnet server be created?
|
| conf_telnet_bind_addr [Server] |
Address of the telnet server.
|
| conf_telnet_port [Server] |
Port of the telnet server.
|
| connect [Http] |
Connect to an http server given an host and a port.
|
| content [MFrame] |
Get the MIDI tracks at a given position, assuming that the frame
already contains only MIDI starting at this point.
|
| content [Frame] |
Get the current content of a frame at a given position.
|
| content [AFrame] |
Get audio contents for access after a given offset.
|
| content_has_type [Frame] | |
| content_of_type [VFrame] |
Create a new video-only content layer for
channels video channels,
at the current position in the frame, i.e., suitable for the next
filling operation.
|
| content_of_type [MFrame] |
Get the MIDI tracks at a given position, creating it if needed.
|
| content_of_type [Frame] |
Get the content for a given position and type in a frame.
|
| content_of_type [AFrame] |
Get audio contents for writing after a given offset.
|
| converter_conf [Audio_converter] | |
| converters [Audio_converter.Samplerate] | |
| copy [Frame] |
Make a copy of the contents of a frame.
|
| copy_with [Lang_types] |
Copy a term, substituting some EVars as indicated by a list
of associations.
|
| create [Tutils] |
Thread wrapper
Give names to threads, and forbid them to raise an exception;
if that happens, the thread dies anyway but it is logged and
main
will notice it.
|
| create [Request] |
For media requests,
resolving includes testing that the file can actually be decoded
into a stream of the expected kind.
|
| create [Plug] | |
| create [Ogg_muxer] |
Create a new encoder.
|
| create [Generator.From_audio_video_plus] | |
| create [Generator.From_audio_video] | |
| create [Generator.From_frames] | |
| create [Generator.Generator] | |
| create [Frame] |
Create a frame of given content kind.
|
| create [Audio_converter.Samplerate] | create chan_nb creates a converter.
|
| create_known [Source.Clock_variables] | |
| create_known [Clock] | |
| create_raw [Request] | |
| create_unknown [Source.Clock_variables] | |
| create_unknown [Clock] | |
D | |
| data_length [Wav] | |
| data_mime [Configure] | |
| debug [Lang_values] |
Are we in debugging mode?
|
| default_font [Configure] |
Default font file
|
| default_transition [Switch] | |
| deref [Lang_types] |
Dereferencing gives you the meaning of a term,
going through links created by instantiations.
|
| destroy [Request] |
Destroying of a requests causes its file to be deleted if it's a temporary
one, for example a downloaded file.
|
| dirname [Http] |
Url without the trailing filename.
|
| disconnect [Http] |
Disconnect from an http server.
|
| display_types [Configure] |
Display inferred types.
|
| doc_of_type [Lang_types] | |
| dresolvers [Request] | |
| dummy [Lang_types] | |
| duration [Wav] |
Returns the duration of the WAV data.
|
| duration [Request] | duration filename computes the duration of audio data contained in
filename.
|
| duration [Frame] |
Duration of a frame in seconds.
|
| duration [AFrame] |
Duration in seconds.
|
| dyn_log [Dyntools] | |
| dynlink [Configure] |
Is dynlink available?
|
| dynlink_list [Dyntools] | |
| dynlink_suffix [Dyntools] | |
E | |
| empty [Lang] | |
| empty_metadata [Encoder.Meta] | |
| encode [Ogg_muxer] |
Encode data.
|
| end_of_stream [Ogg_muxer] |
Ends all tracks, flush remaining encoded data.
|
| end_of_track [Ogg_muxer] |
Finish a track.
|
| errors_as_warnings [Lang_values] |
Should errors be considered as simple warnings?
|
| eval [Lang_values] | |
| eval [Lang] |
Evaluate a string
|
| eval_toplevel [Lang_values] | |
| exec [Server] | exec command executes the command, returns its result.
|
| export_metadata [Encoder.Meta] | |
| extract_common [Switch] | |
| extract_queued_params [Request_source] | |
F | |
| feed [Generator.From_frames] |
Only the breaks and metadata in the considered portion of the
content will be taken into account.
|
| feed_from_frame [Generator.From_frames] |
Take all data from a frame: breaks, metadata and available content.
|
| file_decoder [Decoder.Buffered] | |
| file_decoders [Decoder] |
For a given file, once a decoder is chosen it can be used several
times.
|
| file_mime [Configure] |
Magic mime detection
|
| file_watcher [Configure] |
File watch utility.
|
| fill [Generator.S_Asio] | |
| fill [Generator.S] |
Append a fram to the generator.
|
| fill [Generator.From_audio_video_plus] | |
| fill [Generator.From_audio_video] | |
| fill [Generator.From_frames] | |
| filter_vars [Lang_types] | |
| finalize [Tutils] | finalize ~k f calls f and returns it result,
and always executes k, even when f raises an exception.
|
| find_converter [Video_converter] | find_converter source destination tries
to find a converter from source format
to destination format.
|
| findlib_path [Configure] |
Directories where to search for libraries..
|
| float [Lang] | |
| float_getter_t [Lang] | |
| float_t [Lang] | |
| flush_pages [Ogg_muxer] |
flush all availables pages from an ogg stream
|
| fold [Clock] | |
| fold_types [Lang_values] |
Folds
f over almost all types occurring in a term,
skipping as much as possible while still
guaranteeing that f will see all variables.
|
| fopen [Wav] |
Open the named wav for reading, and return a new wav descriptor.
|
| force_init [Clock] |
Initialize only some sources, recognized by a filter function.
|
| format_t [Lang_values] |
Type of audio formats that can encode frame of a given kind.
|
| format_t [Lang] | |
| frame_kind_of_kind_type [Lang] | |
| frame_kind_t [Lang_values] |
A frame kind type is a purely abstract type representing a frame kind.
|
| frame_kind_t [Lang] | |
| free_all_metadata [Frame] |
Remove all metadata.
|
| free_all_metadata [AFrame] | |
| free_metadata [Frame] |
Remove all metadata at given position.
|
| free_metadata [AFrame] | |
| free_vars [Lang_values] | |
| fresh [Lang_types] |
Simplified version of existential variable generation,
without constraints.
|
| fresh_evar [Lang_types] | |
| from_file [Lang] |
Evaluate a script from a file.
|
| from_id [Request] | |
| from_in_channel [Lang] |
Evaluate a script from an
in_channel.
|
| from_string [Lang] |
Evaluate a script from a string.
|
| full_request [Http] |
Perform a full Http request and return the response status,headers
and data.
|
| fun_t [Lang] | fun_t args r is the type of a function taking args as parameters
and returning values of type r.
|
G | |
| generalizable [Lang_types] |
Return a list of generalizable variables in a type.
|
| get [Source.Clock_variables] | |
| get [Http] | get ?log ?headers ~timeout socket host port file makes a GET request.
|
| get [Generator.Generator] |
Get
size amount of data from g.
|
| get [Clock] | |
| get_all_metadata [Request] | |
| get_all_metadata [MFrame] | |
| get_all_metadata [Frame] |
Retrieve all metadata.
|
| get_all_metadata [AFrame] | |
| get_chunk [Frame] | get_chunk dst src gets the (end of) next chunk from src
(a chunk is a region of a frame between two breaks).
|
| get_chunk [AFrame] | |
| get_content [VFrame] | get_content source frame has source fill frame,
and returns the produced chunk of video content.
|
| get_content_layers [Frame] |
Retrieve all content layers in a frame.
|
| get_data [Ogg_muxer] |
Get and remove encoded data..
|
| get_decoder [Request] |
Return a decoder if the file has been resolved, guaranteed to have
available data to deliver.
|
| get_factory [Encoder] |
Return the first available encoder factory for that format.
|
| get_file [Playlist_parser] | |
| get_file_decoder [Decoder] |
Get a valid decoder creator for
filename.
|
| get_filename [Request] |
Return a valid local filename if there is one, which means that the request
is ready.
|
| get_header [Ogg_muxer] |
Get header of a stream.
|
| get_id [Request] | |
| get_image_file_decoder [Decoder] |
Get a valid image decoder creator for
filename.
|
| get_log [Request] | |
| get_metadata [Request] | |
| get_metadata [MFrame] | |
| get_metadata [Frame] |
Retrieve metadata at a given position.
|
| get_metadata [AFrame] | |
| get_name [Lang_values] | |
| get_past_metadata [Frame] |
Retreive "past metadata" which are stored at offset
-1 (cf.
|
| get_root_metadata [Request] | |
| get_stream_decoder [Decoder] | |
H | |
| has_outputs [Source] | |
| header [Wav] |
Returns the WAV header that declares the given format.
|
| hide_contents [Frame] | hide_contents frame removes all content layers from the frame,
and returns a function that restores them in their current state.
|
| http_sanitize [Http] | http_sanitize url encodes the relevant parts of a url
(path and arguments, without their seperators).
|
I | |
| id3v2_export [Encoder.MP3] | |
| image_file_decoders [Decoder] | |
| in_chan_ops [Wav] | |
| in_chan_read_header [Wav] |
Read WAV data from an input channel.
|
| indicator [Request] | |
| info [Wav] | info w returns a string containing some informations on wav w
|
| instantiate [Lang_values] | |
| instantiate [Lang_types] |
Instantiate a type scheme, given as a type together with a list
of generalized variables.
|
| int [Lang] | |
| int_sub_mul [Frame] | |
| int_t [Lang] | |
| interactive [Lang] |
Interactive loop: read from command line, eval, print and loop.
|
| is_empty [Encoder.Meta] | |
| is_fun [Lang_values] | |
| is_ground [Lang_values] | |
| is_known [Source.Clock_variables] | |
| is_on_air [Request] |
Query whether a request is currently being streamed.
|
| is_partial [VFrame] |
Is it partially filled ?
|
| is_partial [MFrame] |
Is it partially filled ?
|
| is_partial [Frame] |
Is the frame partially filled, i.e.
|
| is_partial [AFrame] |
Is it partially filled ?
|
| is_ready [Request] | is_ready r if there's an available local filename.
|
| is_source [Lang_values] | |
| is_static [Request] |
A static request
r is such that every resolving leads to the same file.
|
| is_url [Http] |
Basic detection of whether a path is an HTTP url.
|
| iter_constr [Lang_types] |
Iterate over all constructed types, giving info about their
positivity, and return
true if there is a var, because it might be
instantiated by a ground type later.
|
| iter_sources [Lang] |
Iter a function over all sources contained in a value.
|
| iterate_new_outputs [Source] | |
J | |
| join_all [Tutils] |
Wait for the threads to terminate,
never return if some thread keeps running.
|
K | |
| kind [Request] |
Return the kind of a media request, None for raw requests.
|
| kind_of_format [Encoder] | |
| kind_sub_kind [Frame] | |
| kind_type_of_frame_kind [Lang] | |
| kind_type_of_kind_format [Lang] | |
L | |
| lazy_cell [Tutils] |
Thread-safe equivalent to Lazy.lazy_from_fun.
|
| length [Generator.S_Asio] | |
| length [Generator.S] |
Length of the generator in ticks.
|
| length [Generator.From_audio_video_plus] | |
| length [Generator.From_audio_video] |
Total length.
|
| length [Generator.From_frames] |
Total length.
|
| length [Generator.Generator] | |
| libs_dir [Configure] |
Where to look for standard .liq scripts to include
|
| libs_versions [Configure] |
String containing versions of all enabled bindings.
|
| list [Plug] | |
| list [Lang] | |
| list_t [Lang] | |
| load_dynlinks [Dyntools] | |
| load_dynlinks [Configure] |
Helper to load dynamic modules.
|
| load_libs [Lang] |
Load the external libraries.
|
| load_plugins_dir [Dyntools] | |
| load_plugins_dir [Configure] |
Helper to load dynamic plugins.
|
| log [Playlist_parser] | |
| log [Ogg_muxer] | |
| log [Lang] | |
| log [Decoder] | |
| logdir [Configure] | |
| lookup [Lang_values] | |
M | |
| main [Tutils] | |
| make [Lang_types] | |
| map_env [Lang_values.V] | |
| map_types [Lang_values.V] |
Map a function on all types occurring in a value.
|
| map_types [Lang_values] |
Maps a function on all types occurring in a term.
|
| master_of_audio [Frame] | |
| master_of_midi [Frame] | |
| master_of_seconds [Frame] | |
| master_of_video [Frame] | |
| master_rate [Frame] |
Ticks per second.
|
| metadata [Lang] |
Convert a metadata packet to a list associating strings to strings.
|
| metadata_t [Lang] |
A shortcut for lists of pairs of strings.
|
| midi_channels [Frame] |
Default number of MIDI channels.
|
| midi_n [Lang] | |
| midi_of_master [Frame] | |
| midi_only [Lang] | |
| midi_rate [Frame] | |
| mode [Generator.From_audio_video_plus] | |
| mode [Generator.From_audio_video] |
Current mode:
in Audio mode (resp.
|
| mresolvers [Request] | |
| mul_eq_int [Frame] | |
| mul_of_int [Frame] | |
| mul_sub_mul [Frame] | |
| multiply [AFrame] | multiply frame off len x multiplies the audio data of the frame from
offset off during length len by coefficent x.
|
| mutexify [Tutils] |
Make a function work in critical section, protected by a given lock.
|
N | |
| need_non_blocking_queue [Tutils] |
Ask for a special queue that treats exclusively non blocking tasks.
|
| next_sample_position [VFrame] |
Position (in video samples) of the next video sample to fill-in.
|
| none [Doc] | |
O | |
| occur_check [Lang_types] |
Check that
a (a dereferenced type variable) does not occur in b,
and prepare the instantiation a<-b by adjusting the levels.
|
| of_frame_kind_t [Lang_values] | |
| of_frame_kind_t [Lang] | |
| of_list_t [Lang] | |
| of_product_t [Lang] | |
| of_request_t [Lang_values] | |
| of_request_t [Lang] | |
| of_source_t [Lang_values] | |
| of_source_t [Lang] | |
| on_air [Request] |
Indicate that a request is currently being streamed.
|
| on_air_requests [Request] | |
P | |
| parsers [Playlist_parser] |
Parsers are given a string and return a list of metadatas,uri, if possible.
|
| peek_data [Ogg_muxer] |
Peek encoded data without removing it.
|
| peek_indicator [Request] |
Return the top URI, without removing it.
|
| plug [Encoder] | |
| plugins_dir [Configure] |
Where to look for dynamically loadable modules (cmxs).
|
| plugs [Plug] | |
| pop_indicator [Request] |
Removes the top URI, possibly destroys the associated file.
|
| position [VFrame] | |
| position [MFrame] |
Position of the first break.
|
| position [Frame] |
Position of the end of the last chunk of the frame (i.e.
|
| position [AFrame] |
Current position in frame.
|
| post [Http] | post ?log ?headers ~timeout data socket host port file makes a POST request.
|
| pp_type [Lang_types] | |
| pp_type_generalized [Lang_types] | |
| print [Lang_types] | |
| print [Doc] | |
| print_constr [Lang_types] | |
| print_ground [Lang_types] | |
| print_lang [Doc] | |
| print_pos [Lang_types] | |
| print_single_pos [Lang_types] | |
| print_some_bool [Encoder.Theora] | |
| print_some_int [Encoder.Theora] | |
| print_term [Lang_values] |
Print terms, (almost) assuming they are in normal form.
|
| print_type_error [Lang_types] | |
| print_value [Lang_values.V] | |
| print_value [Lang] |
Get a string representation of a value.
|
| print_xml [Doc] | |
| product [Lang] | |
| product_t [Lang] | |
| proto [Output] |
Parameters needed to instantiate an output.
|
| protocols [Request] | |
| push_indicators [Request] |
In most of the case you don't peek or pop any URI, you just push the
new URIs you computed from
first_uri.
|
| put [Generator.Generator] |
Feed an item into a generator.
|
| put_audio [Generator.S_Asio] | |
| put_audio [Generator.From_audio_video_plus] | |
| put_audio [Generator.From_audio_video] |
Add some audio content.
|
| put_video [Generator.S_Asio] | |
| put_video [Generator.From_audio_video_plus] | |
| put_video [Generator.From_audio_video] |
Add some video content.
|
Q | |
| queued_proto [Request_source] | |
R | |
| raise_ignored [Lang_values] | |
| read [Http] | read ?log ~timeout len reads len bytes of data
or all available data if len is None.
|
| read_crlf [Http] | |
| read_header [Wav] |
Generic WAV opener.
|
| recode_tag [Configure] |
Function to reencode tags into utf8.
|
| ref_t [Lang_values] | |
| register [Server] | register hint kind creates a new namespace and registers it.
|
| register_track [Ogg_muxer] |
Register a new track to the stream.
|
| remaining [Generator.S_Asio] | |
| remaining [Generator.S] |
Duration of data (in ticks) before the next break, -1 if there's none.
|
| remaining [Generator.From_audio_video_plus] | |
| remaining [Generator.From_audio_video] |
Duration of data (in ticks) before the next break, -1 if there's none.
|
| remaining [Generator.From_frames] |
Duration of data (in ticks) before the next break, -1 if there's none.
|
| remove [Server] |
Remove a command from the server.
|
| remove [Generator.S] |
Forget a given duration (in ticks) of the generator.
|
| remove [Generator.From_audio_video_plus] | |
| remove [Generator.From_audio_video] | |
| remove [Generator.From_frames] | |
| remove [Generator.Generator] |
Remove
len ticks of data.
|
| remove_first [Lang_values] | remove_first f l removes the first element e of l such that f e,
and returns e,l' where l' is the list without e.
|
| request [Lang] | |
| request [Http] | |
| request_t [Lang_values] | |
| request_t [Lang] | |
| requests_max_id [Configure] |
Maximal id for a request.
|
| requests_table_size [Configure] | |
| resample [Audio_converter.Samplerate] | resample converter ratio data offset length: converts input data
at given ratio.
|
| resolve [Request] | resolve request timeout tries to resolve the request within timeout
seconds.
|
| resolving_requests [Request] | |
| rms [AFrame] |
RMS (root mean square) of a portion of a frame.
|
| rundir [Configure] |
Configured directories.
|
| running [Tutils] |
Check if a thread is running.
|
| running [Clock] |
Does the application have started to run?
|
S | |
| sample [Wav] | sample w buf pos len reads up to len characters from
the given wav w, storing them in string buf, starting at
character number pos.
|
| sample_rate [Wav] | |
| sample_size [Wav] | |
| samplerate_conf [Audio_converter.Samplerate] | |
| satisfied [Switch] | |
| scheduler [Tutils] |
task scheduler
|
| scm_snapshot [Configure] |
Is this build a SVN snapshot ?
|
| search_valid [Playlist_parser] |
Get a valid parser for
string.
|
| seconds_of_audio [Frame] | |
| seconds_of_master [Frame] | |
| seconds_of_video [Frame] | |
| seems_locked [Tutils] |
Tests whether a mutex is locked, without blocking.
|
| set_all_metadata [Frame] |
Set all metadata.
|
| set_all_metadata [AFrame] | |
| set_breaks [Frame] |
Set all the breaks of a frame.
|
| set_breaks [AFrame] |
Change all the breaks.
|
| set_metadata [Request] | |
| set_metadata [MFrame] | |
| set_metadata [Frame] |
Attach metadata at a given position in the frame.
|
| set_metadata [AFrame] | |
| set_mode [Generator.S_Asio] | |
| set_mode [Generator.From_audio_video_plus] | |
| set_mode [Generator.From_audio_video] |
Change the generator mode.
|
| set_rewrite_metadata [Generator.From_audio_video_plus] | |
| set_root_metadata [Request] | |
| short_string_of_metadata [Request] | |
| shutdown [Tutils] | |
| size [VFrame] |
Number of video frames.
|
| size [MFrame] |
Number size of a MIDI frame.
|
| size [Frame] |
The frame size (in master ticks) should allow for an integer
number of samples of all types (audio, video).
|
| size [AFrame] |
Size of an audio frame.
|
| source [Lang] | |
| source_t [Lang_values] |
Type of sources carrying frames of a given kind.
|
| source_t [Lang] | |
| start [Clock] | |
| state [Ogg_muxer] |
Get the state of an encoder.
|
| stop [Clock] |
To stop, simply detach everything and the clocks will stop running.
|
| stoppable_thread [Tutils] |
Preemptive stoppable thread.
|
| stream_decoders [Decoder] | |
| streams_start [Ogg_muxer] |
Start streams, set state to
Streaming.
|
| string [Lang] | |
| string_getter_t [Lang] |
A string getter.
|
| string_of_abr [Encoder.MP3] | |
| string_of_application [Encoder.Opus] | |
| string_of_bandwidth [Encoder.Opus] | |
| string_of_bitrate [Encoder.Opus] | |
| string_of_bitrate_control [Encoder.MP3] | |
| string_of_br_ctl [Encoder.Speex] | |
| string_of_category [Lang] |
Get a string representation of a
category.
|
| string_of_complexity [Encoder.Speex] | |
| string_of_content_kind [Frame] | |
| string_of_content_type [Frame] | |
| string_of_error [Http] | |
| string_of_flag [Lang] |
Get a string representation of a
doc_flag.
|
| string_of_format [Encoder] | |
| string_of_log [Request] | |
| string_of_metadata [Request] | |
| string_of_mode [Encoder.Speex] | |
| string_of_mode [Encoder.Opus] | |
| string_of_mode [Encoder.Vorbis] | |
| string_of_signal [Encoder.Opus] | |
| string_of_stereo [Encoder] | |
| string_t [Lang] | |
| subst_vars [Configure] | |
| succ_t [Lang_values] | |
| succ_t [Lang] | |
T | |
| test_file [Decoder] |
Test file extension and mime if available
|
| third [Switch] | |
| tm_map_types [Lang_values.V] | |
| to_bool [Lang] | |
| to_float [Lang] | |
| to_float_getter [Lang] | |
| to_format [Lang] | |
| to_fun [Lang] | |
| to_int [Lang] | |
| to_int_list [Lang] | |
| to_list [Lang] | |
| to_metadata [Lang] | |
| to_metadata [Encoder.Meta] | |
| to_product [Lang] | |
| to_request [Lang] | |
| to_s16le [AFrame] |
Same as
content with offset=0, converted to s16le.
|
| to_source [Lang] | |
| to_source_list [Lang] | |
| to_string [Source.Clock_variables] | |
| to_string [Server] |
Get a string representation of a namespace.
|
| to_string [Lang] | |
| to_string [Encoder.Ogg] | |
| to_string [Encoder.Dirac] | |
| to_string [Encoder.Theora] | |
| to_string [Encoder.GStreamer] | |
| to_string [Encoder.Speex] | |
| to_string [Encoder.External] | |
| to_string [Encoder.VoAacEnc] | |
| to_string [Encoder.AACPlus] | |
| to_string [Encoder.Shine] | |
| to_string [Encoder.Flac] | |
| to_string [Encoder.MP3] | |
| to_string [Encoder.Opus] | |
| to_string [Encoder.Vorbis] | |
| to_string [Encoder.WAV] | |
| to_string [Clock] | |
| to_string_getter [Lang] | |
| to_string_list [Lang] | |
| to_unit [Lang] | |
| toplevel_add [Lang_values] |
Add toplevel definitions to
builtins so they can be looked
during the evaluation of the next scripts.
|
| trivial [Doc] | |
| trivially_true [Switch] | |
| tts_program [Configure] |
Program used for text-to-speech.
|
| type_has_kind [Frame] | |
| type_of_content [Frame] | |
| type_of_format [Lang_values] | |
| type_of_int [Lang_values] | |
| type_of_int [Lang] | |
| type_of_kind [Frame] | |
| type_of_mul [Lang_values] | |
U | |
| unify [Source.Clock_variables] | |
| unify [Clock] | |
| unit [Lang] | |
| unit_t [Lang] | |
| univ_t [Lang] | |
| unregister [Server] |
Release a namespace, deleting all associated commands.
|
| url_decode [Http] |
Decode an url.
|
| url_encode [Http] |
Encode an url.
|
| url_split_host_port [Http] |
Split an URL to return host, port and URI.
|
| user_agent [Http] |
User-agent for liquidsoap
|
V | |
| val_cst_fun [Lang] |
Build a constant function.
|
| val_fun [Lang] |
Build a function from an OCaml function.
|
| value_restriction [Lang_values] | |
| var_script [Configure] |
Substitution of configured variables
|
| variable_t [Lang_values] | |
| variable_t [Lang] | |
| vendor [Configure] |
String describing the software.
|
| version [Configure] |
String describing the version.
|
| video_channels [Frame] |
Default number of video channels.
|
| video_channels [Encoder.GStreamer] | |
| video_converter_conf [Video_converter] | |
| video_converters [Video_converter] |
Plugin to register new converters.
|
| video_height [Frame] |
Height of video images.
|
| video_length [Generator.S_Asio] | |
| video_length [Generator.From_audio_video_plus] | |
| video_length [Generator.From_audio_video] |
Video length, in ticks.
|
| video_n [Lang] | |
| video_of_master [Frame] | |
| video_of_seconds [Frame] | |
| video_only [Lang] | |
| video_rate [Frame] |
Video rate (in images per second).
|
| video_width [Frame] |
Width of video images.
|
W | |
| wait [Tutils] |
Waits for
f() to become true on condition c.
|
| wait_for [Tutils] | |
X | |
| xml_escape [Doc] | |
Z | |
| zero_t [Lang_values] | |
| zero_t [Lang] |