Sound.MIDI.Util

It is recommended to view this Haddock documentation using the -q local option so that, for example, the types Data.EventList.Relative.TimeBody.T, Sound.MIDI.File.T, and Sound.MIDI.File.Event.T don't all get displayed simply as T. Otherwise, hover over the types to see what is referred to.

Types

newtype Beats

Musical time, measured in beats a.k.a. quarter notes.

Constructors

Beats

Fields

fromBeats :: Rational

Instances

Eq Beats

Fractional Beats

Num Beats

Ord Beats

Real Beats

RealFrac Beats

Show Beats

Monoid Beats

C Beats

data TimeSig

Constructors

TimeSig

Fields

timeSigLength :: !Beats

timeSigUnit :: !Beats

Instances

Eq TimeSig

Show TimeSig

newtype Seconds

Real time, measured in seconds.

Constructors

Seconds

Fields

fromSeconds :: Rational

Instances

Eq Seconds

Fractional Seconds

Num Seconds

Ord Seconds

Real Seconds

RealFrac Seconds

Show Seconds

Monoid Seconds

C Seconds

newtype BPS

A ratio between musical time and real time, measured in beats per second.

Constructors

BPS

Fields

fromBPS :: Rational

Instances

Eq BPS

Fractional BPS

Num BPS

Ord BPS

Real BPS

RealFrac BPS

Show BPS

Monoid BPS

C BPS

Reading/writing MIDI files

decodeFile :: T -> Either [T Beats T] [T Seconds T]

Assigns units to the tracks in a MIDI file. Supports both the common ticks-based files as well as real-time SMPTE-encoded files.

encodeFileBeats :: Type -> Integer -> [T Beats T] -> T

Encodes the tracks' beat positions in ticks, using the given resolution. Positions will be rounded if necessary; see minResolution.

minResolution :: [T Beats T] -> Integer

To correctly encode all the given tracks without rounding, the resolution must be a multiple of the returned number.

Tempos

readTempo :: T -> Maybe BPS

Extracts the tempo from a tempo change event.

showTempo :: BPS -> T

Creates a MIDI event to set the tempo to the given value. Rounds the tempo to the nearest whole "microseconds per beat" if necessary.

makeTempo :: Beats -> Seconds -> BPS

Creates a tempo as a ratio of a music duration to a real time duration.

applyTempo :: BPS -> Beats -> Seconds

Uses a tempo to convert from musical time to real time.

unapplyTempo :: BPS -> Seconds -> Beats

Uses a tempo to convert from real time to musical time.

applyTempoTrack :: TempoMap -> T Beats a -> T Seconds a

unapplyTempoTrack :: TempoMap -> T Seconds a -> T Beats a

data TempoMap

Converts between positions in musical time and real time.

Instances

Eq TempoMap

Show TempoMap

makeTempoMap :: T Beats T -> TempoMap

unmakeTempoMap :: TempoMap -> T Beats T

tempoMapFromBPS :: T Beats BPS -> TempoMap

tempoMapToBPS :: TempoMap -> T Beats BPS

applyTempoMap :: TempoMap -> Beats -> Seconds

unapplyTempoMap :: TempoMap -> Seconds -> Beats

Measures and time signatures

readSignature :: T -> Maybe Beats

Given a MIDI event, if it is a time signature event, returns the length of one measure set by the time signature.

readSignatureFull :: T -> Maybe TimeSig

showSignature :: Beats -> Maybe T

Given a measure length, tries to encode it as a MIDI time signature.

showSignatureFull :: TimeSig -> Maybe T

data MeasureMap

Converts between a simple beat position, and a measure offset plus a beat position.

Instances

Eq MeasureMap

Show MeasureMap

type MeasureBeats = (Int, Beats)

A number of measures (starting from 0), and an offset within that measure (also starting from 0).

data MeasureMode

What to do when makeMeasureMap finds a misaligned time signature?

Constructors

Error

Throw an exception.

Ignore

Ignore it.

Truncate

Truncate the previous measure.

Instances

Bounded MeasureMode

Enum MeasureMode

Eq MeasureMode

Ord MeasureMode

Read MeasureMode

Show MeasureMode

measures :: Int -> Beats -> Beats

The duration of a number of measures in a given time signature.

makeMeasureMap :: MeasureMode -> T Beats T -> MeasureMap

Computes the measure map, given the tempo track from the MIDI.

unmakeMeasureMap :: MeasureMap -> T Beats T

measureMapFromLengths :: MeasureMode -> T Beats Beats -> MeasureMap

measureMapToLengths :: MeasureMap -> T Beats Beats

measureMapFromTimeSigs :: MeasureMode -> T Beats TimeSig -> MeasureMap

measureMapToTimeSigs :: MeasureMap -> T Beats TimeSig

applyMeasureMap :: MeasureMap -> Beats -> MeasureBeats

Uses the measure map to compute which measure a beat position is in.

unapplyMeasureMap :: MeasureMap -> MeasureBeats -> Beats

Uses the measure map to convert a measures+beats position to just beats.

measureLengthToTimeSig :: Beats -> TimeSig

Track names

trackName :: C t => T t T -> Maybe String

Looks for a track name event at position zero.

setTrackName :: C t => String -> T t T -> T t T

Removes any existing track name events at position zero and adds a new one.

readTrackName :: T -> Maybe String

showTrackName :: String -> T

Misc. track operations

trackSplitZero :: C t => T t a -> ([a], T t a)

Combines trackTakeZero and trackDropZero.

trackGlueZero :: C t => [a] -> T t a -> T t a

Prepends the given events to the event list at position zero.

trackTakeZero :: C t => T t a -> [a]

Returns the list of events at position zero of the event list.

trackDropZero :: C t => T t a -> T t a

Drops all events at position zero of the event list.

trackJoin :: (C t, Ord a) => T t (T t a) -> T t a

Equivalent to join, except T doesn't have a Monad instance, presumably because merge has an Ord constraint.

trackSplit :: C t => t -> T t a -> (T t a, T t a)

Combines trackTake and trackDrop.

trackTake :: C t => t -> T t a -> T t a

Drops all events at or after the given time from the event list.

trackDrop :: C t => t -> T t a -> T t a

Drops the given amount of time from the start of the event list. Events that are exactly at the time that is dropped will be kept in the list.

extractFirst :: C t => (a -> Maybe b) -> T t a -> Maybe ((t, b), T t a)

Finds and extracts the first event for which the function returns Just.