Safe Haskell	Safe
Language	Haskell2010

Sound.MIDI.Message.Channel.Voice

Description

Channel voice messages

Synopsis

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 #
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] #

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 #
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 #

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.