liquidsoap-prettier 1.8.2 → 1.8.3

package/tests/liq/extra/interactive.liq

@@ -0,0 +1,917 @@
+# Information about all variables
+# @category Interaction
+variables = ref([])
+
+# Float variables
+# @category Interaction
+variables_float = ref([])
+
+# Int variables
+# @category Interaction
+variables_int = ref([])
+
+# Bool variables
+# @category Interaction
+variables_bool = ref([])
+
+# String variables
+# @category Interaction
+variables_string = ref([])
+
+# Unit variables: those are not references but handler functions
+# @category Interaction
+variables_unit = ref([])
+let interactive = ()
+let interactive.float = ()
+let interactive.int = ()
+let interactive.bool = ()
+let interactive.string = ()
+let interactive.unit = ()
+let interactive.error = error.register("interactive.error")
+
+# @flag hidden
+def interactive.list(_) =
+  l = variables()
+  l =
+    list.map(
+      fun (xv) ->
+        begin
+          let (x, v) = xv
+          "#{x} : #{v.type}"
+        end,
+      l
+    )
+
+  string.concat(separator="\n", l)
+end
+
+server.register(
+  usage="list",
+  description="List available interactive variables.",
+  namespace="var",
+  "list",
+  interactive.list
+)
+
+# Description of an interactive variable.
+# @flag hidden
+def interactive.description(name) =
+  list.assoc(name, variables()).description
+end
+
+# Type of an interactive variable.
+# @flag hidden
+def interactive.type(name) =
+  list.assoc(name, variables()).type
+end
+
+# @flag hidden
+def interactive.float.ref(name) =
+  list.assoc(name, variables_float()).ref
+end
+
+# @flag hidden
+def interactive.int.ref(name) =
+  list.assoc(name, variables_int()).ref
+end
+
+# @flag hidden
+def interactive.bool.ref(name) =
+  list.assoc(name, variables_bool()).ref
+end
+
+# @flag hidden
+def interactive.string.ref(name) =
+  list.assoc(name, variables_string()).ref
+end
+
+# @flag hidden
+def interactive.unit.handler(name) =
+  list.assoc(name, variables_unit()).handler
+end
+
+# @flag hidden
+def interactive.remove(name) =
+  variables := list.assoc.remove.all(name, variables())
+end
+
+# Remove an interactive variable.
+# @param name Name of the variable.
+# @category Interaction
+# @flag hidden
+def interactive.float.remove(name) =
+  interactive.remove(name)
+  variables_float := list.assoc.remove.all(name, variables_float())
+end
+
+# Remove an interactive variable.
+# @param name Name of the variable.
+# @category Interaction
+# @flag hidden
+def interactive.int.remove(name) =
+  interactive.remove(name)
+  variables_int := list.assoc.remove.all(name, variables_int())
+end
+
+# Remove an interactive variable.
+# @param name Name of the variable.
+# @category Interaction
+# @flag hidden
+def interactive.bool.remove(name) =
+  interactive.remove(name)
+  variables_bool := list.assoc.remove.all(name, variables_bool())
+end
+
+# Remove an interactive variable.
+# @param name Name of the variable.
+# @category Interaction
+# @flag hidden
+def interactive.string.remove(name) =
+  interactive.remove(name)
+  variables_string := list.assoc.remove.all(name, variables_string())
+end
+
+# Remove an interactive variable.
+# @param name Name of the variable.
+# @category Interaction
+# @flag hidden
+def interactive.unit.remove(name) =
+  interactive.remove(name)
+  variables_unit := list.assoc.remove.all(name, variables_unit())
+end
+
+# Function called to ensure persistency of data.
+# @category Interaction
+let interactive.persistency = ref(fun () -> ())
+
+# @flag hidden
+def interactive.float.set(name, v) =
+  interactive.float.ref(name) := v
+  p = interactive.persistency()
+  p()
+end
+
+# @flag hidden
+def interactive.int.set(name, v) =
+  interactive.int.ref(name) := v
+  p = interactive.persistency()
+  p()
+end
+
+# @flag hidden
+def interactive.bool.set(name, v) =
+  interactive.bool.ref(name) := v
+  p = interactive.persistency()
+  p()
+end
+
+# @flag hidden
+def interactive.string.set(name, v) =
+  interactive.string.ref(name) := v
+  p = interactive.persistency()
+  p()
+end
+
+# @flag hidden
+def interactive.unit.set(name) =
+  f = interactive.unit.handler(name)
+  f()
+end
+
+%ifdef osc.on_float
+let stdlib_osc = osc
+%endif
+
+# Create an interactive variable.
+# @flag hidden
+# @param ~name Name of the variable.
+# @param ~description Description of the variable.
+# @param ~osc OSC address for the variable.
+# @param ~type Type of the variable.
+def interactive.create(~name, ~description="", ~osc="", ~type) =
+  if
+    list.assoc.mem(name, variables())
+  then
+    error.raise(
+      interactive.error,
+      "variable already registered"
+    )
+  end
+
+  variables := (name, {type = type, description = description})::variables()
+  variables :=
+    list.sort(
+      fun (n, n') -> if fst(n) < fst(n') then -1 else 1 end,
+      variables()
+    )
+
+%ifdef osc.on_float
+  if
+    osc != ""
+  then
+    if
+      type == "float"
+    then
+      stdlib_osc.on_float(osc, fun (x) -> interactive.float.set(name, x))
+    elsif
+      type == "int"
+    then
+      stdlib_osc.on_int(osc, fun (x) -> interactive.int.set(name, x))
+    elsif
+      type == "bool"
+    then
+      stdlib_osc.on_bool(osc, fun (x) -> interactive.bool.set(name, x))
+    elsif
+      type == "string"
+    then
+      stdlib_osc.on_string(osc, fun (x) -> interactive.string.set(name, x))
+    elsif
+      type == "unit"
+    then
+      ()
+    else
+      # TODO
+      error.raise(error.not_found)
+    end
+  end
+%else
+  ignore(osc)
+%endif
+end
+
+# @flag hidden
+def interactive.get(name) =
+  try
+    t = interactive.type(name)
+    if
+      t == "float"
+    then
+      r = interactive.float.ref(name)
+      string.float(decimal_places=3, r())
+    elsif
+      t == "int"
+    then
+      r = interactive.int.ref(name)
+      string(r())
+    elsif
+      t == "bool"
+    then
+      r = interactive.bool.ref(name)
+      string(r())
+    elsif
+      t == "string"
+    then
+      r = interactive.string.ref(name)
+      r()
+    elsif
+      t == "unit"
+    then
+      "()"
+    else
+      error.raise(error.not_found)
+    end
+  catch _ do
+    "Variable not found."
+  end
+end
+
+server.register(
+  namespace="var",
+  description="Get the value of a variable.",
+  "get",
+  interactive.get
+)
+
+# @flag hidden
+def interactive.set(arg) =
+  try
+    arg = r/=/.split(arg)
+    name = string.trim(list.nth(arg, 0))
+    value = string.trim(list.nth(arg, 1))
+    t = interactive.type(name)
+    if
+      t == "float"
+    then
+      interactive.float.set(name, float_of_string(value))
+    elsif
+      t == "int"
+    then
+      interactive.int.set(name, int_of_string(value))
+    elsif
+      t == "bool"
+    then
+      interactive.bool.set(name, bool_of_string(value))
+    elsif
+      t == "string"
+    then
+      interactive.string.set(name, value)
+    elsif
+      t == "unit"
+    then
+      interactive.unit.set(name)
+    else
+      error.raise(error.not_found)
+    end
+
+    "Variable #{name} set."
+  catch _ do
+    "Syntax error or variable not found."
+  end
+end
+
+server.register(
+  usage="set <name> = <value>",
+  description="Set the value of a variable.",
+  namespace="var",
+  "set",
+  interactive.set
+)
+
+# Save the value of all interactive variables in a file.
+# @category Interaction
+# @flag extra
+# @param fname Name of the file.
+def interactive.save(fname) =
+  data =
+    json.stringify(
+      {
+        float =
+          list.map(
+            fun (nv) ->
+              begin
+                let (name, v) = nv
+                (name, v.ref())
+              end,
+            variables_float()
+          ),
+        int =
+          list.map(
+            fun (nv) ->
+              begin
+                let (name, v) = nv
+                (name, v.ref())
+              end,
+            variables_int()
+          ),
+        bool =
+          list.map(
+            fun (nv) ->
+              begin
+                let (name, v) = nv
+                (name, v.ref())
+              end,
+            variables_bool()
+          ),
+        string =
+          list.map(
+            fun (nv) ->
+              begin
+                let (name, v) = nv
+                (name, v.ref())
+              end,
+            variables_string()
+          )
+      }
+    )
+
+  file.write(data=data, fname)
+end
+
+# Load the value of interactive variables from a file.
+# @category Interaction
+# @flag extra
+# @param fname Name of the file.
+def interactive.load(fname) =
+  vars = file.contents(fname)
+  let json.parse (vars :
+    {
+      float: [(string * float)],
+      int: [(string * int)],
+      bool: [(string * bool)],
+      string: [(string * string)]
+    }
+  ) = vars
+
+  list.iter(
+    fun (nv) ->
+      try
+        interactive.float.set(fst(nv), snd(nv))
+      catch _ do
+        log.important(
+          label="interactive.load",
+          "Variable #{fst(nv)} not found."
+        )
+      end,
+    vars.float
+  )
+
+  list.iter(
+    fun (nv) ->
+      try
+        interactive.int.set(fst(nv), snd(nv))
+      catch _ do
+        log.important(
+          label="interactive.load",
+          "Variable #{fst(nv)} not found."
+        )
+      end,
+    vars.int
+  )
+
+  list.iter(
+    fun (nv) ->
+      try
+        interactive.bool.set(fst(nv), snd(nv))
+      catch _ do
+        log.important(
+          label="interactive.load",
+          "Variable #{fst(nv)} not found."
+        )
+      end,
+    vars.bool
+  )
+
+  list.iter(
+    fun (nv) ->
+      try
+        interactive.string.set(fst(nv), snd(nv))
+      catch _ do
+        log.important(
+          label="interactive.load",
+          "Variable #{fst(nv)} not found."
+        )
+      end,
+    vars.string
+  )
+end
+
+# Make the value of interactive variables persistent: they are loaded from the
+# given file and stored there whenever updated. This function should be called
+# after all interactive variables have been defined (variables not declared yet
+# will not be loaded).
+# @category Interaction
+# @flag extra
+# @param fname Name of the file.
+def interactive.persistent(fname) =
+  if
+    file.exists(fname)
+  then
+    interactive.load(fname)
+  else
+    interactive.save(fname)
+  end
+
+  interactive.persistency := {interactive.save(fname)}
+end
+
+# Expose interactive variables through harbor http server. Once this is called,
+# with default parameters, you can browse <http://localhost:8000/interactive> to
+# change the value of interactive variables using sliders.
+# @category Interaction
+# @flag extra
+# @param ~port Port of the server.
+# @param ~transport Http transport. Use `http.transport.ssl` or http.transport.secure_transport`, when available, to enable HTTPS output
+# @param ~uri URI of the server.
+def interactive.harbor(
+  ~transport=http.transport.unix,
+  ~port=8000,
+  ~uri="/interactive"
+) =
+  def webpage(request, response) =
+    form_data = request.data
+    data = ref("")
+
+    def add(s) =
+      data := data() ^ s ^ "\n"
+    end
+
+    title =
+      "Interactive values"
+    add(
+      "<!DOCTYPE html><html><head>"
+    )
+    add(
+      "<meta charset='utf-8'/>"
+    )
+    add("<title>#{title}</title>")
+    add(
+      "<style>
+    body {
+      font-family: sans-serif;
+    }
+    h1 {
+      text-align: center;
+    }
+    form {
+      border-radius: 20px;
+      display: block;
+      background-color: whitesmoke;
+      width: max-content;
+      margin: 0 auto;
+      padding: 2ex;
+      display:grid;
+      grid-template-columns: max-content max-content;
+      grid-gap: 5px;
+    }
+    label {
+      text-align: right;
+    }
+    input {
+      width: 300px;
+    }
+    </style>"
+    )
+
+    # TODO: we could send only the updated value instead of sending them all
+    add(
+      "<script>
+    function send() {
+      let interactive = document.getElementsByClassName('interactive');
+      let data = '';
+      for(var i=0; i<interactive.length; i++){
+        if (interactive[i].type == 'checkbox') {
+          if (interactive[i].checked) {
+            interactive[i].value = 'true'
+          } else {
+            interactive[i].value = 'false'
+          }
+        }
+        if (interactive[i].type != 'button') {
+          data = data.concat(interactive[i].name+'='+encodeURIComponent(interactive[i].value))+(i < interactive.length - 1 ? '&' : '')
+        }
+      }
+      console.log('Posting: ' + data);
+      let xmlHttp = new XMLHttpRequest();
+      xmlHttp.open('POST', '#{
+        uri
+      }');
+      xmlHttp.onreadystatechange = function () {
+        if(xmlHttp.readyState === XMLHttpRequest.DONE) {
+          var status = xmlHttp.status;
+          if (status === 0 || (status >= 200 && status < 400)) {
+            //console.log(xmlHttp.responseText);
+          } else {
+            console.log('Failed to send values.')
+          }
+        }
+      }
+      xmlHttp.send(data);
+    }
+    function sendUnit(name) {
+      const body = name + '=';
+      console.log('Posting: ' + body);
+      fetch('#{
+        uri
+      }', {method: 'POST', body: body});
+    }
+    </script>"
+    )
+
+    add("</head><body>")
+    add("<h1>#{title}</h1>")
+
+    def add_var((name, v)) =
+      description = interactive.description(name)
+      description =
+        if
+          description == ""
+        then
+          name
+        else
+          "#{description} (#{name})"
+        end
+
+      add(
+        "<label for=#{name}>#{string.escape.html(description)}</label>"
+      )
+      common =
+        "id='#{name}' name='#{name}' class='interactive' onchange=\"send()\""
+
+      if
+        v.type == "float"
+      then
+        v = list.assoc(name, variables_float())
+        value = http.string_of_float(v.ref())
+        if
+          v.min == 0. - infinity or v.max == infinity
+        then
+          add(
+            "<input type='number' #{common} step='#{v.step}' value='#{value}'>"
+          )
+        else
+          min = http.string_of_float(v.min)
+          max = http.string_of_float(v.max)
+          step = http.string_of_float(v.step)
+          value = http.string_of_float(v.ref())
+          unit =
+            if
+              v.unit == ""
+            then
+              ""
+            else
+              " " ^
+                v.unit
+            end
+          add(
+            "<div><input type='range' #{common} min='#{min}' max='#{max}' step='#{
+              step
+            }' value='#{value}' oninput='document.getElementById(\"#{
+              name
+            }-value\").innerHTML = this.value+\"#{unit}\"'><text id='#{
+              name
+            }-value' style='inline'>#{value}#{unit}</text></div>"
+          )
+        end
+      elsif
+        v.type == "int"
+      then
+        v = list.assoc(name, variables_int())
+        value = string(v.ref())
+        add(
+          "<input type='number' #{common} step='1' value='#{value}'>"
+        )
+      elsif
+        v.type == "bool"
+      then
+        v = list.assoc(name, variables_bool())
+        c = (v.ref()) ? "checked" : ""
+        add(
+          "<input type='checkbox' #{common} value='true' #{c}>"
+        )
+      elsif
+        v.type == "string"
+      then
+        v = list.assoc(name, variables_string())
+        add(
+          "<input type='text' #{common} value='#{string.escape.html(v.ref())}'>"
+        )
+      elsif
+        v.type == "unit"
+      then
+        add(
+          "<button type='button' #{common} onclick=\"sendUnit('#{name}')\">#{
+            name
+          }</button>"
+        )
+      else
+        ()
+      end
+    end
+
+    add("<form>")
+    list.iter(add_var, variables())
+    add("</form>")
+    add("</body>")
+    response.html(data())
+  end
+
+  harbor.http.register(
+    transport=transport,
+    port=port,
+    method="GET",
+    uri,
+    webpage
+  )
+
+  def setter(request, _) =
+    data = url.split_args(request.body())
+
+    def update((name, v)) =
+      try
+        t = interactive.type(name)
+        if
+          t == "float"
+        then
+          interactive.float.set(name, float_of_string(v))
+        elsif
+          t == "int"
+        then
+          interactive.int.set(name, int_of_string(v))
+        elsif
+          t == "bool"
+        then
+          interactive.bool.set(name, bool_of_string(v))
+        elsif
+          t == "string"
+        then
+          interactive.string.set(name, v)
+        elsif
+          t == "unit"
+        then
+          interactive.unit.set(name)
+        end
+      catch e do
+        log.important(
+          label="interactive.harbor",
+          "Could not update variable #{name} (#{e.kind}: #{e.message})."
+        )
+      end
+    end
+
+    list.iter(update, data)
+  end
+
+  harbor.http.register(
+    transport=transport,
+    port=port,
+    method="POST",
+    uri,
+    setter
+  )
+
+  log.important(
+    label="interactive.harbor",
+    "Website should be ready at <http://localhost:#{port}#{uri}>."
+  )
+end
+
+# Read a float from an interactive input.
+# @category Interaction
+# @flag extra
+# @param ~min Minimal value.
+# @param ~max Maximal value.
+# @param ~step Typical variation of the value.
+# @param ~description Description of the variable.
+# @param ~unit Unit for the variable.
+# @param ~osc OSC address.
+# @param name Name of the variable.
+# @param v Initial value.
+def replaces interactive.float(
+  ~min=0. - infinity,
+  ~max=infinity,
+  ~step=0.1,
+  ~description="",
+  ~unit="",
+  ~osc="",
+  name,
+  v
+) =
+  interactive.create(name=name, description=description, osc=osc, type="float")
+  r = ref(v)
+  variables_float :=
+    (
+      name,
+      {ref = r, unit = unit, min = min, max = max, step = step}
+    )::variables_float()
+
+  r.{
+    set = fun (x) -> interactive.float.set(name, x),
+    remove = {interactive.float.remove(name)}
+  }
+end
+
+# Read an integer from an interactive input.
+# @category Interaction
+# @flag extra
+# @param ~description Description of the variable.
+# @param ~osc OSC address.
+# @param name Name of the variable.
+# @param v Initial value.
+def replaces interactive.int(~description="", ~osc="", name, v) =
+  interactive.create(name=name, description=description, osc=osc, type="int")
+  r = ref(v)
+  variables_int := (name, {ref = r})::variables_int()
+  r.{
+    set = fun (x) -> interactive.int.set(name, x),
+    remove = {interactive.int.remove(name)}
+  }
+end
+
+# Read a boolean from an interactive input.
+# @category Interaction
+# @flag extra
+# @param ~description Description of the variable.
+# @param ~osc OSC address.
+# @param name Name of the variable.
+# @param v Initial value.
+def replaces interactive.bool(~description="", ~osc="", name, v) =
+  interactive.create(name=name, description=description, osc=osc, type="bool")
+  r = ref(v)
+  variables_bool := (name, {ref = r})::variables_bool()
+  r.{
+    set = fun (x) -> interactive.bool.set(name, x),
+    remove = {interactive.bool.remove(name)}
+  }
+end
+
+# Read a string from an interactive input.
+# @category Interaction
+# @flag extra
+# @param ~description Description of the variable.
+# @param ~osc OSC address.
+# @param name Name of the variable.
+# @param v Initial value.
+def replaces interactive.string(~description="", ~osc="", name, v) =
+  interactive.create(name=name, description=description, osc=osc, type="string")
+  r = ref(v)
+  variables_string := (name, {ref = r})::variables_string()
+  r.{
+    set = fun (x) -> interactive.string.set(name, x),
+    remove = {interactive.string.remove(name)}
+  }
+end
+
+# Register a callback when a unit interactive input is set.
+# @category Interaction
+# @flag extra
+# @param ~description Description of the variable.
+# @param ~osc OSC address.
+# @param name Name of the variable.
+# @param f Function triggered when the value is set.
+def replaces interactive.unit(~description="", ~osc="", name, f) =
+  interactive.create(name=name, description=description, osc=osc, type="unit")
+  variables_unit := (name, {handler = f})::variables_unit()
+  {set = f, remove = {interactive.float.remove(name)}}
+end
+
+# Create a multiband compressor whose parameters are interactive variables.
+# @category Interaction
+# @flag extra
+# @param ~id Id of the source. Variable names are prefixed with this.
+# @param ~bands Number of bands.
+# @param s Source to compress.
+def compress.multiband.interactive(~id=null, ~bands=5, s) =
+  id = string.id.default(default="compress.multiband.interactive", id)
+  prefix = id ^ "_"
+  wet = interactive.float(prefix ^ "wet", min=0., max=1., 1.)
+  min_freq = 100.
+  max_freq = 15000.
+
+  def band(i) =
+    frequency =
+      exp(
+        (ln(max_freq) - ln(min_freq)) * float_of_int(i) /
+          float_of_int(bands - 1) +
+          ln(min_freq)
+      )
+
+    log.important(
+      label=id,
+      "Adding a band at #{frequency} Hz."
+    )
+    frequency =
+      interactive.float(
+        "#{prefix}frequency#{i}",
+        unit="Hz",
+        min=0.,
+        max=20000.,
+        step=10.,
+        frequency
+      )
+
+    attack =
+      interactive.float(
+        "#{prefix}attack#{i}",
+        unit="ms",
+        min=0.,
+        max=1000.,
+        step=10.,
+        100.
+      )
+
+    release =
+      interactive.float(
+        "#{prefix}release#{i}",
+        unit="ms",
+        min=0.,
+        max=1000.,
+        step=10.,
+        200.
+      )
+
+    threshold =
+      interactive.float(
+        "#{prefix}threshold#{i}",
+        unit="dB",
+        min=-20.,
+        max=0.,
+        step=0.1,
+        -10.
+      )
+
+    ratio =
+      interactive.float("#{prefix}ratio#{i}", min=1., max=10., step=0.1, 4.)
+
+    gain =
+      interactive.float(
+        "#{prefix}gain#{i}",
+        unit="dB",
+        min=0.,
+        max=30.,
+        step=0.1,
+        3.
+      )
+
+    {
+      frequency = frequency,
+      attack = attack,
+      release = release,
+      threshold = threshold,
+      ratio = ratio,
+      gain = gain
+    }
+  end
+
+  l = list.init(bands, band)
+  compress.multiband(wet=wet, s, l)
+end