Safe Haskell	None
Language	Haskell2010

Sound.MIDI.Util

Contents

Types
Reading/writing MIDI files
Tempos
Measures and time signatures
Track names
Misc. track operations

Description

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.

Synopsis

Types

newtype Beats Source

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

newtype Seconds Source

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 Source

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

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 Source

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

minResolution :: [T Beats T] -> Integer Source

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

Tempos

readTempo :: T -> Maybe BPS Source

Extracts the tempo from a tempo change event.

showTempo :: BPS -> T Source

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 Source

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

applyTempo :: BPS -> Beats -> Seconds Source

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

unapplyTempo :: BPS -> Seconds -> Beats Source

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

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

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

data TempoMap Source

Converts between positions in musical time and real time.

makeTempoMap :: T Beats T -> TempoMap Source

applyTempoMap :: TempoMap -> Beats -> Seconds Source

unapplyTempoMap :: TempoMap -> Seconds -> Beats Source

Measures and time signatures

readSignature :: T -> Maybe Beats Source

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

showSignature :: Beats -> Maybe T Source

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

data MeasureMap Source

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

type MeasureBeats = (Int, Beats) Source

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

data MeasureMode Source

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 Source

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

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

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

applyMeasureMap :: MeasureMap -> Beats -> MeasureBeats Source

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

unapplyMeasureMap :: MeasureMap -> MeasureBeats -> Beats Source

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

Track names

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

Looks for a track name event at position zero.

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

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

readTrackName :: T -> Maybe String Source

showTrackName :: String -> T Source

Misc. track operations

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

Combines trackTakeZero and trackDropZero.

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

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

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

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

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

Drops all events at position zero of the event list.

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

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) Source

Combines trackTake and trackDrop.

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

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

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

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) Source

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