Csound.LowLevel

Functions to make your own opcodes. You can find a lot of examples in source code (see directory Csound/Opcode)

Types

data Rate

The Csound rates.

Constructors

Xr

Ar

Kr

Ir

Sr

Fr

Instances

Bounded Rate

Enum Rate

Eq Rate

Ord Rate

Show Rate

type Name = String

type E = Fix RatedExp

The inner representation of csound expressions.

Handy shortcuts

i :: Rate

k :: Rate

a :: Rate

x :: Rate

s :: Rate

f :: Rate

is :: Int -> [Rate]

ks :: Int -> [Rate]

as :: Int -> [Rate]

Standard opcodes

Example:

 oscil :: Sig -> Sig -> Tab -> Sig 
 oscil = opc3 "oscil" [
     (a, [x, x, i, i]),
     (k, [k, k, i, i])]

type Spec1 = [(Rate, [Rate])]

opcs :: (Val a, Val b) => Name -> Spec1 -> [a] -> b

opc0 :: Val a => Name -> Spec1 -> a

opc1 :: (Val a, Val b) => Name -> Spec1 -> a -> b

opc2 :: (Val a1, Val a2, Val b) => Name -> Spec1 -> a1 -> a2 -> b

opc3 :: (Val a1, Val a2, Val a3, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> b

opc4 :: (Val a1, Val a2, Val a3, Val a4, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> b

opc5 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> b

opc6 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b

opc7 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b

opc8 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, Val a8, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> b

opc9 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, Val a8, Val a9, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> b

opc10 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, Val a8, Val a9, Val a10, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> b

opc11 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, Val a8, Val a9, Val a10, Val a11, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> b

opc12 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, Val a8, Val a9, Val a10, Val a11, Val a12, Val b) => Name -> Spec1 -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> b

Multiple outputs

Examples:

 pan2 :: Sig -> Sig -> (Sig, Sig)
 pan2 = mopc2 "pan2" ([a, a], [a, x, i])

When you don't want to specify precise number of outputs:

 soundin :: CsdTuple a => S -> a
 soundin = mopc1 "soundin" (repeat a, s : is 4)

type Specs = ([Rate], [Rate])

mopcs :: (Val a, CsdTuple b) => Name -> Specs -> [a] -> b

mopc0 :: CsdTuple a => Name -> Specs -> a

mopc1 :: (Val a, CsdTuple b) => Name -> Specs -> a -> b

mopc2 :: (Val a1, Val a2, CsdTuple b) => Name -> Specs -> a1 -> a2 -> b

mopc3 :: (Val a1, Val a2, Val a3, CsdTuple b) => Name -> Specs -> a1 -> a2 -> a3 -> b

mopc4 :: (Val a1, Val a2, Val a3, Val a4, CsdTuple b) => Name -> Specs -> a1 -> a2 -> a3 -> a4 -> b

mopc5 :: (Val a1, Val a2, Val a3, Val a4, Val a5, CsdTuple b) => Name -> Specs -> a1 -> a2 -> a3 -> a4 -> a5 -> b

mopc6 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, CsdTuple b) => Name -> Specs -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b

mopc7 :: (Val a1, Val a2, Val a3, Val a4, Val a5, Val a6, Val a7, CsdTuple b) => Name -> Specs -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b

Side effects

Examples:

 delayr :: D -> SE Sig
 delayr a1 = se $ opc1 "delayr" [(a, [i])] a1
 
 delayw :: Sig -> SE ()
 delayw a1 = se_ $ opc1 "delayw" [(x, [a])] a1

Functions that produce no values (procedures) should return value of the type Xr.

When standard functions are not enough

Sometimes Csound opcodes take too many parameters. If you want to use them, you can always use functions that are defined on lists (opcs or mopcs). But in this case you have to convert all arguments to the same type E:

For example:

 oscil :: Sig -> Sig -> Tab -> Sig 
 oscil a1 a2 a3 = opcs "oscil" signature [toE a1, toE a2, toE a3]
    where signature = [
            (a, [x, x, i, i]),
            (k, [k, k, i, i])]

toE :: Val a => a -> E

Converts a value to the private representation.

se :: Val a => E -> SE a

se_ :: E -> SE ()