liquidsoap-prettier 1.8.2 → 1.8.3

package/tests/liq/extra/spinitron.liq

@@ -0,0 +1,272 @@
+let spinitron = {submit = ()}
+
+# Submit a track to the spinitron track system
+# and return the raw response.
+# @category Interaction
+# @flag extra
+# @param ~api_key API key
+def spinitron.submit.raw(
+  ~host="https://spinitron.com/api",
+  ~api_key,
+  ~live=false,
+  ~start=null,
+  ~duration=null,
+  ~artist,
+  ~release=null,
+  ~label=null,
+  ~genre=null,
+  ~song,
+  ~composer=null,
+  ~isrc=null
+) =
+  params = [("song", song), ("artist", artist)]
+
+  def fold_optional_string_params(params, param) =
+    let (label, param) = param
+    if
+      null.defined(param)
+    then
+      [(label, null.get(param)), ...params]
+    else
+      params
+    end
+  end
+
+  params =
+    list.fold(
+      fold_optional_string_params,
+      params,
+      [
+        ("live", null.map(fun (b) -> b ? "1" : "0", (live : bool?))),
+        ("start", start),
+        ("duration", null.map(string, (duration : int?))),
+        ("release", release),
+        ("label", label),
+        ("genre", genre),
+        ("composer", composer),
+        ("isrc", isrc)
+      ]
+    )
+
+  def encode_param(param) =
+    let (label, param) = param
+    "#{label}=#{url.encode(param)}"
+  end
+
+  params = string.concat(separator="&", list.map(encode_param, params))
+
+  http.post(
+    data=params,
+    headers=[
+      ("Accept", "application/json"),
+      ("Content-Type", "application/x-www-form-urlencoded"),
+      (
+        "Authorization",
+        "Bearer #{(api_key : string)}"
+      )
+    ],
+    "#{host}/spins"
+  )
+end
+
+# Submit a track to the spinitron track system
+# and return the parsed response
+# @category Interaction
+# @flag extra
+# @param ~api_key API key
+def replaces spinitron.submit(%argsof(spinitron.submit.raw)) =
+  resp = spinitron.submit.raw(%argsof(spinitron.submit.raw))
+
+  if
+    resp.status_code == 201
+  then
+    let json.parse (resp :
+      {
+        id: int,
+        playlist_id: int,
+        "start" as spin_start: string,
+        "end" as spin_end: string?,
+        duration: int?,
+        timezone: string?,
+        image: string?,
+        classical: bool?,
+        artist: string,
+        "artist-custom" as artist_custom: string?,
+        composer: string?,
+        release: string?,
+        "release-custom" as release_custom: string?,
+        va: bool?,
+        label: string?,
+        "label-custom" as label_custom: string?,
+        released: int?,
+        medium: string?,
+        genre: string?,
+        song: string,
+        note: string?,
+        request: bool?,
+        local: bool?,
+        new: bool?,
+        work: string?,
+        conductor: string?,
+        performers: string?,
+        ensemble: string?,
+        "catalog-number" as catalog_number: string?,
+        isrc: string?,
+        upc: string?,
+        iswc: string?,
+        "_links" as links: {self: {href: string}?, playlist: {href: string}?}?
+      }
+    ) = resp
+
+    resp
+  elsif
+    resp.status_code == 422
+  then
+    let json.parse (errors : [{field: string, message: string}]) = resp
+
+    errors =
+      list.map(
+        fun (p) ->
+          begin
+            let {field, message} = p
+            "#{field}: #{message}"
+          end,
+        errors
+      )
+
+    errors =
+      string.concat(
+        separator=", ",
+        errors
+      )
+
+    error.raise(
+      error.raise(
+        error.http,
+        "Invalid fields: #{errors}"
+      )
+    )
+  else
+    let json.parse ({name, message, code, status, type} :
+      {name: string, message: string, code: int, status: int, type: string?}
+    ) = resp
+
+    type = type ?? "undefined"
+
+    error.raise(
+      error.raise(
+        error.http,
+        "#{name}: #{message} (code: #{code}, status: #{status}, type: #{type})"
+      )
+    )
+  end
+end
+
+# Submit a spin using the given metadata to the spinitron track system
+# and return the parsed response. `artist` and `song` (or `title`) must
+# be present either as metadata or as optional argument.
+# @category Interaction
+# @flag extra
+# @param m Metadata to submit. Overrides optional arguments when present.
+# @param ~mapper Metadata mapper that can be used to map metadata fields to spinitron's expected. \
+#                Returned metadata are added to the submitted metadata. By default, `title` is \
+#                mapped to `song` and `album` to `release` if neither of those passed otherwise.
+# @param ~api_key API key
+def spinitron.submit.metadata(
+  %argsof(spinitron.submit[!artist,!song]),
+  ~mapper=(
+    fun (m) ->
+      [
+        ...(m["song"] != "" or m["title"] == "" ? [] : [("song", m["title"])]),
+        ...(
+          m["release"] != "" or m["album"] == ""
+            ? []
+            : [("release", m["album"])]
+        )
+      ]
+  ),
+  ~artist=null,
+  ~song=null,
+  m
+) =
+  m = [...m, ...mapper(m)]
+
+  def conv_opt_arg(convert, label, default) =
+    list.assoc.mem(label, m) ? convert(m[label]) : default
+  end
+
+  opt_arg =
+    fun (label, default) -> conv_opt_arg(fun (x) -> null(x), label, default)
+
+  live = conv_opt_arg(bool_of_string, "live", live)
+  start = opt_arg("start", start)
+  duration = conv_opt_arg(int_of_string, "duration", duration)
+  artist = opt_arg("artist", artist)
+  release = opt_arg("release", release)
+  label = opt_arg("label", label)
+  genre = opt_arg("genre", genre)
+  song = opt_arg("song", song)
+  composer = opt_arg("composer", composer)
+  isrc = opt_arg("isrc", isrc)
+
+  if
+    artist == null or song == null
+  then
+    error.raise(
+      error.invalid,
+      "Both \"artist\" and \"song\" (or \"title\" metadata) must be provided!"
+    )
+  end
+
+  artist = null.get(artist)
+  song = null.get(song)
+
+  res = spinitron.submit(%argsof(spinitron.submit))
+
+  print(res)
+
+  res
+end
+
+# Specialized version of `s.on_metadata` that submits spins using
+# the source's metadata to the spinitron track system. `artist` and `song`
+# (or `title`) must be present either as metadata or as optional argument.
+# @category Interaction
+# @flag extra
+# @param m Metadata to submit. Overrides optional arguments when present.
+# @param ~api_key API key
+def spinitron.submit.on_metadata(%argsof(spinitron.submit.metadata), s) =
+  def on_metadata(m) =
+    if
+      m["title"] == "" and m["song"] == ""
+    then
+      log.severe(
+        label=source.id(s),
+        "Field \"song\" or \"title\" missing, skipping metadata spinitron \
+         submission."
+      )
+    elsif
+      m["artist"] == ""
+    then
+      log.severe(
+        label=source.id(s),
+        "Field \"artist\" missing, skipping metadata spinitron submission."
+      )
+    else
+      try
+        ignore(spinitron.submit.metadata(%argsof(spinitron.submit.metadata), m))
+        log.important(
+          label=source.id(s),
+          "Successfully submitted spin from metadata"
+        )
+      catch err do
+        log.severe(
+          label=source.id(s),
+          "Error while submitting spin from metadata: #{err}"
+        )
+      end
+    end
+  end
+
+  source.methods(s).on_metadata(synchronous=false, on_metadata)
+end

package/tests/liq/extra/telnet.liq

@@ -0,0 +1,266 @@
+# @docof request.dynamic
+def replaces request.dynamic(%argsof(request.dynamic), fn) =
+  s = request.dynamic(%argsof(request.dynamic), fn)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        server.register(
+          namespace=source.id(s),
+          description="Flush the queue and skip the current track",
+          "flush_and_skip",
+          fun (_) ->
+            try
+              s.set_queue([])
+              s.skip()
+              "Done."
+            catch err do
+              "Error while flushing and skipping source: #{err}"
+            end
+        )
+      }
+    )
+  )
+
+  s
+end
+
+# @docof blank.strip
+def replaces blank.strip(%argsof(blank.strip), s) =
+  s = blank.strip(%argsof(blank.strip), s)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        server.register(
+          namespace=source.id(s),
+          description="Check if the source is stripping.",
+          "is_stripping",
+          fun (_) -> begin "#{s.is_blank()}" end
+        )
+      }
+    )
+  )
+
+  s
+end
+
+# @docof output.external
+def replaces output.external(%argsof(output.external), f, p, s) =
+  s = output.external(%argsof(output.external), f, p, s)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        server.register(
+          namespace=s.id(),
+          description="Re-open the output.",
+          "reopen",
+          fun (_) ->
+            begin
+              s.reopen()
+              "Done."
+            end
+        )
+      }
+    )
+  )
+
+  s
+end
+
+# @docof input.external.avi
+def replaces input.external.avi(%argsof(input.external.avi), s) =
+  s = input.external.avi(%argsof(input.external.avi), s)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        server.register(
+          namespace=source.id(s),
+          description="Show internal buffer length (in seconds).",
+          "buffer_length",
+          fun (_) ->
+            begin
+              buffered = s.buffered()
+              audio = list.assoc(default=0., "audio", buffered)
+              video = list.assoc(default=0., "video", buffered)
+              total = min(audio, video)
+              "audio buffer length: #{audio}\nvideo buffer length: #{
+                video
+              }\ntotal buffer length: #{total}"
+            end
+        )
+      }
+    )
+  )
+
+  s
+end
+
+# @docof input.harbor
+def replaces input.harbor(%argsof(input.harbor), s) =
+  s = input.harbor(%argsof(input.harbor), s)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        begin
+          server.register(
+            namespace=source.id(s),
+            description="Stop current source client, if connected.",
+            "stop",
+            fun (_) ->
+              begin
+                s.stop()
+                "Done"
+              end
+          )
+
+          server.register(
+            namespace=source.id(s),
+            description="Display current status.",
+            "status",
+            fun (_) -> begin s.status() end
+          )
+
+          server.register(
+            namespace=source.id(s),
+            description="Get the buffer's length, in seconds.",
+            "buffer_length",
+            fun (_) -> begin "#{s.buffer_length()}" end
+          )
+        end
+      }
+    )
+  )
+
+  s
+end
+
+%ifdef input.http
+# @docof input.http
+def replaces input.http(%argsof(input.http), s) =
+  s = input.http(%argsof(input.http), s)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        begin
+          server.register(
+            namespace=source.id(s),
+            description="Start the source, if needed.",
+            "start",
+            fun (_) ->
+              begin
+                s.start()
+                "Done!"
+              end
+          )
+
+          server.register(
+            namespace=source.id(s),
+            description="Stop the source if connected.",
+            "stop",
+            fun (_) ->
+              begin
+                s.stop()
+                "Done!"
+              end
+          )
+
+          server.register(
+            namespace=source.id(s),
+            description="Get or set the stream's HTTP URL. Setting a new URL \
+             will not affect an ongoing connection.",
+            usage="url [url]",
+            "url",
+            fun (url) ->
+              begin
+                if
+                  url == ""
+                then
+                  s.url()
+                else
+                  begin
+                    s.set_url({url})
+                    "Done!"
+                  end
+                end
+              end
+          )
+
+          server.register(
+            namespace=source.id(s),
+            description="Return the current status of the source, either \
+             \"stopped\" (the source isn't trying to relay the HTTP stream), \
+             \"polling\" (attempting to connect to the HTTP stream) or \
+             \"connected <url>\" (connected to <url>, buffering or playing back \
+             the stream).",
+            "status",
+            fun (_) -> begin s.status() end
+          )
+
+          server.register(
+            namespace=source.id(s),
+            description="Get the buffer's length, in seconds.",
+            "buffer_length",
+            fun (_) ->
+              "#{list.fold(fun (l, (_, l')) -> max(l, l'), 0., s.buffered())}"
+          )
+        end
+      }
+    )
+  )
+
+  s
+end
+%endif
+
+# @docof lufs
+def replaces lufs(%argsof(lufs), s) =
+  s = lufs(%argsof(lufs), s)
+  s.on_wake_up(
+    synchronous=false,
+    memoize(
+      {
+        server.register(
+          namespace=source.id(s),
+          description="Current value for the LUFS (short-term value computed \
+           over the duration specified by the `window` parameter).",
+          "lufs",
+          fun (_) ->
+            "#{s.lufs()} LUFS"
+        )
+
+        server.register(
+          namespace=source.id(s),
+          description="Average LUFS value over the current track.",
+          "lufs_integrated",
+          fun (_) ->
+            "#{s.lufs_integrated()} LUFS"
+        )
+
+        server.register(
+          namespace=source.id(s),
+          description="Momentary LUFS (over a 400ms window).",
+          "lufs_momentary",
+          fun (_) ->
+            "#{s.lufs_momentary()} LUFS"
+        )
+      }
+    )
+  )
+
+  s
+end
+
+server.register(
+  description="Shutdown the running liquidsoap instance",
+  "shutdown",
+  fun (_) ->
+    begin
+      shutdown()
+      "OK"
+    end
+)

package/tests/liq/extra/video.liq

@@ -0,0 +1,59 @@
+# Extract cover from the source's metadata and add it as a static image.
+# @category Track / Video processing
+# @flag extra
+# @param ~id Force the value of the source ID.
+# @param ~fallible Whether we are allowed to fail (in case the file is non-existent or invalid).
+# @param ~width Scale to width
+# @param ~height Scale to height
+# @param ~x x position.
+# @param ~y y position.
+# @param ~default Default cover file when no cover is available
+# @param ~mime_types Recognized mime types and their corresponding file extensions.
+def video.add_cover(
+  ~fallible=false,
+  ~width=null,
+  ~height=null,
+  ~x=getter(0),
+  ~y=getter(0),
+  ~mime_types=[
+    ("image/gif", "gif"),
+    ("image/jpg", "jpeg"),
+    ("image/jpeg", "jpeg"),
+    ("image/png", "png"),
+    ("image/webp", "webp")
+  ],
+  ~default,
+  s
+) =
+  cover_file = file.cover.manager(mime_types=mime_types, default=default)
+  s.on_metadata(synchronous=true, cover_file.set)
+  video.add_request(
+    fallible=fallible,
+    x=x,
+    y=y,
+    width=width,
+    height=height,
+    request=cover_file,
+    s
+  )
+end
+
+let video.ffmpeg = ()
+
+%ifdef input.ffmpeg
+# ffmpeg's test source video (useful for testing and debugging).
+# @category Source / Video processing
+# @flag extra
+def video.ffmpeg.testsrc(~id="video.testsrc") =
+  video =
+    "testsrc=size=#{video.frame.width()}x#{video.frame.height()}:rate=#{
+      video.frame.rate()
+    }"
+  audio = "sine=frequency=440:beep_factor=2:sample_rate=#{audio.samplerate()}"
+  input.ffmpeg(
+    id=id,
+    format="lavfi",
+    "#{video} [out0]; #{audio} [out1]"
+  )
+end
+%endif

package/tests/liq/extra/visualization.liq

@@ -0,0 +1,68 @@
+# VU meter: display the audio volume (RMS in dB) on the standard output.
+# @category Source / Visualization
+# @flag extra
+# @param ~rms_min Minimal volume (dB).
+# @param ~rms_max Maximal volume (dB).
+# @param ~scroll Update the display in the same line.
+# @param ~window Duration in seconds of volume computation.
+def vumeter(~rms_min=-25., ~rms_max=-5., ~window=0.5, ~scroll=false, s) =
+  screen_width = 80
+  bar_width = screen_width
+  let s = rms(duration=window, s)
+
+  def display() =
+    v = dB_of_lin(s.rms())
+    x = (v - rms_min) / (rms_max - rms_min)
+    x = if x < 0. then 0. else x end
+    x = if x > 1. then 1. else x end
+    n = int_of_float(x * float_of_int(bar_width))
+    bar = ref("")
+    if not scroll then bar := "\r" end
+    for _ = 0 to n - 1 do bar := bar() ^ "="  end
+    for _ = 0 to bar_width - n - 1 do bar := bar() ^ "."  end
+    bar :=
+      bar() ^
+        " " ^
+        string(v)
+    if scroll then bar := bar() ^ "\n" end
+    print(newline=false, bar())
+  end
+
+  thread.run(fast=true, every=window, display)
+  s
+end
+
+# VU meter: display the audio volume (RMS in dB). This adds a video track to the
+# source.
+# @category Source / Visualization
+# @flag extra
+# @param ~rms_min Minimal volume (dB).
+# @param ~rms_max Maximal volume (dB).
+# @param ~window Duration in seconds of volume computation.
+# @param ~color Color of the display (0xRRGGBB).
+# @param ~persistence Persistence of the display (s).
+def video.vumeter(
+  ~rms_min=-35.,
+  ~rms_max=0.,
+  ~window=0.1,
+  ~color=0xff0000,
+  ~persistence=0.,
+  s
+) =
+  s = source(s.{video = source.tracks(blank()).video})
+  s = rms(duration=window, s)
+  height = video.frame.height()
+  width = ref(0)
+
+  def update() =
+    v = dB_of_lin(s.rms())
+    x = (v - rms_min) / (rms_max - rms_min)
+    x = if x < 0. then 0. else x end
+    x = if x > 1. then 1. else x end
+    width := int_of_float(x * float_of_int(video.frame.width()))
+  end
+
+  thread.run(fast=true, every=window, update)
+  s = video.add_rectangle(width=width, height=height, color=color, s)
+  video.persistence(duration=persistence, s)
+end