247 lines
9.3 KiB
Text
247 lines
9.3 KiB
Text
#!/usr/bin/liquidsoap
|
|
|
|
# radieo — couche diffusion.
|
|
# La source principale est pilotée par le daemon d'ingestion via GET /next.
|
|
# Le dossier /cache sert de secours quand le daemon n'a rien à proposer
|
|
# (daemon indisponible, file momentanément vide…). Si tout est vide : silence.
|
|
# Le harbor sert aussi une petite page web (/) et le titre courant (/nowplaying).
|
|
|
|
# --- Journalisation : tout sur la sortie standard (pratique en conteneur) ---
|
|
settings.log.stdout := true
|
|
settings.log.file := false
|
|
settings.log.level := 3
|
|
|
|
# --- Harbor : écoute sur toutes les interfaces du conteneur ---
|
|
settings.harbor.bind_addrs := ["0.0.0.0"]
|
|
|
|
# URL du daemon d'ingestion (nom de service résolu par docker-compose).
|
|
ingest_url = "http://ingest:8080/next"
|
|
|
|
# Callback appelé par request.dynamic pour obtenir le prochain morceau.
|
|
# Renvoie une requête à jouer, ou null si rien n'est disponible (→ secours).
|
|
def next_track() =
|
|
resp = http.get(ingest_url, timeout=5.0)
|
|
body = string.trim(resp)
|
|
if resp.status_code == 200 and body != "" then
|
|
request.create(body)
|
|
else
|
|
null
|
|
end
|
|
end
|
|
|
|
# Source principale : pilotée par le daemon. prefetch=1 pour anticiper le
|
|
# prochain morceau ; retry_delay pour ne pas marteler le daemon en cas de vide.
|
|
main = request.dynamic(next_track, prefetch=1, retry_delay=1.0)
|
|
|
|
# Filtre du secours : ne garder que les vrais fichiers audio et ignorer les
|
|
# fichiers cachés (.gitkeep, téléchargements .part en cours). Ceinture et
|
|
# bretelles : la m3u ne liste déjà que des fichiers audio réels.
|
|
audio_ext = [".mp3", ".flac", ".ogg", ".opus", ".m4a", ".aac", ".wav"]
|
|
def audio_only(r) =
|
|
u = string.case(lower=true, request.uri(r))
|
|
base = path.basename(u)
|
|
is_audio = list.exists(fun(e) -> string.contains(suffix=e, u), audio_ext)
|
|
is_audio and not string.contains(prefix=".", base)
|
|
end
|
|
|
|
# Secours : uniquement les morceaux DÉJÀ passés à l'antenne. Le daemon les
|
|
# expose en m3u (/fallback.m3u) ; on la récupère périodiquement dans un fichier
|
|
# LOCAL que playlist surveille. Le buffer de préchargement (morceaux pas encore
|
|
# diffusés) en est exclu : au démarrage à froid la liste est vide → silence
|
|
# assumé plutôt qu'une boucle sur 2-3 titres.
|
|
# Passer par un fichier local (plutôt qu'une URL directe dans playlist) évite la
|
|
# détection de type hasardeuse du résolveur http, et garde la dernière liste
|
|
# valide si l'ingest devient injoignable.
|
|
fallback_url = "http://ingest:8080/fallback.m3u"
|
|
fallback_file = "/tmp/fallback.m3u"
|
|
file.write(data="#EXTM3U\n", atomic=true, fallback_file) # amorce vide au boot
|
|
|
|
def refresh_fallback() =
|
|
resp = http.get(fallback_url, timeout=5.0)
|
|
if resp.status_code == 200 then
|
|
file.write(data=resp, atomic=true, fallback_file)
|
|
end
|
|
end
|
|
thread.run(fast=false, every={30.}, refresh_fallback)
|
|
|
|
backup = playlist(
|
|
mode="randomize", reload_mode="watch", mime_type="audio/x-mpegurl",
|
|
check_next=audio_only, fallback_file
|
|
)
|
|
|
|
# fallback préfère la source principale et bascule sur le cache si elle n'a
|
|
# rien de prêt. track_sensitive=true : on ne coupe pas un morceau en cours.
|
|
music = fallback(track_sensitive=true, [main, backup])
|
|
|
|
# --- Jingles : intercalés toutes les 2 chansons -----------------------------
|
|
# Le dossier /jingles (monté depuis ./jingles) est parcouru et lu au hasard.
|
|
# reload_mode="watch" : un jingle ajouté/retiré est pris en compte à chaud.
|
|
# Dossier vide → source jamais prête → le switch retombe simplement sur la
|
|
# musique, sans jingle et sans plantage.
|
|
jingles = playlist(
|
|
mode="randomize", reload_mode="watch", check_next=audio_only, "/jingles"
|
|
)
|
|
|
|
# On compte les morceaux de musique réellement diffusés : on_track ne se
|
|
# déclenche que sur la source effectivement tirée par le switch (les sources
|
|
# non sélectionnées ne sont pas consommées), donc les jingles ne comptent pas.
|
|
song_count = ref(0)
|
|
music.on_track(synchronous=false, fun(_) -> song_count := song_count() + 1)
|
|
|
|
# Prédicat du switch : vrai quand 2 chansons ont été diffusées depuis le dernier
|
|
# jingle. Il remet le compteur à zéro au passage pour repartir sur un cycle neuf.
|
|
def time_for_jingle() =
|
|
if song_count() >= 2 then
|
|
song_count := 0
|
|
true
|
|
else
|
|
false
|
|
end
|
|
end
|
|
|
|
# switch track_sensitive : la décision est prise aux frontières de morceaux, on
|
|
# ne coupe donc jamais un titre. Si les jingles ne sont pas prêts (dossier vide),
|
|
# le switch enchaîne directement sur la musique.
|
|
radio = switch(
|
|
track_sensitive=true,
|
|
[(time_for_jingle, jingles), ({true}, music)]
|
|
)
|
|
|
|
# Transition douce entre les morceaux : fondu enchaîné de 3 s. La fin du
|
|
# morceau courant se fond dans le début du suivant.
|
|
radio = crossfade(duration=3.0, fade_in=3.0, fade_out=3.0, radio)
|
|
|
|
# mksafe garantit un flux continu : silence plutôt que plantage si tout est vide.
|
|
radio = mksafe(radio)
|
|
|
|
# --- Métadonnées « en cours de lecture » -----------------------------------
|
|
# On mémorise les dernières métadonnées vues sur le flux réellement diffusé,
|
|
# ainsi qu'un historique borné des titres passés à l'antenne (le plus récent
|
|
# en tête). L'historique reflète ce qui a vraiment été diffusé.
|
|
now_playing = ref([])
|
|
history = ref([])
|
|
history_max = 25
|
|
radio.on_metadata(
|
|
synchronous=false,
|
|
fun(m) -> begin
|
|
now_playing := m
|
|
# `file` : nom de base du fichier à l'antenne, servant de jeton de
|
|
# téléchargement (/download?file=…). Vide si la métadonnée manque.
|
|
entry = {title=m["title"], artist=m["artist"], url=m["url"], file=path.basename(m["filename"])}
|
|
head = list.hd(default={title="", artist="", url="", file=""}, history())
|
|
is_dup = head.title == entry.title and head.artist == entry.artist
|
|
if not is_dup and (entry.title != "" or entry.artist != "") then
|
|
history := list.prefix(history_max, list.add(entry, history()))
|
|
end
|
|
end
|
|
)
|
|
|
|
# --- Sortie : flux MP3 sur http://<hote>:8000/radio.mp3 ---
|
|
output.harbor(
|
|
%mp3(bitrate=192),
|
|
port=8000,
|
|
mount="radio.mp3",
|
|
radio
|
|
)
|
|
|
|
# --- Page web et API de lecture (mêmes port/harbor que le flux) ---
|
|
home_html = file.contents("/etc/liquidsoap/index.html")
|
|
|
|
harbor.http.register(
|
|
port=8000, method="GET", "/",
|
|
fun(_, resp) -> begin
|
|
resp.content_type("text/html; charset=utf-8")
|
|
resp.html(home_html)
|
|
end
|
|
)
|
|
|
|
harbor.http.register(
|
|
port=8000, method="GET", "/nowplaying",
|
|
fun(_, resp) -> begin
|
|
m = now_playing()
|
|
resp.json({title=m["title"], artist=m["artist"], url=m["url"]})
|
|
end
|
|
)
|
|
|
|
# Historique des titres passés (le plus récent en tête, morceau courant inclus).
|
|
harbor.http.register(
|
|
port=8000, method="GET", "/history",
|
|
fun(_, resp) -> resp.json(history())
|
|
)
|
|
|
|
# État du préchargement, relayé depuis le daemon d'ingestion (reverse proxy) :
|
|
# le player n'a pas accès direct au réseau interne, on lui expose donc l'info
|
|
# {ready, prefetch} via le même harbor que le flux. Si le daemon est injoignable
|
|
# on renvoie un objet neutre plutôt qu'une erreur, pour ne pas casser le player.
|
|
ingest_status_url = "http://ingest:8080/status"
|
|
harbor.http.register(
|
|
port=8000, method="GET", "/ingest/status",
|
|
fun(_, resp) -> begin
|
|
resp.content_type("application/json; charset=utf-8")
|
|
body = http.get(ingest_status_url, timeout=5.0)
|
|
if body.status_code == 200 then
|
|
resp.data(string.trim(body) ^ "\n")
|
|
else
|
|
resp.data("{}")
|
|
end
|
|
end
|
|
)
|
|
|
|
# Passer au morceau suivant : on saute le morceau en cours sur la source
|
|
# diffusée. request.dynamic a déjà préchargé le suivant, donc l'enchaînement
|
|
# est immédiat (le prochain /next est demandé au daemon dans la foulée).
|
|
harbor.http.register(
|
|
port=8000, method="POST", "/skip",
|
|
fun(_, resp) -> begin
|
|
source.skip(radio)
|
|
resp.json({skipped=true})
|
|
end
|
|
)
|
|
|
|
# Télécharger un morceau. Sans paramètre : le titre en cours. Avec `?file=<nom>` :
|
|
# n'importe quel fichier encore présent dans le cache (les titres passés listés
|
|
# par /history exposent ce jeton). Le cache étant borné par le LRU, un morceau
|
|
# évincé renvoie simplement 404.
|
|
def content_type_of(name) =
|
|
low = string.case(lower=true, name)
|
|
if string.contains(suffix=".flac", low) then "audio/flac"
|
|
elsif string.contains(suffix=".ogg", low) then "audio/ogg"
|
|
elsif string.contains(suffix=".opus", low) then "audio/opus"
|
|
elsif string.contains(suffix=".m4a", low) or string.contains(suffix=".aac", low) then "audio/mp4"
|
|
elsif string.contains(suffix=".wav", low) then "audio/wav"
|
|
else "audio/mpeg"
|
|
end
|
|
end
|
|
|
|
# Sert un fichier en pièce jointe après validation. `path.basename` neutralise
|
|
# toute tentative de remontée de répertoire (…/…) ; on n'autorise que de vrais
|
|
# fichiers audio du cache, jamais les fichiers cachés (.part en cours, .gitkeep).
|
|
def serve_attachment(resp, name) =
|
|
base = path.basename(name)
|
|
low = string.case(lower=true, base)
|
|
is_audio = list.exists(fun(e) -> string.contains(suffix=e, low), audio_ext)
|
|
full = "/cache/#{base}"
|
|
if base == "" or string.contains(prefix=".", base) or not is_audio
|
|
or not file.exists(full) then
|
|
resp.status_code(404)
|
|
resp.data("track not available")
|
|
else
|
|
resp.content_type(content_type_of(base))
|
|
resp.header("Content-Disposition", "attachment; filename=\"#{base}\"")
|
|
resp.data(file.contents(full))
|
|
end
|
|
end
|
|
|
|
harbor.http.register(
|
|
port=8000, method="GET", "/download",
|
|
fun(req, resp) -> begin
|
|
requested = list.assoc(default="", "file", req.query)
|
|
name =
|
|
if requested != "" then
|
|
requested
|
|
else
|
|
list.assoc(default="", "filename", now_playing())
|
|
end
|
|
serve_attachment(resp, name)
|
|
end
|
|
)
|