liquidsoap-prettier 1.8.2 → 1.8.3

package/tests/liq/extra/externals.liq

@@ -0,0 +1,196 @@
+# Enable the external ffmpeg decoder.
+# @category Liquidsoap
+# @param ~file_extensions File extensions to decode. Should not be empty
+# @param ~mimes Mime types to decode. Empty list means any type.
+# @param ~binary Path to the `ffmpeg` binary.
+def enable_external_ffmpeg_decoder(~binary="ffmpeg", ~mimes, ~file_extensions) =
+  decoder.add(
+    name="FFMPEG",
+    description="Decode files using the ffmpeg decoder binary",
+    mimes=mimes,
+    file_extensions=file_extensions,
+    fun (~rlog, ~maxtime:_, fname) ->
+      begin
+        # File is cleaned up as part of the request workflow.
+        outfile = file.temp(cleanup=false, "ffmpeg", ".wav")
+        try
+          let {status = {code}} =
+            process.run(
+              "#{binary} -i #{process.quote(fname)} #{process.quote(outfile)}"
+            )
+          code == 0 ? outfile : null
+        catch err do
+          file.remove(outfile)
+          rlog(
+            "Error while decoding #{fname} using ffmpeg: #{err}"
+          )
+          null
+        end
+      end
+  )
+end
+
+# Enable the external openmpt123 decoder
+# @category Liquidsoap
+# @param ~file_extensions File extensions to decode.
+# @param ~mimes Mime types to decode. Empty list means any type.
+# @param ~options Extra options.
+# @param ~binary Path to the `ffmpeg` binary.
+def enable_external_openmpt123_decoder(
+  ~binary="openmpt123",
+  ~mimes=[
+    "audio/it",
+    "audio/xm",
+    "audio/s3m",
+    "audio/x-mod",
+    "audio/mod",
+    "audio/module-xm",
+    "audio/x-mod",
+    "application/playerpro",
+    "audio/x-s3m",
+    "application/soundapp",
+    "audio/med",
+    "audio/x-xm"
+  ],
+  ~file_extensions=[
+    "xm",
+    "mtm",
+    "amf",
+    "stm",
+    "ult",
+    "wow",
+    "dmf",
+    "it",
+    "s3m",
+    "far",
+    "mod",
+    "mt2",
+    "okt",
+    "med",
+    "669"
+  ],
+  ~options=""
+) =
+  decoder.add(
+    name="OPENMPT123",
+    description="Decode files using the openmpt123 decoder binary",
+    mimes=mimes,
+    file_extensions=file_extensions,
+    fun (~rlog, ~maxtime:_, infile) ->
+      begin
+        ret =
+          process.read.lines(
+            "#{binary} --info #{process.quote(infile)} 2>&1"
+          )
+        def get_meta(l, s) =
+          ret = string.extract(pattern="^(\\w+).+:\\s(.+)$", s)
+          if
+            list.length(ret) > 2
+          then
+            label = ret[1]
+            val = ret[2]
+            label = "openmpt:#{string.case(lower=true, label)}"
+            ["#{string.quote(label)}=#{string.quote(val)}", ...l]
+          else
+            l
+          end
+        end
+        meta = list.fold(get_meta, [], ret)
+
+        prefix =
+          if
+            meta == []
+          then
+            ""
+          else
+            "annotate:#{string.concat(separator=',', meta)}:"
+          end
+
+        # File is cleaned up as part of the request workflow.
+        outfile = file.temp(cleanup=false, "openmpt", ".wav")
+        try
+          let {status = {code}} =
+            process.run(
+              "#{binary} --assume-terminal --quiet --force #{options} --output #{
+                process.quote(outfile)
+              } #{process.quote(infile)}"
+            )
+          code == 0 ? "#{prefix}#{outfile}" : null
+        catch err do
+          file.remove(outfile)
+          rlog(
+            "Error while decoding #{infile} using ffmpeg: #{err}"
+          )
+          null
+        end
+      end
+  )
+end
+
+# Standard function for displaying metadata.
+# Shows artist and title, using "Unknown" when a field is empty.
+# @param m Metadata packet to be displayed.
+# @category String
+def string_of_metadata(m) =
+  artist = m["artist"]
+  title = m["title"]
+  artist = if "" == artist then "Unknown" else artist end
+  title = if "" == title then "Unknown" else title end
+  "#{artist} -- #{title}"
+end
+
+# Use X On Screen Display to display metadata info.
+# @flag extra
+# @param ~color    Color of the text.
+# @param ~position Position of the text (top|middle|bottom).
+# @param ~font     Font used (xfontsel is your friend...)
+# @param ~display  Function used to display a metadata packet.
+# @category Source / Track processing
+def osd_metadata(
+  ~color="green",
+  ~position="top",
+  ~font="-*-courier-*-r-*-*-*-240-*-*-*-*-*-*",
+  ~display=string_of_metadata,
+  s
+) =
+  osd =
+    'osd_cat -p #{position} --font #{process.quote(font)}' ^
+      ' --color #{color}'
+
+  def feedback(m) =
+    ignore(
+      process.run(
+        "echo #{process.quote(display(m))} | #{osd} &"
+      )
+    )
+  end
+
+  s.on_metadata(synchronous=false, feedback)
+end
+
+# Use notify to display metadata info.
+# @flag extra
+# @param ~urgency Urgency (low|normal|critical).
+# @param ~icon    Icon filename or stock icon to display.
+# @param ~timeout Timeout in seconds.
+# @param ~display Function used to display a metadata packet.
+# @param ~title   Title of the notification message.
+# @category Source / Track processing
+def notify_metadata(
+  ~urgency="low",
+  ~icon="stock_smiley-22",
+  ~timeout=3.,
+  ~display=string_of_metadata,
+  ~title="Liquidsoap: new track",
+  s
+) =
+  time = int_of_float(timeout * 1000.)
+  send =
+    'notify-send -i #{icon} -u #{urgency}' ^
+      ' -t #{time} #{process.quote(title)} '
+
+  s.on_metadata(
+    synchronous=false,
+    fun (m) -> ignore(process.run(send ^ process.quote(display(m))))
+  )
+end

package/tests/liq/extra/fades.liq

@@ -0,0 +1,260 @@
+# Plot the first crossfade transition. Used for visualizing and testing
+# crossfade transitions.
+# @category Source / Track processing
+# @flag extra
+def cross.plot(~png=null, ~dir=null, ~font=null, ~font_size=10, s) =
+  dir =
+    if
+      null.defined(dir)
+    then
+      null.get(dir)
+    else
+      dir = file.temp_dir("plot")
+      on_cleanup({file.rmdir(dir)})
+      dir
+    end
+
+  old_txt = path.concat(dir, "old.txt")
+  new_txt = path.concat(dir, "new.txt")
+
+  def gnuplot_cmd(filename) =
+    term =
+      if
+        null.defined(font)
+      then
+        'pngcairo font "#{null.get(font)},#{font_size}"'
+      else
+        "png"
+      end
+    'set term #{term}; set output "#{(filename : string)}"; plot "#{new_txt}" \
+     using 1:2 with lines title "new track", "#{old_txt}" using 1:2 with lines \
+     title "old track"'
+  end
+
+  def store_rms(~id, s) =
+    s = rms(duration=settings.frame.duration(), s)
+    t0 = ref(null)
+
+    s.on_frame(
+      synchronous=true,
+      before=false,
+      {
+        let t0 =
+          if
+            null.defined(t0())
+          then
+            null.get(t0())
+          else
+            t0 := source.time(s)
+            null.get(t0())
+          end
+        let v = float.truncate(digits=4, mode="floor", s.rms())
+        let p = float.truncate(digits=4, mode="floor", source.time(s) - t0)
+        fname = id == "old" ? old_txt : new_txt
+        file.write(append=true, data="#{p}\t#{v}\n", fname)
+      }
+    )
+
+    s
+  end
+
+  plotted = ref(false)
+
+  def transition(old, new) =
+    old = store_rms(id="old", fade.out(old.source))
+    new = store_rms(id="new", fade.in(new.source))
+
+    s = blank(duration=0.1)
+    s.on_frame(
+      synchronous=true,
+      {
+        if
+          null.defined(png) and not plotted()
+        then
+          ignore(
+            process.run(
+              "gnuplot -e #{process.quote(gnuplot_cmd(null.get(png)))}"
+            )
+          )
+        end
+        plotted := true
+      }
+    )
+
+    sequence(single_track=false, [add(normalize=false, [new, old]), once(s)])
+  end
+
+  cross(transition, s)
+end
+
+# Plot two sine tracks with given autocue params.
+# Used for visualizing and testing autocue crossfade transitions.
+# @category Source / Track processing
+# @flag extra
+def autocue.plot(
+  ~png=null,
+  ~dir=null,
+  ~font=null,
+  ~font_size=10,
+  ~old_autocue,
+  ~new_autocue,
+  ~sync="auto",
+  ~on_stop
+) =
+  dir =
+    if
+      null.defined(dir)
+    then
+      null.get(dir)
+    else
+      dir = file.temp_dir("plot")
+      on_cleanup({file.rmdir(dir)})
+      dir
+    end
+
+  old_txt = path.concat(dir, "old.txt")
+  new_txt = path.concat(dir, "new.txt")
+
+  def gnuplot_cmd(filename) =
+    term =
+      if
+        null.defined(font)
+      then
+        'pngcairo font "#{null.get(font)},#{font_size}"'
+      else
+        "png"
+      end
+    'set term #{term}; set output "#{(filename : string)}"; plot "#{new_txt}" \
+     using 1:2 with lines title "new track", "#{old_txt}" using 1:2 with lines \
+     title "old track"'
+  end
+
+  def autocue_annotate(a, uri) =
+    meta = autocue.metadata(implementation="autocue.plot", a)
+    meta =
+      list.map(fun ((label, value)) -> "#{label}=#{string.quote(value)}", meta)
+    meta = string.concat(separator=",", meta)
+    "annotate:#{meta}:#{uri}"
+  end
+
+  old_uri =
+    process.uri(
+      extname="wav",
+      "ffmpeg -f lavfi -i \"sine=frequency=1000:duration=10\" -y $(output) < \
+       /dev/null"
+    )
+  old_uri = autocue_annotate(old_autocue, old_uri)
+  old_source = request.once(request.create(old_uri))
+
+  new_uri =
+    process.uri(
+      extname="wav",
+      "ffmpeg -f lavfi -i \"sine=frequency=500:duration=10\" -y $(output) < \
+       /dev/null"
+    )
+  new_uri = autocue_annotate(new_autocue, new_uri)
+  new_source = request.once(request.create(new_uri))
+
+  s = sequence([old_source, new_source])
+
+  def store_rms(~fname, s) =
+    s = rms(duration=settings.frame.duration(), s)
+    t0 = ref(null)
+
+    s.on_frame(
+      synchronous=true,
+      before=false,
+      {
+        let t0 =
+          if
+            null.defined(t0())
+          then
+            null.get(t0())
+          else
+            t0 := source.time(s)
+            null.get(t0())
+          end
+        let t = float.truncate(digits=4, mode="floor", source.time(s) - t0)
+        let v = float.truncate(digits=4, mode="floor", s.rms())
+        file.write(append=true, data="#{t}\t#{v}\n", fname)
+      }
+    )
+
+    s
+  end
+
+  is_first_ending = ref(true)
+  is_first_starting = ref(true)
+
+  def transition(old, new) =
+    list.iter(
+      fun (x) ->
+        log(
+          level=4,
+          "Before: #{x}"
+        ),
+      old.metadata
+    )
+
+    list.iter(
+      fun (x) ->
+        log(
+          level=4,
+          "After : #{x}"
+        ),
+      new.metadata
+    )
+
+    def ending_map(s) =
+      if
+        is_first_ending()
+      then
+        is_first_ending := false
+        store_rms(fname=old_txt, s)
+      else
+        s
+      end
+    end
+
+    def starting_map(s) =
+      if
+        is_first_starting()
+      then
+        is_first_starting := false
+        store_rms(fname=new_txt, s)
+      else
+        s
+      end
+    end
+
+    cross.simple(
+      initial_fade_in_metadata=new.metadata,
+      initial_fade_out_metadata=old.metadata,
+      ending_map=ending_map,
+      starting_map=starting_map,
+      old.source,
+      new.source
+    )
+  end
+
+  s = cross(transition, s)
+
+  clock.assign_new(sync=sync, [s])
+
+  def on_stop() =
+    if
+      null.defined(png)
+    then
+      ignore(
+        process.run(
+          "gnuplot -e #{process.quote(gnuplot_cmd(null.get(png)))}"
+        )
+      )
+    end
+    on_stop()
+    clock(s.clock).stop()
+  end
+
+  o = output.dummy(fallible=true, s)
+  o.on_stop(synchronous=true, on_stop)
+end

package/tests/liq/extra/file.liq

@@ -0,0 +1,66 @@
+# Keep a record of played files. This is primarily useful to know when a song
+# was last played and avoid repetitions.
+# @flag extra
+# @param ~duration Duration (in seconds) after which songs are forgotten. By default, songs are not forgotten which means that the playlog will contain all the songs ever played.
+# @param ~hash Function to extract an identifier from the metadata. By default, the filename is used but we could return the artist to know when a song from a given artist was last played for instance.
+# @param ~persistency Set a file name where the values are stored and loaded in case the script is restarted.
+# @category Source / Track processing
+# @method add Record that file with given metadata has been played.
+# @method last How long ago a file was played (in seconds), `infinity` is returned if the song has never been played.
+def playlog(
+  ~duration=infinity,
+  ~persistency=null,
+  ~hash=fun (m) -> m["filename"]
+) =
+  l = ref([])
+
+  # Load from persistency file
+  if
+    null.defined(persistency)
+  then
+    if
+      file.exists(null.get(persistency))
+    then
+      let json.parse (parsed : [(string * float)]?) =
+        file.contents(null.get(persistency))
+
+      if null.defined(parsed) then l := null.get(parsed) end
+    end
+  end
+
+  # Save into persistency file
+  def save() =
+    if
+      null.defined(persistency)
+    then
+      data = json.stringify(l())
+      file.write(data=data, null.get(persistency))
+    end
+  end
+
+  # Remove too old elements
+  def prune() =
+    if
+      duration != infinity
+    then
+      t = time()
+      l := list.assoc.filter(fun (_, tf) -> t - tf <= duration, l())
+    end
+  end
+
+  # Add a new entry
+  def add(m) =
+    prune()
+    f = hash(m)
+    l := (f, time())::l()
+    save()
+  end
+
+  # Last time this entry was played
+  def last(m) =
+    f = hash(m)
+    time() - list.assoc(default=0. - infinity, f, l())
+  end
+
+  {add = add, last = last}
+end

package/tests/liq/extra/http.liq

@@ -0,0 +1,160 @@
+# Harbor middleware to add CORS headers
+# @category Internet
+# @flag extra
+# @param ~origin Configures the Access-Control-Allow-Origin CORS header
+# @param ~origin_callback Origin callback for advanced uses. If passed, overrides `origin` argument. Takes the request as input and returns the allowed origin. Return `null` to skip all CORS headers.
+# @param ~methods Configures the Access-Control-Allow-Methods CORS header.
+# @param ~allowed_headers Configures the Access-Control-Allow-Headers CORS header. If not specified, defaults to reflecting the headers specified in the request's Access-Control-Request-Headers header.
+# @param ~exposed_headers Configures the Access-Control-Expose-Headers CORS header. If not specified, no custom headers are exposed.
+# @param ~credentials Configures the Access-Control-Allow-Credentials CORS header. Set to true to pass the header, otherwise it is omitted.
+# @param ~max_age Configures the Access-Control-Max-Age CORS header. Set to an integer to pass the header, otherwise it is omitted.
+# @param ~preflight_continue Pass the CORS preflight response to the nexnhandler.
+# @param ~options_status_code Provides a status code to use for successful OPTIONS requests, since some legacy browsers (IE11, various SmartTVs) choke on 204.
+def harbor.http.middleware.cors(
+  ~origin=null("*"),
+  ~origin_callback=null,
+  ~methods=["GET", "HEAD", "PUT", "PATCH", "POST", "DELETE"],
+  ~allowed_headers=null,
+  ~exposed_headers=[],
+  ~credentials=false,
+  ~max_age=null,
+  ~preflight_continue=false,
+  ~options_status_code=204
+) =
+  fun (req, res, next) ->
+    begin
+      # This is for typing purposes
+      res = if false then http.response() else res end
+      if
+        false
+      then
+        harbor.http.register(
+          "/foo",
+          fun (r, _) -> ignore(if false then r else req end)
+        )
+      end
+
+      vary = ref([])
+
+      def add_vary() =
+        if
+          vary() != []
+        then
+          res.header("Vary", string.concat(separator=",", vary()))
+        end
+      end
+
+      def vary(v) =
+        vary := v::vary()
+      end
+
+      def add_origin(origin) =
+        res.header("Access-Control-Allow-Origin", origin)
+        if origin != "*" then vary("Origin") end
+      end
+
+      def add_methods() =
+        if
+          methods != []
+        then
+          res.header(
+            "Access-Control-Allow-Methods",
+            string.concat(separator=",", methods)
+          )
+        end
+      end
+
+      def add_credentials() =
+        if
+          credentials
+        then
+          res.header("Access-Control-Allow-Credentials", "true")
+        end
+      end
+
+      def add_allowed_headers() =
+        allowed_headers =
+          if
+            null.defined(allowed_headers)
+          then
+            string.concat(separator=",", null.get(allowed_headers))
+          elsif
+            list.assoc.mem("access-control-request-headers", req.headers)
+          then
+            req.headers["access-control-request-headers"]
+          else
+            null
+          end
+
+        if
+          null.defined(allowed_headers)
+        then
+          res.header("Access-Control-Allow-Headers", null.get(allowed_headers))
+          vary("Access-Control-Request-Headers")
+        end
+      end
+
+      def add_exposed_headers() =
+        if
+          exposed_headers != []
+        then
+          res.header(
+            "Access-Control-Expose-Headers",
+            string.concat(separator=",", exposed_headers)
+          )
+        end
+      end
+
+      def add_max_age() =
+        if
+          null.defined(max_age)
+        then
+          res.header("Access-Control-Max-Age", "#{(null.get(max_age) : int)}")
+        end
+      end
+
+      origin =
+        if
+          null.defined(origin_callback)
+        then
+          fn = null.get(origin_callback)
+          fn(req)
+        else
+          getter.get(origin)
+        end
+
+      if
+        not null.defined(origin)
+      then
+        next(req, res)
+      else
+        add_origin(null.get(origin))
+        if
+          req.method == "OPTIONS"
+        then
+          add_credentials()
+          add_methods()
+          add_allowed_headers()
+          add_max_age()
+          add_exposed_headers()
+          add_vary()
+          if
+            preflight_continue
+          then
+            next(req, res)
+          else
+            res.status_code(options_status_code)
+            res.header("Content-length", "0")
+          end
+        else
+          add_credentials()
+          add_allowed_headers()
+          add_vary()
+          next(req, res)
+        end
+      end
+    end
+end
+
+# This is for typing purposes
+if false then harbor.http.middleware.register(harbor.http.middleware.cors()) end