Smooth Transitions Between Fallback Sources in Liquidsoap

[juanamm]

I'm trying to achieve smooth transitions (crossfades) between sources in a fallback setup, specifically between a live DJ stream (input.harbor) and an automated playlist. My goal is to have the playlist fade out smoothly when the DJ connects, and the DJ's audio fade in, and vice versa when the DJ disconnects. Currently, transitions are abrupt, and my attempts to use custom transitions have either resulted in harsh audio artifacts.

Here's the relevant part of my main.liq script, which works perfectly except for the lack of smooth transitions:

`# Settings
settings.log.level := 3
settings.harbor.bind_addrs := ["0.0.0.0"]
settings.log.file := true
settings.log.file.path := "/home/icecast2/liquidsoap/log/registro.log"

Environment Variables

password_dj=environment.get("PASSWORD_DJ")
password_inv1=environment.get("PASSWORD_INV1")
password_inv2=environment.get("PASSWORD_INV2")
password_inv3=environment.get("PASSWORD_INV3")
source_passw=environment.get("SOURCE_PASSW")
port_https=environment.get("PORT_HTTPS")
port_live=environment.get("PORT_LIVE")
port_inv1=environment.get("PORT_INV1")
port_inv2=environment.get("PORT_INV2")
port_inv3=environment.get("PORT_INV3")
host_https_no_prot=environment.get("HOST_HTTPS_NO_PROT")

Convert string to integer

port_live_int=int_of_string(port_live)
port_https_int=int_of_string(port_https)
port_inv1_int=int_of_string(port_inv1)
port_inv2_int=int_of_string(port_inv2)
port_inv3_int=int_of_string(port_inv3)

Define the original playlist source and apply nrj

original_playlist_source=playlist("~/music/playlist.pls")
original_playlist=nrj(original_playlist_source)

Apply crossfades to the playlist

original_playlist = crossfade(fade_out=3.0, fade_in=3.0, original_playlist)

Security fallback

security_source=single("~/music_security/security.mp3")
playlist_securitized=fallback(track_sensitive=false, [original_playlist, security_source])

Support for live streams

live=input.harbor(
"live",
port=port_live_int,
password=password_dj,
replay_metadata=true,
icy_metadata_charset="UTF-8"
)
inv1=input.harbor(
"inv1",
port=port_inv1_int,
password=password_inv1,
replay_metadata=true,
icy_metadata_charset="UTF-8"
)
inv2=input.harbor(
"inv2",
port=port_inv2_int,
password=password_inv2,
replay_metadata=true,
icy_metadata_charset="UTF-8"
)
inv3=input.harbor(
"inv3",
port=port_inv3_int,
password=password_inv3,
replay_metadata=true,
icy_metadata_charset="UTF-8"
)

Fallback for live and music playlists

radio=fallback(track_sensitive=false, [live, inv1, inv2, inv3, playlist_securitized])

Stream it out MP3

output.icecast(
%ffmpeg(format="mp3", %audio(codec="libmp3lame", b="192k")),
radio,
mount="stream",
fallible=true,
host=host_https_no_prot,
port=port_https_int,
password=source_passw,
transport=transport,
)`

I tried adding custom transitions to the fallback based on the Liquidsoap book (Transitions between different sources), like this:

`# Transition for the live source (live, inv1, inv2, inv3)
def to_live(previous, next)
add([
fade.out(duration=3.0, type="sin", previous),
fade.in(duration=3.0, type="sin", next)
])
end

Transition for the playlist

def to_playlist(previous, next)
add([
fade.out(duration=3.0, type="sin", previous),
fade.in(duration=3.0, type="sin", next)
])
end

radio=fallback(
track_sensitive=false,
transition_length=3.0,
transitions=[to_live, to_live, to_live, to_live, to_playlist],
[live, inv1, inv2, inv3, playlist_securitized]
)`

However, this resulted in a "harsh noise" during transitions and occasional client disconnections.

Could someone help me craft a reliable solution for smooth transitions between these sources? Ideally, I'd like a 1-2 second crossfade when switching between live (or inv1, inv2, inv3) and playlist_securitized, without artifacts or service interruptions. Any advice on avoiding conflicts with the existing crossfade on the playlist would be appreciated.

Versions:
Icecast: 2.4.4
Liquidsoap: 2.3.1+dev (installed via OPAM)
Ubuntu 24.04.2 LTS

Thanks in advance for your help!

[juanamm]

Bumping this thread to check if there are any updates or solutions available now.
I hope I'm not bothering, but 5 days have passed without any response.
In 2023, I asked about the same issue and proposed a couple of ideas to solve it. Although it wasn't the most satisfying solution, it was at least a palliative for the problem. I'm not sure if it's currently resolved.

[gAlleb]

You can try skipping of the current track when DJ connects like Azuracast does
https://github.com/AzuraCast/AzuraCast/blob/main/util/docker/stations/liquidsoap/azuracast.liq

It had some issues at first, but then they were fixed. You can read about it here AzuraCast/AzuraCast#7669

And then you can accommodate this logic to your script and throw out everything that you may not need.

let azuracast = ()

# True if the first "next song" hasn't been received yet, false if it has.
let azuracast.autodj_is_loading = ref(true)

# Number of attempts that have been made to ping the AutoDJ for the next song.
let azuracast.autodj_ping_attempts = ref(0)

# The username/display name of the last authenticated DJ.
let azuracast.last_authenticated_dj = ref("")
let azuracast.last_authenticated_dj_name = ref("")

# The username/display name of the current live DJ.
let azuracast.live_dj = ref("")
let azuracast.live_dj_name = ref("")

# Whether Liquidsoap is currently transitioning to a live stream.
let azuracast.to_live = ref(false)

# Whether a DJ is successfully authenticated (and thus live broadcasting is enabled).
let azuracast.live_enabled = ref(false)

# DJ Authentication
def azuracast.dj_auth(auth_info) =
    try
        api_response = azuracast.api_call(
            timeout=5.0,
            "auth",
            json.stringify(auth_info)
        )

        if null.defined(api_response) then
            let json.parse (
                {
                    allow,
                    username,
                    display_name,
                } : {
                    allow: bool,
                    username: string?,
                    display_name: string?,
                }
            ) = null.get(api_response)

            if allow then
                azuracast.last_authenticated_dj := null.get(default='', username)
                azuracast.last_authenticated_dj_name := null.get(
                    default=settings.azuracast.live_broadcast_text(),
                    display_name
                )

                true
            else
                false
            end
        else 
            false
        end
    catch err do
        log(
            level=1,
            label="azuracast.streamer",
            "ERROR parsing JSON: #{err}"
        )

        false
    end
end

def azuracast.live_connected(header) =
    dj = azuracast.last_authenticated_dj()
    dj_name = azuracast.last_authenticated_dj_name()

    log(
        level=2,
        label="azuracast.dj",
        "DJ Source connected! Last authenticated DJ: #{dj} (#{dj_name}) - #{header}"
    )

    azuracast.live_enabled := true
    azuracast.live_dj := dj
    azuracast.live_dj_name := dj_name

    def f() =
        _ = azuracast.api_call(
            timeout=5.0,
            "djon",
            json.stringify({
                user = azuracast.live_dj()
            })
        )
    end

    thread.run(fast=false, f)
end

def azuracast.live_disconnected() =
    azuracast.live_enabled := false

    def f() =
        _ = azuracast.api_call(
            timeout=5.0,
            "djoff",
            json.stringify({
                user = azuracast.live_dj()
            })
        )

        azuracast.live_dj := ""
        azuracast.live_dj_name := ""
    end

    thread.run(fast=false, f)
end


radio = playlist("/music")

# A Pre-DJ source of radio that can be broadcast if needed
radio_without_live = radio
ignore(radio_without_live)

live = input.harbor("/", id = "", port = port, auth = auth, icy = true, 
icy_metadata_charset = "UTF-8", 
metadata_charset = "UTF-8", 
on_connect = azuracast.live_connected, 
on_disconnect = azuracast.live_disconnected, 
buffer = 5.00, max = 10.00)

radio = fallback(
    id="live_fallback",
    track_sensitive=true,
    replay_metadata=true,
    transitions=[
        fun (_, s) -> begin
            log("executing transition to live")
            s
        end, 
        fun (_, s) -> begin
            s
        end
    ],
    [live, radio]
)

# Skip non-live track when DJ goes live.
def check_live() =
    if live.is_ready() then
        if not azuracast.to_live() then
            azuracast.to_live := true
            radio_without_live.skip()
        end
    else
        azuracast.to_live := false
    end
end

# Continuously check on live.
radio = source.on_frame(radio, check_live)

and some kind of crossfade

def azuracast.live_aware_crossfade_impl(old, new) =
    log.info(label="azuracast.crossfade", "Crossfading")
    list.iter(
        fun (m) -> log.info(label="azuracast.crossfade", "Old metadata: #{fst(m)} -> #{snd(m)}"),
        metadata.cover.remove(old.metadata)
    )
    list.iter(
        fun (m) -> log.info(label="azuracast.crossfade", "New metadata: #{fst(m)} -> #{snd(m)}"),
        metadata.cover.remove(new.metadata)
    )
    if azuracast.to_live() then
        # If going to the live show, play a simple sequence
        # fade out AutoDJ, do (almost) not fade in streamer
        log.info(label="azuracast.crossfade", "Fading to live...")
        sequence([
            fade.out(duration=settings.azuracast.default_fade(), old.source),
            fade.in(duration=settings.azuracast.default_fade(), new.source)
        ])
    elsif settings.azuracast.enable_crossfade() then
        if settings.azuracast.crossfade_type() == "smart" then
            log.info(label="azuracast.crossfade", "Smart crossfade...")
            cross.smart(
                old,
                new,
                margin=8.,
                fade_in=settings.azuracast.default_fade(),
                fade_out=settings.azuracast.default_fade()
            )
        else
            log.info(label="azuracast.crossfade", "Simple crossfade...")
            cross.simple(
                old.source,
                new.source,
                fade_in=settings.azuracast.default_fade(),
                fade_out=settings.azuracast.default_fade()
            )
        end
    else
        # Otherwise, use a beautiful add
        log.info(label="azuracast.crossfade", "Add crossfade...")
        add(normalize=false, [
            fade.in(
                initial_metadata=new.metadata,
                duration=settings.azuracast.default_fade(),
                new.source
            ),
            fade.out(
                initial_metadata=old.metadata,
                duration=settings.azuracast.default_fade(),
                old.source
            )
        ])
    end
end

def azuracast.apply_crossfade(s) =
    cross(
        duration=settings.azuracast.default_cross(),
        azuracast.live_aware_crossfade_impl,
        s
    )
end

[juanamm]

Hi @gAlleb,

Thank you so much for taking the time to help and for sharing your solution for AzuraCast! I really appreciate your effort. However, I don’t have much experience programming Liquidsoap scripts, so adapting this solution to my specific setup feels quite challenging for me. I’ll wait for other users who might be able to help adapt it to my case. I really miss seeing @toots and @vitoyucepi in this thread—they’ve been so helpful in the past.

Thanks again!

[juanamm]

I don’t mean to be a bother again, and in fact, this will be my last message here unless someone responds to me first. However, I’m quite surprised that no one from the team has at least shared their perspective on this issue. I completely understand that my timeline might not align with others’, and that help here is given as much as possible since this is a collaborative and free platform where no one is obligated to assist. But I’d really appreciate at least knowing whether what I need is currently possible or not.

Back in 2023, I faced the same situation months went by, I eventually stopped pushing for a solution, and I ended up abandoning my radio project until now, when I’m back with the same concerns as before. I’ve listened to other colleagues’ radio stations where this feature works perfectly, but I can’t ask them for advice because they use contracted streaming services, meaning they don’t handle the programming themselves. I also provided details in a related bug report (#4179), but so far, those haven’t been addressed either.

Thank you to anyone who takes the time to read this!

[gAlleb]

Hi @juanamm! What help exactly do you need?

I replied to you with a suggestion/solution how you can make this work and accommodate it in your code - nice and working solution. You said:

adapting this solution to my specific setup feels quite challenging for me. I’ll wait for other users who might be able to help adapt it to my case.

Without hesitating and trying you had discarded my proposal and further help and insisted on someone to come and get the code written/adapted/done for you. I completely understand that not every person has time and capabilities to devote their time to learning something new and unfamiliar and go through N iterations of non-working code. So If you don't wanna invest any time on trying to make it work then it's totally normal to hire a professional of some sort to do it for you.

[juanamm]

Hi @Stefan,

Thank you so much for your reply and for the solution you shared earlier—I really appreciate the time and effort you put into helping me. I’m sorry if my previous message came across as dismissive; that wasn’t my intention at all. I truly value your suggestion, but I felt a bit overwhelmed trying to adapt it to my setup since I’m not very experienced with AzuraCast and Liquidsoap configurations. I realize now that I should have tried it first and provided more feedback.

I’d love to give your solution a try, but I could use some guidance on how to start. My setup doesn’t use AzuraCast directly—it’s a custom Icecast2 server with Liquidsoap for streaming, and I’m worried about breaking something if I don’t adapt it correctly. Could you please help me understand how I can test your solution safely in my environment? For example, should I set up a staging server first, or are there specific parts of your code I should adjust for a non-AzuraCast setup?

Thank you again for your patience and support—I’m really grateful for your expertise and willing to put in the effort to make this work with your guidance.

Best regards,
@juanamm

[gAlleb]

In older versions of LS, the "live" source could be before the crossfade, so it could be crossfaded as well. In theory, this would also allow "clean skips", i.e. no artifacts after live ends, because the skip could happen while we still have separate (unmixed) tracks.

Now (in recent versions of LS) the only way to use live without experiencing buffering problems is to move "live" fallback after the crossfade. That, in turn, now brings no crossfades. All you can do is tell LS to skip the non-live source and fade it out after live source is connected. When live source is disconnected - start new track. That's how it is and there is no magic trick to it.

Full examaple code, just change where it's needed and then add them mix it with your own code.

# var: true or false when live is connected. You can make few of them for every live source (to_live1, to_live2...)
let to_live = ref(false)

# main playlist
radio = playlist("~/music")

# crossfade function
def live_aware_crossfade(old, new) =
    if to_live() then
        # If going to the live show, play a simple sequence
        # fade out AutoDJ, do (almost) not fade in streamer
        sequence([
            fade.out(duration=3.0, old.source),
            fade.in(duration=0.1, new.source)
        ])
    else
            cross.simple(
                old.source,
                new.source,
                fade_in=3.0,
                fade_out=3.0
            )
    end
end

radio = cross(
    duration=3.0,
    live_aware_crossfade,
    radio
)

# source before live, which we can skip
radio_without_live = radio
ignore(radio_without_live)

live=input.harbor("live",
port=8001,
password="password",
replay_metadata=true,
buffer = 5.00, 
max = 10.00
)

# fallback
radio = fallback(
    id="live_fallback",
    track_sensitive=true,
    replay_metadata=true,
    transitions=[
        fun (_, s) -> begin
            log("executing transition to live")
            s
        end, 
        fun (_, s) -> begin
            s
        end
    ],
    [live, radio]
)

# Skip non-live track when DJ goes live.
def check_live() =
    if live.is_ready() then
        if not to_live() then
        	# you can add additional ones for every live source
            to_live := true
            radio_without_live.skip()
        end
    else
        to_live := false
        # you can add additional ones for every live source
    end
end

# Continuously check on live.
radio = source.on_frame(radio, check_live)

output.icecast(%ffmpeg(format="mp3", %audio(codec="libmp3lame")), fallible=true,  host = "icecast", port = 8000, password = "hackme", mount = "test", genre = "wow", send_icy_metadata=true, name = "name", mksafe(radio))

Alternativele, since we are dealing with live dj, why not manually mix the sorces upon live connect, this can make transitions smoother butt involes manual handling of the broacast in the beggining and the end of dj session.

# we add interactive harbour with volume controls for every source

settings.harbor.bind_addrs := ["0.0.0.0"]
interactive.harbor(port=8007, uri="/djpanel")
volume_playlist = interactive.float("volume_playlist", min=0., max=1., 1.)
volume_overall = interactive.float("volume_overall", min=0., max=1., 1.)
volume_mic = interactive.float("volume_mic_add", min=0., max=1., 1.)
pause_playlist = interactive.bool("pause_playlist",false)

radio = playlist("~/music")

# apply var to playlist
radio = amplify(volume_playlist, radio)

def live_aware_crossfade(old, new) =
            cross.simple(
                old.source,
                new.source,
                fade_in=3.0,
                fade_out=3.0
            )
end

radio = cross(
    duration=3.0,
    live_aware_crossfade,
    radio
)

# add skip function for playlist: http://localhost:8007/skip
def skipper(_)
radio.skip()
http.response(data="Song was skipped!")
end
harbor.http.register.simple(port=8007, "/skip", skipper)

# blank source
blank = blank()

# manual switch to blank via interactive var
radio = switch(track_sensitive=false, [
  ({pause_playlist() == true}, blank),
  ({true}, radio)
])


live=input.harbor("live",
port=8001,
password="password",
replay_metadata=true,
buffer = 5.00, max = 10.00
)

# apply var to control live volume
live = amplify(volume_mic, live)

radio = add(normalize=false,[live,radio])

# apply var to control overall volume
radio = amplify(volume_overall, radio)

output.icecast(%ffmpeg(format="mp3", %audio(codec="libmp3lame")), fallible=true,  host = "icecast", port = 8000, password = "hackme", mount = "test", genre = "wow", send_icy_metadata=true, name = "name", mksafe(radio))

How it works. After you start a script - you can go to http://localhost:8007/djpanel

Then whin live dj connects - it will be muted. You can unmute it, sliding volume_mic and mute gradually volume_playlist, then pause_playlist and skip playlist via http://localhost:8007/skip. After live dj is through - you can unpause your playlist (`pause_playlist') and inrease it's volume.

[juanamm]

Hi GaLLeb,

Thank you so much for taking the time to help me and for sharing such detailed solutions! I really appreciate your effort and the example code you provided. I tested the script as suggested, and while it ran smoothly with no errors, I didn’t notice a significant difference in my setup compared to my original configuration. I’ve decided to stick with my current setup for now, as it’s working reliably for me. Your input has been incredibly valuable, and I’ll definitely keep your suggestions in mind for future adjustments.
By the way, I’ve marked your answer as correct to acknowledge all the effort and time you’ve dedicated to helping me. :)
Thanks again for your support!

Best regards,
juanamm