src/liquidsoap/archive/unused_out_filesystem.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+r0_enable = list.assoc(default="", "rec_0", ini) == "y"
+r1_enable = list.assoc(default="", "rec_1", ini) == "y"
+r2_enable = list.assoc(default="", "rec_2", ini) == "y"
+r3_enable = list.assoc(default="", "rec_3", ini) == "y"
+r4_enable = list.assoc(default="", "rec_4", ini) == "y"
+
+r0_folder = list.assoc(default="", "rec_0_folder", ini)
+r0_duration = int_of_string(list.assoc(default="", "rec_0_duration", ini))
+r0_encoding = list.assoc(default="", "rec_0_encoding", ini)
+r0_bitrate = int_of_string(list.assoc(default="", "rec_0_bitrate", ini))
+r0_channels = list.assoc(default="", "rec_0_channels", ini)
+r0_filenamepattern = r0_folder^"/%Y-%m-%d/%Y-%m-%d-%H-%M."^r0_encoding
+
+r1_folder = list.assoc(default="", "rec_1_folder", ini)
+r1_duration = int_of_string(list.assoc(default="", "rec_1_duration", ini))
+r1_encoding = list.assoc(default="", "rec_1_encoding", ini)
+r1_bitrate = int_of_string(list.assoc(default="", "rec_1_bitrate", ini))
+r1_channels = list.assoc(default="", "rec_1_channels", ini)
+r1_filenamepattern = r1_folder^"/%Y-%m-%d/%Y-%m-%d-%H-%M."^r1_encoding
+
+r2_folder = list.assoc(default="", "rec_2_folder", ini)
+r2_duration = int_of_string(list.assoc(default="", "rec_2_duration", ini))
+r2_encoding = list.assoc(default="", "rec_2_encoding", ini)
+r2_bitrate = int_of_string(list.assoc(default="", "rec_2_bitrate", ini))
+r2_channels = list.assoc(default="", "rec_2_channels", ini)
+r2_filenamepattern = r2_folder^"/%Y-%m-%d/%Y-%m-%d-%H-%M."^r2_encoding
+
+r3_folder = list.assoc(default="", "rec_3_folder", ini)
+r3_duration = int_of_string(list.assoc(default="", "rec_3_duration", ini))
+r3_encoding = list.assoc(default="", "rec_3_encoding", ini)
+r3_bitrate = int_of_string(list.assoc(default="", "rec_3_bitrate", ini))
+r3_channels = list.assoc(default="", "rec_3_channels", ini)
+r3_filenamepattern = r3_folder^"/%Y-%m-%d/%Y-%m-%d-%H-%M."^r3_encoding
+
+r4_folder = list.assoc(default="", "rec_4_folder", ini)
+r4_duration = int_of_string(list.assoc(default="", "rec_4_duration", ini))
+r4_encoding = list.assoc(default="", "rec_4_encoding", ini)
+r4_bitrate = int_of_string(list.assoc(default="", "rec_4_bitrate", ini))
+r4_channels = list.assoc(default="", "rec_4_channels", ini)
+r4_filenamepattern = r4_folder^"/%Y-%m-%d/%Y-%m-%d-%H-%M."^r4_encoding
+
+r0_is_recording = ref false
+r1_is_recording = ref false
+r2_is_recording = ref false
+r3_is_recording = ref false
+r4_is_recording = ref false
+
+if r0_enable == true then
+    # enable recording status for that recorder
+    server.register(namespace="out_filesystem_0", "recording", fun (s) -> begin if !r0_is_recording == false then "false" else "true" end end)
+
+    # start the recorder
+    start_recorder(r0_folder, r0_duration, r0_encoding, r0_bitrate, r0_channels, r0_filenamepattern, r0_is_recording, output_source, "0")
+end
+
+if r1_enable == true then
+    server.register(namespace="out_filesystem_1", "recording", fun (s) -> begin if !r1_is_recording == false then "false" else "true" end  end)
+    start_recorder(r1_folder, r1_duration, r1_encoding, r1_bitrate, r1_channels, r1_filenamepattern, r1_is_recording, output_source, "1")
+end
+
+if r2_enable == true then
+    server.register(namespace="out_filesystem_2", "recording", fun (s) -> begin if !r2_is_recording == false then "false" else "true" end  end)
+    start_recorder(r2_folder, r2_duration, r2_encoding, r2_bitrate, r2_channels, r2_filenamepattern, r2_is_recording, output_source, "2")
+end
+
+if r3_enable == true then
+    server.register(namespace="out_filesystem_3", "recording", fun (s) -> begin if !r3_is_recording == false then "false" else "true" end  end)
+    start_recorder(r3_folder, r3_duration, r3_encoding, r3_bitrate, r3_channels, r3_filenamepattern, r3_is_recording, output_source, "3")
+end
+
+if r4_enable == true then
+    server.register(namespace="out_filesystem_4", "recording", fun (s) -> begin if !r4_is_recording == false then "false" else "true" end  end)
+    start_recorder(r4_folder, r4_duration, r4_encoding, r4_bitrate, r4_channels, r4_filenamepattern, r4_is_recording, output_source, "4")
+end
\ No newline at end of file

src/liquidsoap/archive/unused_record.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# %include "readini.liq"
+# ini = read_ini("/etc/aura/engine.ini")
+
+# %include "settings.liq"
+
+# TELNET SETTINGS
+# set("server.telnet", true)
+# set("server.telnet.bind_addr", "0.0.0.0")
+# set("server.telnet.port", 2345)
+
+inst = if argv(1) != "" then string_of(argv(1)) else 'record' end
+instance = ref inst
+
+audiobase = if !instance == 'record' then list.assoc(default="", "audiobase", ini) else list.assoc(default="", "altaudiobase", ini)  end
+rec_filetype = list.assoc(default="", "rec_filetype", ini)
+
+filenamepattern = ref audiobase^"/%Y-%m-%d/%Y-%m-%d-%H-%M.flac"
+
+# Der aktuelle Dateiname für die Aufnahme
+recordingfile = ref ""
+
+# wir definieren eine Referenz für die Stop-Funktion, die aber bisher noch nichts tun kann
+stop_f = ref (fun () -> ())
+
+# bewahre uns davor, dass zweimal gleichzeitig die gleiche Date aufgenommen wird
+is_record_active = ref false
+
+# Stop dump - wir definieren die Funktion, die stop_f ausführt
+def stop_dump() =
+  f = !stop_f
+  f ()
+end
+
+def on_start()
+    recordingfile := list.hd(default="", get_process_lines("date +#{!filenamepattern}"))
+end
+
+# Wav header fixen und ggf. die Aufzeichnung beenden
+def on_close(filename)
+    # es darf wieder aufgenommen werden
+    is_record_active := false
+
+    # if list.assoc(default="", "rec_filetype", ini) == 'wav'
+    #     # Korrekten WAV-Header schreiben
+    #     system("qwavheaderdump -F #{filename}")
+
+    # Naechsten Dateinamen vormerken
+    recordingfile := list.hd(default="", get_process_lines("date +#{!filenamepattern}"))
+end
+
+# Der input wie oben definiert
+def get_input()
+    output_source
+    # input.alsa()
+end
+
+def get_output()
+    input = get_input()
+    d = int_of_string(list.assoc(default="", "rec_duration", ini))
+    if rec_filetype == 'flac' then
+        log("output file type is FLAC")
+        output.file(
+            id="recorder",
+            %flac(samplerate=44100, channels=2, compression=5, bits_per_sample=16),
+            perm = 0o664,
+            on_start=on_start,
+            !filenamepattern,
+            on_close=on_close,
+            reopen_when={ if !instance == 'record' then int_of_float(gettimeofday()/60.) mod 30 == 0  else false end },
+            input
+        )
+    else
+        # record in WAV
+        log("output file type is WAV")
+        output.file(
+            id="recorder",
+            %wav(stereo=true, channels=2, samplesize=16, header=true),
+            perm = 0o664,
+            on_start=on_start,
+            !filenamepattern,
+            on_close=on_close,
+            reopen_when={ if !instance == 'record' then int_of_float(gettimeofday()/60.) mod d == 0  else false end },
+            input
+        )
+    end
+end
+
+# Funktion gibt Auskunft welches File aktuell ist und wieviel Prozent bereits aufgenommen werden
+def currecording()
+    curfile = !recordingfile
+    if curfile != "" then
+        percent_done = default="", get_process_lines("echo $(($(stat -c%s "^curfile^")/3174777))"))
+        "#{curfile}, #{percent_done}%"
+    else
+        "Nothing is being recorded now"
+    end
+end
+
+#Funktion zum Start der Aufzeichnung
+def start_dump() =
+    log('start dump')
+
+    # don't record twice is_record_active
+    if !is_record_active == false then
+        is_record_active := true
+        
+        log('starting to record')
+
+        record = get_output()
+        
+        log('record defined')
+        # Die Stopfunkton zeigt nun auf die Shutdown-Funktion der aktuellen Source
+        stop_f := fun () -> begin
+                                log('stop recording')
+                                # Aufnahme sauber beenden
+                                ignore(server.execute('recorder.stop'))
+                                # Source zerstören
+                                source.shutdown(record)
+                                # Variable zurücksetzen
+                                recordingfile := ""
+                            end
+    else 
+        log("recorder already active")
+    end
+end
+
+
+# Der Server wird durch 3 Funktionen bereichert
+# Der User darf die Aufzeichnung manuell starten
+server.register(namespace="record",
+                description="Start recording.",
+                usage="start",
+                "start",
+                fun (s) ->  begin start_dump() "OK" end)
+
+# Der User darf die Aufzeichnung manuell stoppen
+server.register(namespace="record",
+                description="Stop recording.",
+                usage="stop",
+                "stop",
+                fun (s) -> begin stop_dump() "OK" end)
+
+if !instance != 'record' then
+    # Der User darf einen Dateinamen für die Aufnahme definieren
+    server.register(namespace="record",
+                    description="Define filename for output.",
+                    usage="setfilename",
+                    "setfilename",
+                    fun (s) -> begin filenamepattern := audiobase^"/"^string_of(s)  "OK" end)
+end
+
+# Der User kann sich über den Fortschritt der Aufnahme informieren
+server.register(namespace="record",
+                description="Show current file.",
+                usage="curfile",
+                "curfile",
+                fun (s) -> currecording() )
+
+output.dummy(blank(id="serve"))

src/liquidsoap/archive/unused_recorder.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# define file name pattern
+filenamepattern = ref audiobase^"/%Y-%m-%d/%Y-%m-%d-%H-%M.flac"
+
+# Der aktuelle Dateiname für die Aufnahme
+recordingfile = ref ""
+
+# bewahre uns davor, dass zweimal gleichzeitig die gleiche Date aufgenommen wird
+is_record_active = ref false
+
+#wir definieren eine Referenz für die Stop-Funktion, die aber bisher noch nichts tun kann
+stop_f = ref (fun () -> ())
+
+
+
+def start_wav_output(recfile, filenamepattern, recorder_number)
+    duration   = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_duration",     ini))
+    channels   = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_channels",     ini))
+    samplesize = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_samplesize",     ini))
+
+    ignore(duration)
+    ignore(channels)
+    ignore(samplesize)
+
+#    def on_start()
+#        recfile := list.hd(default="", get_process_lines("date +#{!filenamepattern}"))
+#    end
+#    def on_close(filename)
+#        recordingfile := list.hd(default="", get_process_lines("date +#{!filenamepattern}"))
+#    end
+
+    print(channels)
+    print(samplesize)
+    #out_wav = output.file(id="recorder", perm = 0o664, on_start=on_start, on_close=on_close, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 })
+    #out_wav(%wav(stereo=true, channels=2, samplesize=8, header=true, !filenamepattern, output_source)
+    #ignore(out_wav)
+
+    output.dummy(id="wav_dummy_recording", blank())
+
+#    if channels == 2 then
+#        output.file(id="recorder", %wav(stereo=true, channels=2, samplesize=8, header=true), perm = 0o664, on_start=on_start, on_close=on_close, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 }, !filenamepattern, audio_to_stereo(output_source))
+##        out_wav(output_source)
+#    else
+#        output.file(id="recorder", %wav(stereo=true, channels=1, samplesize=8, header=true), perm = 0o664, on_start=on_start, on_close=on_close, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 }, !filenamepattern, output_source)
+    #    out_wav(output_source)
+#    end
+
+    #if channels == 2 then
+    #    if samplesize < 12 then
+    #        ignore(out_wav(%wav(stereo=true, channels=2, samplesize=8, header=true), !filenamepattern, output_source))
+    #    else
+    #        ignore(out_wav(%wav(stereo=true, channels=2, samplesize=16, header=true), !filenamepattern, output_source))
+    #    end
+    #else
+    #    if samplesize < 12 then
+    #        ignore(out_wav(%wav(stereo=true, channels=1, samplesize=8, header=true), !filenamepattern, output_source))
+    #    else
+    #        ignore(out_wav(%wav(stereo=true, channels=1, samplesize=16, header=true), !filenamepattern, output_source))
+    #    end
+    #end
+end
+
+def start_flac_output(recorder_number, filenamepattern, duration)
+#    duration        = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_samplerate",     ini))
+#    samplerate      = list.assoc(default="", "rec_"^recorder_number^"_samplerate",      ini)
+    channels        = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_channels",        ini))
+#    compression     = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_compression",     ini))
+#    bits_per_sample = int_of_string(list.assoc(default="", "rec_"^recorder_number^"_bits_per_sample", ini))
+    #output.file(id="recorder", %flac(samplerate=44100, channels=1, compression=7, bits_per_sample=32), perm = 0o664, on_start=on_start, !filenamepattern, on_close=on_close, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 }, output_source)
+
+    recfile = ref ''
+
+    def on_start()
+        recfile := list.hd(default="", get_process_lines("date +#{filenamepattern}"))
+    end
+    def on_close(filename)
+        recfile := list.hd(default="", get_process_lines("date +#{filenamepattern}"))
+    end
+
+    # dumbass liquidsoap cannot handle one output definition for mono and stereo
+    output_filesystem_mono   = output.file(id="recorder", perm = 0o664, on_start=on_start, on_close=on_close, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 })
+    output_filesystem_stereo = output.file(id="recorder", perm = 0o664, on_start=on_start, on_close=on_close, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 })
+
+    ignore(output_filesystem_mono)
+    ignore(output_filesystem_stereo)
+
+    if channels == 2 then
+        output.dummy(id="flac_dummy_recording_stereo", blank())
+#        output_stereof(%flac(samplerate=44100, channels=1, compression=1, bits_per_sample=16), !filenamepattern, output_source)
+    else
+        output.dummy(id="flac_dummy_recording_mono", blank())
+#        output_icecast_monof(%flac(samplerate=44100, channels=1, compression=1, bits_per_sample=16), !filenamepattern, output_source)
+    end
+
+
+end
+
+
+
+
+
+def enable_stop_function(record)
+    # Die Stopfunkton zeigt nun auf die Shutdown-Funktion der aktuellen Source
+    stop_f := fun () -> begin
+                            log('stop recording')
+                            # Aufnahme sauber beenden
+                            ignore(server.execute('recorder.stop'))
+                            # Source zerstören
+                            source.shutdown(record)
+                            # Variable zurücksetzen
+                            recordingfile := ""
+                        end
+end
+
+def set_recorder_output(rec_filetype, recorder_number)
+    # flac output
+    if rec_filetype == 'flac' then
+        log("output file type is FLAC")
+        record = start_flac_output(recorder_number)
+        enable_stop_function(record)
+
+    # WAV output
+    else
+        log("output file type is WAV")
+        record = start_wav_output(recorder_number)
+        enable_stop_function(record)
+    end
+end
+
+# shows current file and how many bytes were written so far
+def currecording()
+    curfile = !recordingfile
+    if curfile != "" then
+        bytes_written = list.hd(default="", get_process_lines("echo $(($(stat -c%s "^curfile^")))"))
+        "#{curfile}, #{bytes_written}B"
+    else
+        ""
+    end
+end
+
+
+
+### LIBRARY ###
+
+
+########################
+# record to filesystem #
+########################
+
+# shows current file and how many bytes were written so far
+def currecording(recfile)
+    if recfile != "" then
+        bytes_written = list.hd(default="", get_process_lines("echo $(($(stat -c%s "^recfile^")))"))
+        "#{recfile}, #{bytes_written}B"
+    else
+        ""
+    end
+end
+
+def start_recorder(folder, duration, encoding, bitrate, channels, filenamepattern, is_recording, stream, recorder_number) =
+    source = ref stream
+    stereo = (int_of_string(channels) >= 2)
+
+    # define on_start, on_close (good case) and on_stop (error case)
+    recfile = ref ''
+    def on_start()
+        is_recording := true
+        recfile := list.hd(default="", get_process_lines("date +#{filenamepattern}"))
+    end
+    def on_close(filename)
+        is_recording := false
+        recfile := list.hd(default="", get_process_lines("date +#{filenamepattern}"))
+    end
+    def on_stop()
+        is_recording := false
+    end
+
+    # register server function
+    server.register(namespace="recorder_"^recorder_number, description="Show current file.", usage="curfile", "curfile", fun (s) -> currecording(!recfile) )
+
+    # dumbass liquidsoap cannot handle one output definition for mono and stereo
+    output_filesystem_mono   = output.file(id="recorder_"^recorder_number, perm = 0o664, on_start=on_start, on_close=on_close, on_stop=on_stop, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 })
+    output_filesystem_stereo = output.file(id="recorder_"^recorder_number, perm = 0o664, on_start=on_start, on_close=on_close, on_stop=on_stop, reopen_when={ int_of_float(gettimeofday()/60.) mod duration == 0 })
+
+#    %ifencoder %aac
+    # if encoding == "aac" then
+    #     log("ENABLING aac recorder to filesystem")
+    #     %include "outgoing_recordings/aac.liq"
+    # end
+#    %endif
+
+#    %ifencoder %flac
+    if encoding == "flac" then
+        log("ENABLING flac recorder to filesystem")
+        %include "outgoing_recordings/flac.liq"
+    end
+#    %endif
+
+#    %ifencoder %mp3
+    if encoding == "mp3" then
+        log("ENABLING mp3 recorder to filesystem")
+        %include "outgoing_recordings/mp3.liq"
+    end
+#    %endif
+
+#    %ifencoder %vorbis
+    if encoding == "ogg" then
+        log("ENABLING ogg recorder to filesystem")
+        %include "outgoing_recordings/ogg.liq"
+    end
+#    %endif
+
+#    %ifencoder %opus
+    if encoding == "opus" then
+        log("ENABLING opus recorder to filesystem")
+        %include "outgoing_recordings/opus.liq"
+    end
+#    %endif
+
+#    %ifencoder %wav
+    if encoding == "wav" then
+        log("ENABLING wav recorder to filesystem")
+        %include "outgoing_recordings/wav.liq"
+    end
+#    %endif
+end

src/liquidsoap/archive/unused_stream.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+def get_icecast_mp3_stream(number)
+    stream_bitrate = int_of_string(list.assoc(default="", "stream_#{number}_bitrate", ini))
+    stream_mountpoint = list.assoc(default="", "stream_#{number}_mountpoint", ini)
+    stream_host = list.assoc(default="", "stream_#{number}_host", ini)
+    stream_port = int_of_string(list.assoc(default="", "stream_#{number}_port", ini))
+    stream_name = list.assoc(default="", "stream_#{number}_name", ini)
+    stream_url = list.assoc(default="", "stream_#{number}_url", ini)
+    stream_genre = list.assoc(default="", "stream_#{number}_genre", ini)
+    stream_description = list.assoc(default="", "stream_#{number}_description", ini)
+    stream_user = list.assoc(default="", "stream_#{number}_user", ini)
+    stream_password = list.assoc(default="", "stream_#{number}_password", ini)
+
+
+
+    if stream_bitrate == 24 then
+        icecast_stream = output.icecast(%mp3(bitrate = 24, samplerate = 22050), mount=stream_mountpoint, host=stream_host, port=stream_port, name=stream_name, url=stream_url, genre=stream_genre, description=stream_description, user=stream_user, password=stream_password, icy_metadata="true", fallible=true, buffer(output_source))
+        clock.assign_new(id="stream_#{number}",
+            [icecast_stream]
+        )
+        icecast_stream
+    else
+        icecast_stream = output.icecast(%mp3(samplerate = 44100), mount=stream_mountpoint, host=stream_host, port=stream_port, name=stream_name, url=stream_url, genre=stream_genre, description=stream_description, user=stream_user, password=stream_password, icy_metadata="true", fallible=true, buffer(output_source))
+        clock.assign_new(id="stream_#{number}",
+            [icecast_stream]
+        )
+        icecast_stream
+    end
+end
+
+def get_icecast_ogg_stream(number)
+    stream_quality = float_of_string(list.assoc(default="", "stream_#{number}_quality", ini))
+
+    stream_mountpoint = list.assoc(default="", "stream_#{number}_mountpoint", ini)
+    stream_host = list.assoc(default="", "stream_#{number}_host", ini)
+    stream_port = int_of_string(default="", list.assoc("stream_#{number}_port", ini))
+    stream_name = list.assoc(default="", "stream_#{number}_name", ini)
+    stream_url = list.assoc(default="", "stream_#{number}_url", ini)
+    stream_genre = list.assoc(default="", "stream_#{number}_genre", ini)
+    stream_description = list.assoc(default="", "stream_#{number}_description", ini)
+    stream_user = list.assoc(default="", "stream_#{number}_user", ini)
+    stream_password = list.assoc(default="", "stream_#{number}_password", ini)
+
+    if stream_quality >= 0.5 then
+        icecast_stream = output.icecast(%vorbis(quality = 1.0), mount=stream_mountpoint, host=stream_host, port=stream_port, name=stream_name, url=stream_url, genre=stream_genre, description=stream_description, user=stream_user, password=stream_password, icy_metadata="true", fallible=true, buffer(output_source))
+        clock.assign_new(id="stream_#{number}",
+            [icecast_stream]
+        )
+        icecast_stream
+    else
+        icecast_stream = output.icecast(%vorbis(quality = 0.1), mount=stream_mountpoint, host=stream_host, port=stream_port, name=stream_name, url=stream_url, genre=stream_genre, description=stream_description, user=stream_user, password=stream_password, icy_metadata="true", fallible=true, buffer(output_source))
+        clock.assign_new(id="stream_#{number}",
+            [icecast_stream]
+        )
+        icecast_stream
+    end
+end
+
+def get_harbour_mp3_stream(number)
+
+    stream_bitrate = int_of_string(list.assoc(default="", "stream_#{number}_bitrate", ini))
+    stream_user = list.assoc(default="", "stream_#{number}_user", ini)
+    stream_password =  list.assoc(default="", "stream_#{number}_password", ini)
+    stream_port = int_of_string(list.assoc(default="", "stream_#{number}_port", ini))
+    stream_url = list.assoc(default="", "stream_#{number}_url", ini)
+    stream_mountpoint = list.assoc(default="", "stream_#{number}_mountpoint", ini)
+
+    if stream_bitrate == 24 then
+        harbourstream = output.harbor(%mp3(bitrate = 24, samplerate = 22050), user=stream_user, password=stream_password, id="stream", port=stream_port, url=stream_url, mount=stream_mountpoint, icy_metadata="true", fallible=true, buffer(output_source))
+        clock.assign_new(id="stream_#{number}",
+            [harbourstream]
+        )
+        harbourstream
+    else
+        harbourstream = output.harbor(%mp3, user=stream_user, password=stream_password, id="stream", port=stream_port, url=stream_url, mount=stream_mountpoint, icy_metadata="true", fallible=true, buffer(output_source))
+        clock.assign_new(id="stream_#{number}",
+            [harbourstream]
+        )
+        harbourstream
+    end
+end
+
+def get_stream(number)
+    stream = list.assoc(default="", "stream_#{number}", ini)
+    stream_type = list.assoc(default="", "stream_#{number}_type", ini)
+    stream_format = list.assoc(default="", "stream_#{number}_format", ini)
+
+    # is stream enabled?
+    if stream == "y" then
+        log("activating stream #{number}")
+        if stream_type == "icecast" then
+            log("its an icecast stream")
+            if stream_format == "mp3" then
+                log("filled with mp3")
+                get_icecast_mp3_stream(number)
+            elsif stream_format == "vorbis" then
+                log("filled with ogg")
+                get_icecast_ogg_stream(number)
+            else
+                output.dummy(id="no_valid_stream_format_DUMMY_ICECAST", blank())
+            end
+
+        elsif stream_type == "harbor" then
+            log("its an harbor stream")
+            if stream_format == "mp3" then
+                get_harbour_mp3_stream(number)
+            else
+                output.dummy(id="no_valid_stream_format_DUMMY_HARBOUR", blank())
+            end
+        else
+            output.dummy(id="no_valid_stream_type_DUMMY", blank())
+        end
+    else
+        output.dummy(id="no_stream_enabled_DUMMY", blank())
+    end
+end
+
+def set_streams()
+    stream_0 = get_stream(0)
+    #stream_1 = get_stream(1)
+    #stream_2 = get_stream(2)
+    #stream_3 = get_stream(3)
+    #stream_4 = get_stream(4)
+end
+

src/liquidsoap/engine.liq

+#!/usr/bin/liquidsoap
+
+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+icecast_vorbis_metadata = false
+inputs = ref []
+
+# Load settings from ini file
+%include "settings.liq"
+
+# Include some functions
+%include "library.liq"
+
+#####################################
+#              EVENTS               #
+#####################################
+
+# Called when some new metadata info is available
+def on_metadata_notification(meta) =
+    filename = meta["filename"]
+    track_duration = request.duration(filename)
+    json_data = json_of(meta)
+    json_data = '{ "action": "on_metadata", "data": #{json_data}, "track_duration": "#{track_duration}" }'
+    # There's currently an issue with Liquidsoap http.post requests:
+    # headers = [("Content-Type","application/json; charset=utf-8")]
+    # ignore(http.post(headers=headers, data="#{json_data}", "http://localhost:1337"))
+    ignore(system("curl -X POST -H 'Content-Type: application/json' --data '#{json_data}' localhost:1337"))
+end
+
+#####################################
+#              INPUTS               #
+#####################################
+
+# Enable queue sources
+%include "in_queue.liq"
+
+# Enable fallback sources
+%include "in_fallback.liq"
+
+# Enable stream overtakes
+%include "in_stream.liq"
+
+# Enabled line in from soundcard
+%include "in_soundcard.liq"
+
+
+#####################################
+#             ROUTING               #
+#####################################
+
+
+# When some regular playout is happening and it is returned to the fallback,
+# we don't want to resume the previous fallback track:
+def on_track_change(s) = 
+    source.skip(station_playlist)
+    source.skip(station_folder)
+end
+
+
+mixer = mix(id="mixer", 
+        list.append(
+            [
+                input_filesystem_0, 
+                input_filesystem_1, 
+                input_http_0, 
+                input_http_1, 
+                input_https_0, 
+                input_https_1
+            ], 
+            !inputs
+        )
+    )
+
+stripped_stream = strip_blank(
+        id="strip_blank", 
+        track_sensitive=false, 
+        max_blank=fallback_max_blank, 
+        min_noise=fallback_min_noise, 
+        threshold=fallback_threshold, 
+        mixer
+    )
+
+stripped_stream = on_track(on_track_change, stripped_stream)
+
+fallback_one = fallback(
+    id="fallback-scheduled", 
+    track_sensitive=false,
+    replay_metadata=true,
+    [ stripped_stream, stripped_fallback_mixer])
+
+fallback_one = on_track(on_track_change, fallback_one)
+
+fallback_two = fallback(
+    id="fallback-station-playlist", 
+    track_sensitive=false,
+    replay_metadata=true,
+    [ fallback_one, station_playlist])
+
+fallback_three = fallback(
+    id="fallback-station-folder", 
+    track_sensitive=false,
+    replay_metadata=true,
+    [ fallback_two, station_folder])
+
+output_source = fallback_three
+
+#####################################
+#             OUTPUTS               #
+#####################################
+
+# create soundcard output
+%include "out_soundcard.liq"
+
+# stream output
+%include "out_stream.liq"
+
+# enable socket functions
+%include "serverfunctions.liq"
+

src/liquidsoap/helpers/__init__.py

+
+import os
+import sys

src/liquidsoap/helpers/silence.sh

+#!/bin/bash
+
+pack_int(){ printf "%08X\n" $1 | sed 's/\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)/\\\\\\x\4\\\\\\x\3\\\\\\x\2\\\\\\x\1/I' | xargs printf; }
+
+pack_short(){ printf "%04X\n" $1 | sed 's/\([0-9A-F]\{2\}\)\([0-9A-F]\{2\}\)/\\\\\\x\2\\\\\\x\1/I' | xargs printf; }
+
+duration=1800
+if [[ $# -eq 1 ]]; then
+    duration=$1
+fi
+
+channels=2
+bps=16
+sample=44100
+Subchunk1Size=18
+Subchunk2Size=$(echo "$duration*$sample*$channels*$bps/8" | bc)
+ChunkSize=$((20 + $Subchunk1Size + $Subchunk2Size))
+
+echo -n RIFF
+pack_int $ChunkSize
+echo -n "WAVEfmt "
+pack_int $Subchunk1Size
+pack_short 1
+pack_short $channels
+pack_int $sample
+pack_int $((bps/8 * channels * sample))
+pack_short $((bps/8 * channels))
+pack_short $bps
+pack_short 0
+echo -n data
+pack_int $Subchunk2Size
+
+dd if=/dev/zero bs=1 count=$Subchunk2Size 2>/dev/null

src/liquidsoap/in_fallback.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+fallback_inputs = ref []
+
+#####################################
+#         FALLBACK SOURCES          #
+#####################################
+
+
+# Create Sources
+input_fallback_scheduled_0 = request.equeue(id="in_fallback_scheduled_0")
+input_fallback_scheduled_1 = request.equeue(id="in_fallback_scheduled_1")
+
+station_playlist = playlist(
+    id="station_playlist", 
+    fallback_station_playlist_path, 
+    mode="randomize",    
+    reload_mode="watch",
+    reload=0)
+
+station_folder = mksafe(
+    playlist(id="station_folder", 
+    fallback_station_dir, 
+    mode="randomize", 
+    reload=fallback_station_dir_reload, 
+    reload_mode="seconds"))
+
+# Apply ReplayGain Normalization
+input_fallback_scheduled_0 = amplify(id="in_fallback_scheduled_0", 1., override="replay_gain", input_fallback_scheduled_0)
+input_fallback_scheduled_1 = amplify(id="in_fallback_scheduled_1", 1., override="replay_gain", input_fallback_scheduled_1)
+station_playlist = amplify(id="station_playlist", 1., override="replay_gain", station_playlist)
+station_folder = amplify(id="station_folder", 1., override="replay_gain", station_folder)
+
+# Add Event Handlers
+input_fallback_scheduled_0 = on_metadata(id="in_fallback_scheduled_0", on_metadata_notification, input_fallback_scheduled_0)
+input_fallback_scheduled_1 = on_metadata(id="in_fallback_scheduled_1", on_metadata_notification, input_fallback_scheduled_1)
+station_playlist = on_metadata(id="station_playlist", on_metadata_notification, station_playlist)
+station_folder = on_metadata(id="station_folder", on_metadata_notification, station_folder)
+
+# Mixer for more control of scheduled fallbacks
+fallback_mixer = mix(id="mixer_fallback", 
+        list.append(
+            [
+                input_fallback_scheduled_0, 
+                input_fallback_scheduled_1
+            ], 
+            !fallback_inputs
+        )
+    )
+
+stripped_fallback_mixer = strip_blank(
+        id="fallback_strip_blank", 
+        track_sensitive=false, 
+        max_blank=fallback_max_blank, 
+        min_noise=fallback_min_noise, 
+        threshold=fallback_threshold, 
+        fallback_mixer
+    )
+
+#####################################
+#          SERVER FUNCTIONS         #
+#####################################
+
+
+
+# Clear Fallback Queue A
+server.register(namespace=source.id(input_fallback_scheduled_0),
+        description="Clear all items of the scheduled fallback queue A.",
+        usage="clear",
+        "clear",
+
+    fun (s) -> 
+        begin
+            source.skip(input_fallback_scheduled_0)
+            clear_queue(input_fallback_scheduled_0) 
+            "Clearing done."     
+        end
+    )
+
+# Clear Fallback Queue B
+server.register(namespace=source.id(input_fallback_scheduled_1),
+        description="Clear all items of the scheduled fallback queue B.",
+        usage="clear",
+        "clear",
+
+    fun (s) -> 
+        begin
+            source.skip(input_fallback_scheduled_1)
+            clear_queue(input_fallback_scheduled_1) 
+            "Clearing done." 
+        end
+    )
+
+# Seek Fallback Queue A
+server.register(namespace = source.id(input_fallback_scheduled_0),
+    description="Seek to relative position in #{source.id(input_fallback_scheduled_0)}",
+    usage = "seek <duration in seconds>",
+    "seek",
+
+    fun (t) -> 
+        begin
+            log("Seeking #{t} sec")
+            t = float_of_string(default=0.,t)
+            ret = source.seek(input_fallback_scheduled_0, t)
+            "Seeked #{ret} seconds."
+        end
+    )
+
+# Seek Fallback Queue B
+server.register(namespace = source.id(input_fallback_scheduled_1),
+    description="Seek to relative position in #{source.id(input_fallback_scheduled_1)}",
+    usage = "seek <duration in seconds>",
+    "seek",
+
+    fun (t) -> 
+        begin
+            log("Seeking #{t} sec")
+            t = float_of_string(default=0.,t)
+            ret = source.seek(input_fallback_scheduled_1, t)
+            "Seeked #{ret} seconds."
+        end
+    )    
\ No newline at end of file

src/liquidsoap/in_queue.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# # Called when some new metadata info is available
+# def on_metadata_notification(meta) =
+#     filename = meta["filename"]
+#     # artist = meta["artist"]
+#     # title = meta["title"]
+#     system('#{list.assoc(default="", "install_dir", ini)}/guru.py --on_play "#{filename}"')
+# end
+
+
+#####################################
+#           QUEUE SOURCES           #
+#####################################
+
+# Create Sources
+input_filesystem_0 = request.equeue(id="in_filesystem_0")
+input_filesystem_1 = request.equeue(id="in_filesystem_1")
+
+# Apply ReplayGain Normalization
+input_filesystem_0 = amplify(id="in_filesystem_0", 1., override="replay_gain", input_filesystem_0)
+input_filesystem_1 = amplify(id="in_filesystem_1", 1., override="replay_gain", input_filesystem_1)
+
+# Add Event Handlers
+input_filesystem_0 = on_metadata(id="in_filesystem_0", on_metadata_notification, input_filesystem_0)
+input_filesystem_1 = on_metadata(id="in_filesystem_1", on_metadata_notification, input_filesystem_1)
+
+
+#####################################
+#          SERVER FUNCTIONS         #
+#####################################
+
+
+# Clear Default Queue A
+server.register(namespace=source.id(input_filesystem_0),
+        description="Clear all items of the default queue A.",
+        usage="clear",
+        "clear",
+
+    fun (s) -> 
+        begin 
+            clear_queue(input_filesystem_0) 
+            "Clearing done."     
+        end
+    )
+
+# Clear Default Queue B
+server.register(namespace=source.id(input_filesystem_1),
+        description="Clear all items of the default queue B.",
+        usage="clear",
+        "clear",
+
+    fun (s) -> 
+        begin 
+            clear_queue(input_filesystem_1) 
+            "Clearing done." 
+        end
+    )
+
+# Seek Filesystem Queue A
+server.register(namespace = source.id(input_filesystem_0),
+    description="Seek to relative position in #{source.id(input_filesystem_0)}",
+    usage = "seek <duration in seconds>",
+    "seek",
+
+    fun (t) -> 
+        begin
+            log("Seeking #{t} sec")
+            t = float_of_string(default=0.,t)
+            ret = source.seek(input_filesystem_0, t)
+            "Seeked #{ret} seconds."
+        end
+    )
+
+# Seek Filesystem Queue B
+server.register(namespace = source.id(input_filesystem_1),
+    description="Seek to relative position in #{source.id(input_filesystem_1)}",
+    usage = "seek <duration in seconds>",
+    "seek",
+
+    fun (t) -> 
+        begin
+            log("Seeking #{t} sec")
+            t = float_of_string(default=0.,t)
+            ret = source.seek(input_filesystem_1, t)
+            "Seeked #{ret} seconds."
+        end
+    )

src/liquidsoap/in_soundcard.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+if a0_in != "" then
+    # we can ignore the result, since it is stored in the list 'inputs'
+    set_input(a0_in, "linein_0")
+end
+
+if a1_in != "" then
+    ignore(set_input(a1_in, "linein_1"))
+end
+
+if a2_in != "" then
+    ignore(set_input(a2_in, "linein_2"))
+end
+
+if a3_in != "" then
+    ignore(set_input(a3_in, "linein_3"))
+end
+
+if a4_in != "" then
+    ignore(set_input(a4_in, "linein_4"))
+
+#    input_4 = ref output.dummy(blank())
+#    set_input(input_4, a4_in, "linein_4")
+#    inputs := list.append([!input_4], !inputs)
+end
\ No newline at end of file

src/liquidsoap/in_stream.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+
+# Pre-population of stream input sources, as Liquidsoap needs it to initialize this input.
+# This is overwritten as soon as some other Stream is scheduled.
+
+# http_starturl = "http://stream01.kapper.net:8001/live.mp3"
+# http_starturl = "http://stream.fro.at/fro-128.ogg"
+http_starturl = "http://trance.out.airtime.pro:8000/trance_a"
+# http_starturl = "http://chill.out.airtime.pro:8000/chill_a"
+# http_starturl = "http://212.89.182.114:8008/frf"
+
+https_starturl = "https://securestream.o94.at/live.mp3"
+# https_starturl = "https://live.helsinki.at:8088/live160.ogg"
+# https_starturl = "https://stream.fro.at/fro-128.ogg"
+
+
+
+input_http_0 = input.http(id="in_http_0", buffer=input_stream_buffer, max=60.0, timeout=60.0, autostart=false, http_starturl)
+input_http_1 = input.http(id="in_http_1", buffer=input_stream_buffer, max=60.0, timeout=60.0, autostart=false, http_starturl)
+input_https_0 = input.https(id="in_https_0", buffer=input_stream_buffer, max=60.0, timeout=60.0, autostart=false, https_starturl)
+input_https_1 = input.https(id="in_https_1", buffer=input_stream_buffer, max=60.0, timeout=60.0, autostart=false, https_starturl)
+
+# Route input stream to an dummy output to avoid buffer-overrun messages
+# output.dummy(id="SPAM_HTTP_OUTPUT_0", fallible=true, input_http_0)
+# output.dummy(id="SPAM_HTTP_OUTPUT_1", fallible=true, input_http_1)
+# output.dummy(id="SPAM_HTTPS_OUTPUT_0", fallible=true, input_https_0)
+# output.dummy(id="SPAM_HTTPS_OUTPUT_1", fallible=true, input_https_1)
+# output.dummy(blank())
\ No newline at end of file

src/liquidsoap/library.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+
+#####################################
+#         CLEAR SOURCE              #
+#####################################
+
+def clear_items(ns) =
+    ret = server.execute("#{source.id(ns)}.primary_queue")
+    ret = list.hd(default="", ret)
+    if ret == "" then
+        log("Queue cleared.")
+        (-1.)
+    else
+        log("There are still items in the queue, trying skip ...")
+        source.skip(ns)
+        (0.1)
+    end
+end
+
+def clear_queue(ns) =
+    add_timeout(fast=false, 0.5, {clear_items(ns)})
+end
+
+
+#####################################
+#         DYNAMIC SOURCES           #
+#####################################
+
+def create_dynamic_source(~skip=true, name)
+    log("Creating dynamic source '#{name}'")
+    track = get_process_lines("cat "^string.quote("next-track.txt"))
+    track = list.hd(default="", track)
+    dyn_source = request.dynamic.list(
+      { [request.create(track)] })
+    dyn_source
+end
+
+
+#####################
+# stream to icecast #
+#####################
+
+def stream_to_icecast(id, encoding, bitrate, host, port, pass, mount_point, url, description, genre, user, stream, streamnumber, connected, name, channels) =
+    source = ref stream
+
+    def on_error(msg)
+        connected := "false"
+        log(msg)
+        5.
+    end
+    def on_connect()
+        connected := "true"
+        log("Successfully connected to stream_#{streamnumber}")
+    end
+
+    stereo = (int_of_string(channels) >= 2)
+
+    user_ref = ref user
+    if user == "" then
+        user_ref := "source"
+    end
+
+    # Liquidsoap cannot handle one output definition for mono and stereo
+    output_icecast_mono   = output.icecast(id = id, host = host, port = port, password = pass, mount = mount_point, fallible = true, url = url, description = description, name = name, genre = genre, user = !user_ref, on_error = on_error, on_connect = on_connect, icy_metadata = "true")
+    output_icecast_stereo = output.icecast(id = id, host = host, port = port, password = pass, mount = mount_point, fallible = true, url = url, description = description, name = name, genre = genre, user = !user_ref, on_error = on_error, on_connect = on_connect, icy_metadata = "true")
+
+#    %ifencoder %aac
+#    if encoding == "aac" then
+#        log("ENABLING AAC to ICECAST")
+#        %include "outgoing_streams/aac.liq"
+#    end
+#    %endif
+#
+#    %ifencoder %flac
+#    if encoding == "flac" then
+#        log("ENABLING FLAC to ICECAST")
+#        %include "outgoing_streams/flac.liq"
+#    end
+#    %endif
+
+    if encoding == "mp3" then
+        log("ENABLING Mp3 to ICECAST")
+        %include "outgoing_streams/mp3.liq"
+    end
+
+    if encoding == "ogg" then
+        log("ENABLING OGG to ICECAST")
+        %include "outgoing_streams/ogg.liq"
+    end
+
+#    %ifencoder %opus
+#    if encoding == "opus" then
+#        log("ENABLING OPUS to ICECAST")
+#        %include "outgoing_streams/opus.liq"
+#    end
+#    %endif
+end
+
+###########
+# line in #
+###########
+
+def set_input(device, name) =
+    if use_alsa == true then
+        alsa_in = input.alsa(id=name, device=a0_in, clock_safe=false, bufferize = false)
+        inputs := list.append([alsa_in], !inputs)
+
+    elsif use_jack == true then
+        jack_in = input.jack(id=name, clock_safe=false)
+        inputs := list.append([jack_in], !inputs)
+
+    else
+        pulse_in = input.pulseaudio(id=name, client="AuraEngine Line IN")
+        inputs := list.append([pulse_in], !inputs)
+    end
+end
+
+############
+# line out #
+############
+
+def get_output(source, device, name) =
+    if device != "" then
+        if use_alsa == true then
+            log("--- Set ALSA Output ---")
+            if device == "default" then
+                output.alsa(id="lineout", bufferize = false, source)
+            else
+                output.alsa(id=name, device=device, bufferize = false, source)
+            end
+        elsif use_jack == true then
+            log("--- Set JACK AUDIO Output ---")
+            output.jack(id=name, source)
+        else
+            log("--- Set PULSE AUDIO Output ---")
+            output.pulseaudio(id=name, client="AuraEngine Line OUT", source)
+        end
+    else
+        log("OUTPUT DUMMY")
+        output.dummy(id=name^"_DUMMY", blank())
+    end
+end

src/liquidsoap/out_soundcard.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+if a0_out != "" then
+    ignore(get_output(output_source, a0_out, "lineout_0"))
+end
+
+if a1_out != "" then
+    ignore(get_output(output_source, a1_out, "lineout_1"))
+end
+
+if a2_out != "" then
+    ignore(get_output(output_source, a2_out, "lineout_2"))
+end
+
+if a3_out != "" then
+    ignore(get_output(output_source, a3_out, "lineout_3"))
+end
+
+if a4_out != "" then
+    ignore(get_output(output_source, a4_out, "lineout_4"))
+
+    #output_4 = ref output.dummy(blank())
+    #get_output(output_4, output_source, a4_out, "lineout_4")
+
+    #output_4 := get_output(output_source, a4_out, "lineout_4")
+    #get_output(output_source, a4_out, "aura_lineout_4")
+end

src/liquidsoap/out_stream.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+# Output streaming settings
+# What a mess...
+s0_enable = list.assoc(default="", "stream_0", ini) == "y"
+s1_enable = list.assoc(default="", "stream_1", ini) == "y"
+s2_enable = list.assoc(default="", "stream_2", ini) == "y"
+s3_enable = list.assoc(default="", "stream_3", ini) == "y"
+s4_enable = list.assoc(default="", "stream_4", ini) == "y"
+
+s0_encoding = list.assoc(default="", "stream_0_encoding", ini)
+s0_bitrate = int_of_string(list.assoc(default="", "stream_0_bitrate", ini))
+s0_host = list.assoc(default="", "stream_0_host", ini)
+s0_port = int_of_string(list.assoc(default="", "stream_0_port", ini))
+s0_user = list.assoc(default="", "stream_0_user", ini)
+s0_pass = list.assoc(default="", "stream_0_password", ini)
+s0_mount = list.assoc(default="", "stream_0_mountpoint", ini)
+s0_url = list.assoc(default="", "stream_0_displayurl", ini)
+s0_desc = list.assoc(default="", "stream_0_description", ini)
+s0_genre = list.assoc(default="", "stream_0_genre", ini)
+s0_name = list.assoc(default="", "stream_0_name", ini)
+s0_channels = list.assoc(default="", "stream_0_channels", ini)
+
+s1_encoding = list.assoc(default="", "stream_1_encoding", ini)
+s1_bitrate = int_of_string(list.assoc(default="", "stream_1_bitrate", ini))
+s1_host = list.assoc(default="", "stream_1_host", ini)
+s1_port = int_of_string(list.assoc(default="", "stream_1_port", ini))
+s1_user = list.assoc(default="", "stream_1_user", ini)
+s1_pass = list.assoc(default="", "stream_1_password", ini)
+s1_mount = list.assoc(default="", "stream_1_mountpoint", ini)
+s1_url = list.assoc(default="", "stream_1_displayurl", ini)
+s1_desc = list.assoc(default="", "stream_1_description", ini)
+s1_genre = list.assoc(default="", "stream_1_genre", ini)
+s1_name = list.assoc(default="", "stream_1_name", ini)
+s1_channels = list.assoc(default="", "stream_1_channels", ini)
+
+s2_encoding = list.assoc(default="", "stream_2_encoding", ini)
+s2_bitrate = int_of_string(list.assoc(default="", "stream_2_bitrate", ini))
+s2_host = list.assoc(default="", "stream_2_host", ini)
+s2_port = int_of_string(list.assoc(default="", "stream_2_port", ini))
+s2_user = list.assoc(default="", "stream_2_user", ini)
+s2_pass = list.assoc(default="", "stream_2_password", ini)
+s2_mount = list.assoc(default="", "stream_2_mountpoint", ini)
+s2_url = list.assoc(default="", "stream_2_displayurl", ini)
+s2_desc = list.assoc(default="", "stream_2_description", ini)
+s2_genre = list.assoc(default="", "stream_2_genre", ini)
+s2_name = list.assoc(default="", "stream_2_name", ini)
+s2_channels = list.assoc(default="", "stream_2_channels", ini)
+
+s3_encoding = list.assoc(default="", "stream_3_encoding", ini)
+s3_bitrate = int_of_string(list.assoc(default="", "stream_3_bitrate", ini))
+s3_host = list.assoc(default="", "stream_3_host", ini)
+s3_port = int_of_string(list.assoc(default="", "stream_3_port", ini))
+s3_user = list.assoc(default="", "stream_3_user", ini)
+s3_pass = list.assoc(default="", "stream_3_password", ini)
+s3_mount = list.assoc(default="", "stream_3_mountpoint", ini)
+s3_url = list.assoc(default="", "stream_3_displayurl", ini)
+s3_desc = list.assoc(default="", "stream_3_description", ini)
+s3_genre = list.assoc(default="", "stream_3_genre", ini)
+s3_name = list.assoc(default="", "stream_3_name", ini)
+s3_channels = list.assoc(default="", "stream_3_channels", ini)
+
+s4_encoding = list.assoc(default="", "stream_4_encoding", ini)
+s4_bitrate = int_of_string(list.assoc(default="", "stream_4_bitrate", ini))
+s4_host = list.assoc(default="", "stream_4_host", ini)
+s4_port = int_of_string(list.assoc(default="", "stream_4_port", ini))
+s4_user = list.assoc(default="", "stream_4_user", ini)
+s4_pass = list.assoc(default="", "stream_4_password", ini)
+s4_mount = list.assoc(default="", "stream_4_mountpoint", ini)
+s4_url = list.assoc(default="", "stream_4_displayurl", ini)
+s4_desc = list.assoc(default="", "stream_4_description", ini)
+s4_genre = list.assoc(default="", "stream_4_genre", ini)
+s4_name = list.assoc(default="", "stream_4_name", ini)
+s4_channels = list.assoc(default="", "stream_4_channels", ini)
+
+s0_connected = ref ''
+s1_connected = ref ''
+s2_connected = ref ''
+s3_connected = ref ''
+s4_connected = ref ''
+
+if s0_enable == true then
+    # enable connection status for that stream
+    server.register(namespace="out_http_0", "connected", fun (s) -> begin !s0_connected end)
+
+    # aaand stream
+    stream_to_icecast("out_http_0", s0_encoding, s0_bitrate, s0_host, s0_port, s0_pass, s0_mount, s0_url, s0_desc, s0_genre, s0_user, output_source, "0", s0_connected, s0_name, s0_channels)
+end
+
+if s1_enable == true then
+    server.register(namespace="out_http_1", "connected", fun (s) -> begin !s1_connected end)
+    stream_to_icecast("out_http_1", s1_encoding, s1_bitrate, s1_host, s1_port, s1_pass, s1_mount, s1_url, s1_desc, s1_genre, s1_user, output_source, "1", s1_connected, s1_name, s1_channels)
+end
+
+if s2_enable == true then
+    server.register(namespace="out_http_2", "connected", fun (s) -> begin !s2_connected end)
+    stream_to_icecast("out_http_2", s2_encoding, s2_bitrate, s2_host, s2_port, s2_pass, s2_mount, s2_url, s2_desc, s2_genre, s2_user, output_source, "2", s2_connected, s2_name, s2_channels)
+end
+
+if s3_enable == true then
+    server.register(namespace="out_http_3", "connected", fun (s) -> begin !s3_connected end)
+    stream_to_icecast("out_http_3", s3_encoding, s3_bitrate, s3_host, s3_port, s3_pass, s3_mount, s3_url, s3_desc, s3_genre, s3_user, output_source, "3", s3_connected, s3_name, s3_channels)
+end
+
+if s4_enable == true then
+    server.register(namespace="out_http_4", "connected", fun (s) -> begin !s4_connected end)
+    stream_to_icecast("out_http_4", s4_encoding, s4_bitrate, s4_host, s4_port, s4_pass, s4_mount, s4_url, s4_desc, s4_genre, s4_user, output_source, "4", s4_connected, s4_name, s4_channels)
+end

src/liquidsoap/outgoing_recordings/aac.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+if bitrate == 24 then 
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 24, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 24, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 32 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 32, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 32, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 48 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 48, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 48, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 64 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 64, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 64, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 96 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 96, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 96, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 128 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 128, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 128, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 160 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 160, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 160, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 192 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 192, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 192, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 224 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 224, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 224, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 256 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 256, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 256, channels = 1), filenamepattern, mean(!source)))
+#    end
+elsif bitrate == 320 then
+#    if stereo then
+        ignore(output_filesystem_stereo(%fdkaac(bitrate = 320, channels = 2), filenamepattern, !source))
+#    else
+#        ignore(output_filesystem_mono(%fdkaac(bitrate = 320, channels = 1), filenamepattern, mean(!source)))
+#    end
+end
+

src/liquidsoap/outgoing_recordings/flac.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+if bitrate == 24 or bitrate == 32 or bitrate == 48 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 7, bits_per_sample=8), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 7, bits_per_sample=8), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 64 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 7, bits_per_sample=8), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 7, bits_per_sample=8), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 96 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 7, bits_per_sample=8), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 7, bits_per_sample=8), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 128 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 6, bits_per_sample=16), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 6, bits_per_sample=16), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 160 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 5, bits_per_sample=16), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 5, bits_per_sample=16), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 192 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 4, bits_per_sample=16), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 4, bits_per_sample=16), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 224 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 3, bits_per_sample=32), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 3, bits_per_sample=32), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 256 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 2, bits_per_sample=32), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 2, bits_per_sample=32), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 320 then
+    if stereo then
+        ignore(output_filesystem_stereo(%flac(samplerate=44100, channels = 2, compression = 1, bits_per_sample=32), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%flac(samplerate=44100, channels = 1, compression = 1, bits_per_sample=32), filenamepattern, mean(!source)))
+    end
+end
+

src/liquidsoap/outgoing_recordings/mp3.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+if bitrate == 24 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 24, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 24, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 32 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 32, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 32, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 48 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 48, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 48, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 64 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 64, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 64, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 96 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 96, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 96, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 128 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 128, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 128, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 160 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 160, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 160, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 192 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 192, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 192, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 224 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 224, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 224, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 256 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 256, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 256, stereo = false), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 320 then
+    if stereo then
+        ignore(output_filesystem_stereo(%mp3(bitrate = 320, stereo = true), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%mp3(bitrate = 320, stereo = false), filenamepattern, mean(!source)))
+    end
+end
+

src/liquidsoap/outgoing_recordings/ogg.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+if bitrate == 24 or bitrate == 32 or bitrate == 48 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=-0.1, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=-0.1, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 64 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 96 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.2, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.2, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 128 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.4, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.4, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 160 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.5, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.5, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 192 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.6, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.6, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 224 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.7, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.7, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 256 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.8, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.8, channels = 1), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 320 then
+    if stereo then
+        ignore(output_filesystem_stereo(%vorbis(quality=0.9, channels = 2), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%vorbis(quality=0.9, channels = 1), filenamepattern, mean(!source)))
+    end
+end
+

src/liquidsoap/outgoing_recordings/opus.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+if bitrate == 24 then 
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 24, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 24, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 32 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 32, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 32, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 48 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 48, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 48, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 64 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 64, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 64, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 96 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 96, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 96, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 128 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 128, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 128, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 160 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 160, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 160, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 192 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 192, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 192, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 224 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 224, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 224, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 256 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 256, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 256, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+elsif bitrate == 320 then
+    if stereo then
+        ignore(output_filesystem_stereo(%opus(bitrate = 320, channels = 2, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%opus(bitrate = 320, channels = 1, signal="music", application="audio", complexity=10, vbr="constrained"), filenamepattern, mean(!source)))
+    end
+end
+

src/liquidsoap/outgoing_recordings/wav.liq

+#
+# Aura Engine (https://gitlab.servus.at/aura/engine)
+#
+# Copyright (C) 2017-2020 - The Aura Engine Team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+if bitrate <= 128 then
+    if stereo then
+        ignore(output_filesystem_stereo(%wav(stereo=true, channels=2, samplesize=8, header=true, duration=30.), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%wav(stereo=false, channels=1, samplesize=8, header=true, duration=30.), filenamepattern, mean(!source)))
+    end
+else
+    if stereo then
+        ignore(output_filesystem_stereo(%wav(stereo=true, channels=2, samplesize=16, header=true, duration=30.), filenamepattern, !source))
+    else
+        ignore(output_filesystem_mono(%wav(stereo=false, channels=1, samplesize=16, header=true, duration=30.), filenamepattern, mean(!source)))
+    end
+end
\ No newline at end of file