| Age | Commit message (Collapse) | Author | Files | Lines |
|---|
|
This also replaces Github workflows with .fmsbw CI scripts.
|
|
* Docker turned out to be impractical since you cannot connect a dockerized Jack client
to a Jack server on the host as library versions would have to match exactly.
Neither did I get Netjack to run in Docker.
Also when running in Docker, it would be tricky to get gnuplot to work (and Tcl/Tk support in the future).
Especially the Jupyter notebook packaging would have been a lot easier, though with Docker.
* AppImage will automatically avoid bundling libjack and require a compatible libjack on the host instead.
* Using pkg2appimage ensures we can pull in dependencies as Debian packages.
* This version of AppImage.yml does not contain Jupyter notebooks.
|
|
* this is unreliable but should be tested on the build server as well
* drops the lua-discount dependency
* updated TODO
|
|
* This allows the native syntax `for f in Stream:iter() do ... end` without using lambda
functions.
Also you can use `break` and `return` statements.
* On the other hand we cannot exploit the extended xpcall() semantics and had to introduce
another lambda in Stream:play().
* In general the number of function calls per tick stays the same.
Stream:gtick() itself could be used as an iterator, but Stream:iter() adds checking for CTRL+C,
resetting of the sample cache and binding functions.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
* Just like the original LuaJIT interpreter, this will use a hook to automatically
raise an error from Lua code.
* Unfortunately, as long as Jit compilation is enabled, this cannot reliably work.
Therefore we still set an `interrupted` flag that must be
polled from tight loops.
* Instead of polling via applause_push_sample() which gave interruption-support only
to Stream:play(), we now have a separate checkint() function.
* checkint() should be manually added to all tight loops.
* Stream:foreach() and everthing based on it is now also supporting interruptions
(via checkint()).
* This internally works via applause_is_interrupted().
A C function was exposed only because LuaJIT does not support volatile-qualifiers and
would optimize away reads to the interrupted-flag.
As a side effect, we can also reset the hook.
* Flags set in signal handlers should be `volatile`.
* Added likely() and unlikely() macros to C code.
* Updated sample.ipynb Jupyter notebook: Everything important is now supported, albeit
requiring custom ILua patches.
|
|
display graphics and rich text
|
|
* This is at the very least cool to have and will be worthwile to write about in the dissertation.
* Added ilua-wrapper.sh script which can be used as the ILua interpreter and/or can be symlinked to `lua` in PATH,
so ILua will pick up Applause even in Notebooks without any additional tweaks.
|
|
Stream:ccscale()
* Stream:CC14() allows reading 14-bit CCs (split over two 7-bit MIDI messages).
It's actually capable to handle regular 7-bit controllers just fine.
The question is whether we still need a distinction between Stream:CC() and Stream:CC14().
Stream:CC14() has a slight overhead, but only when actually receiving MIDI messages.
* Stream:CC14() and Stream:CC() output values normalized to [-1,+1] now.
We actually never made use of raw CC values and the scaling can be done only once whenever
a matching MIDI message is received, so the runtime overhead is irrelevant.
* This means we could also get rid of Stream:ccscale() now.
Just use Stream:scale() from nowon.
* Use Stream:scan() now whenever relying on previous values.
That way, you can often avoid having to keep an accumulator variable in the closure.
|
|
* in particular: SndfileStream(...):sub(...) for multi-channel audio files.
* The fix is more of a workaround just like the initial skipping of samples by sub()
is a workaround.
I couldn't yet think of a way how to seek in streams elegantly.
|
|
|
|
* gives a useful overview of everything supported right now
* especially the type documentation is useful, as these things are not self-evident in Lua (because of dynamic typing).
* The LDoc page can later be published as the Github pages of the project.
This can even be done automatically by a Github action.
However, we should first make sure that it's okay to publish the project before defending the thesis since
Github pages will always be public even for private repositories.
* Documentation of command-line parameters is lacking (TODO).
* It may be possible to use types like "Stream(number)" to describe streams of numbers.
The LDoc documentation mentions boxed types.
Perhaps there can even be Streamable(number)?
* We are also lacking good example programs and/or introductory material.
|
|
|
