% from AutoTrack by Stefan Ratschan \section{Styles} \begin{haskelllisting} 
> module Haskore.Interface.AutoTrack.Style
>           (T, playToStream, jazz, bossa, takeFive, rock,
>            thomasCarib, harmonic) where

> import Data.Bool.HT (select, )
> import Data.List.HT (viewR, )
> import Haskore.Basic.Duration (en, qn, (%+), )
> import Haskore.Music ((+:+), (=:=), )

> import qualified Haskore.Composition.Rhythm as Rhythm
> import qualified Haskore.Composition.Drum   as Drum
> import qualified Haskore.Basic.Duration as Dur
> import qualified Haskore.Basic.Pitch    as Pitch
> import qualified Haskore.Music          as Music
> import qualified Haskore.Music.GeneralMIDI as MidiMusic
> import qualified Haskore.Melody         as Melody
> import qualified Haskore.Interface.MIDI.Render as MidiRender
> import qualified Sound.MIDI.File.Save   as MidiSave

> import qualified Haskore.Interface.AutoTrack.Transposeable as Transposeable
> import qualified Haskore.Interface.AutoTrack.ChordSymbol as ChordSymbol
> import qualified Haskore.Interface.AutoTrack.ChartBar    as ChartBar
> import qualified Haskore.Interface.AutoTrack.ChordChart  as ChordChart
> import qualified Haskore.Interface.AutoTrack.EventChart  as EventChart
> import qualified Haskore.Interface.AutoTrack.Instrument  as Instrument

> import qualified Data.ByteString.Lazy as B
\end{haskelllisting} A style takes a chord chart and creates some music out of it. \begin{haskelllisting} 
> type T       = ChordChart.T -> MidiMusic.T
> type TMelody = ChordChart.T -> Melody.T ()
\end{haskelllisting} \subsection{Filtering music} Filtering certain parts from music, in order to introduce rests \emph{after} the creation of some music. The needed information can be encoded in several ways: \begin{enumerate} \item [ (Music.Dur, Music.Dur) ]: Place of rest, length of rest, sorted \item [ Music.Dur ]: Place to switch from rest to music, or other way round \item Music.Dur [ Bool ]: Some basic duration and then True implies music, False implies Rest \end{enumerate} We use the third possibility here, but use a helper function with a more general interface, which additionally specifies the length of the first list member (different from the basic duration). \begin{haskelllisting} 
> filterMusic :: Music.Dur -> [ Bool ] -> Music.T note -> Music.T note
> filterMusic = fm 0

> fm :: Music.Dur -> Music.Dur -> [ Bool ] -> Music.T note -> Music.T note
> fm fDur bDur plc =
>    Music.switchBinary
>       (\dur at -> case at of
>           (Just  _) -> Music.atom (min dur (musicDur fDur bDur plc)) at
>           (Nothing) -> Music.rest dur)
>       (\ctrl m -> case ctrl of
>           (Music.Tempo t) -> Music.changeTempo t (fm (fDur*t) (bDur*t) plc m)
>           _               -> Music.control ctrl m)
>       (\m0 m1 -> let m0' = fm fDur  bDur plc  m0
>                      (rFDur, rPlc) = remLen bDur plc (Music.dur m0 - fDur)
>                      m1' = fm rFDur bDur rPlc m1
>                  in m0' +:+ m1')
>       (\m0 m1 -> fm fDur bDur plc m0 =:= fm fDur bDur plc m1)
>       (Music.rest 0)

> remLen :: Music.Dur -> [ Bool ] -> Music.Dur -> (Music.Dur, [ Bool ])
> remLen bDur plc len =
>    if bDur>len
>    then (bDur-len, plc)
>    else (len-bDur, tail plc)

> musicDur :: (Num a) => a -> a -> [Bool] -> a
> musicDur fDur bDir plc =
>    sum (zipWith const (fDur : repeat bDir) (takeWhile id plc))
> --   sum (map fst (takeWhile snd (zip (fDur : repeat bDir) plc)))
\end{haskelllisting} \subsection{Playing Styles} Playing a chord chart and style into a stream of binary MIDI data. We abuse a String to store it. \begin{haskelllisting} 
> playToStream :: Int -> T -> Integer -> Int -> ChordChart.T -> B.ByteString
> playToStream trans style tempo chornum chart =
>     let countin = Rhythm.countIn (ChartBar.dur (head (ChordChart.bars chart)))
>         choruses = Music.replicate chornum (style (Transposeable.transpose trans chart))
>         music = Music.changeTempo (tempo%+60) (countin +:+ choruses)
>     in MidiSave.toByteString (MidiRender.generalMidiDeflt music)
\end{haskelllisting} \subsection{Drum Fill} \begin{haskelllisting} 
> jazzFill :: Music.Dur -> MidiMusic.T
> jazzFill d =
>    if d >= 2%+4
>      then
>        let shuffle dr =
>               Rhythm.toShuffledMusicWithDrumUnit en dr . Rhythm.fromString
>        in  Music.rest (d-2%+4) +:+
>               (shuffle Drum.SplashCymbal     "...x" =:=
>                shuffle Drum.AcousticBassDrum "...x" =:=
>                shuffle Drum.AcousticSnare    ".xx.")
>      else error "jazzFill: d must be at least 2%+4"

> endFill :: [ ChartBar.T ] -> MidiMusic.T
> endFill l =
>    let Just (initLd,lastLd) = viewR $ map ChartBar.dur l
>    in  Music.line (map Music.rest initLd) +:+
>        jazzFill lastLd
\end{haskelllisting} \subsection{Bass Lines} First some auxiliary function to play the bass note of a chord. \begin{haskelllisting} 
> bassFromMelody :: Melody.T () -> MidiMusic.T
> bassFromMelody =
>    MidiMusic.fromMelodyNullAttr MidiMusic.AcousticBass

> bassChoose :: (Music.Dur, ChordSymbol.T) -> Melody.T ()
> bassChoose (l, (ChordSymbol.Cons _ b _)) = bassNote l b

> bassNote :: Music.Dur -> Pitch.Class -> Melody.T ()
> bassNote l b =
>    Melody.note (Instrument.bottomRange Instrument.bass b) l ()
\end{haskelllisting} \subsubsection{Chart Bass} This bass line style plays the root of a chord on every chord of a chord chart. \begin{haskelllisting} 
> evFromCC :: ChordChart.T -> [(Music.Dur, ChordSymbol.T)]
> evFromCC = EventChart.events . EventChart.fromChordChart

> chartBass :: TMelody
> chartBass =
>    Music.line . map bassChoose . evFromCC
\end{haskelllisting} \subsubsection{Quarter Bass} This bass line style plays the root of the current chord on every quarter note. It first creates chords on every beat, then maps bassChoose to it. Problem: Right now only works if all chords are on quarter notes! \begin{haskelllisting} 
> splitToDur :: Music.Dur -> [ ( Music.Dur, e ) ] -> [ ( Music.Dur, e ) ]
> splitToDur sd =
>    concatMap (\(d,e) -> replicate (fromInteger (Dur.divide d sd)) (sd, e))

> quarterBass :: TMelody
> quarterBass =
>    Music.line . map bassChoose . splitToDur (1%+4) . evFromCC

> eighthBass :: TMelody
> eighthBass =
>    Music.line . map bassChoose . splitToDur (1%+8) . evFromCC
\end{haskelllisting} \subsubsection{Bossa Bass} A simple bass for Bossas using the bass note and its fifth. \begin{haskelllisting} 
> bossaBass :: TMelody
> bossaBass = Music.line . map bossaBassC . evFromCC

> bossaBassC :: (Music.Dur, ChordSymbol.T) -> Melody.T ()
> bossaBassC (l, ch@(ChordSymbol.Cons r _ _)) =
>   let r7 = Transposeable.transpose 7 r
>       bossa' = bassNote (3%+8) r +:+ bassNote (1%+8) r7 +:+
>                bassNote (1%+2) r7 +:+
>                bossaBassC (l - 1%+1, ch)
>   in select (bassChoose (l, ch))
>         [(l >= 1%+1, bossa'),
>          (l >= 1%+2, bassNote (3%+8) r +:+ bassNote (1%+8) r)]
\end{haskelllisting} \subsubsection{Walking Bass Line} Creating a good walking bass is a science in itself. There are numerous books which give various rules for creating good bass lines. The following code is still VERY experimental and just follows these basic rules: \begin{itemize} \item Create the root on the first quarter note of a chord, and \item create random quarter notes of the appropriate scale for the rest. \end{itemize} We do this by creating a walking bass line for every chord of a chart separately and then concatenating the created bass lines. \begin{haskelllisting} walking :: T walking = Music.line . map walkChord . evFromCC c \end{haskelllisting} Walking bass line for a single chord of a certain length. Take the root for the first note and random notes for the rest. \begin{haskelllisting} walkChord :: (Music.Dur, ChordSymbol.T) -> Melody.T () walkChord (d, ch) | (divisible d (1%+4)) = bassChoose ((1%+4), ch) +:+ walkRandom ((divide d (1%+4))-1) ch \end{haskelllisting} Create a random walking bass line of n quarter notes using chord ch. \begin{haskelllisting} walkRandom :: Int -> ChordSymbol.T -> Melody.T () walkRandom n ch = let scale = (chordToScale ch) choice = \n -> bassChooseR n (1%+4, scale) in line (map choice (take n (randList (length scale)))) bassChooseR :: Int -> (Music.Dur, Scale) -> Melody.T () bassChooseR n (d, s) = Melody.note d (pitch (s!!n)) () \end{haskelllisting} \subsection{Full Styles} The jazz style works for 3/4 and 4/4 measure. It currently does not yet use walking bass, but uses the quarter bass style above. \begin{haskelllisting} 
> jazzDrum :: Music.Dur -> MidiMusic.T
> jazzDrum d =
>    select (error "jazzDrum supports only 3%+4 and 4%+4")
>       [(d==3%+4, Rhythm.jazzWaltzRideP Drum.RideCymbal2 =:=
>                  Rhythm.jazzWaltzHiHatP Drum.PedalHiHat),
>        (d==4%+4, Music.replicate 2
>                    (Rhythm.jazzRideP Drum.RideCymbal2 =:=
>                     Rhythm.backBeatP Drum.PedalHiHat))]

> jazz :: T
> jazz s = let drums = Music.line (map (jazzDrum . ChartBar.dur) (ChordChart.bars s)) =:=
>                      endFill (ChordChart.bars s)
>              (bd, hc) = ChordChart.hasChord s
>          in  filterMusic bd hc drums =:=
>                 bassFromMelody (quarterBass s)
>
\end{haskelllisting} The bossa style just plays the usual bossa clave with the hi-hat on the backbeat and some simple bass. \begin{haskelllisting} 
> bossa :: T
> bossa c = let drums = Music.repeat Rhythm.claveBossa =:=
>                       Music.repeat Rhythm.ride =:=
>                       Music.repeat (Rhythm.backBeatP Drum.PedalHiHat)
>               bass = bassFromMelody (bossaBass c)
>           in Music.take ((4 * ChordChart.length c) %+ 4) drums =:= bass
\end{haskelllisting} The Take-Five style works for charts with 5/4 measures only. \begin{haskelllisting} 
> takeFiveBass :: ChartBar.T -> Melody.T ()
> takeFiveBass b =
>    if ChartBar.dur b == 5%+4  &&  length (ChartBar.chords b) <= 2
>      then
>        let c=ChartBar.chords b
>            bass d Nothing  = Music.rest d
>            bass d (Just x) = bassChoose (d, x)
>        in if length c == 2
>             then bass (3%+4) (c!!0) +:+ bass (2%+4) (c!!1)
>             else bass (3%+4) (c!!0) +:+ bass (2%+4) (c!!0)
>      else error "takeFiveBass: only allowed for 5%+4 and maximally 2 chords per bar"

> takeFive :: T
> takeFive (ChordChart.Cons l) =
>     let rep pat = concat (replicate (length l) (Rhythm.fromString pat))
>         hiHatR  = rep "..x .x"
>         cymbalR = rep "x. xx x. x. xx"
>     in Rhythm.toMusicWithDrumUnit         qn Drum.PedalHiHat  hiHatR  =:=
>        Rhythm.toShuffledMusicWithDrumUnit en Drum.RideCymbal2 cymbalR =:=
>        endFill l =:=
>        bassFromMelody (Music.line (map takeFiveBass l))
\end{haskelllisting} The rock style just plays the usual hi-hat eights, bass drum on downbeat, snare on backbeat. \begin{haskelllisting} 
> rock :: T
> rock c = let drums = Music.repeat Rhythm.basicBassDrum =:=
>                      Music.repeat Rhythm.basicSnare =:=
>                      Music.repeat Rhythm.basicHiHat
>              bass  = bassFromMelody (eighthBass c)
>          in Music.take ((4 * ChordChart.length c) %+ 4) drums =:= bass
\end{haskelllisting} This style is not yet finished. \begin{haskelllisting} 
> thomasCarib :: T
> thomasCarib c =
>    Rhythm.backBeatP Drum.PedalHiHat =:=
>    Rhythm.basicBassDrum =:=
>    Rhythm.toShuffledMusicWithDrumUnit en Drum.Claves
>       (Rhythm.fromString ".. .x .x x.") =:=
>    bassFromMelody (chartBass c)
\end{haskelllisting} This is a rather simple style where the tones of a chord a played simultaneously. \begin{haskelllisting} 
> harmonic :: T
> harmonic =
>    let chordSymbolToMusic (dur, cs) = Music.chord $
>           map (\p -> Melody.note p dur ()) $
>              ChordSymbol.toChord cs
>    in  bassFromMelody . Music.line .
>           map chordSymbolToMusic . evFromCC
\end{haskelllisting}