aboutsummaryrefslogtreecommitdiffhomepage
path: root/applause.lua
AgeCommit message (Collapse)AuthorFilesLines
2016-01-03fixed optimizations for multiple consecutive arithmetic operatorsRobin Haberkorn1-18/+16
* we have to make sure that exactly the same function values are used
2016-01-03SyncedStream optimization: Allow streams to be reused within one stream ↵Robin Haberkorn1-59/+121
graph without recomputation * Since it comes with an overhead, it has to be enabled by constructing a SyncedStream or calling Stream:sync() * Reusing samples works by sharing generator functions and caching samples until a clock signal changes. The clock signal is currently a global variable "clock_signal" that oscillates between true and false. * This means that all sample generating methods like :play() or :totable() will have to advance the clock using the global clockCycle() function. It is a global function, so it can be invoked more or less efficiently by the :play() implementation (currently using the old-school Lua/C API). These restrictions might fall when using the LuaJIT way of interacting with native code. * Since playback must begin from the beginning for every :play(), an explicit reset() mechanism has been introduced which can usually be ignored in Stream implementations. It does however allow SyncedStream to reset the generator closure. * SndfileStream has been simplified since now it is possible to keep the file handle open. However as long as Stream synchronization is not automatic, SndfileStreams must be explicitly synced when using one stream multiple times. * Syncing is thought to be performed automatically by an optimizer when one object is used more than once e.g. in a :play() call. * Non-synced streams are currently slightly slower than before this commit, probably because of the additional clockCycle() call.
2016-01-03preliminary (broken) client forking supportRobin Haberkorn1-1/+33
2015-12-31support only LuaJIT and use some additional (insignificant) optimizationsRobin Haberkorn1-2/+2
2015-12-31fixed potential segfaults in MIDI processing & 1-based channelsRobin Haberkorn1-6/+10
* there are at most 128 different MIDI notes; mtof() will now also work for all of them * channels have origin 1 now in the public APIs. This is what most applications seem to use, so in order to avoid confusion it's probably a good idea to use it as well.
2015-12-31implemented basic support for MIDI NOTE ON/OFF eventsRobin Haberkorn1-2/+92
* MIDIVelocityStream will report the velocities on a particular note. This can be used to build polyphonic instruments. * MIDINoteStream will report all possible notes on a particular channel. The velocity of the note last triggered is also encoded into the stream values. This can be used to build simple monophonic instruments. * Map bit methods to stream methods, e.g. Stream:band() Is especially useful for streams that encode multiple values into single integers for performance reasons. * mtof() and ftom() methods for converting from and to MIDI note numbers. mtof() is very efficient since its values are all precalculated in a lookup table. * fixed tostring() method for streams smaller than 1024 samples
2015-11-04added simple support for MIDI CC commandsRobin Haberkorn1-0/+21
* MIDICCStream provides a stream of CC values as if polled from the controller (this is emulated in applause.c)
2015-11-03fixed ZipStream for non-stream operands (like numbers)Robin Haberkorn1-1/+2
2015-05-03changed semantics of the __call metamethod: create VectorStreamRobin Haberkorn1-18/+25
* the call metamethod is most useful in compositions in order to evaluate a stream to save computing power at runtime. * this meant that in addition to adding () to a stream expression it was necessary to convert the table to a stream (e.g. using tostream()). * Now the totable() method converts to a pure table, while __call returns a VectorStream. This means it will be sufficient to add "()" in order to evaluate a stream eagerly
2015-04-30added Stream.save() and SndfileStream based on FFI wrapper around libsndfileRobin Haberkorn1-0/+56
2015-04-30use LuaJIT's FFI instead of lposix library for clock_gettime()Robin Haberkorn1-5/+33
2015-04-30added RavelStream and minor changes to make streams of non-numbers possibleRobin Haberkorn1-5/+68
2015-04-28optimizations, scalar operations and ZipStream as an abstraction of stream ↵Robin Haberkorn1-138/+211
operations
2015-04-20resample() and toplot() methodsRobin Haberkorn1-0/+49
2015-04-20added bit-crusher effectRobin Haberkorn1-0/+6
2015-04-20filters: handle input streams shorter than the frequency streamRobin Haberkorn1-18/+24
2015-04-20filtering: handle frequency streams short than the input streamRobin Haberkorn1-4/+16
2015-04-20added filter streams adapted from ChucK and revised wave form functionsRobin Haberkorn1-19/+373
* LPF, HPF, BPF, BRF filters are 2nd order Butterworth filters. Derived verbatim from ChucK's implementation. This can probably be optimized by caching the tan/cos functions. Also, they do not yet handle frequency streams shorter than the stream to filter. * Basic wave forms are now Stream methods to allow concatenative style of FM synthesis (or LFOs). To generate e.g. a sine wave with constant frequency, you can still write Stream.SinOsc(440); or tostream(440):SinOsc()
2015-04-11added custom interactive Lua interpreter for evaluating applause expressionsRobin Haberkorn1-1/+1
* implements Stream:play() using Jack as the audio backend
2015-04-09additional useful stream operationsRobin Haberkorn1-13/+54
2015-04-07replaced co-routine based implementation with closuresRobin Haberkorn1-72/+153
* this improves performance by 10 times (both lua5.1 and luajit) * also, when using luajit, there appears to be little peformance loss when using stream compositions instead of maps (which are sometimes even slower!?)
2015-04-07initial commit based on coroutinesRobin Haberkorn1-0/+462