diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2013, Anton Kholomiov +Copyright (c) 2014, Anton Kholomiov All rights reserved. diff --git a/src/Csound.hs b/src/Csound.hs --- a/src/Csound.hs +++ b/src/Csound.hs @@ -1,5 +1,6 @@ {-# Language FlexibleInstances #-} --- | Defines instance of 'Csound.Base.CsdSco' for 'Temporal.Music.Score.Score'. +-- | Defines instance of 'Csound.Base.CsdSco' for 'Temporal.Music.Score.Score' and +-- reexports all functions from packages csound-expression and temporal-music-notation-western. -- -- We can trigger Csound orchestra with 'Temporal.Music.Score.Score'. -- @@ -26,55 +27,177 @@ -- There are two handy infix operators for delay and stretch: @(+|)@ and @(*|)@. So we can write the previous score: -- -- > res = 0.5 *| mel [ temp a, 2 *| temp b, 1 +| har [temp a, temp b] ] +-- +-- There are shortcuts for notes in western notation (a is 440 Hz). +-- +-- > a, b, c, d, e, f, g +-- +-- Notes reside in the same octave. To get the notes in higher or lower octaves +-- we can apply the functions: +-- +-- * 'Temporal.Music.Score.high', 'Temporal.Music.Score.low' -- take note an octaver higher or lower +-- +-- * 'Temporal.Music.Score.higher' n, 'Temporal.Music.Score.lower' n -- take note for @n@ octaves higher or lower +-- +-- There are shortcuts for stretching the notes and rests: +-- +-- > bn, wn, qn, en, sn -- brevis, whole, quarter, eight, sixteenth notes +-- +-- and for rests +-- +-- > bnr, wnr, qnr, enr, snr +-- +-- These functions transform the melodies with given factors. +-- We can construct melodies: +-- +-- > melody = mel [qn $ mel [c, e, g], bn $ har [c, e, g, high c], wnr] +-- +-- Then we can apply a csound instrument to the melody to get the signal. +-- +-- > res = notes someInstr melody +-- +-- Now let's mix it to the signal and send the output to speakers: +-- +-- > dac $ mix res +-- +-- WARNING: The function 'dac' spawns a csound process in the background which +-- can run forever. If your haskell build tool doesn't kills the child processes with +-- haskell-runing process (As far as I know Sublime Editor doesn't, but vim does) +-- it's better to run the program from ghci and to stop it press @Ctrl+C@: +-- +-- > % ghci MyMusic +-- > MyMusic> main +-- > +-- > ... The programm runs ... press Ctrl+C to stop it +-- > +-- +-- @runhaskell@ doesn't stop the child process. So it's better to use the +-- @dac@ function with terminal. +-- +-- If signal is to loud or to quiet we can scale it: +-- +-- > dac $ mul factor $ mix res +-- +-- We can make it brighter with reverb ('Csound.Air.smallRoom', 'Csound.Air.smallHall', 'Csound.Air.largeHall', 'Csound.Air.reverTime') +-- +-- > dac $ mul 0.2 $ smallHall $ mix res + module Csound ( - {- + -- * Converters - CsdNote, csdNote, CsdDrum, csdDrum, + CsdNote(..), csdNote, CsdDrum, csdDrum, N, Dr, -- * Scores - - -- | Tools to make compositions out of timbres. - sco, notes, drums, - -} + -- + -- | Funxtions that apply instruments to scores. + -- + -- Notes on signatures: + -- + -- * The class 'Csound.Base.Outs' includes the tuples of signals + -- that have side effects or have no side effects. + -- + -- * @SigOuts@ -- means an underlying tuple of signals. + -- For instance, it can be @Sig@ or @SE Sig@, the @SigOuts@ + -- converts it to the @Sig@. The @SigOuts@ removes the + -- prefix @SE@ if it is present. + -- + -- * To get the final signal out of the type @Score (Mix (SigOuts b))@ + -- we should apply the function 'Csound.Base.mix' to it: + -- + -- > mix :: (CsdSco f, Sigs a) => f (Mix a) -> a + -- + -- Or we can continue to build the track of signals with + -- functions loke 'Temporal.Music.Score.mel', 'Temporal.Music.Score.har', 'Temporal.Music.Score.str'. + notes, drums, + + -- * Midis + -- + -- | Plays instruments with midi devices. + -- + -- > import Csound + -- > import Csound.Patch(vibraphone2) + -- > + -- > -- | Plays with virtual midi device (if you have a midi device + -- > -- you can substitute @vdac@ for @dac@). + -- > main = vdac $ mul 0.1 $ largeHall $ onMidi vibraphone2 + -- + onMidi, onMidin, onPgmidi, + onMidiWith, onMidinWith, onPgmidiWith, - module Temporal.Music, + module Temporal.Music.Western.P12, module Csound.Base ) where -import Temporal.Music hiding (delay, event, line, chord) import Temporal.Media(Track) import Csound.Base - -import qualified Temporal.Music as T +import Temporal.Music.Western.P12 hiding (delay, event, line, chord, tone) instance CsdSco (Track Double) where toCsdEventList x = CsdEventList (dur x) (fmap toEvt $ render x) where toEvt a = (eventStart a, eventDur a, eventContent a) singleCsdEvent (start, dt, a) = del start $ str dt $ temp a -{- --- | Plays some notes with Csound instrument. -sco :: Arg a => (a -> Out) -> Score a -> SigOut -sco instr s = score instr (fmap unpackEvent $ alignByZero $ render s) - where unpackEvent e = (eventStart e, eventDur e, eventContent e) +type N = CsdNote Unit +type Dr = CsdDrum Unit --- | Playes notes. -notes :: Arg a => (CsdNote a -> Out) -> Score (Note a) -> SigOut -notes instr as = sco instr (fmap csdNote as) +-- | Contains amplitude, frequency and auxiliary parameters. +-- +-- > (amplitude, frequencyInHz, timbralParameters) +type CsdNote a = (D, D, a) --- | Plays drum-notes. -drums :: Arg a => (CsdDrum a -> Out) -> Score (Drum a) -> SigOut -drums instr as = sco instr (fmap csdDrum as) - --- | Csound note: (amplitude, cyclesPerSecond, otherParams) -type CsdNote a = (D, D, a) +-- | Contains amplitude and auxiliary parameters. +-- +-- > (amplitude, timbralParameters) +type CsdDrum a = (D, a) -csdNote :: Note a -> CsdNote a -csdNote a = (double $ amp $ noteVolume a, double $ hz $ notePitch a, noteParam a) +-- | Converts the @Note@ to low level @CsdNote@. +csdNote :: Default a => Note a -> CsdNote a +csdNote a = + ( double $ volumeAsDouble $ noteVolume a + , double $ absPitch $ notePitch a + , maybe def id $ noteParam a) --- | Csound drum-note: (amplitude, otherParams) -type CsdDrum a = (D, a) +-- | Converts the @Note@ to low level @CsdNote@. +csdDrum :: Default a => Drum a -> CsdDrum a +csdDrum a = + ( double $ volumeAsDouble $ drumVolume a + , maybe def id $ drumParam a) -csdDrum :: Drum a -> CsdDrum a -csdDrum a = (double $ amp $ drumVolume a, drumParam a) --} +-- | Plays the notes with csound instrument. +notes :: (Arg a, Default a, Outs b) => (CsdNote a -> b) -> Score (Note a) -> Score (Mix (SigOuts b)) +notes g f = sco (toOuts . g) (fmap csdNote f) + +-- | Plays the drum notes with csound instrument. +drums :: (Arg a, Default a, Outs b) => (CsdDrum a -> b) -> Score (Drum a) -> Score (Mix (SigOuts b)) +drums g f = sco (toOuts . g) (fmap csdDrum f) + +toMidiInstr :: (Default a, Outs b) => (CsdNote a -> b) -> (Msg -> SE (SigOuts b)) +toMidiInstr f = \msg -> toOuts $ f (ampmidi msg 1, cpsmidi msg, def) + +toMidiInstrWith :: (Outs b) => a -> (CsdNote a -> b) -> (Msg -> SE (SigOuts b)) +toMidiInstrWith defVal f = \msg -> toOuts $ f (ampmidi msg 1, cpsmidi msg, defVal) + +-- | Triggers an instrument on all midi-channels. +onMidi :: (Default a, Outs b) => (CsdNote a -> b) -> SigOuts b +onMidi f = midi $ toMidiInstr f + +-- | Triggers an instrument on the given midi-channel. +onMidin :: (Default a, Outs b) => Channel -> (CsdNote a -> b) -> SigOuts b +onMidin chn f = midin chn $ toMidiInstr f + +-- | Triggers an instrument on channel and programm bank. +onPgmidi :: (Default a, Outs b) => Maybe Int -> Channel -> (CsdNote a -> b) -> SigOuts b +onPgmidi pgm chn f = pgmidi pgm chn $ toMidiInstr f + +-- | Just like @onMidi@ but takes a value for default auxiliary parameters. +onMidiWith :: (Outs b) => a -> (CsdNote a -> b) -> SigOuts b +onMidiWith defVal f = midi $ toMidiInstrWith defVal f + +-- | Just like @onMidin@ but takes a value for default auxiliary parameters. +onMidinWith :: (Outs b) => a -> Channel -> (CsdNote a -> b) -> SigOuts b +onMidinWith defVal chn f = midin chn $ toMidiInstrWith defVal f + +-- | Just like @onPgmidi@ but takes a value for default auxiliary parameters. +onPgmidiWith :: (Outs b) => a -> Maybe Int -> Channel -> (CsdNote a -> b) -> SigOuts b +onPgmidiWith defVal pgm chn f = pgmidi pgm chn $ toMidiInstrWith defVal f + diff --git a/src/Csound/Converter.hs b/src/Csound/Converter.hs new file mode 100644 --- /dev/null +++ b/src/Csound/Converter.hs @@ -0,0 +1,33 @@ +-- | Converters for the instruments. +module Csound.Converter( + -- * Pitched instruments + fromF, fromFs, fromAF, fromAsFs, fromAFs, fromAsF, + + -- * Drums + fromDrum +) where + +import Csound + +fromF :: SigSpace a => (D -> a) -> CsdNote Unit -> a +fromF f (amp, cps, _) = mul (sig amp) $ f cps + +fromFs :: SigSpace a => (Sig -> a) -> CsdNote Unit -> a +fromFs f (amp, cps, _) = mul (sig amp) $ f (sig cps) + +fromAF :: (D -> D -> a) -> CsdNote Unit -> a +fromAF f (amp, cps, _) = f amp cps + +fromAsFs :: (Sig -> Sig -> a) -> CsdNote Unit -> a +fromAsFs f (amp, cps, _) = f (sig amp) (sig cps) + +fromAFs :: (D -> Sig -> a) -> CsdNote Unit -> a +fromAFs f (amp, cps, _) = f amp (sig cps) + +fromAsF :: (Sig -> D -> a) -> CsdNote Unit -> a +fromAsF f (amp, cps, _) = f (sig amp) cps + +-- Drums + +fromDrum :: SigSpace a => a -> Dr -> a +fromDrum a (amp, _) = mul (sig amp) a diff --git a/src/Csound/Patch.hs b/src/Csound/Patch.hs new file mode 100644 --- /dev/null +++ b/src/Csound/Patch.hs @@ -0,0 +1,301 @@ +-- | Ready to use instruments. +-- +-- An instrument takes in a note (@N@ which is shortcut for @CsdNote Unit@ +-- or @Dr@ which is shortcut for @CsdDrum Unit@) and procuces a signal. +-- We can use instruments with functions 'Csound.notes' and 'Csound.drums'. +-- +-- > import Csound +-- > import Csound.Patch(stringPad) +-- > +-- > -- | Plays C-major chord. +-- > main = dac $ mul 0.2 $ smallHall $ mix $ notes stringPad $ +-- > str 0.5 $ mel [c, e, g, str 4 $ har [c, e, g, high c], rest 4] +-- +-- Let's explain the functions: +-- +-- > -- dac -- sends signal to speakers +-- > -- +-- > -- mul -- scales the signal +-- > -- +-- > -- smallHall -- adds a reverb +-- > -- +-- > -- mix -- mixes several tracks to a single signal +-- > -- +-- > -- notes -- applies an instrument to the notes +-- > -- +-- > -- stringPad -- predefined instrument +-- > -- +-- > -- str -- stretch the notes in time domain +-- > -- +-- > -- mel, har -- sequential and parallel composition of the notes +-- > -- +-- > -- c, e, g -- notes in western notation (a, b, c, d, ...), a is 440 Hz +-- > -- +-- > -- high -- an octave higher +-- > -- +-- > -- rest -- pause for a given amount of time +module Csound.Patch( + -- * Pads + stringPad, phasingSynth, pulseWidthPad, + melodica, tibetan, + + -- * Mystic + sparkles, xanaduHarp, + + -- * Lead + delaySaw, pulseWidth, toneWheel, + + -- * Tech + okComp, OkCompParam(..), fmMod, + + -- * Plucked + delayedStringLong, delayedStringShort, + plucked, xanadu1, xanadu2, + guitar, harpsichord, harpsichordHarp, plainString, plainStringHarp, + + -- * Strike + noisyMarimba, dahina, banyan, xylophone, + spinelSphere, aluminumBar, + vibraphone1, vibraphone2, wineGlass, xing, + + -- ** Bells + amBell, fmTubularBell, tubularBell, albertClockBellBelfast, + + -- * Drums + dumb, dumbBass, pluckSnare, knockSweep, metalBoink, + snare, openHihat, closedHihat, bassDrum, crash, handClap, + bambooDr, guiroDr, tambourineDr, cabasaDr, crunchDr, + sleighbellsDr, sekereDr, sandpaperDr + +) where + +import Csound(N, Dr, CsdNote, CsdDrum) +import Csound.Base + +import qualified Csound.Catalog.Wave as C +import qualified Csound.Catalog.Effect as C +import qualified Csound.Catalog.Reson as C +import qualified Csound.Catalog.Drum as C + +import Csound.Converter + +fade :: SigSpace a => D -> D -> (b -> a) -> (b -> a) +fade ris dec f = mul (fades ris dec) . f + +-------------------------------------------------------------------- +-- Padds + +stringPad :: N -> Sig +stringPad = fade 0.5 1.5 $ fromAsFs C.stringPad + +phasingSynth :: N -> Sig +phasingSynth = fade 0.3 1.5 $ fromAsFs C.phasingSynth + +melodica :: N -> SE Sig +melodica = fade 0.5 2.5 $ fromFs $ C.melody 5 + +-- | Parameter is time of fade out in seconds. +tibetan :: D -> N -> Sig +tibetan dec = fade 1 dec $ fromF $ C.tibetan 9 0.02 + +pulseWidthPad :: N -> Sig +pulseWidthPad = fade 1 1.5 $ fromAsFs C.pulseWidth + +-------------------------------------------------------------------- +-- Mystic + +sparkles :: N -> SE Sig +sparkles = fade 0.01 2.5 $ fromFs $ C.blue 3 8 0.5 15 + +xanaduHarp :: N -> SE Sig +xanaduHarp = fade 0.01 5 $ fromF C.xanadu1 + +-------------------------------------------------------------------- +-- Lead + +pulseWidth :: N -> Sig +pulseWidth = fade 0.1 0.1 $ fromAsFs C.pulseWidth + +delaySaw :: N -> Sig +delaySaw = fade 0.1 0.2 $ fromFs $ C.delaySaw + +toneWheel :: N -> Sig +toneWheel = fade 0.01 0.1 $ fromF C.toneWheel + +-------------------------------------------------------------------- +-- Tech + +okComp :: CsdDrum OkCompParam -> SE Sig +okComp = fade 0.01 0.1 $ \(amp, OkCompParam rate) -> mul (sig amp) $ C.okComputer (sig rate) + +newtype OkCompParam = OkCompParam { unOkCompParam :: D } + +instance Tuple OkCompParam where + tupleMethods = makeTupleMethods OkCompParam unOkCompParam + +instance Arg OkCompParam + +instance Default OkCompParam where + def = OkCompParam 10 + +fmMod :: N -> Sig +fmMod = fade 0.01 0.1 $ fromFs $ C.fmMod 5 + +-------------------------------------------------------------------- +-- Plucked + +pick :: SigSpace b => D -> (a -> b) -> (a -> b) +pick dec = fade 0.01 dec + +delayedStringLong :: N -> Sig +delayedStringLong = pick 2.5 $ fromF C.delayedString + +delayedStringShort :: N -> Sig +delayedStringShort = pick 0.1 $ fromF C.delayedString + +plucked :: N -> Sig +plucked = pick 0.3 $ fromFs C.rhodes + +xanadu1 :: N -> SE Sig +xanadu1 = pick 1.5 $ fromF C.xanadu1 + +xanadu2 :: N -> SE Sig +xanadu2 = pick 0.8 $ fromF C.xanadu2 + +guitar :: N -> Sig +guitar = fade 0.05 2 $ fromF C.guitar + +harpsichord :: N -> Sig +harpsichord = pick 0.2 $ fromF C.harpsichord + +harpsichordHarp :: N -> Sig +harpsichordHarp = pick 5 $ fromF C.harpsichord + +plainString :: N -> Sig +plainString = pick 0.5 $ fromF C.plainString + +plainStringHarp :: N -> Sig +plainStringHarp = pick 5 $ fromF C.plainString + +-------------------------------------------------------------------- +-- Striked + +strk :: SigSpace b => (a -> b) -> (a -> b) +strk = pick 2.5 + +noisyMarimba :: N -> SE Sig +noisyMarimba = strk $ fromFs C.blackMarimba + +dahina :: N -> Sig +dahina = strk $ fromFs C.dahina + +banyan :: N -> Sig +banyan = strk $ fromFs C.banyan + +xylophone :: N -> Sig +xylophone = strk $ fromFs C.xylophone + +spinelSphere :: N -> Sig +spinelSphere = strk $ fromFs C.spinelSphere + +aluminumBar :: N -> Sig +aluminumBar = strk $ fromFs C.uniformAluminumBar + +vibraphone1 :: N -> Sig +vibraphone1 = strk $ fromFs C.vibraphone1 + +vibraphone2 :: N -> Sig +vibraphone2 = strk $ fromFs C.vibraphone2 + +wineGlass :: N -> Sig +wineGlass = strk $ fromFs C.wineGlass + +xing :: N -> Sig +xing = strk $ fromFs $ C.xing 3 + +-- Bells + +bl :: SigSpace b => (a -> b) -> (a -> b) +bl = pick 4 + +amBell :: N -> Sig +amBell = bl $ fromAFs $ C.amBell + +fmTubularBell :: N -> Sig +fmTubularBell = bl $ fromFs $ C.fmTubularBell + +tubularBell :: N -> Sig +tubularBell = bl $ fromFs C.tubularBell + +albertClockBellBelfast :: N -> Sig +albertClockBellBelfast = bl $ fromFs C.albertClockBellBelfast + +-------------------------------------------------------------------- +-- drums + +dumb :: Dr -> SE Sig +dumb = fromDrum C.dumb + +dumbBass :: Dr -> SE Sig +dumbBass = fromDrum C.dumbBass + +pluckSnare :: Dr -> Sig +pluckSnare = fromDrum C.pluckSnare + +knockSweep :: Dr -> SE Sig +knockSweep = fromDrum C.sortaKnockSweep + +metalBoink :: Dr -> Sig +metalBoink = fromDrum C.metalBoink + +snare :: Dr -> SE Sig +snare = fromDrum C.snare + +openHihat :: Dr -> SE Sig +openHihat = fromDrum C.openHihat + +closedHihat :: Dr -> SE Sig +closedHihat = fromDrum C.closedHihat + +bassDrum :: D -> Dr -> Sig +bassDrum cps = fromDrum $ C.bassDrum cps + +-- | Recommended values for frequency parameter @cpspch(13.03) - cpspch(13.10)@ +crash :: D -> Dr -> SE Sig +crash cps = fromDrum $ C.crash cps + +handClap :: D -> Dr -> SE Sig +handClap cps = fromDrum $ C.handClap cps + +-- models + +fromModel :: (Sig -> D -> Sig) -> Dr -> Sig +fromModel f (amp, _) = f (sig amp) 0.01 + +fromModelD :: (D -> D -> Sig) -> Dr -> Sig +fromModelD f (amp, _) = f amp 0.01 + +bambooDr :: Dr -> Sig +bambooDr = fromModel bamboo + +guiroDr :: Dr -> Sig +guiroDr = fromModel guiro + +tambourineDr :: Dr -> Sig +tambourineDr = fromModel tambourine + +cabasaDr :: Dr -> Sig +cabasaDr = fromModelD cabasa + +crunchDr :: Dr -> Sig +crunchDr = fromModelD crunch + +sleighbellsDr :: Dr -> Sig +sleighbellsDr = fromModel sleighbells + +sekereDr :: Dr -> Sig +sekereDr = fromModelD sekere + +sandpaperDr :: Dr -> Sig +sandpaperDr = fromModelD sandpaper + diff --git a/temporal-csound.cabal b/temporal-csound.cabal --- a/temporal-csound.cabal +++ b/temporal-csound.cabal @@ -2,9 +2,8 @@ -- documentation, see http://haskell.org/cabal/users-guide/ name: temporal-csound -version: 0.2.1 -synopsis: brings together temporal-music-notation and csound-expression packages --- description: +version: 0.3.0 +synopsis: library to make electronic music, brings together temporal-music-notation and csound-expression packages license: BSD3 license-file: LICENSE author: Anton Kholomiov @@ -14,6 +13,53 @@ build-type: Simple cabal-version: >=1.6 +description: + This package joins the forces of the packages temporal-music-notation + and csound-expression. + The former package gives you handy primitives to arrange the events + in sequences (like parallel or sequential composition, the tempo change, + standard names for notes and durations) and the later is used for + creation of musical timbres or software synthesizers. + . + You can find the short intro in the module "Csound". + . + * The tutorial for csound-epression packageb (timbres): + + . + * The tutorial for temporal-music-notation package (composition) + and temporal-music-notation-western package (standard names for notes): see module "Csound" + . + This library defines standard note representation that let's you + invoke csound instruments with notes defined in the package temporal-music-notation. + . + Also this library provides you with some cool instruments to try the things out (see "Csound.Patch"). + . + WARNING: the library works best within ghci. The real-time sound rendering function dac spawns + a child process in the background which may continue to execute after you stop the main process that runs the programm. + It's not so in vim but it happens in the Sublime Editor and when you invoke runhaskell. So the best + is to write you program in the separate file and then load it in the ghci and invoke the function main (which + runs the sound rendering with the function dac). + . + Library strives to be very simple. For example, to trigger the instrument with virtual midi-device is + as simple as (in ghci with loaded modules "Csound" and "Csound.Patch") + . + > Csound Csound.Patch> vdac $ mul 0.2 $ largeHall $ onMidi stringPad + . + If you have a connected hardware midi-device you can just type: + . + > Csound Csound.Patch> dac $ mul 0.2 $ largeHall $ onMidi stringPad + . + And you are ready to go. To play a C-major chord just do: + . + > Csound Csound.Patch> dac $ mul 0.2 $ magicCave $ mix $ notes vibraphone2 $ mel [c, e, g, high c, rest 15] + . + Here we send the output to speakers (dac or vdac), scale the signal to make it quiter (mul), + place the signal in some room with reverberation (largeHall or magicCave), listen to midi + events (onMidi or onMidin for a midi on the given channel) or get the signal from scores (mix), + trigger the csound instrument (stringPad or vibraphone2) on events (notes) and construct + the events in sequence (mel). Events include notes (c, e, g - C major) and rests (rest). + + Extra-Source-Files : Homepage: https://github.com/anton-k/temporal-csound @@ -28,5 +74,10 @@ Hs-Source-Dirs: src/ exposed-modules: Csound + Csound.Patch + Csound.Converter -- other-modules: - build-depends: base >= 4, base < 5, temporal-music-notation>=0.4, csound-expression>=3.1.0 , temporal-media >= 0.4 + build-depends: + base >= 4, base < 5, temporal-music-notation>=0.4, + csound-expression>=3.2.1, csound-catalog>=0.1.1, + temporal-media >= 0.4, temporal-music-notation-western>=0.4.0