How to tune the delay time?

[pde-system-integration]

I use Play IT + liquidsoap + icecast to stream audio (Play IT => liquidsoap => icecast)
Currently the delay is about 5 seconds. How to tune the delay time to the lowest?
Thanks.

Liquidsoap Configuration

set("init.daemon", false)
set("init.daemon.pidfile.path","/var/azuracast/stations/station_3/config/liquidsoap.pid")
set("log.stdout", true)
set("log.file", false)
set("server.telnet",true)
set("server.telnet.bind_addr","0.0.0.0")
set("server.telnet.port", 8024)
set("harbor.bind_addrs",["0.0.0.0"])

set("tag.encodings",["UTF-8","ISO-8859-1"])
set("encoder.encoder.export",["artist","title","album","song"])

setenv("TZ", "Asia/Ho_Chi_Minh")

azuracast_api_auth = ref "d0c025f757ddf0c873582a19984618ff8efc85d094ba4c86096f68f0df936f217fc2595fe936f124a232032441b4c67d3535"
ignore(azuracast_api_auth)

autodj_is_loading = ref true
ignore(autodj_is_loading)

autodj_ping_attempts = ref 0
ignore(autodj_ping_attempts)
playlist_default = playlist(id="playlist_default",mode="randomize",reload_mode="watch",conservative=true,default_duration=10.,length=20.,"/var/azuracast/stations/station_3/playlists/playlist_default.m3u")
playlist_default = audio_to_stereo(id="stereo_playlist_default", playlist_default)
playlist_default = cue_cut(id="cue_playlist_default", playlist_default)

# Standard Playlists
radio = random(id="standard_playlists", weights=[3], [playlist_default])

# AutoDJ Next Song Script
def autodj_next_song() =
    uri = list.hd(get_process_lines(env=[("API_AUTH", !azuracast_api_auth)], 'curl -s --request POST --url http://web/api/internal/11/nextsong --form api_auth="$API_AUTH"'), default="")
    log("AzuraCast Raw Response: #{uri}")

    if uri == "" or string.match(pattern="Error", uri) then
        []
    else
        r = request.create(uri)
        if request.resolve(r) then
            [r]
        else
            []
       end
    end
end

# Delayed ping for AutoDJ Next Song
def wait_for_next_song(autodj)
    autodj_ping_attempts := !autodj_ping_attempts + 1
    delay = ref 0.5

    if source.is_ready(!autodj) then
        log("AutoDJ is ready!")

        autodj_is_loading := false
        delay := -1.0
    elsif !autodj_ping_attempts > 200 then
        log("AutoDJ could not be initialized within the specified timeout.")

        autodj_is_loading := false
        shutdown()

        delay := -1.0
    end

    !delay
end

dynamic = request.dynamic.list(id="next_song", timeout=20., retry_delay=2., autodj_next_song)
dynamic = audio_to_stereo(id="stereo_next_song", dynamic)
dynamic = cue_cut(id="cue_next_song", dynamic)

dynamic_startup = fallback(
    id = "dynamic_startup",
    track_sensitive = false,
    [
        dynamic,
        at(
            fun()-> !autodj_is_loading,
            blank(id = "autodj_startup_blank", duration = 120.)
        )
    ]
)
radio = fallback(id="autodj_fallback", track_sensitive = true, [dynamic_startup, radio])

ref_dynamic = ref dynamic;
add_timeout(0.25,fun()->wait_for_next_song(ref_dynamic))

requests = request.queue(id="requests")
requests = audio_to_stereo(id="stereo_requests", requests)
requests = cue_cut(id="cue_requests", requests)

radio = fallback(id="requests_fallback", track_sensitive = true, [requests, radio])
add_skip_command(radio)
# DJ Authentication
live_enabled = ref false
last_authenticated_dj = ref ""
live_dj = ref ""

def dj_auth(auth_user,auth_pw) =
    user = ref ""
    password = ref ""

    if (auth_user == "source" or auth_user == "") and (string.match(pattern="(:|,)+", auth_pw)) then
        auth_string = string.split(separator="(:|,)", auth_pw)

        user := list.nth(default="", auth_string, 0)
        password := list.nth(default="", auth_string, 2)
    else
        user := auth_user
        password := auth_pw
    end

    log("Authenticating DJ: #{!user}")

    ret = list.hd(get_process_lines(env=[("DJ_USER", !user), ("DJ_PASSWORD", !password), ("API_AUTH", !azuracast_api_auth)], 'curl -s --request POST --url http://web/api/internal/11/auth --form dj-user="$DJ_USER" --form dj-password="$DJ_PASSWORD" --form api_auth="$API_AUTH"'), default="")
    log("AzuraCast DJ Auth Response: #{ret}")

    authed = bool_of_string(ret)
    if (authed) then
        last_authenticated_dj := !user
    end

    authed
end

def live_connected(header) =
    dj = !last_authenticated_dj
    log("DJ Source connected! Last authenticated DJ: #{dj} - #{header}")

    live_enabled := true
    live_dj := dj

    ret = list.hd(get_process_lines(env=[("DJ_USER", dj), ("API_AUTH", !azuracast_api_auth)], 'curl -s --request POST --url http://web/api/internal/11/djon --form dj-user="$DJ_USER" --form api_auth="$API_AUTH"'), default="")
    log("AzuraCast Live Connected Response: #{ret}")
end

def live_disconnected() =
    dj = !live_dj

    log("DJ Source disconnected! Current live DJ: #{dj}")

    ret = list.hd(get_process_lines(env=[("DJ_USER", dj), ("API_AUTH", !azuracast_api_auth)], 'curl -s --request POST --url http://web/api/internal/11/djoff --form dj-user="$DJ_USER" --form api_auth="$API_AUTH"'), default="")
    log("AzuraCast Live Disconnected Response: #{ret}")

    live_enabled := false
    last_authenticated_dj := ""
    live_dj := ""
end

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

# Live Broadcasting
live = audio_to_stereo(input.harbor("/", id = "input_streamer", port = 8025, auth = dj_auth, icy = true, icy_metadata_charset = "UTF-8", metadata_charset = "UTF-8", on_connect = live_connected, on_disconnect = live_disconnected, buffer = 2.00, max = 10.00))
ignore(output.dummy(live, fallible=true))

radio = fallback(id="live_fallback", replay_metadata=false, track_sensitive=false, [live, radio])

# Allow for Telnet-driven insertion of custom metadata.
radio = server.insert_metadata(id="custom_metadata", radio)

# Apply amplification metadata (if supplied)
radio = amplify(override="liq_amplify", 1., radio)

# Normalization and Compression
radio = normalize(target = 0., window = 0.03, gain_min = -16., gain_max = 0., radio)
radio = compress.exponential(radio, mu = 1.0)

radio = fallback(id="safe_fallback", track_sensitive = false, [radio, single(id="error_jingle", "/usr/local/share/icecast/web/error.mp3")])
# Send metadata changes back to AzuraCast
def metadata_updated(m) =
    def f() =
        if (m["song_id"] != "") then
            ret = list.hd(get_process_lines(env=[("SONG", m["song_id"]), ("MEDIA", m["media_id"]), ("PLAYLIST", m["playlist_id"]), ("API_AUTH", !azuracast_api_auth)], 'curl -s --request POST --url http://web/api/internal/11/feedback --form song="$SONG" --form media="$MEDIA" --form playlist="$PLAYLIST" --form api_auth="$API_AUTH"'), default="")
            log("AzuraCast Feedback Response: #{ret}")
        end
        (-1.)
    end

    add_timeout(fast=false, 0., f)
end

radio = on_metadata(metadata_updated,radio)

# Local Broadcasts
output.icecast(%mp3(samplerate=44100, stereo=true, bitrate=320, id3v2=true), id="local_1", host = "127.0.0.1", port = 8020, password = "d7XK2Dkd", mount = "/radio.mp3", name = "Station 3", description = "", genre = "", public = false, encoding = "UTF-8", radio)
# Remote Relays

Threadpool, burst on connect, burst size

<threadpool>5</threadpool>
<burst-on-connect>0</burst-on-connect>
<burst-size>0</burst-size>

[toots]

I would look at the frame size though it is usually around 0.04s so probably not your issue here.

I would also try to get an idea of how much of that delay is added by liquidsoap or other part of the chain/stack and also which operators. Typically, input.harbor has an internal buffer, you might want to see how large it it.