Lazy evaluation and switch method

[boyska]

I'm handling part of a radio automation with liquidsoap, and a large part of our setup relies on sth like this:

audio = switch([
({12h-13h}, input.http("http://some.whe.re/news.ogg")),
({13h-13h30}, input.http("http://some.whe.re/music.ogg")),
…
])

This works perfectly. However, those HTTP streams are always on. We don't need this to be the case, as it uselessly consume bandwidth.

That's not just about efficiency, though. For some reason, we sometimes need to follow dynamic http links. For example, we could have http://some.whe.re/localnews which is actually redirecting (at the HTTP level) to the actual stream we want to relay:

audio = switch([
…
({15h-15h30}, input.http("http://some.whe.re/localnews")),
…
])

In this case, the eager evaluation done by liquidsoap is actually producing bad behavior: the redirect is followed just once. I want this to be followed again every day.

Is there a way I can make sources start and stop based on a time predicate? switch doesn't seem to be doing this, it's just "muting" sources but not stopping them.

Thanks!

[gAlleb]

Hi @boyska!

input.http is an active source so it needs to be ready. However it has start and stop method. So you can control that whenever you want. Some detailed logic which you can tune up.

s1 = playlist(id="s1","/music")
s2 = input.http(self_sync=false,"http://192.168.1.1:8000/radio")

def stopInputHttp() =
	  s2.stop()
end

def startInputHttp() =
	  s2.start()
end

s = switch(track_sensitive=false, [ ({ 00h00m-00h30m }, s2), ({true}, s1) ])

# on liquidsoap start - stop input.http
thread.run(delay=10.0, fun() -> stopInputHttp())

# start and stop input.http somewhere before the switch activates and after you resume to normal rotation
thread.when(predicate.activates({ 00h00m00s }), fun() -> startInputHttp())
thread.when(predicate.activates({ 00h30m10s }), fun() -> stopInputHttp())


output.dummy(mksafe(s))

Changing urls is also an option with s.set_url("http://new_url/stream") so you can use

def stop_change_start() =
          s2.stop()
          s2.set_url("http://new_url/stream")
	  s2.start()
end

Finally it can look like this:

...
# remote playlist
s1 =  input.http(self_sync=false,"https://other.stream:80/radio.mp3")
def startup_check() =
     if ( (0w) and 17h0m-22h0m ) then 
     null()
     else
     s1.stop()
     end
end
thread.run(delay=10.0, fun() -> startup_check())
thread.when(predicate.activates({ (0w) and 17h0m }), fun() -> s1.start())
thread.when(predicate.activates({ (0w) and 22h0m }), fun() -> s2.stop())

radio = switch(id="schedule_switch", track_sensitive=false, [ ({ (0w) and 17h0m-22h0m }, s1), ({true}, radio) ])
...

[boyska]

Hey, thanks for that, this sounds really promising! I'll test this ASAP.

Ideally, I'd like all of this a bit more encapsulated (ie: I'd like to write something like stream_at ({10h-11h}, "http://example.com/stream") and that should do everything: I'm afraid of spaghettification of my liquidsoap script!
This sounds feasible using predicate.changes, at least for unbuffered scenarios, so I'll try to do that and post a solution.

I'm surprised that this answer wasn't easy to find, as this sounds like a very common thing people might want to do.

[toots]

The most complicated part is that your input.http needs to be turned on some time before the switch directive because it needs to connect and process some data to be ready at exactly the right moment.

How to perfectly tune that can be tricky so, so far, this is left to the user. It would be nice to have some defaults, indeed. Something to think about when we meet at FOSDEM with @smimram

[boyska]

For my needs, I'm ok with accepting that this would not be as timely as it would have been otherwise.
A simple, yet effective, way of achieving this would be some ability to perform "time deltas": if I know that I'm going to actually start streaming at 10h30, and I assume that 2 minutes is enough, I would like to start the source at 10h28. This is not rocket science, but I don't bother implementing it right now.

Dreaming, I think it would be ideal to have this methods built in:

• only_active_at(predicate, source) → this method starts the source when predicate is true, and stops it when the predicate is false. ie, what @gAlleb proposed
• predicate_grow(time_predicate, before, after) → given any time predicate, returns a new one which begins before seconds earlier and ends after seconds later

Those methods would allow me to do sth like this, which would be elegant and effective

def play_at(timepred, url) =
    (timepred, only_active_at(predicate_grow(timepred, 120, 0), input.http(url)))
end
switch([
play_at({12h-12h30}, "http://xxx"),
play_at({10h-11h}, "http://yyy"),
])

[boyska]

@gAlleb solution works!

I refactored it into this function, which seems to do encapsulate everything I need, and is extremely convenient to put inside a switch.

def only_active_at(timepred, s) =
    def source_update() = 
        if timepred() then
            log("start")
            s.start()
        else
            log("stop")
            s.stop()
        end
    end
    source_update()
    thread.when(predicate.changes(timepred), source_update)
    s
end

def play_at(timepred, url) =
    (timepred, only_active_at(timepred, input.http(url)))
end

One limitation of this technique is that it works for input.http, but not for input.external.rawaudio (and therefore, not for input.mplayer), because input.external.wav has no start and stop methods. (Why, by the way?). which is something I like to use sometimes: it supports HTTPS, it supports playlists... Is there any way to have an external source which can be started/stopped?