Loading next track specific amount of time before a track ends with request.dynamic

[pteich]

With Liquidsoap 1.4.x we are using statements like this:

playlist = request.dynamic.list(id="playlist",retry_delay=3.0,timeout=60.,length=90.,default_duration=60.,conservative=false,get_request)

to queue new songs 90s before the last one ends. We need this to be able to change the next song just before it is needed. Imagine playing a mix track of 1 hour length and a news audio that should be played directly after. It makes no sense to load this news audio file 1 hour before it is played and in this case we can not provide the latest news file.

How can we achieve a similar approach with the simplified API in Liquidsoap 2.x.x?
I've tested

playlist = request.dynamic(id="playlist", timeout=15.0, prefetch=1, retry_delay=5.0, native=false,  get_request)

but it directly loads the next song and the new prefetch argument only controls the number of tracks.

Thanks for any suggestions!

[FlorianReiterer]

May i chime in with a question: how do you request.dynamic the starting time for your news bit? I try to launch a pre-recorded show at 18:00 (playlist from a folder), play once and switch back. Similar thoughts to your issue. I was thinking predicate.once, am now investigating predicate.signal. That would launch your news bit without prefetch too i think.

[FlorianReiterer]

Oh, ok, sorry, the line IS the request.dynamic, and it applies to your playlist, and you have a switch that does the time.
How do you call up that playlist to be played? Should be my question.

[FlorianReiterer]

See, i think you could do
radio = switch([ (predicate.once({0m-15m}), news), ({true}, music) ])
this way the source news is not prefetched. Is that what you'd need?

[pteich]

All our logic is in our back-end services and not in Liquidsoap itself. So get_request just wraps a HTTP call to our API that then decides what should be played next. So the call is always the same and in our LIQ script we don't need and don't want to know whether it is news or music. The API just returns the file that should be played together with some metadata.
And for this to work it is crucial that the request is not one track before but only like 90s or so before a track stops.

Using switch is not what we need because as I said before the logic sits in the back-end and can be dynamically changed without restarting the LIQ script.

[FlorianReiterer]

I see, thanks for the insight!

[toots]

Hi!

Thanks for reporting. We have simplified the fetching logic with 2.0.0, which should make it easier for the majority of users. However, more advanced cases like this one need a little lifting now.

First, I would like to mention that queueing at the last minute can be tricky. Liquidsoap needs time to process and prepare a request and, if this is not done on time, this can lead to a moment when no requests are available, leading to the either the source failing or a transition to another source.

That being said, the request operators now have a fetch method that can be called whenever the user wants to queue a new request. If you combine that with a prefetch=0 argument, you should be able to fully control when the source fetches a new request.

Eventually, the source.on_end provides the last piece of the puzzle, allowing to trigger a callback when there are less that xx seconds left.

Here we go:

queue_when_this_amount_is_left = 90.

r = request.dynamic.list(...)

def queue(remaining, _) =
  log("Queueing with #{remaining} seconds remaining")
  if not r.fetch() then
    # You might want to recurse and/or handle errors here:
    log("Fetching next query failed")
  end
end

r = source.on_end(delay=queue_when_this_amount_is_left , r, queue)

[pteich]

Thanks for the example - works as expected and helped me a lot to understand how to use the new methods.

[rrolla]

Thanks for the script, I have the same situation, all logic that needs to be played is on the other backend side, but cannot manage to get it working with prefetch=0. If I change to prefetch=1 all songs are played twice. I mark as played with HTTP hit to the backend on mainSource.on_metadata(onMetadataHandler)

Looks like the problem is that request.dynamic prefetches the next song faster than it marks the current playing song as played

[rrolla]

@toots @smimram can you please help me to find where is def request.dynamic source? Here cannot find https://github.com/savonet/liquidsoap/blob/main/libs/request.liq

[danbo]

@toots, I noticed the same behaviour in 2.0.6 and 2.1.0 - prefetch=1 / default plays twice (seems like it will fetch what it needs now and one upcoming) and prefetch=0 doesn't fetch either but should fetch the initial the initial track.

[UnkwUsr]

Note: argument delay of function source.on_end relies on track duration, hence if there is problems with getting it, delay argument will not be honored. First clue of this problem is that parameter remaining in on_end callback is much lower than your required delay (in my case it was ~1.5 regardless of delay value).

Solution of getting duration for tracks for me was to force using ffmpeg, but your situation may be different:

settings.decoder.decoders := ["ffmpeg"]

[Pitu]

@toots sorry for reviving such an old discussed topic, but I'm facing something similar myself.
I'm trying to delay the loading of the next track until there are 10s left on the currently playing song with your snippet and using liquidsoap v2.1.4, but the songs are being loaded straight away.

The way the script that returns the path to a song works, is it publishes the song name upon executing it, so I need to delay the process.read.lines call until there are 10 or so seconds left on the song, but that's not what's happening below.

Any help would be appreciated, thanks!

set("log.stdout",true)
set("log.level",3)

enable_replaygain_metadata()
queue_when_this_amount_is_left = 10.

def get_request() =
  uri = list.hd(default="", process.read.lines("node /home/radio/getSong.js"))
  print("Uri: #{uri}")
  [request.create(uri)]
end

s = request.dynamic.list(id="s", get_request)
s = amplify(1.,override="replay_gain",s)

def queue(remaining, _) =
  log("Queueing with #{remaining} seconds remaining")
end

s = source.on_end(delay=queue_when_this_amount_is_left , s, queue)

output.icecast(%opus(
...

This is a partial output of the log

2023/08/09 11:25:58 [s:3] Prepared "/home/radio/songs/Dreaming_34_qQzMykFx7wA38GwpuhPnHdfPQF_99t_1544529171000.mp3" (RID 0).
2023/08/09 11:25:58 [mksafe:3] Switch to on_end_0 with transition.
2023/08/09 11:25:58 [mksafe:3] Switch to on_end_0 with transition.
2023/08/09 11:25:58 [mksafe:3] Switch to on_end_0 with transition.
[mp3float @ 0x7f511c13b540] Could not update timestamps for skipped samples.
Uri: /home/radio/songs/好き好きびーむ_34_8tb1ZU_tILDM9RAK65cKmkIZPJL3NO_1533909275000.mp3
2023/08/09 11:26:00 [clock.main:2] We must catchup 1.17 seconds!
2023/08/09 11:30:29 [lang:3] Queueing with 9.94965986395 seconds remaining
[mp3float @ 0x7f511c13b540] Could not update timestamps for discarded samples.
2023/08/09 11:30:39 [decoder:2] Decoding "/home/radio/songs/Dreaming_34_qQzMykFx7wA38GwpuhPnHdfPQF_99t_1544529171000.mp3" ended: Ffmpeg_decoder.End_of_file.
2023/08/09 11:30:39 [s:3] Prepared "/home/radio/songs/好き好きびーむ_34_8tb1ZU_tILDM9RAK65cKmkIZPJL3NO_1533909275000.mp3" (RID 1).
[mp3float @ 0x7f511c116f80] Could not update timestamps for skipped samples.
Uri: /home/radio/songs/OKAMOTOS'S/OKAMOTO'S - Yokubo/OKAMOTO'S - 手紙.mp3
[mp3 @ 0x7f5114134b80] Estimating duration from bitrate, this may be inaccurate
[mp3 @ 0x7f511403cc80] Estimating duration from bitrate, this may be inaccurate
2023/08/09 11:33:44 [lang:3] Queueing with 9.94975056689 seconds remaining
[mp3float @ 0x7f511c116f80] Could not update timestamps for discarded samples.
2023/08/09 11:33:54 [decoder:2] Decoding "/home/radio/songs/好き好きびーむ_34_8tb1ZU_tILDM9RAK65cKmkIZPJL3NO_1533909275000.mp3" ended: Ffmpeg_decoder.End_of_file.
[mp3 @ 0x7f511c0ff400] Estimating duration from bitrate, this may be inaccurate
[mp3 @ 0x7f511c0ff400] Estimating duration from bitrate, this may be inaccurate
2023/08/09 11:33:54 [s:3] Prepared "/home/radio/songs/OKAMOTOS'S/OKAMOTO'S - Yokubo/OKAMOTO'S - 手紙.mp3" (RID 2).
Uri: /home/radio/songs/Remember again._1188_E9oRCbYXCbQbsYWY4vbBFhoVsthGxo.mp3_1619682043000.mp3
2023/08/09 11:33:57 [clock.main:2] We must catchup 2.02 seconds!

[Intelli]

You didn't add prefetch=0 or call .fetch().