Trying to understand the s:source workaround for dynamic streams

[theotherjenkutler]

Hi. I'm trying to get an example of dynamic streams working. I saw the workaround which involved using s:source but unfortunately I always get a syntax error message when I include the colon after the source. Can anyone share an example of a dynamic playlist stream that works? Much appreciated.

Edit: to clarify, I'm referring to lists of stream variables which are not recognized as streams in the type checker.

[toots]

Hi! Make sure that you surround everything with parenthesis. The complete syntax is: (s:source)

[theotherjenkutler]

Thanks toots. I am still getting errors. If you can help me get a working example of this, I'll make pull requests for the documentation.

This is what I'm working with. I added the correct syntax for the type definition and I am still getting an error related to other sources that I cannot resolve by adding the type definition. This is what I'm working from:

#!/home/jenkutler/.opam/4.10.0/bin/liquidsoap

settings.init.force_start.set(true) #this will allow LS to start w/o an active source
settings.server.telnet.set(true) #starts telnet server

set("log.file",false)
#set("log.file.path", "/home/jenkutler/ls_logs/measures.log")
set("log.stdout",true)
set("log.level",5)

# First, we create a list referencing the dynamic sources:
dyn_sources = ref([])

# This is our icecast output.
# It is a partial application: the source needs to be given!
out = output.icecast(%mp3,
                     host="localhost",
                     password="measures",
                     fallible=true)

# Now we write a function to create 
# a playlist source and output it.
def create_playlist(uri) =
  # The playlist source 
  s = playlist(uri)

  # The output
  output = out(s)

  # We register both source and output 
  # in the list of sources
  dyn_sources := 
      list.append( [(uri,s),(uri,(output:source))],
                    !dyn_sources)
  "Done!"
end

# And a function to destroy a dynamic source
def destroy_playlist(uri) = 
  # We need to find the source in the list,
  # remove it and destroy it. Currently, the language
  # lacks some nice operators for that so we do it
  # the functional way

  # This function is executed on every item in the list
  # of dynamic sources
  def parse_list(ret, current_element) = 
    # ret is of the form: (matching_sources, remaining_sources)
    # We extract those two:
    matching_sources = fst(ret)
    remaining_sources = snd(ret)

    # current_element is of the form: ("uri", source) so 
    # we check the first element
    current_uri = fst(current_element)
    if current_uri == uri then
      # In this case, we add the source to the list of
      # matched sources
      (list.append( [snd(current_element)], 
                     matching_sources),
       remaining_sources)
    else
      # In this case, we put the element in the list of remaining
      # sources
      (matching_sources,
       list.append([current_element], 
                    remaining_sources))
    end
  end
    
  # Now we execute the function:
  result = list.fold(parse_list, ([], []), !dyn_sources)
  matching_sources = fst(result)
  remaining_sources = snd(result)

  # We store the remaining sources in dyn_sources
  dyn_sources := remaining_sources

  # If no source matched, we return an error
  if list.length(matching_sources) == 0 then
    "Error: no matching sources!"
  else
    # We stop all sources
    list.iter(source.shutdown, matching_sources)
    # And return
    "Done!"
  end
end


# Now we register the telnet commands:
server.register(namespace="dynamic_playlist",
                description="Start a new dynamic playlist.",
                usage="start <uri>",
                "start",
                create_playlist)
server.register(namespace="dynamic_playlist",
                description="Stop a dynamic playlist.",
                usage="stop <uri>",
                "stop",
                destroy_playlist)

#If you execute this code (add a output.dummy(blank()) if you have no other output..), you have two new telnet commands:

    #dynamic_playlist.start <uri>
    #dynamic_playlist.stop <uri>

#output.dummy(blank())

Thank you for your help!

[toots]

Problem was from the create_playlist function. We changed the type of output operators in the 2.0 release to be only unit so it cannot be registered in the list. Here's the fixed function:

# Now we write a function to create
# a playlist source and output it.
def create_playlist(uri) =
  # The playlist source
  s = playlist(uri)

  # The output
  out(s)

  # We register the source in the list of sources
  dyn_sources := list.append( [(uri,s)], !dyn_sources)
  "Done!"
end

I'll update the doc. Thanks!

[theotherjenkutler]

You can't see me but I am tossing my arms and doing a dance with joy. Thank you!

[theotherjenkutler]

@toots one other question:
this example from the book throws errors as well regarding the list.assoc() function.
is there a trick to make it work?

#!/home/jenkutler/.opam/4.10.0/bin/liquidsoap

settings.init.force_start.set(true) #this will allow LS to start w/o an active source
settings.server.telnet.set(true) #starts telnet server

set("log.file",false)
#set("log.file.path", "/home/jenkutler/ls_logs/measures.log")
set("log.stdout",true)
set("log.level",5)

identifierstring = ""
mac = ref(identifierstring)

dyn_sources = ref([])

def start(m)
    mac := (m)
    log.debug(!mac)
    
    pl = playlist(mode='randomize',reload=1,reload_mode="rounds", "/home/jenkutler/audio/")
    s = output.icecast(%mp3, host="localhost", password="measures", fallible=true, mount=!mac, pl)
    dyn_sources := list.add((pl, s), !dyn_sources)
    "starting #{mac}"
end
server.register(usage= "mac <mac>",
                "mac", start)
def stop(pl)
    s = list.assoc(pl, !dyn_sources)
    #dyn_sources := list.assoc.remove(pl, !dyn_sources)
    #s.shutdown()
    "stopping #{mac}"
end
server.register("stop",stop)

[theotherjenkutler]

To clarify, this is the error:

line 28, char 23-35:
    s = list.assoc(pl, !dyn_sources)

Error 5: this value has type
  [source(audio=pcm(stereo), video=none, midi=none) * _] (inferred at ./dynamicProgress.liq, line 14, char 18-20)
but it should be a subtype of the type of the value at /home/jenkutler/.opam/4.10.0/lib/liquidsoap/share/liquidsoap/2.0.2/libs/list.liq, line 200, char 37
  [?A * _] where ?A is an orderable type (inferred at /home/jenkutler/.opam/4.10.0/lib/liquidsoap/share/liquidsoap/2.0.2/libs/list.liq, line 11, char 29)

[theotherjenkutler]

Nevermind. I think that the example from the book is just outdated. I will work with the example posted. Is there any drawback to having the output defined within the create_playlist function as opposed to having an output without a mountpoint declared beforehand?

I thank you for your patience as I do my best to learn!

[toots]

This should pretty much the same. Thanks for your patience dealing with our outdated doc as well, this is very helpful. At some point we'll have to do a revision of the book (cc @smimram). Also, keep us posted about the example, we haven't worked on these features for a while and, in particular, I'd like to make sure that the output is properly cleaned up when you shutdown the source!

[theotherjenkutler]

@toots Thanks. I'm having trouble getting the source shutdown to work at all. Basically, I need a single random track to play from a local folder and then shut down when the track ends. I tried using source.on_end but it didn't seem to fire when the track ended so I switched to a silly workaround where it crudely checks to see if more than one metadata update has occurred. I added some debug messages to try to see where it all goes wrong but it hasn't shed light on much. Here is where I've landed:

#!/home/jenkutler/.opam/4.10.0/bin/liquidsoap

settings.init.force_start.set(true) #this will allow LS to start w/o an active source
settings.server.telnet.set(true) #starts telnet server

set("log.file",false)
#set("log.file.path", "/home/jenkutler/ls_logs/measures.log")
set("log.stdout",true)
set("log.level",5)

# First, we create a list referencing the dynamic sources:
dyn_sources = ref([])

#esp32 must send a message over telnet formatted as:
#"mac 000000000000.mp3" the telnet server will register
#the mountpoint as 000000000000.mp3 automatically
def on_telconnect(m)
    identifierstring = ""
    i = ref(identifierstring)
    i := (m)
    log.debug(!i)
    # The playlist source 
    uri = "/home/jenkutler/audio/"
    s = playlist(uri)
    # The output
    output = output.icecast(%mp3(samplerate = 44100, internal_quality=1),
    host = "localhost", port = 8000,
    password = "measures", mount = !i,
    s,
    fallible = true)

    # We register both source and output 
    # in the list of sources
    dyn_sources := 
        list.append( [(uri,s)],
                    !dyn_sources)
    
    trackbool = true
    trackplayed = ref(trackbool)


    def handlemetadata(m)
        log.debug("handling metadata")
        if !trackplayed then
            log.debug("print info to file")
            trackplayed := false
        else
            log.debug("handling the end")
            def parse_list(ret, current_element) = 
                log.debug("parse_list called")
                # ret is of the form: (matching_sources, remaining_sources)
                # We extract those two:
                matching_sources = fst(ret)
                remaining_sources = snd(ret)

                # current_element is of the form: ("uri", source) so 
                # we check the first element
                current_uri = fst(current_element)
                if current_uri == uri then
                    # In this case, we add the source to the list of
                    # matched sources
                    (list.append( [snd(current_element)], 
                             matching_sources),
                            remaining_sources)
                else
                    # In this case, we put the element in the list of remaining
                    # sources
                    (matching_sources,
                    list.append([current_element], 
                                remaining_sources))
                end
            end    
    
            # Now we execute the function:
            result = list.fold(parse_list, ([], []), !dyn_sources)
            matching_sources = fst(result)
            remaining_sources = snd(result)

            # We store the remaining sources in dyn_sources
            dyn_sources := remaining_sources

            # If no source matched, we return an error
            if list.length(matching_sources) == 0 then
                log.debug("Error: no matching sources!")
            else
                # We stop all sources
                log.debug("We stop all sources")
                list.iter(source.shutdown, matching_sources)
                # And return
            
            end
        end       
    end
    source.on_metadata(s, handlemetadata)

    "Done"
end
server.register(usage= "mac <mac>",
                "mac", on_telconnect)

[theotherjenkutler]

Update: it isn't able to find any matching sources. this might just be an error i made.

[theotherjenkutler]

Update: yes, in moving stuff around I accidentally lost two arguments to a function that I included in a different function. there is no ret or current_element definitions getting passed into the list functions to remove the streams. My mistake! I'll try to fix the issue and see what it does.

[theotherjenkutler]

Oh thats not true actually. Nevermind. The arguments are there in result = list.fold(parse_list, ([], []), !dyn_sources) I will try printing the list to the log and see if maybe there is an issue with them having been added in the first place.

[theotherjenkutler]

It looks like part of the issue might be that the playlist that is created is considered to be static, not dynamic and I'm not sure why that would be. That might be the reason that list.iter(source.shutdown, matching_sources) can't shut it down.