A stream of blocks of interleaved samples.

There is an invariant that the length of the vector should always be a multiple of channels, in other words that a block is an integral number of frames. The blocks may be of variable size, but should default to blockSize, and align to multiples of blockSize, to minimize re-chunking when synchronizing streams.

Non-interleaved audio stream. Ok so it's still interleaved, just per block instead of per sample.

Each of the lists will be channels length. Each Sample vector will be the same length until the signal runs out, at which point it may be short, and then will be empty. The stream ends when all signals are empty.

The same block length guidelines as in Audio also apply.

Unlike Audio, the channel count is dynamic, not static. This is because I use NAudio to stream a variably sized collection of control signals, while I use Audio to represent audio signals, which generally have a global number of channels determined by how many speakers you have. But it does mean that you have to be careful that the length of each blocks list always matches _nchannels. TODO it should be possible to use an existentially quantified type natural and length indexed list to ensure this, but not sure if it's worth it.

This is an Audio with dynamic rate and channels.

There is a special representation for a constant block. 0 blocks are common when aligning sounds, and constant ones are common for control signals.

I hardcode the sample format to Float for now, since I have no need to work with any other format.

Should be >=0.

Sample count. This is Frames * channels.

Construct audio manually for testing. The length of each vector should be a multiple of the channels, or this will crash.

Set linear gain. Use dbToLinear to scale by dB.

Multiply two signals, and end with the shorter one.

This is like take, but it takes a close action to run when the audio stream is terminated. This is because streaming can't otherwise close the input file in a timely way, because the take can't tell upstream that it will never demand another chunk. This appears to be a problem with all pull-based streaming libraries, including pipes and conduit.

Pan a stereo signal with a mono one. The pan signal goes from -1 to 1.

TODO This is linear panning, try constant power or -4.5dB: http://www.cs.cmu.edu/~music/icm-online/readings/panlaws/

Like pan, but more efficient. TODO also linear pan, as in pan.

Mix together the audio streams at the given start times.

TODO the input could also be a stream, in case it somehow comes from IO.

Add vectors of samples. The output will be the max of the longest vector and the provided minimum length.

Extract a single channel. It will crash unless 0 <= idx < chan.

See splitChannels to get them all.

De-interleave the audio. This is the inverse of splitChannels, but it converts to NAudio, since [Audio] would amount to an unzip, which streams don't support in a straightforward way.

Take a single channel signal to multiple channels by copying samples.

This could be generalized to expand n to m where m is divisible by n, but that's more complicated and I don't need it.

Do the reverse of expandChannels, mixing all channels to a mono signal.

Merge Audios into a single NAudio stream, synchronized with the given block size.

Convert a non-interleaved NAudio with an unknown number of channels to an interleaved one with a known number. This is the inverse of nonInterleaved.

This is limited to only work when the channels are equal, or the NAudio has 1 channel, in which case it acts like expandChannels. Similar to expandChannels, I could generalize it, but I don't need that now.

Extend blocks shorter than the given size with zeros, and pad the end with zeros forever. Composed with nonInterleaved, which may leave a short final block, the output should be infinite and have uniform block size.

Silence. Forever.

Generate a test tone at the given frequency, forever. This is not efficient, but it's just for testing.

Generate a piecewise linear signal from breakpoints. The signal will continue forever with the last value.

TODO take blockSize and start args so a subsequent synchronization doesn't have to reallocate.

Prepend an effect to the stream, useful to log when a stream is started.

Insert an assertion into the audio stream.

Take >= the given number of frames. It may take more if the size doesn't line up on a block boundary.

TODO rename to splitAtGE

Take exactly the given number of frames.

Nothing if the Audio stream is completed. Otherwise, it returns the same stream but with the first chunk evaluated, to avoid duplicating effects.