| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Csound.Typed.Control
Synopsis
- newtype SE a = SE {
- unSE :: Dep a
- data LocalHistory = LocalHistory {
- expDependency :: E
- newLineNum :: Int
- newLocalVarId :: Int
- runSE :: SE a -> GE a
- execSE :: SE () -> GE InstrBody
- evalSE :: SE a -> GE a
- execGEinSE :: SE (GE a) -> SE a
- hideGEinDep :: GE (Dep a) -> Dep a
- fromDep :: Dep a -> SE (GE a)
- fromDep_ :: Dep () -> SE ()
- geToSe :: GE a -> SE a
- newLocalVar :: Rate -> GE E -> SE Var
- newLocalVars :: [Rate] -> GE [E] -> SE [Var]
- newGlobalVars :: [Rate] -> GE [E] -> SE [Var]
- newClearableGlobalVars :: [Rate] -> GE [E] -> SE [Var]
- newLocalArrVar :: Rate -> GE [E] -> SE Var
- newGlobalArrVar :: Rate -> GE [E] -> SE Var
- newTmpArrVar :: Rate -> SE Var
- newtype Ref a = Ref [Var]
- writeRef :: Tuple a => Ref a -> a -> SE ()
- readRef :: Tuple a => Ref a -> SE a
- newRef :: Tuple a => a -> SE (Ref a)
- mixRef :: (Num a, Tuple a) => Ref a -> a -> SE ()
- modifyRef :: Tuple a => Ref a -> (a -> a) -> SE ()
- sensorsSE :: Tuple a => a -> SE (SE a, a -> SE ())
- newGlobalRef :: Tuple a => a -> SE (Ref a)
- concatRef :: (Tuple a, Tuple b) => Ref a -> Ref b -> Ref (a, b)
- concatRef3 :: (Tuple a, Tuple b, Tuple c) => Ref a -> Ref b -> Ref c -> Ref (a, b, c)
- concatRef4 :: (Tuple a, Tuple b, Tuple c, Tuple d) => Ref a -> Ref b -> Ref c -> Ref d -> Ref (a, b, c, d)
- concatRef5 :: (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e) => Ref a -> Ref b -> Ref c -> Ref d -> Ref e -> Ref (a, b, c, d, e)
- newCtrlRef :: Tuple a => a -> SE (Ref a)
- newGlobalCtrlRef :: Tuple a => a -> SE (Ref a)
- globalSensorsSE :: Tuple a => a -> SE (SE a, a -> SE ())
- newClearableGlobalRef :: Tuple a => a -> SE (Ref a)
- newTab :: D -> SE Tab
- newGlobalTab :: Int -> SE Tab
- whileRef :: forall st. Tuple st => st -> (st -> SE BoolSig) -> (st -> SE st) -> SE ()
- whileRefD :: forall st. Tuple st => st -> (st -> SE BoolD) -> (st -> SE st) -> SE ()
- instr0 :: Tuple a => SE a -> SE a
- getIns :: Sigs a => SE a
- setDur :: Sigs a => D -> a -> a
- freshId :: SE D
- data Mix a
- sco :: (Arg a, Sigs b) => (a -> SE b) -> Sco a -> Sco (Mix b)
- eff :: (Sigs a, Sigs b) => (a -> SE b) -> Sco (Mix a) -> Sco (Mix b)
- mix :: Sigs a => Sco (Mix a) -> a
- mixBy :: (Arg a, Sigs b) => (a -> Sco (Mix b)) -> a -> b
- monoSco :: forall a. Sigs a => (MonoArg -> SE a) -> Sco (D, D) -> Sco (Mix a)
- sco_ :: Arg a => (a -> SE ()) -> Sco a -> Sco (Mix Unit)
- mix_ :: Sco (Mix Unit) -> SE ()
- mixBy_ :: Arg a => (a -> Sco (Mix Unit)) -> a -> SE ()
- type Sco a = Track Sig a
- type CsdEventList a = Track Sig a
- type CsdEvent = (Double, Double, Note)
- data Msg
- type Channel = Int
- midi :: (Num a, Sigs a) => (Msg -> SE a) -> SE a
- midin :: (Num a, Sigs a) => Channel -> (Msg -> SE a) -> SE a
- pgmidi :: (Num a, Sigs a) => Maybe Int -> Channel -> (Msg -> SE a) -> SE a
- midi_ :: (Msg -> SE ()) -> SE ()
- midin_ :: Channel -> (Msg -> SE ()) -> SE ()
- pgmidi_ :: Maybe Int -> Channel -> (Msg -> SE ()) -> SE ()
- initMidiCtrl :: D -> D -> D -> SE ()
- trigByName :: (Arg a, Sigs b) => String -> (a -> SE b) -> SE b
- trigByName_ :: Arg a => String -> (a -> SE ()) -> SE ()
- trigByNameMidi :: (Arg a, Sigs b) => String -> ((D, D, a) -> SE b) -> SE b
- trigByNameMidi_ :: forall a. Arg a => String -> ((D, D, a) -> SE ()) -> SE ()
- namedMonoMsg :: String -> SE MonoArg
- data OscRef
- type OscHost = String
- type OscPort = Int
- type OscAddress = String
- type OscType = String
- initOsc :: OscPort -> OscRef
- listenOsc :: forall a. Tuple a => OscRef -> OscAddress -> OscType -> Evt a
- sendOsc :: forall a. Tuple a => OscHost -> OscPort -> OscAddress -> OscType -> Evt a -> SE ()
- class Tuple a => OscVal a
- listenOscVal :: (Tuple a, OscVal a) => OscRef -> String -> a -> SE a
- chnGetD :: Str -> SE D
- chnGetSig :: Str -> SE Sig
- chnGetCtrl :: Str -> SE Sig
- chnGetStr :: Str -> SE Str
- chnSetD :: D -> Str -> SE ()
- chnSetSig :: Sig -> Str -> SE ()
- chnSetCtrl :: Sig -> Str -> SE ()
- chnSetStr :: Str -> Str -> SE ()
- data Sf
- unSf :: Sf -> GE E
- sched :: (Arg a, Sigs b) => (a -> SE b) -> Evt (Sco a) -> b
- sched_ :: Arg a => (a -> SE ()) -> Evt (Sco a) -> SE ()
- schedBy :: (Arg a, Sigs b, Arg c) => (a -> SE b) -> (c -> Evt (Sco a)) -> c -> b
- schedHarp :: (Arg a, Sigs b) => D -> (a -> SE b) -> Evt [a] -> b
- schedHarpBy :: (Arg a, Sigs b, Arg c) => D -> (a -> SE b) -> (c -> Evt [a]) -> c -> b
- monoSched :: Evt (Sco (D, D)) -> SE MonoArg
- monoSchedUntil :: Evt (D, D) -> Evt a -> SE MonoArg
- monoSchedHarp :: Evt (D, D) -> SE MonoArg
- retrigs :: (Arg a, Sigs b) => (a -> SE b) -> Evt [a] -> b
- evtLoop :: (Num a, Tuple a, Sigs a) => Maybe (Evt Unit) -> [SE a] -> [Evt Unit] -> a
- evtLoopOnce :: (Num a, Tuple a, Sigs a) => Maybe (Evt Unit) -> [SE a] -> [Evt Unit] -> a
- saw :: Sig -> Sig
- isaw :: Sig -> Sig
- pulse :: Sig -> Sig
- tri :: Sig -> Sig
- sqr :: Sig -> Sig
- blosc :: Tab -> Sig -> Sig
- saw' :: D -> Sig -> Sig
- isaw' :: D -> Sig -> Sig
- pulse' :: D -> Sig -> Sig
- tri' :: D -> Sig -> Sig
- sqr' :: D -> Sig -> Sig
- blosc' :: Tab -> D -> Sig -> Sig
- data SyncSmooth
- sawSync :: Sig -> Sig -> Sig
- isawSync :: Sig -> Sig -> Sig
- pulseSync :: Sig -> Sig -> Sig
- triSync :: Sig -> Sig -> Sig
- sqrSync :: Sig -> Sig -> Sig
- bloscSync :: Tab -> Sig -> Sig -> Sig
- sawSync' :: D -> Sig -> Sig -> Sig
- isawSync' :: D -> Sig -> Sig -> Sig
- pulseSync' :: D -> Sig -> Sig -> Sig
- triSync' :: D -> Sig -> Sig -> Sig
- sqrSync' :: D -> Sig -> Sig -> Sig
- bloscSync' :: Tab -> D -> Sig -> Sig -> Sig
- sawSyncAbs :: Sig -> Sig -> Sig
- isawSyncAbs :: Sig -> Sig -> Sig
- pulseSyncAbs :: Sig -> Sig -> Sig
- triSyncAbs :: Sig -> Sig -> Sig
- sqrSyncAbs :: Sig -> Sig -> Sig
- bloscSyncAbs :: Tab -> Sig -> Sig -> Sig
- sawSyncAbs' :: D -> Sig -> Sig -> Sig
- isawSyncAbs' :: D -> Sig -> Sig -> Sig
- pulseSyncAbs' :: D -> Sig -> Sig -> Sig
- triSyncAbs' :: D -> Sig -> Sig -> Sig
- sqrSyncAbs' :: D -> Sig -> Sig -> Sig
- bloscSyncAbs' :: Tab -> D -> Sig -> Sig -> Sig
- sawSyncBy :: SyncSmooth -> Sig -> Sig -> Sig
- isawSyncBy :: SyncSmooth -> Sig -> Sig -> Sig
- pulseSyncBy :: SyncSmooth -> Sig -> Sig -> Sig
- triSyncBy :: SyncSmooth -> Sig -> Sig -> Sig
- sqrSyncBy :: SyncSmooth -> Sig -> Sig -> Sig
- bloscSyncBy :: SyncSmooth -> Tab -> Sig -> Sig -> Sig
- sawSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- isawSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- pulseSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- triSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- sqrSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- bloscSyncBy' :: SyncSmooth -> Tab -> D -> Sig -> Sig -> Sig
- sawSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig
- isawSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig
- pulseSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig
- triSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig
- sqrSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig
- bloscSyncAbsBy :: SyncSmooth -> Tab -> Sig -> Sig -> Sig
- sawSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- isawSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- pulseSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- triSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- sqrSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig
- bloscSyncAbsBy' :: SyncSmooth -> Tab -> D -> Sig -> Sig -> Sig
- data InstrRef a
- newInstr :: Arg a => (a -> SE ()) -> SE (InstrRef a)
- scheduleEvent :: Arg a => InstrRef a -> D -> D -> a -> SE ()
- turnoff2 :: InstrRef a -> Sig -> Sig -> SE ()
- negateInstrRef :: InstrRef a -> InstrRef a
- addFracInstrRef :: D -> D -> InstrRef a -> InstrRef a
- newOutInstr :: (Arg a, Sigs b) => (a -> SE b) -> SE (InstrRef a, b)
- noteOn :: Arg a => D -> D -> InstrRef a -> a -> SE ()
- noteOff :: (Default a, Arg a) => D -> D -> InstrRef a -> SE ()
- foreachArr :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE ()
- foreachArrD :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE ()
- forRowArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE ()
- forColumnArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE ()
- forRowArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE ()
- forColumnArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE ()
- foldArr :: (Tuple ix, Tuple a, Tuple b) => ((ix, a) -> b -> SE b) -> b -> Arr ix a -> SE b
- foldRowArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b
- foldColumnArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b
- foldRowsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b
- foldColumnsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b
- readMacrosString :: String -> String -> Str
- readMacrosDouble :: String -> Double -> D
- readMacrosInt :: String -> Int -> D
SE
The Csound's IO-monad. All values that produce side effects are wrapped
in the SE-monad.
Instances
data LocalHistory #
Constructors
| LocalHistory | |
Fields
| |
Instances
| Default LocalHistory | |
Defined in Csound.Dynamic.Types.Dep Methods def :: LocalHistory # | |
hideGEinDep :: GE (Dep a) -> Dep a Source #
SE reference
newRef :: Tuple a => a -> SE (Ref a) Source #
Allocates a new local (it is visible within the instrument) mutable value and initializes it with value. A reference can contain a tuple of variables.
mixRef :: (Num a, Tuple a) => Ref a -> a -> SE () Source #
Adds the given signal to the value that is contained in the reference.
modifyRef :: Tuple a => Ref a -> (a -> a) -> SE () Source #
Modifies the Ref value with given function.
sensorsSE :: Tuple a => a -> SE (SE a, a -> SE ()) Source #
An alias for the function newRef. It returns not the reference
to mutable value but a pair of reader and writer functions.
newGlobalRef :: Tuple a => a -> SE (Ref a) Source #
Allocates a new global mutable value and initializes it with value. A reference can contain a tuple of variables.
concatRef4 :: (Tuple a, Tuple b, Tuple c, Tuple d) => Ref a -> Ref b -> Ref c -> Ref d -> Ref (a, b, c, d) Source #
concatRef5 :: (Tuple a, Tuple b, Tuple c, Tuple d, Tuple e) => Ref a -> Ref b -> Ref c -> Ref d -> Ref e -> Ref (a, b, c, d, e) Source #
newCtrlRef :: Tuple a => a -> SE (Ref a) Source #
Allocates a new local (it is visible within the instrument) mutable value and initializes it with value. A reference can contain a tuple of variables. It contains control signals (k-rate) and constants for numbers (i-rates).
newGlobalCtrlRef :: Tuple a => a -> SE (Ref a) Source #
Allocates a new global mutable value and initializes it with value. A reference can contain a tuple of variables. It contains control signals (k-rate) and constants for numbers (i-rates).
globalSensorsSE :: Tuple a => a -> SE (SE a, a -> SE ()) Source #
An alias for the function newRef. It returns not the reference
to mutable value but a pair of reader and writer functions.
newClearableGlobalRef :: Tuple a => a -> SE (Ref a) Source #
Allocates a new clearable global mutable value and initializes it with value. A reference can contain a tuple of variables. The variable is set to zero at the end of every iteration. It's useful for accumulation of audio values from several instruments.
newTab :: D -> SE Tab Source #
Creates a new table. The Tab could be used while the instrument is playing. When the instrument is retriggered the new tab is allocated.
newTab size
newGlobalTab :: Int -> SE Tab Source #
Creates a new global table. It's generated only once. It's persisted between instrument calls.
newGlobalTab identifier size
Global settings
setDur :: Sigs a => D -> a -> a Source #
Sets the global duration of the file or output signal to the given value.
It should be used only once! The proper place is in the top-most
expression before sending to dac or writeWav.
Misc
Score
Special type that represents a scores of sound signals. If an instrument is triggered with the scores the result is wrapped in the value of this type.
Instances
sco :: (Arg a, Sigs b) => (a -> SE b) -> Sco a -> Sco (Mix b) Source #
Plays a bunch of notes with the given instrument.
res = sco instrument scores
eff :: (Sigs a, Sigs b) => (a -> SE b) -> Sco (Mix a) -> Sco (Mix b) Source #
Applies an effect to the sound. Effect is applied to the sound on the give track.
res = eff effect sco
effect- a function that takes a tuple of signals and produces a tuple of signals.sco- something that is constructed withscooreff.
With the function eff you can apply a reverb or adjust the
level of the signal. It functions like a mixing board but unlike mixing
board it produces the value that you can arrange with functions from your
favorite Score-generation library. You can delay it or mix with some other track and
apply some another effect on top of it!
mix :: Sigs a => Sco (Mix a) -> a Source #
Renders a scores to the sound signals. we can use it inside the other instruments.
mixBy :: (Arg a, Sigs b) => (a -> Sco (Mix b)) -> a -> b Source #
Imitates a closure for a bunch of notes to be played within another instrument.
monoSco :: forall a. Sigs a => (MonoArg -> SE a) -> Sco (D, D) -> Sco (Mix a) Source #
Plays a bunch of notes with the given monophonic instrument. See details on type MonoArg.
The scores contain the pairs of amplitude (0 to 1) and frequency (in Hz).
res = monoSco instrument scores
sco_ :: Arg a => (a -> SE ()) -> Sco a -> Sco (Mix Unit) Source #
Invokes a procedure for the given bunch of events.
mix_ :: Sco (Mix Unit) -> SE () Source #
Converts a bunch of procedures scheduled with scores to a single procedure.
mixBy_ :: Arg a => (a -> Sco (Mix Unit)) -> a -> SE () Source #
Imitates a closure for a bunch of procedures to be played within another instrument.
type CsdEventList a = Track Sig a Source #
type CsdEvent = (Double, Double, Note) #
The Csound note. It's a triple of
(startTime, duration, parameters)
Midi
Instances
| DirtyMulti b => DirtyMulti (Msg -> b) Source # | |
Defined in Csound.Typed.Types.Lift | |
| PureMulti b => PureMulti (Msg -> b) Source # | |
Defined in Csound.Typed.Types.Lift | |
| Procedure b => Procedure (Msg -> b) Source # | |
Defined in Csound.Typed.Types.Lift Methods procedureGE :: GE ([E] -> Dep ()) -> Msg -> b | |
| DirtySingle b => DirtySingle (Msg -> b) Source # | |
Defined in Csound.Typed.Types.Lift Methods dirtySingleGE :: GE ([E] -> Dep E) -> Msg -> b | |
| PureSingle b => PureSingle (Msg -> b) Source # | |
Defined in Csound.Typed.Types.Lift Methods pureSingleGE :: GE ([E] -> E) -> Msg -> b | |
midi :: (Num a, Sigs a) => (Msg -> SE a) -> SE a Source #
Triggers a midi-instrument (aka Csound's massign) for all channels. It's useful to test a single instrument.
midin :: (Num a, Sigs a) => Channel -> (Msg -> SE a) -> SE a Source #
Triggers a midi-instrument (aka Csound's massign) on the specified channel.
pgmidi :: (Num a, Sigs a) => Maybe Int -> Channel -> (Msg -> SE a) -> SE a Source #
Triggers a midi-instrument (aka Csound's pgmassign) on the specified programm bank.
midi_ :: (Msg -> SE ()) -> SE () Source #
Triggers a midi-procedure (aka Csound's massign) for all channels.
midin_ :: Channel -> (Msg -> SE ()) -> SE () Source #
Triggers a midi-procedure (aka Csound's pgmassign) on the given channel.
pgmidi_ :: Maybe Int -> Channel -> (Msg -> SE ()) -> SE () Source #
Triggers a midi-procedure (aka Csound's pgmassign) on the given programm bank.
Named instruments (API)
trigByName :: (Arg a, Sigs b) => String -> (a -> SE b) -> SE b Source #
Creates an instrument that can be triggered by name with Csound API.
The arguments are determined from the structure of the input for the instrument.
If we have a tuple of arguments: (D, D, Tab)
The would be rendered to instrument arguments that strts from p4.
p1 is the name of teh instrument, p2 is the start time of the note,
p3 is the duration of the note. Then p4 and p5 are going to be doubles and p6
is an integer that denotes a functional table.
trigByName_ :: Arg a => String -> (a -> SE ()) -> SE () Source #
Creates an instrument that can be triggered by name with Csound API. The arguments are determined from the structure of the input for the instrument.
With Csound API we can send messages
i "name" time duration arg1 arg2 arg3
trigByNameMidi :: (Arg a, Sigs b) => String -> ((D, D, a) -> SE b) -> SE b Source #
Creates an instrument that can be triggered by name with Csound API.
It's intended to be used like a midi instrument. It simulates a simplified midi protocol. We can trigger notes:
i "givenName" delay duration 1 pitchKey volumeKey auxParams -- note on i "givenName" delay duration 0 pitchKey volumeKey auxParams -- note off
The arguments are
trigByNameMidi name instrument
The instrument takes a triplet of (pitchKey, volumeKey, auxilliaryTuple).
The order does matter. Please don't pass the volumeKey as the first argument.
The instrument expects the pitch key to be a first argument.
trigByNameMidi_ :: forall a. Arg a => String -> ((D, D, a) -> SE ()) -> SE () Source #
It behaves just like the function trigByNameMidi. Only it doesn't produce an audio
signal. It performs some procedure on note on and stops doing the precedure on note off.
OSC
type OscAddress = String Source #
Path-like string ("foobar/baz")
type OscType = String Source #
The string specifies the type of expected arguments. The string can contain the characters "bcdfilmst" which stand for Boolean, character, double, float, 32-bit integer, 64-bit integer, MIDI, string and timestamp.
initOsc :: OscPort -> OscRef Source #
Initializes host client. The process starts to run in the background.
listenOsc :: forall a. Tuple a => OscRef -> OscAddress -> OscType -> Evt a Source #
Listens for the OSC-messages. The first argument is OSC-reference.
We can create it with the function initOsc. The next two arguments are strings.
The former specifies the path-like address to listen the messages. It can be:
/foo/bar/baz
The latter specifies the type of expected arguments. The string can contain the characters "bcdfilmst" which stand for Boolean, character, double, float, 32-bit integer, 64-bit integer, MIDI, string and timestamp.
The result is an event of messages. We can run a callback on it
with standard function runEvt:
runEvt :: Evt a -> (a -> SE ()) -> SE ()
sendOsc :: forall a. Tuple a => OscHost -> OscPort -> OscAddress -> OscType -> Evt a -> SE () Source #
Sends OSC-messages. It takes in a name of the host computer (empty string is alocal machine), port on which the target machine is listening, OSC-addres and type. The last argument produces the values for OSC-messages.
class Tuple a => OscVal a Source #
Minimal complete definition
getOscTypes, getOscRef
Instances
| OscVal Str Source # | |
Defined in Csound.Typed.Control.Osc | |
| OscVal Sig Source # | |
Defined in Csound.Typed.Control.Osc | |
| (OscVal a, OscVal b) => OscVal (a, b) Source # | |
Defined in Csound.Typed.Control.Osc | |
| (OscVal a, OscVal b, OscVal c) => OscVal (a, b, c) Source # | |
Defined in Csound.Typed.Control.Osc | |
| (OscVal a, OscVal b, OscVal c, OscVal d) => OscVal (a, b, c, d) Source # | |
Defined in Csound.Typed.Control.Osc | |
| (OscVal a, OscVal b, OscVal c, OscVal d, OscVal e) => OscVal (a, b, c, d, e) Source # | |
Defined in Csound.Typed.Control.Osc Methods getOscTypes :: (a, b, c, d, e) -> String | |
listenOscVal :: (Tuple a, OscVal a) => OscRef -> String -> a -> SE a Source #
Listens for tuples of continuous signals read from OSC-channel.
listenOscVal ref address initValue
Channel
Getters
chnGetCtrl :: Str -> SE Sig Source #
Reads a control signal. The control signals are updated at the lower rate.
Setters
chnSetCtrl :: Sig -> Str -> SE () Source #
Writes a control signal. The control signals are updated at the lower rate.
Sf2
The sf2 sound font preset. It is defined with file name, bank and program integers.
Events
sched_ :: Arg a => (a -> SE ()) -> Evt (Sco a) -> SE () Source #
Triggers a procedure on the event stream.
schedBy :: (Arg a, Sigs b, Arg c) => (a -> SE b) -> (c -> Evt (Sco a)) -> c -> b Source #
A closure to trigger an instrument inside the body of another instrument.
schedHarp :: (Arg a, Sigs b) => D -> (a -> SE b) -> Evt [a] -> b Source #
An instrument is triggered with event stream and delay time is set to zero (event fires immediately) and duration is set to inifinite time. The note is held while the instrument is producing something. If the instrument is silent for some seconds (specified in the first argument) then it's turned off.
schedHarpBy :: (Arg a, Sigs b, Arg c) => D -> (a -> SE b) -> (c -> Evt [a]) -> c -> b Source #
A closure to trigger an instrument inside the body of another instrument.
monoSchedUntil :: Evt (D, D) -> Evt a -> SE MonoArg Source #
Plays the note until next note comes or something happens on the second event stream.
retrigs :: (Arg a, Sigs b) => (a -> SE b) -> Evt [a] -> b Source #
Retriggers an instrument every time an event happens. The note is held until the next event happens.
Band-limited oscillators
blosc :: Tab -> Sig -> Sig Source #
A band-limited oscillator with user defined waveform (it's stored in the table).
blosc' :: Tab -> D -> Sig -> Sig Source #
A band-limited oscillator with user defined waveform (it's stored in the table).
Hard sync
data SyncSmooth Source #
Type of smooth shape to make smooth transitions on retrigger. Available types are:
- No smooth:
RawSync - Ramp smooth:
SawSync - Triangular smooth:
TriSync - User defined shape:
UserSync
Instances
| Default SyncSmooth Source # | |
Defined in Csound.Typed.Control.Vco Methods def :: SyncSmooth # | |
sawSync :: Sig -> Sig -> Sig Source #
Sawtooth oscillator with hard-sync. The first argument is a ration between slave and master oscillators.
sawSync ratio cps
isawSync :: Sig -> Sig -> Sig Source #
Integrated sawtooth oscillator with hard-sync. The first argument is a ration between slave and master oscillators.
isawSync ratio cps
pulseSync :: Sig -> Sig -> Sig Source #
Pulse oscillator with hard-sync. The first argument is a ration between slave and master oscillators.
pulseSync ratio cps
triSync :: Sig -> Sig -> Sig Source #
Triangle oscillator with hard-sync. The first argument is a ration between slave and master oscillators.
triSync ratio cps
sqrSync :: Sig -> Sig -> Sig Source #
Square oscillator with hard-sync. The first argument is a ration between slave and master oscillators.
sqrSync ratio cps
bloscSync :: Tab -> Sig -> Sig -> Sig Source #
Band-limited oscillator with hard-sync. The first argument is a ration between slave and master oscillators.
bloscSync tab ratio cps
sawSync' :: D -> Sig -> Sig -> Sig Source #
Sawtooth oscillator with hard-sync with phase. The second argument is a ration between slave and master oscillators.
sawSync' phase ratio cps
isawSync' :: D -> Sig -> Sig -> Sig Source #
Integrated sawtooth oscillator with hard-sync with phase. The second argument is a ration between slave and master oscillators.
isawSync' phase ratio cps
pulseSync' :: D -> Sig -> Sig -> Sig Source #
Pulse oscillator with hard-sync with phase. The second argument is a ration between slave and master oscillators.
pulseSync' phase ratio cps
triSync' :: D -> Sig -> Sig -> Sig Source #
Triangle oscillator with hard-sync with phase. The second argument is a ration between slave and master oscillators.
triSync' phase ratio cps
sqrSync' :: D -> Sig -> Sig -> Sig Source #
Square oscillator with hard-sync with phase. The second argument is a ration between slave and master oscillators.
sqrSync' phase ratio cps
bloscSync' :: Tab -> D -> Sig -> Sig -> Sig Source #
Band-limited oscillator with hard-sync with phase. The second argument is a ration between slave and master oscillators.
bloscSync' phase tab ratio cps
Hard sync with absolute frequency for slave oscillator
sawSyncAbs :: Sig -> Sig -> Sig Source #
Sawtooth oscillator with hard-sync.
The freq argument is an absolute frequency of a slave oscillator.
sawSyncAbs freq slaveCps masterCps
isawSyncAbs :: Sig -> Sig -> Sig Source #
Integrated sawtooth oscillator with hard-sync.
The freq argument is an absolute frequency of a slave oscillator.
isawSyncAbs freq slaveCps masterCps
pulseSyncAbs :: Sig -> Sig -> Sig Source #
Pulse oscillator with hard-sync.
The freq argument is an absolute frequency of a slave oscillator.
pulseSyncAbs freq slaveCps masterCps
triSyncAbs :: Sig -> Sig -> Sig Source #
Triangle oscillator with hard-sync.
The freq argument is an absolute frequency of a slave oscillator.
triSyncAbs freq slaveCps masterCps
sqrSyncAbs :: Sig -> Sig -> Sig Source #
Square oscillator with hard-sync.
The freq argument is an absolute frequency of a slave oscillator.
sqrSyncAbs freq slaveCps masterCps
bloscSyncAbs :: Tab -> Sig -> Sig -> Sig Source #
Bandlimited table oscillator with hard-sync.
The freq argument is an absolute frequency of a slave oscillator.
bloscSyncAbs tab freq slaveCps masterCps
sawSyncAbs' :: D -> Sig -> Sig -> Sig Source #
Sawtooth oscillator with hard-sync with phase.
The freq argument is an absolute frequency of a slave oscillator.
sawSyncAbs' phase freq slaveCps masterCps
isawSyncAbs' :: D -> Sig -> Sig -> Sig Source #
Integrated sawtooth oscillator with hard-sync with phase.
The freq argument is an absolute frequency of a slave oscillator.
isawSyncAbs' phase freq slaveCps masterCps
pulseSyncAbs' :: D -> Sig -> Sig -> Sig Source #
Pulse oscillator with hard-sync with phase.
The freq argument is an absolute frequency of a slave oscillator.
pulseSyncAbs' phase freq slaveCps masterCps
triSyncAbs' :: D -> Sig -> Sig -> Sig Source #
Triangle oscillator with hard-sync with phase.
The freq argument is an absolute frequency of a slave oscillator.
triSyncAbs' phase freq slaveCps masterCps
sqrSyncAbs' :: D -> Sig -> Sig -> Sig Source #
Square oscillator with hard-sync with phase.
The freq argument is an absolute frequency of a slave oscillator.
sqrSyncAbs' phase freq slaveCps masterCps
bloscSyncAbs' :: Tab -> D -> Sig -> Sig -> Sig Source #
Bandlimited table oscillator with hard-sync with phase.
The freq argument is an absolute frequency of a slave oscillator.
bloscSyncAbs' phase tab freq slaveCps masterCps
Hard sync with custom smoothing algorythm
sawSyncBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
Sawtooth oscillator with hard-sync. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
sawSyncBy spec ratio cps
isawSyncBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
Integrated sawtooth oscillator with hard-sync. We can specify the smoothness type. The first argument is a ration between slave and master oscillators.
isawSyncB specy ratio cps
pulseSyncBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
Pulse oscillator with hard-sync. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
pulseSyncBy spec ratio cps
triSyncBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
Triangle oscillator with hard-sync. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
triSyncBy spec ratio cps
sqrSyncBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
Square oscillator with hard-sync. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
sawSyncBy spec ratio cps
bloscSyncBy :: SyncSmooth -> Tab -> Sig -> Sig -> Sig Source #
Bandlimited table oscillator with hard-sync. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
bloscSyncBy spec tab ratio cps
sawSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Sawtooth oscillator with hard-sync with phase. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
sawSyncBy' spec phase ratio cps
isawSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Integrated sawtooth oscillator with hard-sync with phase. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
isawSyncBy' spec phase ratio cps
pulseSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Pulse oscillator with hard-sync with phase. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
pulseSyncBy' spec phase ratio cps
triSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Triangle oscillator with hard-sync with phase. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
triSyncBy' spec phase ratio cps
sqrSyncBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Square oscillator with hard-sync with phase. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
sawSyncBy' spec phase ratio cps
bloscSyncBy' :: SyncSmooth -> Tab -> D -> Sig -> Sig -> Sig Source #
Bandlimited table oscillator with hard-sync with phase. We can specify the smoothness type.
The ratio argument is a ration between slave and master oscillators.
bloscSyncBy' spec phase tab ratio cps
Hard sync with absolute frequency for slave oscillator
sawSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
A hard sync for sawtooth with absolute slave frequency.
sawSyncAbs syncType salveCps masterCps
isawSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
A hard sync for integrated sawtooth: 4 * x * (1 - x) with absolute slave frequency.
isawSyncAbs syncType salveCps masterCps
pulseSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
A hard sync for pulse wave with absolute slave frequency.
pulseSyncAbs syncType salveCps masterCps
triSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
A hard sync for triangle wave with absolute slave frequency.
triSyncAbs syncType salveCps masterCps
sqrSyncAbsBy :: SyncSmooth -> Sig -> Sig -> Sig Source #
A hard sync for square wave with absolute slave frequency.
sqrSyncAbs syncType salveCps masterCps
bloscSyncAbsBy :: SyncSmooth -> Tab -> Sig -> Sig -> Sig Source #
A hard sync for band-limited oscillator with user defined waveform (it's stored in the table) woth absolute frequency.
bloscSyncAbs syncType ftable salveCps masterCps
sawSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
A sawtooth.
isawSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Integrated sawtooth: 4 * x * (1 - x).
pulseSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
Pulse (not normalized).
triSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
A triangle wave.
sqrSyncAbsBy' :: SyncSmooth -> D -> Sig -> Sig -> Sig Source #
A square wave.
bloscSyncAbsBy' :: SyncSmooth -> Tab -> D -> Sig -> Sig -> Sig Source #
A band-limited oscillator with user defined waveform (it's stored in the table).
Imperative instruments
Instrument reference. we can invoke or stop the instrument by the identifier.
newInstr :: Arg a => (a -> SE ()) -> SE (InstrRef a) Source #
Creates a new instrument and generates a unique identifier.
scheduleEvent :: Arg a => InstrRef a -> D -> D -> a -> SE () Source #
Schedules an event for the instrument.
scheduleEvent instrRef delay duration args
The arguments for time values are set in seconds.
turnoff2 :: InstrRef a -> Sig -> Sig -> SE () Source #
Turns off the note played on the given instrument. Use fractional instrument reference to turn off specific instance.
turnoff2 instrRef mode releaseTime
The mode is sum of the following values:
- 0, 1, or 2: turn off all instances (0), oldest only (1), or newest only (2)
- 4: only turn off notes with exactly matching (fractional) instrument number, rather than ignoring fractional part
- 8: only turn off notes with indefinite duration (idur < 0 or MIDI)
releaseTime if non-zero, the turned off instances are allowed to release, otherwise are deactivated immediately (possibly resulting in clicks).
negateInstrRef :: InstrRef a -> InstrRef a Source #
Negates the instrument identifier. This trick is used in Csound to update the instrument arguments while instrument is working.
addFracInstrRef :: D -> D -> InstrRef a -> InstrRef a Source #
Adds fractional part to the instrument reference. This trick is used in Csound to identify the notes (or specific instrument invokation).
newOutInstr :: (Arg a, Sigs b) => (a -> SE b) -> SE (InstrRef a, b) Source #
Creates an insturment that produces a value.
noteOn :: Arg a => D -> D -> InstrRef a -> a -> SE () Source #
Triggers a note with fractional instrument reference. We can later stop the instrument on specific note with function noteOff.
noteOff :: (Default a, Arg a) => D -> D -> InstrRef a -> SE () Source #
Stops a note with fractional instrument reference.
Array folding and traversals
foreachArr :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE () Source #
Traverses all elements of the array array and applies a procedure to each element. The procedure takes in a pair of index and the current value at the given index.
foreachArrD :: (Tuple ix, Tuple a) => Arr ix a -> ((ix, a) -> SE ()) -> SE () Source #
Traverses all elements of the array at the **init rate** and applies a procedure to each element. The procedure takes in a pair of index and the current value at the given index.
forRowArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE () Source #
Traverses all elements in the given row of 2D array at the signal rate and applies a procedure to all elements.
forColumnArr :: Tuple a => Sig -> Arr Sig2 a -> ((Sig, a) -> SE ()) -> SE () Source #
Traverses all elements in the given column of 2D array at the signal rate and applies a procedure to all elements.
forRowArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE () Source #
Traverses all elements in the given row of 2D array at the init rate and applies a procedure to all elements.
forColumnArrD :: Tuple a => D -> Arr D2 a -> ((D, a) -> SE ()) -> SE () Source #
Traverses all elements in the given column of 2D array at the init rate and applies a procedure to all elements.
foldArr :: (Tuple ix, Tuple a, Tuple b) => ((ix, a) -> b -> SE b) -> b -> Arr ix a -> SE b Source #
Traverses an array and accumulates a value. We invoke the function with accumulator function, initial value and the array.
foldRowArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b Source #
Traverses a row in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldRowArr accum initValue rowId array
foldColumnArr :: (Tuple a, Tuple b) => ((Sig, a) -> b -> SE b) -> b -> Sig -> Arr Sig2 a -> SE b Source #
Traverses a column in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldColumnArr accum initValue columnId array
foldRowsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b Source #
Traverses a row at the **init rate** in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldRowArr accum initValue rowId array
foldColumnsArrD :: (Tuple a, Tuple b) => ((D, a) -> b -> SE b) -> b -> D -> Arr D2 a -> SE b Source #
Traverses a column at the **init rate** in the array and accumulates a value. We invoke the function with accumulator function, initial value and the array with signal of the row number.
foldColumnArr accum initValue columnId array