liquidsoap-prettier 1.8.2 → 1.8.3

package/tests/liq/runtime.liq

@@ -0,0 +1,70 @@
+# @docof runtime.memory
+def replaces runtime.memory() =
+  x =
+    {
+      ...runtime.memory(),
+      process_managed_memory =
+        runtime.gc.quick_stat().heap_words * runtime.sys.word_size / 8
+    }
+
+  let x.pretty =
+    {
+      process_managed_memory =
+        runtime.memory.prettify_bytes(x.process_managed_memory),
+      total_virtual_memory =
+        runtime.memory.prettify_bytes(x.total_virtual_memory),
+      total_physical_memory =
+        runtime.memory.prettify_bytes(x.total_physical_memory),
+      total_used_virtual_memory =
+        runtime.memory.prettify_bytes(x.total_used_virtual_memory),
+      total_used_physical_memory =
+        runtime.memory.prettify_bytes(x.total_used_physical_memory),
+      process_virtual_memory =
+        runtime.memory.prettify_bytes(x.process_virtual_memory),
+      process_physical_memory =
+        runtime.memory.prettify_bytes(x.process_physical_memory),
+      process_private_memory =
+        runtime.memory.prettify_bytes(x.process_private_memory),
+      process_swapped_memory =
+        runtime.memory.prettify_bytes(x.process_swapped_memory)
+    }
+
+  x
+end
+
+let runtime.cpu = ()
+%ifdef process.time
+# Create a function returning CPU usage (in `float` percent so
+# `0.2` means `20%`) since the last time it was called.
+# @category Liquidsoap
+def runtime.cpu.usage_getter() =
+  t = ref(time())
+  let {user, system} = process.time()
+  u = ref(user)
+  s = ref(system)
+
+  def f() =
+    t' = time()
+    delta = t' - t()
+    let {user, system} = process.time()
+    u' = user - u()
+    s' = system - s()
+    t := t'
+    u := user
+    s := system
+    {user = u' / delta, system = s' / delta, total = (u' + s') / delta}
+  end
+
+  f
+end
+%endif
+
+# Set the current time zone. This is
+# equivalent to setting the `TZ` environment
+# variable.
+# @category Time
+def time.zone.set(tz) =
+  environment.set("TZ", tz)
+end
+
+runtime.gc.set(runtime.gc.get().{space_overhead = 80})

package/tests/liq/server.liq

@@ -0,0 +1,99 @@
+# Enable telnet server.
+# @category Interaction
+# @param ~port Port on which we should listen.
+def server.telnet(~port=1234) =
+  settings.server.telnet.port := port
+  settings.server.telnet := true
+end
+
+server.register(
+  namespace="runtime.gc",
+  description="Run a full memory collection",
+  "full_major",
+  fun (_) ->
+    begin
+      runtime.gc.full_major()
+      "Done!"
+    end
+)
+
+server.register(
+  namespace="runtime.gc",
+  description="Compact OCaml memory",
+  "compact",
+  fun (_) ->
+    begin
+      runtime.gc.compact()
+      "Done!"
+    end
+)
+
+server.register(
+  namespace="runtime",
+  description="Return a description of the memory used by the process",
+  "memory",
+  fun (_) ->
+    begin
+      let {
+        process_managed_memory,
+        process_physical_memory,
+        process_private_memory,
+        process_swapped_memory
+      } = runtime.memory().pretty
+      "Physical memory: #{process_physical_memory}\nPrivate memory: #{
+        process_private_memory
+      }\nManaged memory: #{process_managed_memory}\nSwapped memory: #{
+        process_swapped_memory
+      }"
+    end
+)
+
+server.register(
+  namespace="clock",
+  description="Dump a description of the current clocks and sources",
+  "dump",
+  fun (_) -> clock.dump()
+)
+
+server.register(
+  namespace="clock",
+  description="Dump the source graph for all active clocks",
+  "dump_all_sources",
+  fun (_) -> clock.dump_all_sources()
+)
+
+on_start(
+  fun () ->
+    begin
+      if
+        settings.request.deprecated_on_air_metadata()
+      then
+        server.register(
+          namespace="request",
+          description="Return all the requests currently on_air (DEPRECATED)!",
+          "on_air",
+          fun (_) ->
+            string.concat(
+              separator=" ",
+              list.map(
+                string,
+                list.sort(
+                  fun (a, b) -> a - b,
+                  list.filter_map(
+                    fun (r) ->
+                      if
+                        list.assoc.mem("on_air", request.metadata(r))
+                      then
+                        request.id(r)
+                      else
+                        null
+                      end,
+                    request.all()
+                  )
+                )
+              )
+            )
+        )
+      end
+    end
+)

package/tests/liq/settings.liq

@@ -0,0 +1,41 @@
+# Instantiate a new setting.
+# @category Settings
+# @flag hidden
+def settings.make(~comments="", ~(description:string), v) =
+  current_value = ref(v)
+  current_value.{description = description, comments = comments}
+end
+
+# Instantiate a new empty setting.
+# @category Settings
+# @flag hidden
+def settings.make.void(~comments="", (description:string)) =
+  {description = description, comments = comments}
+end
+
+let frame = ()
+
+# Duration of a frame.
+# @category Settings
+def frame.duration =
+  settings.frame.duration
+end
+
+let settings.init.compact_before_start =
+  settings.make(
+    description="Run the OCaml memory compaction algorithm before starting your \
+     script. This is useful when script caching is not possible but initial \
+     memory consumption is a concern. This will result in a large chunk of \
+     memory being freed right before starting the script. This also increases \
+     the script's initial startup time.",
+    true
+  )
+
+# Top-level init module for convenience.
+# @category Settings
+# @flag hidden
+init = settings.init
+
+on_start(
+  {if settings.init.compact_before_start() then runtime.gc.compact() end}
+)

package/tests/liq/socket.liq

@@ -0,0 +1,33 @@
+# Open a named UNIX socket and connect as a client.
+# @param ~non_blocking Open in non-blocking mode.
+# @category File
+def socket.unix.client(~non_blocking=false, path) =
+  s = socket.unix(domain=socket.domain.unix)
+  s.non_blocking(non_blocking)
+  s.connect(socket.address.unix(path))
+  (s : socket).{read = s.read, write = s.write, type = s.type, close = s.close}
+end
+
+# Open a named socket and wait for a client to connect
+# @param ~non_blocking Open in non-blocking mode.
+# @category File
+def socket.unix.listen(~non_blocking=false, path) =
+  s = socket.unix(domain=socket.domain.unix)
+  s.non_blocking(non_blocking)
+  s.bind(socket.address.unix(path))
+  s.listen(1)
+  let (s', _) = s.accept()
+  close =
+    fun () ->
+      begin
+        s'.close()
+        s.close()
+      end
+
+  (s' : socket).{
+    read = s'.read,
+    write = s'.write,
+    type = s'.type,
+    close = close
+  }
+end

package/tests/liq/source.liq

@@ -0,0 +1,362 @@
+# Create an audio source from the given track, with
+# metadata and track marks from that same track.
+# @category Source / Track processing
+def source.audio(~id=null("source.audio"), audio) =
+  source(
+    id=id,
+    {
+      audio = audio,
+      metadata = track.metadata(audio),
+      track_marks = track.track_marks(audio)
+    }
+  )
+end
+
+# Create a video source from the given track, with
+# metadata and track marks from that same track.
+# @category Source / Track processing
+def source.video(~id=null("source.video"), video) =
+  source(
+    id=id,
+    {
+      video = video,
+      metadata = track.metadata(video),
+      track_marks = track.track_marks(video)
+    }
+  )
+end
+
+# Remove duplicate metadata in a track.
+# @param ~using Labels to use to compare the metadata. Defaults to all of them \
+#               when `null`.
+# @category Metadata
+def track.metadata.deduplicate(
+  ~id=null("track.metadata.deduplicate"),
+  ~using=null,
+  t
+) =
+  last_meta = ref([])
+
+  def f(m) =
+    m =
+      if
+        null.defined(using)
+      then
+        using = null.get(using)
+        list.filter(fun (x) -> list.mem(fst(x), using), m)
+      else
+        m
+      end
+
+    if
+      m == last_meta()
+    then
+      []
+    else
+      last_meta := m
+      m
+    end
+  end
+
+  track.metadata.map(
+    id=id,
+    insert_missing=false,
+    update=false,
+    strip=true,
+    f,
+    t
+  )
+end
+
+# Remove duplicate metadata in a source.
+# @category Metadata
+# @param ~using Labels to use to compare the metadata. Defaults to all of them \
+#               when `null`.
+# @param ~id Source id
+# @param s source
+def metadata.deduplicate(~id=null("metadata.deduplicate"), ~using=null, s) =
+  tracks = source.tracks(s)
+  source(
+    id=id,
+    tracks.{metadata = track.metadata.deduplicate(using=using, tracks.metadata)}
+  )
+end
+
+# Rewrite metadata on the fly using a function.
+# @category Source / Track processing
+# @argsof track.metadata.map
+def metadata.map(
+  ~id=null("metadata.map"),
+  %argsof(track.metadata.map[!id]),
+  f,
+  (s:source)
+) =
+  tracks = source.tracks(s)
+  source(
+    id=id,
+    tracks.{
+      metadata =
+        track.metadata.map(%argsof(track.metadata.map), f, tracks.metadata)
+    }
+  )
+end
+
+# Turn a source into an infaillible source by adding blank when the source is
+# not available.
+# @param s the source to turn infaillible
+# @category Source / Track processing
+def mksafe(~id="mksafe", s) =
+  fallback(
+    id=id,
+    [(s : source).{track_sensitive = false}, blank(id="safe_blank")]
+  )
+end
+
+# Creates a source that plays only one track of the input source.
+# @category Source / Track processing
+# @param s The input source.
+def once(~id=null("once"), s) =
+  sequence(id=id, [(s : source), source.fail()])
+end
+
+# Skip track when detecting a blank.
+# @category Source / Track processing
+# @param ~id Force the value of the source ID.
+# @param ~threshold Power in decibels under which the stream is considered silent.
+# @param ~max_blank Maximum silence length allowed, in seconds.
+# @param ~min_noise Minimum duration of noise required to end silence, in seconds.
+# @param ~track_sensitive Reset blank counter at each track.
+def blank.skip(
+  ~id=null("blank.skip"),
+  ~threshold=-40.,
+  ~max_blank=20.,
+  ~min_noise=0.,
+  ~track_sensitive=true,
+  s
+) =
+  s' =
+    blank.detect(
+      id=id,
+      threshold=threshold,
+      max_blank=max_blank,
+      min_noise=min_noise,
+      track_sensitive=track_sensitive,
+      s
+    )
+  s'.on_blank(synchronous=true, source.methods(s).skip)
+  s'
+end
+
+# Run a function regularly. This is similar to `thread.run` but based on a
+# source internal time instead of the computer's time.
+# @category Source / Track processing
+# @param s Source whose time is taken as reference.
+# @param ~delay Time to wait before the first run (in seconds).
+# @param ~every How often to run the function (in seconds). The function is run once if `null`.
+# @param f Function to run.
+def source.run(s, ~delay=0., ~every=null, f) =
+  next = ref(delay)
+
+  def check() =
+    if
+      source.time(s) >= next()
+    then
+      null.case(
+        every,
+        {next := infinity},
+        fun (every) -> next := next() + every
+      )
+
+      f()
+    end
+  end
+
+  source.methods(s).on_frame(synchronous=true, check)
+  s
+end
+
+# Append an extra track to every track. Set the metadata ‘liq_append’ to
+# `false` to inhibit appending on one track.
+# @category Source / Track processing
+# @param f Given the metadata, build the source producing the track to append. The function can return `null` to prevent appending a new track.
+# @param ~insert_missing Treat track beginnings without metadata as having empty one.
+# @param ~merge Merge the track with its appended track.
+# @flag extra
+def append(~id=null("append"), ~insert_missing=true, ~merge=false, s, f) =
+  last_meta = ref(null)
+  pending = ref(null)
+
+  def next() =
+    p = pending()
+    pending := null
+    last_meta := null
+
+    if null.defined(p) then null.get(p) else (s : source) end
+  end
+
+  d =
+    source.dynamic(
+      track_sensitive=true,
+      merge={merge and null.defined(pending)},
+      next
+    )
+
+  def f(m) =
+    if
+      d.current_source() == (s : source)
+    then
+      if
+        m["liq_append"] == "false"
+      then
+        last_meta := null
+        pending := null
+      elsif
+        last_meta() != m
+      then
+        last_meta := m
+        s = f(m)
+        s = d.prepare(s)
+        pending := s
+      end
+    end
+  end
+
+  if insert_missing then d.on_track(synchronous=true, f) end
+  d.on_metadata(synchronous=true, f)
+
+  s = fallback(id=id, [d, s])
+  s.{
+    pending =
+      # Return the pending source
+      fun () -> pending(),
+    set_pending =
+      # Set the pending source
+      fun (s) -> pending.set(s),
+    cancel_pending =
+      # Cancel any pending appended source.
+      fun () -> pending.set(null),
+    skip =
+      # Skip the current track. Pending appended source are cancelled by default. Pass `cancel_pending=false` to keep it.
+      fun (~cancel_pending=true) ->
+        begin
+          if cancel_pending then pending.set(null) end
+          s.skip()
+        end
+  }
+end
+
+# Prepend an extra track before every track. Set the metadata `liq_prepend` to
+# `false` to inhibit prepending on one track.
+# @category Source / Track processing
+# @param f Given the metadata, build the source producing the track to append. The function can return `null` to prevent any track prepend.
+# @param ~merge Merge the track with its appended track.
+# @flag extra
+def prepend(~id=null("prepend"), ~merge=false, s, f) =
+  last_meta = ref(null)
+
+  def on_meta(m) =
+    if
+      m["liq_prepend"] == "false"
+    then
+      last_meta := null
+    elsif
+      last_meta() != m
+    then
+      last_meta := m
+    end
+  end
+
+  s.on_track(
+    synchronous=true,
+    fun (m) -> m == [] ? last_meta := null : on_meta(m)
+  )
+  s.on_metadata(synchronous=true, on_meta)
+
+  def next() =
+    if
+      null.defined(last_meta)
+    then
+      m = last_meta()
+      last_meta := null
+      if
+        null.defined(m)
+      then
+        m = null.get(m)
+        p = (f(m) : source?)
+        if
+          null.defined(p)
+        then
+          sequence(merge=merge, [null.get(p), s])
+        else
+          s
+        end
+      else
+        s
+      end
+    else
+      s
+    end
+  end
+
+  d = source.dynamic(track_sensitive=true, next)
+  fallback(id=id, [d, s])
+end
+
+# Call a callback on each subtitle in the source.
+# @category Source / Track processing
+# @param f Callback function called on each subtitle.
+# @argsof track.on_subtitle
+def on_subtitle(
+  ~id=null("on_subtitle"),
+  %argsof(track.on_subtitle[!id]),
+  f,
+  s
+) =
+  let {subtitles, ...tracks} = source.tracks(s)
+  source(
+    id=id,
+    tracks.{
+      subtitles =
+        track.on_subtitle(%argsof(track.on_subtitle[!id]), f, subtitles)
+    }
+  )
+end
+
+# Map a function over each subtitle in the source.
+# @category Source / Track processing
+# @param f Callback function called on each subtitle. Returns transformed subtitle or null to filter out.
+# @argsof track.subtitles.map
+def subtitles.map(
+  ~id=null("subtitles.map"),
+  %argsof(track.subtitles.map[!id]),
+  f,
+  s
+) =
+  let {subtitles, ...tracks} = source.tracks(s)
+  source(
+    id=id,
+    tracks.{
+      subtitles =
+        track.subtitles.map(%argsof(track.subtitles.map[!id]), f, subtitles)
+    }
+  )
+end
+
+# Allow inserting subtitles into the source.
+# subtitles track is created is the source does
+# not have one.
+# @category Source / Track processing
+# @argsof track.subtitles.insert
+def subtitles.insert(
+  ~id=null("subtitles.insert"),
+  %argsof(track.subtitles.insert[!id]),
+  s
+) =
+  tracks = source.tracks(s)
+  subtitles = tracks?.subtitles
+  let subtitles =
+    track.subtitles.insert(%argsof(track.subtitles.insert[!id]), subtitles)
+  source(id=id, tracks.{subtitles = subtitles}).{
+    insert_subtitle = subtitles.insert_subtitle
+  }
+end