Safe Haskell	Safe
Language	Haskell2010

Sound.MIDI.Message.Channel

Description

Channel messages

Synopsis

Documentation

data T #

Constructors

Cons
Fields messageChannel :: Channel messageBody :: Body

Instances

Eq T #
Methods (==) :: T -> T -> Bool # (/=) :: T -> T -> Bool #
Ord T #
Methods compare :: T -> T -> Ordering # (<) :: T -> T -> Bool # (<=) :: T -> T -> Bool # (>) :: T -> T -> Bool # (>=) :: T -> T -> Bool # max :: T -> T -> T # min :: T -> T -> T #
Show T #
Methods showsPrec :: Int -> T -> ShowS # show :: T -> String # showList :: [T] -> ShowS #
Arbitrary T #
Methods arbitrary :: Gen T # shrink :: T -> [T] #
C T #
Methods note :: T -> Maybe (Channel, (Velocity, Pitch, Bool)) # program :: T -> Maybe (Channel, Program) # anyController :: T -> Maybe (Channel, (Controller, Int)) # pitchBend :: T -> Maybe (Channel, Int) # channelPressure :: T -> Maybe (Channel, Int) # mode :: T -> Maybe (Channel, T) #
C T #
Methods note :: Channel -> (Velocity, Pitch, Bool) -> T # program :: Channel -> Program -> T # anyController :: Channel -> (Controller, Int) -> T # pitchBend :: Channel -> Int -> T # channelPressure :: Channel -> Int -> T # mode :: Channel -> T -> T #
C T #
Methods note :: Channel -> T -> Maybe (Velocity, Pitch, Bool) # program :: Channel -> T -> Maybe Program # anyController :: Channel -> T -> Maybe (Controller, Int) # pitchBend :: Channel -> T -> Maybe Int # channelPressure :: Channel -> T -> Maybe Int # mode :: Channel -> T -> Maybe T #

data Body #

Constructors

Voice T
Mode T

Instances

Eq Body #
Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Ord Body #
Methods compare :: Body -> Body -> Ordering # (<) :: Body -> Body -> Bool # (<=) :: Body -> Body -> Bool # (>) :: Body -> Body -> Bool # (>=) :: Body -> Body -> Bool # max :: Body -> Body -> Body # min :: Body -> Body -> Body #
Show Body #
Methods showsPrec :: Int -> Body -> ShowS # show :: Body -> String # showList :: [Body] -> ShowS #

get :: C parser => Int -> Channel -> Int -> Fragile parser T #

Parse a MIDI Channel message. Note that since getting the first byte is a little complex (there are issues with running status), the code, channel and first data byte must be determined by the caller.

getWithStatus :: C parser => Int -> Fragile (T parser) T #

Parse an event. Note that in the case of a regular MIDI Event, the tag is the status, and we read the first byte of data before we call get. In the case of a MIDIEvent with running status, we find out the status from the parser (it's been nice enough to keep track of it for us), and the tag that we've already gotten is the first byte of data.

put :: C writer => T -> writer #

putWithStatus :: (Compression compress, C writer) => T -> T compress writer #

data Channel #

This definition should be in Message.Channel, but this results in a cyclic import.

Instances

Bounded Channel #
Methods minBound :: Channel # maxBound :: Channel #
Enum Channel #
Methods succ :: Channel -> Channel # pred :: Channel -> Channel # toEnum :: Int -> Channel # fromEnum :: Channel -> Int # enumFrom :: Channel -> [Channel] # enumFromThen :: Channel -> Channel -> [Channel] # enumFromTo :: Channel -> Channel -> [Channel] # enumFromThenTo :: Channel -> Channel -> Channel -> [Channel] #
Eq Channel #
Methods (==) :: Channel -> Channel -> Bool # (/=) :: Channel -> Channel -> Bool #
Ord Channel #
Methods compare :: Channel -> Channel -> Ordering # (<) :: Channel -> Channel -> Bool # (<=) :: Channel -> Channel -> Bool # (>) :: Channel -> Channel -> Bool # (>=) :: Channel -> Channel -> Bool # max :: Channel -> Channel -> Channel # min :: Channel -> Channel -> Channel #
Show Channel #
Methods showsPrec :: Int -> Channel -> ShowS # show :: Channel -> String # showList :: [Channel] -> ShowS #
Ix Channel #
Methods range :: (Channel, Channel) -> [Channel] # index :: (Channel, Channel) -> Channel -> Int # unsafeIndex :: (Channel, Channel) -> Channel -> Int inRange :: (Channel, Channel) -> Channel -> Bool # rangeSize :: (Channel, Channel) -> Int # unsafeRangeSize :: (Channel, Channel) -> Int
Arbitrary Channel #
Methods arbitrary :: Gen Channel # shrink :: Channel -> [Channel] #

fromChannel :: Channel -> Int #

toChannel :: Int -> Channel #

data Pitch #

Instances

Bounded Pitch #
Methods minBound :: Pitch # maxBound :: Pitch #
Enum Pitch #
Methods succ :: Pitch -> Pitch # pred :: Pitch -> Pitch # toEnum :: Int -> Pitch # fromEnum :: Pitch -> Int # enumFrom :: Pitch -> [Pitch] # enumFromThen :: Pitch -> Pitch -> [Pitch] # enumFromTo :: Pitch -> Pitch -> [Pitch] # enumFromThenTo :: Pitch -> Pitch -> Pitch -> [Pitch] #
Eq Pitch #
Methods (==) :: Pitch -> Pitch -> Bool # (/=) :: Pitch -> Pitch -> Bool #
Ord Pitch #
Methods compare :: Pitch -> Pitch -> Ordering # (<) :: Pitch -> Pitch -> Bool # (<=) :: Pitch -> Pitch -> Bool # (>) :: Pitch -> Pitch -> Bool # (>=) :: Pitch -> Pitch -> Bool # max :: Pitch -> Pitch -> Pitch # min :: Pitch -> Pitch -> Pitch #
Show Pitch #
Methods showsPrec :: Int -> Pitch -> ShowS # show :: Pitch -> String # showList :: [Pitch] -> ShowS #
Ix Pitch #
Methods range :: (Pitch, Pitch) -> [Pitch] # index :: (Pitch, Pitch) -> Pitch -> Int # unsafeIndex :: (Pitch, Pitch) -> Pitch -> Int inRange :: (Pitch, Pitch) -> Pitch -> Bool # rangeSize :: (Pitch, Pitch) -> Int # unsafeRangeSize :: (Pitch, Pitch) -> Int
Arbitrary Pitch #
Methods arbitrary :: Gen Pitch # shrink :: Pitch -> [Pitch] #
Random Pitch #
Methods randomR :: RandomGen g => (Pitch, Pitch) -> g -> (Pitch, g) # random :: RandomGen g => g -> (Pitch, g) # randomRs :: RandomGen g => (Pitch, Pitch) -> g -> [Pitch] # randoms :: RandomGen g => g -> [Pitch] # randomRIO :: (Pitch, Pitch) -> IO Pitch # randomIO :: IO Pitch #

fromPitch :: Pitch -> Int #

toPitch :: Int -> Pitch #

data Velocity #

Instances

Bounded Velocity #	ToDo: We have defined minBound = Velocity 0, but strictly spoken the minimum Velocity is 1, since Velocity zero means NoteOff. One can at least think of NoteOff with (Velocity 0), but I have never seen that.
Methods minBound :: Velocity # maxBound :: Velocity #
Eq Velocity #
Methods (==) :: Velocity -> Velocity -> Bool # (/=) :: Velocity -> Velocity -> Bool #
Ord Velocity #
Methods compare :: Velocity -> Velocity -> Ordering # (<) :: Velocity -> Velocity -> Bool # (<=) :: Velocity -> Velocity -> Bool # (>) :: Velocity -> Velocity -> Bool # (>=) :: Velocity -> Velocity -> Bool # max :: Velocity -> Velocity -> Velocity # min :: Velocity -> Velocity -> Velocity #
Show Velocity #
Methods showsPrec :: Int -> Velocity -> ShowS # show :: Velocity -> String # showList :: [Velocity] -> ShowS #
Arbitrary Velocity #
Methods arbitrary :: Gen Velocity # shrink :: Velocity -> [Velocity] #
Random Velocity #
Methods randomR :: RandomGen g => (Velocity, Velocity) -> g -> (Velocity, g) # random :: RandomGen g => g -> (Velocity, g) # randomRs :: RandomGen g => (Velocity, Velocity) -> g -> [Velocity] # randoms :: RandomGen g => g -> [Velocity] # randomRIO :: (Velocity, Velocity) -> IO Velocity # randomIO :: IO Velocity #

fromVelocity :: Velocity -> Int #

toVelocity :: Int -> Velocity #

data Program #

Instances

Bounded Program #
Methods minBound :: Program # maxBound :: Program #
Enum Program #
Methods succ :: Program -> Program # pred :: Program -> Program # toEnum :: Int -> Program # fromEnum :: Program -> Int # enumFrom :: Program -> [Program] # enumFromThen :: Program -> Program -> [Program] # enumFromTo :: Program -> Program -> [Program] # enumFromThenTo :: Program -> Program -> Program -> [Program] #
Eq Program #
Methods (==) :: Program -> Program -> Bool # (/=) :: Program -> Program -> Bool #
Ord Program #
Methods compare :: Program -> Program -> Ordering # (<) :: Program -> Program -> Bool # (<=) :: Program -> Program -> Bool # (>) :: Program -> Program -> Bool # (>=) :: Program -> Program -> Bool # max :: Program -> Program -> Program # min :: Program -> Program -> Program #
Show Program #
Methods showsPrec :: Int -> Program -> ShowS # show :: Program -> String # showList :: [Program] -> ShowS #
Ix Program #
Methods range :: (Program, Program) -> [Program] # index :: (Program, Program) -> Program -> Int # unsafeIndex :: (Program, Program) -> Program -> Int inRange :: (Program, Program) -> Program -> Bool # rangeSize :: (Program, Program) -> Int # unsafeRangeSize :: (Program, Program) -> Int
Arbitrary Program #
Methods arbitrary :: Gen Program # shrink :: Program -> [Program] #
Random Program #
Methods randomR :: RandomGen g => (Program, Program) -> g -> (Program, g) # random :: RandomGen g => g -> (Program, g) # randomRs :: RandomGen g => (Program, Program) -> g -> [Program] # randoms :: RandomGen g => g -> [Program] # randomRIO :: (Program, Program) -> IO Program # randomIO :: IO Program #

fromProgram :: Program -> Int #

toProgram :: Int -> Program #

data Controller #

We do not define Controller as enumeration with many constructors, because some controllers have multiple names and some are undefined. It is also more efficient this way. Thus you cannot use case for processing controller types, but you can use lookup instead.

maybe (putStrLn "unsupported controller") putStrLn $
lookup ctrl $
   (portamento, "portamento") :
   (modulation, "modulation") :
   []

Instances

Bounded Controller #
Methods minBound :: Controller # maxBound :: Controller #
Enum Controller #
Methods succ :: Controller -> Controller # pred :: Controller -> Controller # toEnum :: Int -> Controller # fromEnum :: Controller -> Int # enumFrom :: Controller -> [Controller] # enumFromThen :: Controller -> Controller -> [Controller] # enumFromTo :: Controller -> Controller -> [Controller] # enumFromThenTo :: Controller -> Controller -> Controller -> [Controller] #
Eq Controller #
Methods (==) :: Controller -> Controller -> Bool # (/=) :: Controller -> Controller -> Bool #
Ord Controller #
Methods compare :: Controller -> Controller -> Ordering # (<) :: Controller -> Controller -> Bool # (<=) :: Controller -> Controller -> Bool # (>) :: Controller -> Controller -> Bool # (>=) :: Controller -> Controller -> Bool # max :: Controller -> Controller -> Controller # min :: Controller -> Controller -> Controller #
Show Controller #
Methods showsPrec :: Int -> Controller -> ShowS # show :: Controller -> String # showList :: [Controller] -> ShowS #
Ix Controller #
Methods range :: (Controller, Controller) -> [Controller] # index :: (Controller, Controller) -> Controller -> Int # unsafeIndex :: (Controller, Controller) -> Controller -> Int inRange :: (Controller, Controller) -> Controller -> Bool # rangeSize :: (Controller, Controller) -> Int # unsafeRangeSize :: (Controller, Controller) -> Int
Arbitrary Controller #
Methods arbitrary :: Gen Controller # shrink :: Controller -> [Controller] #
Random Controller #
Methods randomR :: RandomGen g => (Controller, Controller) -> g -> (Controller, g) # random :: RandomGen g => g -> (Controller, g) # randomRs :: RandomGen g => (Controller, Controller) -> g -> [Controller] # randoms :: RandomGen g => g -> [Controller] # randomRIO :: (Controller, Controller) -> IO Controller # randomIO :: IO Controller #

fromController :: Controller -> Int #

toController :: Int -> Controller #

decodeStatus :: Int -> (Int, Channel) #

for internal use