module Synthesizer.LLVM.ALSA.MIDI (
module Synthesizer.LLVM.ALSA.MIDI,
Gen.applyModulation,
PC.BendModulation(PC.BendModulation),
) where
import Synthesizer.EventList.ALSA.MIDI
(Program, Channel, Filter, Note,
)
import qualified Synthesizer.Generic.ALSA.MIDI as Gen
import qualified Synthesizer.PiecewiseConstant.ALSA.MIDI as PC
import Synthesizer.LLVM.ALSA.BendModulation ()
import Synthesizer.LLVM.CausalParameterized.Process (($>), )
import qualified Synthesizer.LLVM.Parameterized.SignalPacked as SigPS
import qualified Synthesizer.LLVM.CausalParameterized.Process as CausalP
import qualified Synthesizer.LLVM.Parameterized.Signal as SigP
import qualified Synthesizer.LLVM.Storable.Signal as SigStL
import qualified Synthesizer.LLVM.Parameter as Param
import qualified Synthesizer.LLVM.Wave as Wave
import qualified Synthesizer.LLVM.Sample as Sample
import qualified LLVM.Extra.ScalarOrVector as SoV
import qualified LLVM.Extra.Vector as Vector
import qualified LLVM.Extra.Representation as Rep
import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Core as LLVM
import qualified Data.TypeLevel.Num as TypeNum
import qualified Synthesizer.Generic.Cut as CutG
import qualified Synthesizer.Storable.Signal as SigSt
import qualified Data.StorableVector.Lazy as SVL
import Foreign.Storable (Storable, )
import qualified Algebra.Transcendental as Trans
import qualified Algebra.RealField as RealField
import qualified Algebra.Ring as Ring
import qualified Algebra.Additive as Additive
import Control.Arrow (second, (<<<), (<<^), )
import Control.Monad ( liftM2, )
import NumericPrelude.Numeric
import Prelude ()
frequencyFromBendModulation ::
(Ring.C a, LLVM.IsConst a,
Ring.C y, Additive.C y, LLVM.IsConst y, LLVM.IsSized y size,
Storable y, LLVM.MakeValueTuple y (LLVM.Value y),
SoV.Fraction y, SoV.Replicate a y) =>
Param.T p y ->
CausalP.T p (PC.BendModulation (LLVM.Value y)) (LLVM.Value y)
frequencyFromBendModulation speed =
CausalP.envelope
<<<
second
(CausalP.mapSimple (A.add (SoV.replicateOf 1)) <<< CausalP.envelope
$> SigP.osciSimple Wave.approxSine2 zero speed)
<<^
(\(PC.BendModulation b m) -> (b,m))
frequencyFromBendModulationPacked ::
(RealField.C a, LLVM.IsConst a, LLVM.IsFloating a,
Storable a, LLVM.MakeValueTuple a (LLVM.Value a), LLVM.IsSized a size,
Vector.Real a, SoV.Replicate a (LLVM.Vector n a), LLVM.IsPowerOf2 n,
TypeNum.Mul n size vsize, TypeNum.Pos vsize) =>
Param.T p a ->
CausalP.T p
(PC.BendModulation (LLVM.Value a))
(LLVM.Value (LLVM.Vector n a))
frequencyFromBendModulationPacked speed =
CausalP.envelope
<<<
second
(CausalP.mapSimple (A.add (SoV.replicateOf 1)) <<< CausalP.envelope
$> SigPS.osciSimple Wave.approxSine2 zero speed)
<<<
CausalP.mapSimple
(\(PC.BendModulation b m) ->
liftM2 (,) (SoV.replicate b) (SoV.replicate m))
type Instrument y yv = Gen.Instrument y (SigSt.T yv)
type Bank y yv = Gen.Bank y (SigSt.T yv)
sequenceCore ::
(Storable yv, Sample.Additive value,
LLVM.MakeValueTuple yv value, Rep.Memory value struct) =>
SigSt.ChunkSize ->
Channel ->
Program ->
Gen.Modulator Note (SigSt.T yv) ->
Filter (SigSt.T yv)
sequenceCore chunkSize =
Gen.sequenceCore (SigStL.arrange chunkSize)
sequence ::
(Storable yv, Trans.C y, Sample.Additive value,
LLVM.MakeValueTuple yv value, Rep.Memory value struct) =>
SigSt.ChunkSize ->
Channel ->
Instrument y yv ->
Filter (SigSt.T yv)
sequence chunkSize =
Gen.sequence (SigStL.arrange chunkSize)
sequenceModulated ::
(CutG.Transform ctrl, CutG.NormalForm ctrl,
Storable yv, Trans.C y, Sample.Additive value,
LLVM.MakeValueTuple yv value, Rep.Memory value struct) =>
SigSt.ChunkSize ->
ctrl ->
Channel ->
(ctrl -> Instrument y yv) ->
Filter (SigSt.T yv)
sequenceModulated chunkSize =
Gen.sequenceModulated (SigStL.arrange chunkSize)
sequenceMultiModulated ::
(Storable yv, Trans.C y, Sample.Additive value,
LLVM.MakeValueTuple yv value, Rep.Memory value struct) =>
SigSt.ChunkSize ->
Channel ->
instrument ->
Gen.Modulator (instrument, Note) (Instrument y yv, Note) ->
Filter (SigSt.T yv)
sequenceMultiModulated chunkSize =
Gen.sequenceMultiModulated (SigStL.arrange chunkSize)
sequenceMultiProgram ::
(Storable yv, Trans.C y, Sample.Additive value,
LLVM.MakeValueTuple yv value, Rep.Memory value struct) =>
SigSt.ChunkSize ->
Channel ->
Program ->
[Instrument y yv] ->
Filter (SigSt.T yv)
sequenceMultiProgram chunkSize =
Gen.sequenceMultiProgram (SigStL.arrange chunkSize)
sequenceModulatedMultiProgram ::
(CutG.Transform ctrl, CutG.NormalForm ctrl,
Storable yv, Trans.C y, Sample.Additive value,
LLVM.MakeValueTuple yv value, Rep.Memory value struct) =>
SigSt.ChunkSize ->
ctrl ->
Channel ->
Program ->
[ctrl -> Instrument y yv] ->
Filter (SigSt.T yv)
sequenceModulatedMultiProgram chunkSize =
Gen.sequenceModulatedMultiProgram (SigStL.arrange chunkSize)