Safe Haskell	Safe
Language	Haskell2010

Sound.MIDI.Message.Channel.Voice

Description

Channel voice messages

Synopsis

data T
- = NoteOff Pitch Velocity
- | NoteOn Pitch Velocity
- | PolyAftertouch Pitch Pressure
- | ProgramChange Program
- | Control T ControllerValue
- | PitchBend PitchBendRange
- | MonoAftertouch Pressure
get :: C parser => Int -> Int -> Fragile parser T
putWithStatus :: C writer => (Int -> T compress writer) -> T -> T compress writer
type ControllerValue = Value
type PitchBendRange = Int
type Pressure = Int
isNote :: T -> Bool
isNoteOn :: T -> Bool
isNoteOff :: T -> Bool
zeroKey :: Pitch
explicitNoteOff :: T -> T
implicitNoteOff :: T -> T
realFromControllerValue :: (Integral a, Fractional b) => a -> b
bankSelect :: T
modulation :: T
breathControl :: T
footControl :: T
portamentoTime :: T
dataEntry :: T
mainVolume :: T
balance :: T
panorama :: T
expression :: T
generalPurpose1 :: T
generalPurpose2 :: T
generalPurpose3 :: T
generalPurpose4 :: T
vectorX :: T
vectorY :: T
bankSelectMSB :: T
modulationMSB :: T
breathControlMSB :: T
footControlMSB :: T
portamentoTimeMSB :: T
dataEntryMSB :: T
mainVolumeMSB :: T
balanceMSB :: T
panoramaMSB :: T
expressionMSB :: T
generalPurpose1MSB :: T
generalPurpose2MSB :: T
generalPurpose3MSB :: T
generalPurpose4MSB :: T
bankSelectLSB :: T
modulationLSB :: T
breathControlLSB :: T
footControlLSB :: T
portamentoTimeLSB :: T
dataEntryLSB :: T
mainVolumeLSB :: T
balanceLSB :: T
panoramaLSB :: T
expressionLSB :: T
generalPurpose1LSB :: T
generalPurpose2LSB :: T
generalPurpose3LSB :: T
generalPurpose4LSB :: T
sustain :: T
porta :: T
sustenuto :: T
softPedal :: T
hold2 :: T
generalPurpose5 :: T
generalPurpose6 :: T
generalPurpose7 :: T
generalPurpose8 :: T
extDepth :: T
tremoloDepth :: T
chorusDepth :: T
celesteDepth :: T
phaserDepth :: T
dataIncrement :: T
dataDecrement :: T
nonRegisteredParameterLSB :: T
nonRegisteredParameterMSB :: T
registeredParameterLSB :: T
registeredParameterMSB :: T
data Pitch
fromPitch :: Pitch -> Int
toPitch :: Int -> Pitch
data Velocity
fromVelocity :: Velocity -> Int
toVelocity :: Int -> Velocity
data Program
fromProgram :: Program -> Int
toProgram :: Int -> Program
data Controller
fromController :: Controller -> Int
toController :: Int -> Controller
increasePitch :: Int -> Pitch -> Pitch
subtractPitch :: Pitch -> Pitch -> Int
frequencyFromPitch :: Floating a => Pitch -> a
maximumVelocity :: Velocity
normalVelocity :: Velocity
realFromVelocity :: Fractional b => Velocity -> b

Documentation

data T #

Constructors

NoteOff Pitch Velocity
NoteOn Pitch Velocity
PolyAftertouch Pitch Pressure
ProgramChange Program
Control T ControllerValue
PitchBend PitchBendRange
MonoAftertouch Pressure

Instances

Eq T #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods (==) :: T -> T -> Bool # (/=) :: T -> T -> Bool #
Ord T #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods showsPrec :: Int -> T -> ShowS # show :: T -> String # showList :: [T] -> ShowS #
Arbitrary T #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods arbitrary :: Gen T # shrink :: T -> [T] #

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

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

type ControllerValue = Value #

type PitchBendRange = Int #

type Pressure = Int #

isNote :: T -> Bool #

isNoteOn :: T -> Bool #

NoteOn with zero velocity is considered NoteOff according to MIDI specification.

isNoteOff :: T -> Bool #

NoteOn with zero velocity is considered NoteOff according to MIDI specification.

zeroKey :: Pitch #

A MIDI problem is that one cannot uniquely map a MIDI key to a frequency. The frequency depends on the instrument. I don't know if the deviations are defined for General MIDI. If this applies one could add transposition information to the use patch map. For now I have chosen a value that leads to the right frequency for some piano sound in my setup.

explicitNoteOff :: T -> T #

Convert all NoteOn p 0 to NoteOff p 64. The latter one is easier to process.

implicitNoteOff :: T -> T #

Convert all NoteOff p 64 to NoteOn p 0. The latter one can be encoded more efficiently using the running status.

realFromControllerValue :: (Integral a, Fractional b) => a -> b #

Map integral MIDI controller value to floating point value. Maximum integral MIDI controller value 127 is mapped to 1. Minimum integral MIDI controller value 0 is mapped to 0.

bankSelect :: T #

modulation :: T #

breathControl :: T #

footControl :: T #

portamentoTime :: T #

dataEntry :: T #

mainVolume :: T #

balance :: T #

panorama :: T #

expression :: T #

generalPurpose1 :: T #

generalPurpose2 :: T #

generalPurpose3 :: T #

generalPurpose4 :: T #

vectorX :: T #

vectorY :: T #

bankSelectMSB :: T #

modulationMSB :: T #

breathControlMSB :: T #

footControlMSB :: T #

portamentoTimeMSB :: T #

dataEntryMSB :: T #

mainVolumeMSB :: T #

balanceMSB :: T #

panoramaMSB :: T #

expressionMSB :: T #

generalPurpose1MSB :: T #

generalPurpose2MSB :: T #

generalPurpose3MSB :: T #

generalPurpose4MSB :: T #

bankSelectLSB :: T #

modulationLSB :: T #

breathControlLSB :: T #

footControlLSB :: T #

portamentoTimeLSB :: T #

dataEntryLSB :: T #

mainVolumeLSB :: T #

balanceLSB :: T #

panoramaLSB :: T #

expressionLSB :: T #

generalPurpose1LSB :: T #

generalPurpose2LSB :: T #

generalPurpose3LSB :: T #

generalPurpose4LSB :: T #

sustain :: T #

porta :: T #

sustenuto :: T #

softPedal :: T #

hold2 :: T #

generalPurpose5 :: T #

generalPurpose6 :: T #

generalPurpose7 :: T #

generalPurpose8 :: T #

extDepth :: T #

tremoloDepth :: T #

chorusDepth :: T #

celesteDepth :: T #

phaserDepth :: T #

dataIncrement :: T #

dataDecrement :: T #

nonRegisteredParameterLSB :: T #

nonRegisteredParameterMSB :: T #

registeredParameterLSB :: T #

registeredParameterMSB :: T #

data Pitch #

Instances

Bounded Pitch #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods minBound :: Pitch # maxBound :: Pitch #
Enum Pitch #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods (==) :: Pitch -> Pitch -> Bool # (/=) :: Pitch -> Pitch -> Bool #
Ord Pitch #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods showsPrec :: Int -> Pitch -> ShowS # show :: Pitch -> String # showList :: [Pitch] -> ShowS #
Ix Pitch #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods arbitrary :: Gen Pitch # shrink :: Pitch -> [Pitch] #
Random Pitch #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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.
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods minBound :: Velocity # maxBound :: Velocity #
Eq Velocity #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods (==) :: Velocity -> Velocity -> Bool # (/=) :: Velocity -> Velocity -> Bool #
Ord Velocity #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods showsPrec :: Int -> Velocity -> ShowS # show :: Velocity -> String # showList :: [Velocity] -> ShowS #
Arbitrary Velocity #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods arbitrary :: Gen Velocity # shrink :: Velocity -> [Velocity] #
Random Velocity #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods minBound :: Program # maxBound :: Program #
Enum Program #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods (==) :: Program -> Program -> Bool # (/=) :: Program -> Program -> Bool #
Ord Program #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods showsPrec :: Int -> Program -> ShowS # show :: Program -> String # showList :: [Program] -> ShowS #
Ix Program #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.Message.Channel.Voice Methods arbitrary :: Gen Program # shrink :: Program -> [Program] #
Random Program #
Instance details Defined in Sound.MIDI.Message.Channel.Voice 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 #
Instance details Defined in Sound.MIDI.ControllerPrivate Methods minBound :: Controller # maxBound :: Controller #
Enum Controller #
Instance details Defined in Sound.MIDI.ControllerPrivate 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 #
Instance details Defined in Sound.MIDI.ControllerPrivate Methods (==) :: Controller -> Controller -> Bool # (/=) :: Controller -> Controller -> Bool #
Ord Controller #
Instance details Defined in Sound.MIDI.ControllerPrivate 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 #
Instance details Defined in Sound.MIDI.ControllerPrivate Methods showsPrec :: Int -> Controller -> ShowS # show :: Controller -> String # showList :: [Controller] -> ShowS #
Ix Controller #
Instance details Defined in Sound.MIDI.ControllerPrivate 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 #
Instance details Defined in Sound.MIDI.ControllerPrivate Methods arbitrary :: Gen Controller # shrink :: Controller -> [Controller] #
Random Controller #
Instance details Defined in Sound.MIDI.ControllerPrivate 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 #

increasePitch :: Int -> Pitch -> Pitch #

subtractPitch :: Pitch -> Pitch -> Int #

frequencyFromPitch :: Floating a => Pitch -> a #

Convert pitch to frequency according to the default tuning given in MIDI 1.0 Detailed Specification.

maximumVelocity :: Velocity #

The velocity of an ordinary key stroke and the maximum possible velocity.

normalVelocity :: Velocity #

The velocity of an ordinary key stroke and the maximum possible velocity.

realFromVelocity :: Fractional b => Velocity -> b #

MIDI specification says, if velocity is simply mapped to amplitude, then this should be done by an exponential function. Thus we map normalVelocity (64) to 0, maximumVelocity (127) to 1, and minimumVelocity (1) to -1. That is, normally you should write something like amplitude = 2 ** realFromVelocity vel or 3 ** realFromVelocity vel.