How to play one song from a specific playlist once every hour?

[Laav]

Hello,

For internal use, we have been successfully operating a continuous audio stream from a single directory for quite some time, without any issues. The system has been functioning flawlessly.

However, a new request has been made to incorporate a specific playlist (news) once every hour, preferably after the completion of the first track of that hour. This process should be repeated hourly.

I have attempted various solutions but have not yet achieved a fully functional system. Would anyone be able to assist with this matter? At present, I have implemented the following;

radio 	=	playlist(mode="randomize", reload_mode="watch", "/music")
news	=	playlist(mode="randomize", reload_mode="watch", "/news")

radio = switch( [ ({ 01m-15m }, once(news)), ({true}, radio)] )

[gAlleb]

Hi @Laav ! I think this #4004 might be helpful for you.

preferably after the completion of the first track of that hour.

For this you can change fallback(track_sensitive=true,[... from the thread above or move predicate.once a few minutes after the beginning of the hour.

p.s. also standalone once operator that you've initially used would play a source only once. Then source becomes unavailable after that. It's an inteded behavior for single butt I assume it works the same way for a playlist.

[Laav]

@gAlleb thank for your help so far, but unfortunately, it's still not working. Maybe it'll be clearer if I share the entire config here. I've also left the attempts that didn't work, marked with a # at the beginning of the line.

pl_radio 	=	playlist(mode="randomize", reload_mode="watch", "/music")
pl_news		=	playlist(mode="randomize", reload_mode="watch", "/news")

radio = crossfade(
    conservative=true, 
    pl_radio
)

#radio		=	switch( [ ({ 01m-15m }, once(pl_news)), ({true}, radio)] )
#radio		=	fallback.skip(pl_news, fallback=radio)
#nieuws		=	fallback( [ switch( id="news_switch", [ ( predicate.once( { (7h00-19h00) and 01m00s } ), pl_news) ] ) ] )

radio		=	switch( [ ( predicate.activates({1m-5m}), pl_news ), ( {true}, radio) ] )

radio		=	mksafe(radio)

output.shoutcast(*

Do you have any idea what's going wrong here?

[gAlleb]

It should be like this

pl_radio 	=	playlist(mode="randomize", reload_mode="watch", "/music")
pl_news		=	playlist(mode="randomize", reload_mode="watch", "/news")


radio	        =       fallback(
  			track_sensitive=true,
		        [
    			switch(
      			id="news_switch",
      			[(predicate.once({ 00m }), pl_news)]
    			), pl_radio
  			]
			)

radio = crossfade(
    conservative=true, 
    radio
)

radio		=	mksafe(radio)

output(radio)

1. (predicate.once({ 00m }), pl_news) At 00 minutes every hour we will peak pl_news to play 1 track. And if something is playing already at this time (00m) then pl_news will wait for that track to finish.
2. Crossfade function should be after fallback.
3. If pl_news contains only 1 track and it's being changed (because it's news, they've got to be new) - I stroongly recommend reloading this playlist manually with

thread.when(predicate.activates({ 59m }), fun() -> pl_news.reload())

[caf2022]

@gAlleb Hi how are you? Please, and if I want to play more than 1 track? Example, 2, 5, 10 tracks every hour or every minutes?

[gAlleb]

Hi.

Here, for example, when it's available - 6 jingles would be played between indicated times. If your tacks are no longer then a window of 00m-20m or 30m-50m - then you can expect 6 jingles too be played in a row among this times.

music = playlist(mode="randomize", reload_mode="watch", "./music")
jingles = playlist(mode="randomize", reload_mode="watch", "./jingles")


radio = switch([
        (predicate.at_most(6,{ 00m-20m or 30m-50m}), jingles), 
	({true}, music)
	])
	

radio = mksafe(radio)

output(radio)

Please look into the book e.g. p.104-105 https://www.liquidsoap.info/book/book.pdf
All of your use cases have been more or less covered.

[Laav]

Thanks for the explanation and the code, it works well indeed.

Just one last question: what's the advantage of using thread.when compared to reload_mode="watch"?

[gAlleb]

Usual practice for news integration is:

1. Make a script that fetches/creates news_file. Usually it's the file with the same name.
2. If a playlist consists of the above one file with reload_mode="watch" there is a chance that next time you'll hear the same news/not updated news block. In such case reloading a playlist (with one file) with thread.when some time before playout guarantees that the exact new news file will be played at specific time.
3. Things are constantly improving. If it's not the case anymore please tell us (if you're using one_file_updated_with_new_news_scheme).

[Laav]

Thanks for getting back to me again. I've been using the following code, but it’s still not working:

radio	        =       fallback( track_sensitive=true, [ switch( id="news_switch", [(predicate.once({ 01m }), pl_news)] ), pl_radio ]	)

radio = crossfade(
    conservative=true, 
    radio
)

The /news directory contains at most one file, which is replaced every hour by a cronjob (this is also related to an API for the news MP3).

I've tried all sorts of things with the fallback function and have read through discussions here, but I haven't had any luck yet.

[gAlleb]

What do you mean not working? You've written earlier:

Thanks for the explanation and the code, it works well indeed.

I think you should make pl_news a playlist - then it should work.

pl_radio 	=	playlist(mode="randomize", reload_mode="watch", "/music")
pl_news		=	playlist(mode="randomize", reload_mode="watch", "/news.m3u")
thread.when(predicate.activates({ 59m }), fun() -> pl_news.reload())

radio	        =       fallback(
  			track_sensitive=true,
		        [
    			switch(
      			id="news_switch",
      			[(predicate.once({ 00m }), pl_news)]
    			), pl_radio
  			]
			)

radio = crossfade(
    conservative=true, 
    radio
)

radio		=	mksafe(radio)

output(radio)

e.g. pl_news = playlist(mode="randomize", reload_mode="watch", "/news.m3u" and serve your file from the playlist (not from a directory).

That is why we make a playlist and reload it with a function.

[gAlleb]

So, yeah, i thought a bit)

Probably you should use either

pl_radio 	=	playlist(mode="randomize", reload_mode="watch", "./music")
pl_news		=	playlist(mode="randomize", reload_mode="watch", "./news.m3u")
thread.when(predicate.activates({ 59m }), fun() -> pl_news.reload())

radio	        =       fallback(
  			track_sensitive=false,
		        [
    			switch(
      			id="news_switch",
      			[(predicate.once({ 00m00s }), pl_news)]
    			), pl_radio
  			]
			)

radio = crossfade(
    conservative=true, 
    radio
)

radio		=	mksafe(radio)

output(radio)

with track_sensetive=false. Or use something like this with fallback.skip:

pl_radio 	=	playlist(mode="randomize", reload_mode="watch", "./music")
pl_news		=	playlist(mode="randomize", reload_mode="watch", "./news.m3u")
thread.when(predicate.activates({ 59m }), fun() -> pl_news.reload())

pl_news	        =       fallback(
  			track_sensitive=false,
		        [
    			switch(
      			id="news_switch",
      			[(predicate.once({ 00m00s }), pl_news)]
    			)
  			]
			)

radio = fallback.skip(pl_news, fallback=pl_radio)
radio = crossfade(
    conservative=true, 
    radio
)

radio		=	mksafe(radio)

output(radio)

Because track_sensitive=true doesn't wanna work. So use either first one (then track will resume after news) or second one (track will be skipped).

[Laav]

Thanks a ton for your help and the scripts! I've given both a test run, but the fallback still isn't working quite right. Looking at the logs, I can see that Liquidsoap is actually making the switch, but it's only playing the news MP3 file for less than a second. Because of this, you can barely hear it, so it seems like the switch isn't working at all. Any ideas what might be causing this?

I've attached a screenshot of the log file at the moment of switching if that helps;

[gAlleb]

looks like it switches instantly back. No idea why. I have just tested this script:

pl_radio 	=	playlist(mode="randomize", reload_mode="watch", "./music")
pl_news		=	playlist(mode="randomize", reload_mode="watch", "./news.m3u")
thread.when(predicate.activates({ 29m }), fun() -> pl_news.reload())

pl_news	        =       fallback(
  			track_sensitive=false,
		        [
    			switch(
      			id="news_switch",
      			[(predicate.once({ 29m30s }), pl_news)]
    			)
  			]
			)

radio = fallback.skip(pl_news, fallback=pl_radio)
radio = crossfade(
    conservative=true, 
    radio
)

radio		=	mksafe(radio)

output(radio)

And it works fine with me. Maybe you've missed something?
I've tested it on LS 2.2.5.

[Laav]

Apologies for the delay, got some things on my hand in real life; It appears that I was running an outdated version of Liquidsoap, specifically version 1.4.

I have since attempted multiple versions (both minimal and standard) of 2.2 and 2.3. However, with this script, I consistently receive the error message "No output defined, nothing to do" across all versions, preventing me from testing.

Does anyone have any suggestions on how to resolve this error message first, so that I can proceed to test the script with a 2.* version of savonet/liquidsoap?

[gAlleb]

Could you share your script? It would be easier to identify the issue.

[Laav]

Certainly. Here is the script, which I have now stripped of extraneous functions to the greatest extent possible:

radio = playlist(mode="randomize", reload_mode="watch", "/music")

radio = crossfade(conservative=true, radio)

radio = mksafe(radio)

output.icecast(%mp3(bitrate=192), host="172.18.0.2",port=8000,password="xxx", mount="radio",radio)

[gAlleb]

Well, it looks ok.

The only thing left is your docker setup. You have to define a command and path to your liquidsoap script.

e.g. if it's docker compose:

services:
  liquidsoap:
    image: savonet/liquidsoap:v2.2.5

    command:
      - /path/to/script.liq

Because now yyou are running LS without a sccript so it has nothing to do indeed.

[Laav]

Thanks, at the moment i'm using an docker run command to test;

docker run --name liquidsoap -d --restart=always --volume /home/music:/music --volume /home/script/script.liq:/etc/liquidsoap/script.liq --volume /home/news:/news savonet/liquidsoap:v2.2.5

Later i will transfrom this on to an compose.yml.

[gAlleb]

As I say, you have to point your LS to the script. Now your LS doesn't run the script.

Add a command to execute /etc/liquidsoap/script.liq

docker run --name liquidsoap -d --restart=always --volume /home/music:/music --volume /home/script/script.liq:/etc/liquidsoap/script.liq --volume /home/news:/news savonet/liquidsoap:v2.2.5 /etc/liquidsoap/script.liq

Be sure that LS in docker has access to all the mounted volumes in regards to paths and permissions.

P.S. maybe you have confused official savonet/liquidsoap with pltnk/liquidsoap where the command is hardcoded and you don't need to specify it:

docker run --name liquidsoap -d --restart=always \
--volume /path/to/your/script.liq:/etc/liquidsoap/script.liq \
--volume /path/to/your/music:/music \
pltnk/liquidsoap

Otherwise you have to make sure all the permissions and paths are intact with your mounted LS script.

[Laav]

Thank you for your response, and this indeed resolves the issue. Initially, I was using the pltnk variant, but after the problems with the script, I switched to the savonet version (2.2.5), which required me to pass the script as a command.

After updating to 2.2.5, the initial question also seems to be resolved. The code from gAlleb (#4096 (reply in thread)) now appears to be working as expected.