Synthesizer.LLVM.Storable.Signal

Functions on lazy storable vectors that are implemented using LLVM.

Documentation

unpackStrict :: (Storable a, IsPrimitive a, IsPowerOf2 n) => Vector (Vector n a) -> Vector a

This function needs only constant time in contrast to Synthesizer.LLVM.Parameterized.SignalPacked.unpack.

We cannot provide a pack function since the array size may not line up. It would also need copying since the source data may not be aligned properly.

unpack :: (Storable a, IsPrimitive a, IsPowerOf2 n) => Vector (Vector n a) -> Vector a

makeUnpackGenericStrict :: (Access n va vv, Storable a, MakeValueTuple a va, Memory va as, IsSized as asize, Storable v, MakeValueTuple v vv, Memory vv vs, IsSized vs vsize) => IO (Vector v -> Vector a)

This is similar to unpackStrict but performs rearrangement of data. This is for instance necessary for stereo signals where the data layout of packed and unpacked data is different, thus simple casting of the data is not possible.

makeUnpackGeneric :: (Access n va vv, Storable a, MakeValueTuple a va, Memory va as, IsSized as asize, Storable v, MakeValueTuple v vv, Memory vv vs, IsSized vs vsize) => IO (Vector v -> Vector a)

makeReversePackedStrict :: (Storable v, Access n va vv, MakeValueTuple v vv, Memory vv vs, IsSized vs vsize) => IO (Vector v -> Vector v)

makeReversePacked :: (Storable v, Access n va vv, MakeValueTuple v vv, Memory vv vs, IsSized vs vsize) => IO (Vector v -> Vector v)

continue :: Storable a => Vector a -> (a -> Vector a) -> Vector a

Append two signals where the second signal gets the last value of the first signal as parameter. If the first signal is empty then there is no parameter for the second signal and thus we simply return an empty signal in that case.

continuePacked :: (IsPowerOf2 n, Storable a, IsPrimitive a) => Vector (Vector n a) -> (a -> Vector (Vector n a)) -> Vector (Vector n a)

continuePackedGeneric :: (Storable v, Storable a) => (Vector v -> Vector a) -> Vector v -> (a -> Vector v) -> Vector v

Use this like

 do unpackGeneric <- makeUnpackGenericStrict
    return (continuePackedGeneric unpackGeneric x y)

makeMixer :: (Storable a, Additive value, MakeValueTuple a value, Memory value struct) => value -> IO (Word32 -> Ptr a -> Ptr a -> IO ())

makeArranger :: (Storable a, Additive value, MakeValueTuple a value, Memory value struct) => IO (ChunkSize -> T Int (Vector a) -> Vector a)

arrange

Arguments

:: (Storable a, Additive value, MakeValueTuple a value, Memory value struct)

=> ChunkSize

-> T Int (Vector a)

A list of pairs: (relative start time, signal part), The start time is relative to the start time of the previous event.

-> Vector a

The mixed signal.

This is unsafe since it relies on the prior initialization of the LLVM JIT. Better use makeArranger.