I was able to kind of put it to work, I leave here the complete script. It fails to play other audio then the auto dj it self. What could be wrong?
boot_timestamp = string_of(gettimeofday())
web_stream_enabled = ref false
web_stream_id = ref '-1'
show_name = interactive.string("show_name", "")
dynamic_metadata_callback = ref fun (~new_track=false, s) -> begin () end
just_switched = ref false
%include "ls_lib.liq"
sources = ref []
source_id = ref 0
def create_source()
this_source_id = !source_id
l = request.equeue(id="s#{this_source_id}", length=0.5)
l = audio_to_stereo(id="queue_src", l)
l = cue_cut(l)
l = amplify(1., override="replay_gain", l)
# Fade the tracks to avoid hard cuts in between two tracks and at the end of the shows.
# Liquidsoap reads the fade in/out durations from the annotation "liq_fade_in/out" which
# value can be set via Libretime settings.
l = fade.in(l)
l = fade.out(l)
l = on_metadata(notify_queue, l)
sources := list.append([l], !sources)
server.register(namespace="queues",
"s#{this_source_id}_skip",
fun (s) -> begin log("queues.s#{this_source_id}_skip")
clear_queue(l)
"Done"
end)
source_id := !source_id + 1
end
create_source()
create_source()
create_source()
create_source()
queue = add(!sources, normalize=false)
pair = insert_metadata(queue)
dynamic_metadata_callback := fst(pair)
queue = snd(pair)
output.dummy(fallible=true, queue)
http = input.http_restart(id="http")
http = cross_http(http_input_id="http",http)
output.dummy(fallible=true, http)
stream_queue = http_fallback(http_input_id="http", http=http, default=queue)
stream_queue = map_metadata(id="map_metadata:schedule", update=false, append_title, stream_queue)
ignore(output.dummy(stream_queue, fallible=true))
def web_stream_set_id(value)
web_stream_id := value
string_of(!web_stream_id)
end
def web_stream_get_id()
string_of(!web_stream_id)
end
server.register(namespace="sources",
description="Start webstream source",
"start_web_stream",
fun (s) -> begin log("sources.start_web_stream")
notify([("schedule_table_id", !web_stream_id)])
web_stream_enabled := true "enabled" end)
server.register(namespace="sources",
description="Stop webstream source",
"stop_web_stream",
fun (s) -> begin log("sources.stop_web_stream") web_stream_enabled := false "disabled" end)
server.register(namespace="web_stream",
description="Set the web stream id",
"set_id",
fun (s) -> begin log("web_stream.set_id") web_stream_set_id(s) end)
server.register(namespace="web_stream",
description="Get the web stream id",
"get_id",
fun (s) -> begin log("web_stream.get_id") web_stream_get_id() end)
#default = amplify(id="silence_src", 0.00001, noise())
def map_message_offline(m) =
[("title", message_offline())]
end
#default = map_metadata(id="map_metadata:offline", map_message_offline, default)
# autodj start
# Your jingles
jingles = playlist("/srv/libretime/autodj/jingles/")
# Your backup playlist
musics = playlist(mode="randomize",reload=1,reload_mode="rounds","/srv/libretime/autodj/music/")
# Your hours time signals
clock = single(id="clock","/srv/libretime/autodj/clock.mp3")
# Your security jingle if the AutoDJ drop
security = single("/srv/libretime/autodj/offair.mp3")
# 1 jingle every 4 songs
streamradio = rotate(weights=[1,4], [jingles, musics])
# Setting up the crossfade
def crossfade (~start_next=5.,~fade_in=3.,
~fade_out=3., ~width=2.,
~conservative=false,s)
high = -20.
medium = -32.
margin = 4.
fade.out = fade.out(type="sin",duration=fade_out)
fade.in = fade.in(type="sin",duration=fade_in)
add = fun (a,b) -> add(normalize=false,[b,a])
log = log(label="crossfade")
def transition(a,b,ma,mb,sa,sb)
list.iter(fun(x)->
log(level=4,"Before: #{x}"),ma)
list.iter(fun(x)->
log(level=4,"After : #{x}"),mb)
if
# If A and B and not too loud and close,
# fully cross-fade them.
a <= medium and
b <= medium and
abs(a - b) <= margin
then
log("Transition: crossed, fade-in, fade-out.")
add(fade.out(sa),fade.in(sb))
elsif
# If B is significantly louder than A,
# only fade-out A.
# We don't want to fade almost silent things,
# ask for >medium.
b >= a + margin and a >= medium and b <= high
then
log("Transition: crossed, fade-out.")
add(fade.out(sa),sb)
elsif
# Do not fade if it's already very low.
b >= a + margin and a <= medium and b <= high
then
log("Transition: crossed, no fade-out.")
add(sa,sb)
elsif
# Opposite as the previous one.
a >= b + margin and b >= medium and a <= high
then
log("Transition: crossed, fade-in.")
add(sa,fade.in(sb))
# What to do with a loud end and
# a quiet beginning ?
# A good idea is to use a jingle to separate
# the two tracks, but that's another story.
else
# Otherwise, A and B are just too loud
# to overlap nicely, or the difference
# between them is too large and
# overlapping would completely mask one
# of them.
log("No transition: just sequencing.")
sequence([sa, sb])
end
end
cross(width=width, duration=start_next,
conservative=conservative,
transition,s)
end
# Enable crossfade between Tracks and Jingles
streamradio = crossfade(start_next=5.,fade_out=3.,fade_in=3.,streamradio)
# Enable every hours time signals
#streamradio = add([streamradio, switch([
# ({0m0s},clock),
# ])
#])
# Metadata updater
def update_metadata(m) =
title = m["title"]
ignore(title)
artist = m["artist"]
ignore(artist)
[("artist","#{artist}"),("title","#{title}")]
end
# Enable AutoDJ with metadata
default = fallback(track_sensitive = false,[streamradio,security])
default = map_metadata(update_metadata, default)
# autodj end
#ignore(output.dummy(default, fallible=true))
input_main_streaming = ref false
input_show_streaming = ref false
schedule_streaming = ref false
def start_input_main() input_main_streaming := true end
def stop_input_main() input_main_streaming := false end
def start_input_show() input_show_streaming := true end
def stop_input_show() input_show_streaming := false end
def start_schedule() schedule_streaming := true; just_switched := true end
def stop_schedule() schedule_streaming := false end
def update_source_status(sourcename, status) =
gateway("live '#{sourcename}' '#{status}'")
end
def input_main_on_connect(header) update_source_status("master_dj", true) end
def input_main_on_disconnect() update_source_status("master_dj", false) end
def input_show_on_connect(header) update_source_status("live_dj", true) end
def input_show_on_disconnect() update_source_status("live_dj", false) end
def make_input_func(secure)
if secure then
input.harbor.ssl
else
input.harbor
end
end
def make_input_auth_handler(input_name)
def auth_handler(user, password)
log("user '#{user}' connected", label="#{input_name}_input")
# Check auth based on return value from auth script
ret = test_process("libretime-playout-notify live-auth '#{input_name}' '#{user}' '#{password}'")
if ret then
log("user '#{user}' authenticated", label="#{input_name}_input")
else
log("user '#{user}' auth failed", label="#{input_name}_input",level=2)
end
ret
end
auth_handler
end
s = switch(id="switch:blank+schedule",
track_sensitive=false,
transitions=[transition_default, transition],
[({!schedule_streaming}, stream_queue), ({true}, default)]
)
s = if input_show_port != 0 and input_show_mount != "" then
input_show_func = make_input_func(input_show_secure)
input_show_source =
audio_to_stereo(
input_show_func(id="harbor:input_show",
input_show_mount,
port=input_show_port,
auth=make_input_auth_handler("show"),
max=40.,
on_connect=input_show_on_connect,
on_disconnect=input_show_on_disconnect))
ignore(output.dummy(input_show_source, fallible=true))
switch(id="switch:blank+schedule+show",
track_sensitive=false,
transitions=[transition, transition],
[({!input_show_streaming}, input_show_source), ({true}, s)]
)
else
s
end
s = if input_main_port != 0 and input_main_mount != "" then
input_main_func = make_input_func(input_main_secure)
input_main_source =
audio_to_stereo(
input_main_func(id="harbor:input_main",
input_main_mount,
port=input_main_port,
auth=make_input_auth_handler("main"),
max=40.,
on_connect=input_main_on_connect,
on_disconnect=input_main_on_disconnect))
ignore(output.dummy(input_main_source, fallible=true))
switch(id="switch:blank+schedule+show+main",
track_sensitive=false,
transitions=[transition, transition],
[({!input_main_streaming}, input_main_source), ({true}, s)]
)
else
s
end
server.register(namespace="sources",
description="Stop main input source.",
usage="stop_input_main",
"stop_input_main",
fun (s) -> begin log("sources.stop_input_main") stop_input_main() "Done." end)
server.register(namespace="sources",
description="Start main input source.",
usage="start_input_main",
"start_input_main",
fun (s) -> begin log("sources.start_input_main") start_input_main() "Done." end)
server.register(namespace="sources",
description="Stop show input source.",
usage="stop_input_show",
"stop_input_show",
fun (s) -> begin log("sources.stop_input_show") stop_input_show() "Done." end)
server.register(namespace="sources",
description="Start show input source.",
usage="start_input_show",
"start_input_show",
fun (s) -> begin log("sources.start_input_show") start_input_show() "Done." end)
server.register(namespace="sources",
description="Stop schedule source.",
usage="stop_schedule",
"stop_schedule",
fun (s) -> begin log("sources.stop_schedule") stop_schedule() "Done." end)
server.register(namespace="sources",
description="Start schedule source.",
usage="start_schedule",
"start_schedule",
fun (s) -> begin log("sources.start_schedule") start_schedule() "Done." end)