Sound.MIDI.Message.Channel.Voice

Channel voice messages

Documentation

data T

Constructors

NoteOff Pitch Velocity

NoteOn Pitch Velocity

PolyAftertouch Pitch Pressure

ProgramChange Program

Control T ControllerValue

PitchBend PitchBendRange

MonoAftertouch Pressure

Instances

Arbitrary T

Defined in Sound.MIDI.Message.Channel.Voice

Methods

arbitrary :: Gen T

shrink :: T -> [T]

Show T

Defined in Sound.MIDI.Message.Channel.Voice

Methods

showsPrec :: Int -> T -> ShowS

show :: T -> String

showList :: [T] -> ShowS

Eq T

Defined in Sound.MIDI.Message.Channel.Voice

Methods

(==) :: T -> T -> Bool

(/=) :: T -> T -> Bool

Ord T

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

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

Arbitrary Pitch

Defined in Sound.MIDI.Message.Channel.Voice

Methods

arbitrary :: Gen Pitch

shrink :: Pitch -> [Pitch]

Bounded Pitch

Defined in Sound.MIDI.Message.Channel.Voice

Methods

minBound :: Pitch

maxBound :: Pitch

Enum Pitch

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]

Ix Pitch

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

Show Pitch

Defined in Sound.MIDI.Message.Channel.Voice

Methods

showsPrec :: Int -> Pitch -> ShowS

show :: Pitch -> String

showList :: [Pitch] -> ShowS

Eq Pitch

Defined in Sound.MIDI.Message.Channel.Voice

Methods

(==) :: Pitch -> Pitch -> Bool

(/=) :: Pitch -> Pitch -> Bool

Ord Pitch

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

Random Pitch

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]

fromPitch :: Pitch -> Int

toPitch :: Int -> Pitch

data Velocity

Instances

Arbitrary Velocity

Defined in Sound.MIDI.Message.Channel.Voice

Methods

arbitrary :: Gen Velocity

shrink :: Velocity -> [Velocity]

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.

Defined in Sound.MIDI.Message.Channel.Voice

Methods

minBound :: Velocity

maxBound :: Velocity

Show Velocity

Defined in Sound.MIDI.Message.Channel.Voice

Methods

showsPrec :: Int -> Velocity -> ShowS

show :: Velocity -> String

showList :: [Velocity] -> ShowS

Eq Velocity

Defined in Sound.MIDI.Message.Channel.Voice

Methods

(==) :: Velocity -> Velocity -> Bool

(/=) :: Velocity -> Velocity -> Bool

Ord Velocity

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

Random Velocity

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]

fromVelocity :: Velocity -> Int

toVelocity :: Int -> Velocity

data Program

Instances

Arbitrary Program

Defined in Sound.MIDI.Message.Channel.Voice

Methods

arbitrary :: Gen Program

shrink :: Program -> [Program]

Bounded Program

Defined in Sound.MIDI.Message.Channel.Voice

Methods

minBound :: Program

maxBound :: Program

Enum Program

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]

Ix Program

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

Show Program

Defined in Sound.MIDI.Message.Channel.Voice

Methods

showsPrec :: Int -> Program -> ShowS

show :: Program -> String

showList :: [Program] -> ShowS

Eq Program

Defined in Sound.MIDI.Message.Channel.Voice

Methods

(==) :: Program -> Program -> Bool

(/=) :: Program -> Program -> Bool

Ord Program

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

Random Program

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]

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

Arbitrary Controller

Defined in Sound.MIDI.ControllerPrivate

Methods

arbitrary :: Gen Controller

shrink :: Controller -> [Controller]

Bounded Controller

Defined in Sound.MIDI.ControllerPrivate

Methods

minBound :: Controller

maxBound :: Controller

Enum Controller

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]

Ix Controller

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

Show Controller

Defined in Sound.MIDI.ControllerPrivate

Methods

showsPrec :: Int -> Controller -> ShowS

show :: Controller -> String

showList :: [Controller] -> ShowS

Eq Controller

Defined in Sound.MIDI.ControllerPrivate

Methods

(==) :: Controller -> Controller -> Bool

(/=) :: Controller -> Controller -> Bool

Ord Controller

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

Random Controller

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]

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.