Synthesizer.MIDI.EventList

Documentation

type StrictTime = Integer

type LazyTime = T Integer

event filters

type Filter event = State (T StrictTime [event])

getSlice :: (event -> Maybe a) -> Filter event (T StrictTime [a])

We turn the strict time values into lazy ones according to the breaks by our beat. However for the laziness breaks we ignore the events that are filtered out. That is we loose laziness granularity but hopefully gain efficiency by larger blocks.

type Channel = Channel

type Controller = Controller

type Pitch = Pitch

type Velocity = Velocity

type Program = Program

getControllerEvents :: C event => Channel -> Controller -> Filter event (T StrictTime [Int])

data NoteBoundary a

Constructors

NoteBoundary Pitch Velocity a

AllNotesOff

Instances

Eq a => Eq (NoteBoundary a)

Show a => Show (NoteBoundary a)

data Note

Constructors

Note Program Pitch Velocity LazyTime

Instances

Eq Note

Show Note

case_ :: Maybe a -> (a -> b) -> Maybe b

getNoteEvents :: C event => Channel -> Filter event (T StrictTime [Either Program (NoteBoundary Bool)])

checkNoteEvent :: C event => Channel -> event -> Maybe (Either Program (NoteBoundary Bool))

embedPrograms :: Program -> T StrictTime [Either Program (NoteBoundary Bool)] -> T StrictTime [NoteBoundary (Maybe Program)]

embedProgramState :: Either Program (NoteBoundary Bool) -> State Program (Maybe (NoteBoundary (Maybe Program)))

matchNoteEvents :: T StrictTime [NoteBoundary (Maybe Program)] -> T StrictTime [Note]

matchNoteEventsCore :: (noteBnd -> Maybe (noteBnd -> Bool, LazyTime -> Note)) -> T StrictTime [noteBnd] -> T StrictTime [Note]

durationRemove :: C time => (body -> Bool) -> T time [body] -> (T time, T time [body])

Search for specific event, return its time stamp and remove it.

durationRemoveTB :: C time => (body -> Bool) -> T time [body] -> (T time, T time [body])

makeInstrumentArray :: [instr] -> Array Program instr

getInstrumentFromArray :: Array Program instr -> Program -> Program -> instr