-- | Generic constructors for the command set implemented by the SuperCollider synthesis server.
module Sound.Sc3.Server.Command.Generic where

import Data.List {- base -}
import Data.Maybe {- base -}

import Sound.Osc.Core {- hosc -}

import qualified Sound.Sc3.Common.Base as Common.Base
import qualified Sound.Sc3.Server.Command.Enum as Server.Command.Enum
import qualified Sound.Sc3.Server.Enum as Server.Enum
import qualified Sound.Sc3.Server.Graphdef as Server.Graphdef
import qualified Sound.Sc3.Server.Graphdef.Binary as Server.Graphdef
import qualified Sound.Sc3.Server.Synthdef as Server.Synthdef

cmd_check_arg :: String -> (t -> Bool) -> t -> t
cmd_check_arg :: forall t. Address_Pattern -> (t -> Bool) -> t -> t
cmd_check_arg Address_Pattern
e t -> Bool
f t
x = if Bool -> Bool
not (t -> Bool
f t
x) then forall a. HasCallStack => Address_Pattern -> a
error Address_Pattern
e else t
x

-- * Buffer commands (b_)

-- | BUF-NUM must be >= 0
b_bufnum :: Integral t => t -> Datum
b_bufnum :: forall t. Integral t => t -> Datum
b_bufnum = forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Address_Pattern -> (t -> Bool) -> t -> t
cmd_check_arg Address_Pattern
"buffer-number < 0?" (forall a. Ord a => a -> a -> Bool
>= t
0)

-- | BUF-FRAME-IX must be >= 0
b_ix :: Integral t => t -> Datum
b_ix :: forall t. Integral t => t -> Datum
b_ix = forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Address_Pattern -> (t -> Bool) -> t -> t
cmd_check_arg Address_Pattern
"buffer-ix < 0?" (forall a. Ord a => a -> a -> Bool
>= t
0)

-- | BUF-CHANNEL must be >= 0
b_ch :: Integral t => t -> Datum
b_ch :: forall t. Integral t => t -> Datum
b_ch = forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Address_Pattern -> (t -> Bool) -> t -> t
cmd_check_arg Address_Pattern
"buffer-channel < 0?" (forall a. Ord a => a -> a -> Bool
>= t
0)

-- | BUF-FRAME-CNT must be >= 0
b_size :: Integral t => t -> Datum
b_size :: forall t. Integral t => t -> Datum
b_size = forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Address_Pattern -> (t -> Bool) -> t -> t
cmd_check_arg Address_Pattern
"buffer-size < 0?" (forall a. Ord a => a -> a -> Bool
>= t
0)

-- | Allocates zero filled buffer to number of channels and samples. (Asynchronous)
b_alloc :: Integral i => i -> i -> i -> Message
b_alloc :: forall i. Integral i => i -> i -> i -> Message
b_alloc i
b i
frames i
channels = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_alloc" [forall t. Integral t => t -> Datum
b_bufnum i
b,forall t. Integral t => t -> Datum
b_size i
frames,forall t. Integral t => t -> Datum
int32 i
channels]

-- | Allocate buffer space and read a sound file. (Asynchronous)
b_allocRead :: Integral i => i -> String -> i -> i -> Message
b_allocRead :: forall i. Integral i => i -> Address_Pattern -> i -> i -> Message
b_allocRead i
b Address_Pattern
p i
f i
n = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_allocRead" [forall t. Integral t => t -> Datum
b_bufnum i
b,Address_Pattern -> Datum
string Address_Pattern
p,forall t. Integral t => t -> Datum
b_ix i
f,forall t. Integral t => t -> Datum
b_ix i
n]

-- | Allocate buffer space and read a sound file, picking specific channels. (Asynchronous)
b_allocReadChannel :: Integral i => i -> String -> i -> i -> [i] -> Message
b_allocReadChannel :: forall i.
Integral i =>
i -> Address_Pattern -> i -> i -> [i] -> Message
b_allocReadChannel i
b Address_Pattern
p i
f i
n [i]
cs = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_allocReadChannel" ([forall t. Integral t => t -> Datum
b_bufnum i
b,Address_Pattern -> Datum
string Address_Pattern
p,forall t. Integral t => t -> Datum
b_ix i
f,forall t. Integral t => t -> Datum
b_ix i
n] forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
b_ch [i]
cs)

-- | Close attached soundfile and write header information. (Asynchronous)
b_close :: Integral i => i -> Message
b_close :: forall i. Integral i => i -> Message
b_close i
b = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_close" [forall t. Integral t => t -> Datum
b_bufnum i
b]

-- | Fill ranges of sample values.
b_fill :: (Integral i,Real n) => i -> [(i,i,n)] -> Message
b_fill :: forall i n. (Integral i, Real n) => i -> [(i, i, n)] -> Message
b_fill i
b [(i, i, n)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_fill" (forall t. Integral t => t -> Datum
b_bufnum i
b forall a. a -> [a] -> [a]
: forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32 forall n. Real n => n -> Datum
float [(i, i, n)]
l)

-- | Free buffer data. (Asynchronous)
b_free :: Integral i => i -> Message
b_free :: forall i. Integral i => i -> Message
b_free i
b = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_free" [forall t. Integral t => t -> Datum
b_bufnum i
b]

-- | Call a command to fill a buffer.  (Asynchronous)
b_gen :: Integral i => i -> String -> [Datum] -> Message
b_gen :: forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
b Address_Pattern
name [Datum]
arg = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_gen" (forall t. Integral t => t -> Datum
b_bufnum i
b forall a. a -> [a] -> [a]
: Address_Pattern -> Datum
string Address_Pattern
name forall a. a -> [a] -> [a]
: [Datum]
arg)

-- | Call @sine1@ 'b_gen' command.
b_gen_sine1 :: (Integral i,Real n) => i -> [Server.Enum.B_Gen] -> [n] -> Message
b_gen_sine1 :: forall i n. (Integral i, Real n) => i -> [B_Gen] -> [n] -> Message
b_gen_sine1 i
z [B_Gen]
f [n]
n = forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
z Address_Pattern
"sine1" (forall t. Integral t => t -> Datum
int32 ([B_Gen] -> Int
Server.Enum.b_gen_flag [B_Gen]
f) forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall n. Real n => n -> Datum
float [n]
n)

-- | Call @sine2@ 'b_gen' command.
b_gen_sine2 :: (Integral i,Real n) => i -> [Server.Enum.B_Gen] -> [(n,n)] -> Message
b_gen_sine2 :: forall i n.
(Integral i, Real n) =>
i -> [B_Gen] -> [(n, n)] -> Message
b_gen_sine2 i
z [B_Gen]
f [(n, n)]
n = forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
z Address_Pattern
"sine2" (forall t. Integral t => t -> Datum
int32 ([B_Gen] -> Int
Server.Enum.b_gen_flag [B_Gen]
f) forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall n. Real n => n -> Datum
float forall n. Real n => n -> Datum
float [(n, n)]
n)

-- | Call @sine3@ 'b_gen' command.
b_gen_sine3 :: (Integral i,Real n) => i -> [Server.Enum.B_Gen] -> [(n,n,n)] -> Message
b_gen_sine3 :: forall i n.
(Integral i, Real n) =>
i -> [B_Gen] -> [(n, n, n)] -> Message
b_gen_sine3 i
z [B_Gen]
f [(n, n, n)]
n = forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
z Address_Pattern
"sine3" (forall t. Integral t => t -> Datum
int32 ([B_Gen] -> Int
Server.Enum.b_gen_flag [B_Gen]
f) forall a. a -> [a] -> [a]
: forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples forall n. Real n => n -> Datum
float forall n. Real n => n -> Datum
float forall n. Real n => n -> Datum
float [(n, n, n)]
n)

-- | Call @cheby@ 'b_gen' command.
b_gen_cheby :: (Integral i,Real n) => i -> [Server.Enum.B_Gen] -> [n] -> Message
b_gen_cheby :: forall i n. (Integral i, Real n) => i -> [B_Gen] -> [n] -> Message
b_gen_cheby i
z [B_Gen]
f [n]
n = forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
z Address_Pattern
"cheby" (forall t. Integral t => t -> Datum
int32 ([B_Gen] -> Int
Server.Enum.b_gen_flag [B_Gen]
f) forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall n. Real n => n -> Datum
float [n]
n)

-- | Call @copy@ 'b_gen' command.
b_gen_copy :: Integral i => i -> i -> i -> i -> Maybe i -> Message
b_gen_copy :: forall i. Integral i => i -> i -> i -> i -> Maybe i -> Message
b_gen_copy i
dst_b i
dst_ix i
src_b i
src_ix Maybe i
nf =
    let nf' :: i
nf' = forall a. a -> Maybe a -> a
fromMaybe (-i
1) Maybe i
nf
    in forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
dst_b Address_Pattern
"copy" (forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32 [i
dst_ix,i
src_b,i
src_ix,i
nf'])

-- | Get sample values.
b_get :: Integral i => i -> [i] -> Message
b_get :: forall i. Integral i => i -> [i] -> Message
b_get i
b [i]
i = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_get" (forall t. Integral t => t -> Datum
b_bufnum i
b forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32 [i]
i)

-- | Get ranges of sample values.
b_getn :: Integral i => i -> [(i,i)] -> Message
b_getn :: forall i. Integral i => i -> [(i, i)] -> Message
b_getn i
b [(i, i)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_getn" (forall t. Integral t => t -> Datum
b_bufnum i
b forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
b_ix forall t. Integral t => t -> Datum
b_size [(i, i)]
l)

-- | Request \/b_info messages.
b_query :: Integral i => [i] -> Message
b_query :: forall i. Integral i => [i] -> Message
b_query = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_query" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32

{- | Read sound file data into an existing buffer. (Asynchronous)
     Param: bufId pathName startFrame numFrames bufFrame leaveOpen
-}
b_read :: Integral i => i -> String -> i -> i -> i -> Bool -> Message
b_read :: forall i.
Integral i =>
i -> Address_Pattern -> i -> i -> i -> Bool -> Message
b_read i
bufId Address_Pattern
pathName i
startFrame i
numFrames i
bufFrame Bool
leaveOpen =
  Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_read" [forall t. Integral t => t -> Datum
b_bufnum i
bufId,Address_Pattern -> Datum
string Address_Pattern
pathName,forall t. Integral t => t -> Datum
int32 i
startFrame,forall t. Integral t => t -> Datum
int32 i
numFrames,forall t. Integral t => t -> Datum
int32 i
bufFrame,forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum Bool
leaveOpen)]

-- | Read sound file data into an existing buffer, picking specific channels. (Asynchronous)
b_readChannel :: Integral i => i -> String -> i -> i -> i -> Bool -> [i] -> Message
b_readChannel :: forall i.
Integral i =>
i -> Address_Pattern -> i -> i -> i -> Bool -> [i] -> Message
b_readChannel i
b Address_Pattern
p i
f i
n i
f' Bool
z [i]
cs = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_readChannel" ([forall t. Integral t => t -> Datum
b_bufnum i
b,Address_Pattern -> Datum
string Address_Pattern
p,forall t. Integral t => t -> Datum
int32 i
f,forall t. Integral t => t -> Datum
int32 i
n,forall t. Integral t => t -> Datum
int32 i
f',forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum Bool
z)] forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32 [i]
cs)

-- | Set sample values.
b_set :: (Integral i,Real n) => i -> [(i,n)] -> Message
b_set :: forall i n. (Integral i, Real n) => i -> [(i, n)] -> Message
b_set i
b [(i, n)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_set" (forall t. Integral t => t -> Datum
b_bufnum i
b forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 forall n. Real n => n -> Datum
float [(i, n)]
l)

-- | Set ranges of sample values.
b_setn :: (Integral i,Real n) => i -> [(i,[n])] -> Message
b_setn :: forall i n. (Integral i, Real n) => i -> [(i, [n])] -> Message
b_setn i
b [(i, [n])]
l =
    let f :: (n, [a]) -> [Datum]
f (n
i,[a]
d) = forall t. Integral t => t -> Datum
int32 n
i forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 (forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
d) forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall n. Real n => n -> Datum
float [a]
d
    in Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_setn" (forall t. Integral t => t -> Datum
b_bufnum i
b forall a. a -> [a] -> [a]
: forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall {n} {a}. (Integral n, Real a) => (n, [a]) -> [Datum]
f [(i, [n])]
l)

-- | Write sound file data. (Asynchronous)
b_write :: Integral i => i -> String -> Server.Enum.SoundFileFormat -> Server.Enum.SampleFormat -> i -> i -> Bool -> Message
b_write :: forall i.
Integral i =>
i
-> Address_Pattern
-> SoundFileFormat
-> SampleFormat
-> i
-> i
-> Bool
-> Message
b_write i
b Address_Pattern
p SoundFileFormat
h SampleFormat
t i
f i
s Bool
z =
    let h' :: Datum
h' = Address_Pattern -> Datum
string (SoundFileFormat -> Address_Pattern
Server.Enum.soundFileFormatString SoundFileFormat
h)
        t' :: Datum
t' = Address_Pattern -> Datum
string (SampleFormat -> Address_Pattern
Server.Enum.sampleFormatString SampleFormat
t)
    in Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_write" [forall t. Integral t => t -> Datum
b_bufnum i
b,Address_Pattern -> Datum
string Address_Pattern
p,Datum
h',Datum
t',forall t. Integral t => t -> Datum
int32 i
f,forall t. Integral t => t -> Datum
int32 i
s,forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum Bool
z)]

-- | Zero sample data. (Asynchronous)
b_zero :: Integral i => i -> Message
b_zero :: forall i. Integral i => i -> Message
b_zero i
b = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/b_zero" [forall t. Integral t => t -> Datum
b_bufnum i
b]

-- * Control bus commands (c_)

-- |  Fill ranges of bus values.
c_fill :: (Integral i,Real n) => [(i,i,n)] -> Message
c_fill :: forall i n. (Integral i, Real n) => [(i, i, n)] -> Message
c_fill = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/c_fill" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32 forall n. Real n => n -> Datum
float

-- | Get bus values.
c_get :: Integral i => [i] -> Message
c_get :: forall i. Integral i => [i] -> Message
c_get = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/c_get" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32

-- | Get ranges of bus values.
c_getn :: Integral i => [(i,i)] -> Message
c_getn :: forall i. Integral i => [(i, i)] -> Message
c_getn = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/c_getn" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32

-- | Set bus values.
c_set :: (Integral i,Real n) => [(i,n)] -> Message
c_set :: forall i n. (Integral i, Real n) => [(i, n)] -> Message
c_set = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/c_set" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 forall n. Real n => n -> Datum
float

-- | Set ranges of bus values.
c_setn :: (Integral i,Real n) => [(i,[n])] -> Message
c_setn :: forall i n. (Integral i, Real n) => [(i, [n])] -> Message
c_setn [(i, [n])]
l =
    let f :: (n, [a]) -> [Datum]
f (n
i,[a]
d) = forall t. Integral t => t -> Datum
int32 n
i forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 (forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
d) forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall n. Real n => n -> Datum
float [a]
d
    in Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/c_setn" (forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall {n} {a}. (Integral n, Real a) => (n, [a]) -> [Datum]
f [(i, [n])]
l)

-- * Instrument definition commands (d_)

-- | Install a bytecode instrument definition. (Asynchronous)
d_recv_bytes :: Blob -> Message
d_recv_bytes :: Blob -> Message
d_recv_bytes Blob
b = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/d_recv" [Blob -> Datum
Blob Blob
b]

-- | Graphdef encoding variant.
d_recv_gr :: Server.Graphdef.Graphdef -> Message
d_recv_gr :: Graphdef -> Message
d_recv_gr = Blob -> Message
d_recv_bytes forall b c a. (b -> c) -> (a -> b) -> a -> c
. Graphdef -> Blob
Server.Graphdef.encode_graphdef

-- | Synthdef encoding variant.
d_recv :: Server.Synthdef.Synthdef -> Message
d_recv :: Synthdef -> Message
d_recv = Blob -> Message
d_recv_bytes forall b c a. (b -> c) -> (a -> b) -> a -> c
. Synthdef -> Blob
Server.Synthdef.synthdefData

-- | Load an instrument definition from a named file. (Asynchronous)
d_load :: String -> Message
d_load :: Address_Pattern -> Message
d_load Address_Pattern
p = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/d_load" [Address_Pattern -> Datum
string Address_Pattern
p]

-- | Load a directory of instrument definitions files. (Asynchronous)
d_loadDir :: String -> Message
d_loadDir :: Address_Pattern -> Message
d_loadDir Address_Pattern
p = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/d_loadDir" [Address_Pattern -> Datum
string Address_Pattern
p]

-- | Remove definition once all nodes using it have ended.
d_free :: [String] -> Message
d_free :: [Address_Pattern] -> Message
d_free = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/d_free" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Address_Pattern -> Datum
string

-- * Group node commands (g_)

-- | Free all synths in this group and all its sub-groups.
g_deepFree :: Integral i => [i] -> Message
g_deepFree :: forall i. Integral i => [i] -> Message
g_deepFree = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_deepFree" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32

-- | Delete all nodes in a group.
g_freeAll :: Integral i => [i] -> Message
g_freeAll :: forall i. Integral i => [i] -> Message
g_freeAll = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_freeAll" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32

-- | Add node to head of group.
g_head :: Integral i => [(i,i)] -> Message
g_head :: forall i. Integral i => [(i, i)] -> Message
g_head = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_head" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32

-- | Create a new group.
g_new :: Integral i => [(i,Server.Enum.AddAction,i)] -> Message
g_new :: forall i. Integral i => [(i, AddAction, i)] -> Message
g_new = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_new" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples forall t. Integral t => t -> Datum
int32 (forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) forall t. Integral t => t -> Datum
int32

-- | Add node to tail of group.
g_tail :: Integral i => [(i,i)] -> Message
g_tail :: forall i. Integral i => [(i, i)] -> Message
g_tail = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_tail" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32

-- | Post a representation of a group's node subtree, optionally including the current control values for synths.
g_dumpTree :: Integral i => [(i,Bool)] -> Message
g_dumpTree :: forall i. Integral i => [(i, Bool)] -> Message
g_dumpTree = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_dumpTree" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 (forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum)

-- | Request a representation of a group's node subtree, optionally including the current control values for synths.
--
-- Replies to the sender with a @/g_queryTree.reply@ message listing all of the nodes contained within the group in the following format:
--
-- > int32 - if synth control values are included 1, else 0
-- > int32 - node ID of the requested group
-- > int32 - number of child nodes contained within the requested group
-- >
-- > For each node in the subtree:
-- > [
-- >   int32 - node ID
-- >   int32 - number of child nodes contained within this node. If -1 this is a synth, if >= 0 it's a group.
-- >
-- >   If this node is a synth:
-- >     symbol - the SynthDef name for this node.
-- >
-- >   If flag (see above) is true:
-- >     int32 - numControls for this synth (M)
-- >     [
-- >       symbol or int: control name or index
-- >       float or symbol: value or control bus mapping symbol (e.g. 'c1')
-- >     ] * M
-- > ] * the number of nodes in the subtree
--
-- N.Common.Base. The order of nodes corresponds to their execution order on the server. Thus child nodes (those contained within a group) are listed immediately following their parent.
g_queryTree :: Integral i => [(i,Bool)] -> Message
g_queryTree :: forall i. Integral i => [(i, Bool)] -> Message
g_queryTree = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/g_queryTree" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 (forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum)

-- * Node commands (n_)

-- | NODE-ID must be >= -1
n_id :: Integral t => t -> Datum
n_id :: forall t. Integral t => t -> Datum
n_id = forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall t. Address_Pattern -> (t -> Bool) -> t -> t
cmd_check_arg Address_Pattern
"node-id < -1?" (forall a. Ord a => a -> a -> Bool
>= (-t
1))

-- | Place a node after another.
n_after :: Integral i => [(i,i)] -> Message
n_after :: forall i. Integral i => [(i, i)] -> Message
n_after = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_after" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
n_id forall t. Integral t => t -> Datum
n_id

-- | Place a node before another.
n_before :: Integral i => [(i,i)] -> Message
n_before :: forall i. Integral i => [(i, i)] -> Message
n_before = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_before" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32

-- | Fill ranges of a node's control values.
n_fill :: (Integral i,Real f) => i -> [(String,i,f)] -> Message
n_fill :: forall i f.
(Integral i, Real f) =>
i -> [(Address_Pattern, i, f)] -> Message
n_fill i
n [(Address_Pattern, i, f)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_fill" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples Address_Pattern -> Datum
string forall t. Integral t => t -> Datum
int32 forall n. Real n => n -> Datum
float [(Address_Pattern, i, f)]
l)

-- | Delete a node.
n_free :: Integral i => [i] -> Message
n_free :: forall i. Integral i => [i] -> Message
n_free = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_free" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
n_id

n_map :: Integral i => i -> [(String,i)] -> Message
n_map :: forall i. Integral i => i -> [(Address_Pattern, i)] -> Message
n_map i
n [(Address_Pattern, i)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_map" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples Address_Pattern -> Datum
string forall t. Integral t => t -> Datum
int32 [(Address_Pattern, i)]
l)

-- | Map a node's controls to read from buses.
--   n_mapn only works if the control is given as an index and not as a name (3.8.0).
n_mapn :: Integral i => i -> [(i,i,i)] -> Message
n_mapn :: forall i. Integral i => i -> [(i, i, i)] -> Message
n_mapn i
n [(i, i, i)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_mapn" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32 [(i, i, i)]
l)

-- | Map a node's controls to read from an audio bus.
n_mapa :: Integral i => i -> [(String,i)] -> Message
n_mapa :: forall i. Integral i => i -> [(Address_Pattern, i)] -> Message
n_mapa i
n [(Address_Pattern, i)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_mapa" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples Address_Pattern -> Datum
string forall t. Integral t => t -> Datum
int32 [(Address_Pattern, i)]
l)

-- | Map a node's controls to read from audio buses.
n_mapan :: Integral i => i -> [(String,i,i)] -> Message
n_mapan :: forall i. Integral i => i -> [(Address_Pattern, i, i)] -> Message
n_mapan i
n [(Address_Pattern, i, i)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_mapan" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples Address_Pattern -> Datum
string forall t. Integral t => t -> Datum
int32 forall t. Integral t => t -> Datum
int32 [(Address_Pattern, i, i)]
l)

-- | Get info about a node.
n_query :: Integral i => [i] -> Message
n_query :: forall i. Integral i => [i] -> Message
n_query = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_query" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
n_id

-- | Turn node on or off.
n_run :: Integral i => [(i,Bool)] -> Message
n_run :: forall i. Integral i => [(i, Bool)] -> Message
n_run = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_run" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples forall t. Integral t => t -> Datum
n_id (forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum)

-- | Set a node's control values.
n_set :: (Integral i,Real n) => i -> [(String,n)] -> Message
n_set :: forall i n.
(Integral i, Real n) =>
i -> [(Address_Pattern, n)] -> Message
n_set i
n [(Address_Pattern, n)]
c = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_set" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples Address_Pattern -> Datum
string forall n. Real n => n -> Datum
float [(Address_Pattern, n)]
c)

-- | Set ranges of a node's control values.
-- n_mapn and n_setn only work if the control is given as an index and not as a name.
n_setn :: (Integral i,Real n) => i -> [(i,[n])] -> Message
n_setn :: forall i n. (Integral i, Real n) => i -> [(i, [n])] -> Message
n_setn i
n [(i, [n])]
l =
    let f :: (n, [a]) -> [Datum]
f (n
s,[a]
d) = forall t. Integral t => t -> Datum
int32 n
s forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 (forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
d) forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall n. Real n => n -> Datum
float [a]
d
    in Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_setn" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap forall {n} {a}. (Integral n, Real a) => (n, [a]) -> [Datum]
f [(i, [n])]
l)

-- | Trace a node.
n_trace :: Integral i => [i] -> Message
n_trace :: forall i. Integral i => [i] -> Message
n_trace = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_trace" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32

-- | Move an ordered sequence of nodes.
n_order :: Integral i => Server.Enum.AddAction -> i -> [i] -> Message
n_order :: forall i. Integral i => AddAction -> i -> [i] -> Message
n_order AddAction
a i
n [i]
ns = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/n_order" (forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum AddAction
a) forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 i
n forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32 [i]
ns)

-- * Par commands (p_)

-- | Create a new parallel group (supernova specific).
p_new :: Integral i => [(i,Server.Enum.AddAction,i)] -> Message
p_new :: forall i. Integral i => [(i, AddAction, i)] -> Message
p_new = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/p_new" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a d b c.
(a -> d) -> (b -> d) -> (c -> d) -> [(a, b, c)] -> [d]
Common.Base.mk_triples forall t. Integral t => t -> Datum
int32 (forall t. Integral t => t -> Datum
int32 forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) forall t. Integral t => t -> Datum
int32

-- * Synthesis node commands (s_)

-- | Get control values.
s_get :: Integral i => i -> [String] -> Message
s_get :: forall i. Integral i => i -> [Address_Pattern] -> Message
s_get i
n [Address_Pattern]
i = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/s_get" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map Address_Pattern -> Datum
string [Address_Pattern]
i)

-- | Get ranges of control values.
s_getn :: Integral i => i -> [(String,i)] -> Message
s_getn :: forall i. Integral i => i -> [(Address_Pattern, i)] -> Message
s_getn i
n [(Address_Pattern, i)]
l = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/s_getn" (forall t. Integral t => t -> Datum
n_id i
n forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples Address_Pattern -> Datum
string forall t. Integral t => t -> Datum
int32 [(Address_Pattern, i)]
l)

-- | Create a new synth.
s_new :: (Integral i,Real n) => String -> i -> Server.Enum.AddAction -> i -> [(String,n)] -> Message
s_new :: forall i n.
(Integral i, Real n) =>
Address_Pattern
-> i -> AddAction -> i -> [(Address_Pattern, n)] -> Message
s_new Address_Pattern
n i
i AddAction
a i
t [(Address_Pattern, n)]
c = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/s_new" (Address_Pattern -> Datum
string Address_Pattern
n forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 i
i forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum AddAction
a) forall a. a -> [a] -> [a]
: forall t. Integral t => t -> Datum
int32 i
t forall a. a -> [a] -> [a]
: forall a c b. (a -> c) -> (b -> c) -> [(a, b)] -> [c]
Common.Base.mk_duples Address_Pattern -> Datum
string forall n. Real n => n -> Datum
float [(Address_Pattern, n)]
c)

-- | Auto-reassign synth's ID to a reserved value.
s_noid :: Integral i => [i] -> Message
s_noid :: forall i. Integral i => [i] -> Message
s_noid = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/s_noid" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32

-- * Ugen commands (u_)

-- | Send a command to a unit generator.
u_cmd :: Integral i => i -> i -> String -> [Datum] -> Message
u_cmd :: forall i.
Integral i =>
i -> i -> Address_Pattern -> [Datum] -> Message
u_cmd i
n i
uid Address_Pattern
name [Datum]
arg = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/u_cmd" ([forall t. Integral t => t -> Datum
n_id i
n,forall t. Integral t => t -> Datum
int32 i
uid,Address_Pattern -> Datum
string Address_Pattern
name] forall a. [a] -> [a] -> [a]
++ [Datum]
arg)

-- * Server operation commands

-- | Send a plugin command.
cmd :: String -> [Datum] -> Message
cmd :: Address_Pattern -> [Datum] -> Message
cmd Address_Pattern
name = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/cmd" forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Address_Pattern -> Datum
string Address_Pattern
name forall a. a -> [a] -> [a]
:)

-- | Remove all bundles from the scheduling queue.
clearSched :: Message
clearSched :: Message
clearSched = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/clearSched" []

-- | Select printing of incoming Open Sound Control messages.
dumpOsc :: Server.Enum.PrintLevel -> Message
dumpOsc :: PrintLevel -> Message
dumpOsc PrintLevel
c = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/dumpOSC" [forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum PrintLevel
c)]

-- | Set error posting scope and mode.
errorMode :: Server.Enum.ErrorScope -> Server.Enum.ErrorMode -> Message
errorMode :: ErrorScope -> ErrorMode -> Message
errorMode ErrorScope
scope ErrorMode
mode =
    let e :: Int
e = case ErrorScope
scope of
              ErrorScope
Server.Enum.Globally -> forall a. Enum a => a -> Int
fromEnum ErrorMode
mode
              ErrorScope
Server.Enum.Locally  -> -Int
1 forall a. Num a => a -> a -> a
- forall a. Enum a => a -> Int
fromEnum ErrorMode
mode
    in Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/error" [forall t. Integral t => t -> Datum
int32 Int
e]

-- | Select reception of notification messages. (Asynchronous)
notify :: Bool -> Message
notify :: Bool -> Message
notify Bool
c = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/notify" [forall t. Integral t => t -> Datum
int32 (forall a. Enum a => a -> Int
fromEnum Bool
c)]

-- | End real time mode, close file (un-implemented).
nrt_end :: Message
nrt_end :: Message
nrt_end = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/nrt_end" []

-- | Stop synthesis server.
quit :: Message
quit :: Message
quit = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/quit" []

-- | Request \/status.reply message.
status :: Message
status :: Message
status = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/status" []

-- | Request \/synced message when all current asynchronous commands complete.
sync :: Integral i => i -> Message
sync :: forall i. Integral i => i -> Message
sync i
sid = Address_Pattern -> [Datum] -> Message
message Address_Pattern
"/sync" [forall t. Integral t => t -> Datum
int32 i
sid]

-- * Modify existing message to include completion message

-- | Add a completion packet to an existing asynchronous command.
with_completion_packet :: Message -> Packet -> Message
with_completion_packet :: Message -> Packet -> Message
with_completion_packet (Message Address_Pattern
c [Datum]
xs) Packet
cm =
    if Address_Pattern
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Address_Pattern]
Server.Command.Enum.async_cmds
    then let xs' :: [Datum]
xs' = [Datum]
xs forall a. [a] -> [a] -> [a]
++ [Blob -> Datum
Blob (Packet -> Blob
encodePacket Packet
cm)]
         in Address_Pattern -> [Datum] -> Message
Message Address_Pattern
c [Datum]
xs'
    else forall a. HasCallStack => Address_Pattern -> a
error (Address_Pattern
"with_completion_packet: not async: " forall a. [a] -> [a] -> [a]
++ Address_Pattern
c)

-- | Add a completion message to an existing asynchronous command.
--
-- > let m = n_set1 0 "0" 0
-- > let e = encodeMessage m
-- > withCM (b_close 0) m == Message "/b_close" [Int32 0,Blob e]
withCM :: Message -> Message -> Message
withCM :: Message -> Message -> Message
withCM Message
m Message
cm = Message -> Packet -> Message
with_completion_packet Message
m (Message -> Packet
Packet_Message Message
cm)

-- * Variants to simplify common cases

-- | Pre-allocate for b_setn1, values preceding offset are zeroed.
b_alloc_setn1 :: (Integral i,Real n) => i -> i -> [n] -> Message
b_alloc_setn1 :: forall i n. (Integral i, Real n) => i -> i -> [n] -> Message
b_alloc_setn1 i
b i
i [n]
xs =
    let k :: i
k = i
i forall a. Num a => a -> a -> a
+ forall i a. Num i => [a] -> i
genericLength [n]
xs
        xs' :: [n]
xs' = forall i a. Integral i => i -> a -> [a]
genericReplicate i
i n
0 forall a. [a] -> [a] -> [a]
++ [n]
xs
    in Message -> Message -> Message
withCM (forall i. Integral i => i -> i -> i -> Message
b_alloc i
b i
k i
1) (forall i n. (Integral i, Real n) => i -> i -> [n] -> Message
b_setn1 i
b i
0 [n]
xs')

-- | Get ranges of sample values.
b_getn1 :: Integral i => i -> (i,i) -> Message
b_getn1 :: forall i. Integral i => i -> (i, i) -> Message
b_getn1 i
b = forall i. Integral i => i -> [(i, i)] -> Message
b_getn i
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Variant on 'b_query'.
b_query1 :: Integral i => i -> Message
b_query1 :: forall i. Integral i => i -> Message
b_query1 = forall i. Integral i => [i] -> Message
b_query forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Set single sample value.
b_set1 :: (Integral i,Real n) => i -> i -> n -> Message
b_set1 :: forall i n. (Integral i, Real n) => i -> i -> n -> Message
b_set1 i
b i
i n
x = forall i n. (Integral i, Real n) => i -> [(i, n)] -> Message
b_set i
b [(i
i,n
x)]

-- | Set a range of sample values.
b_setn1 :: (Integral i,Real n) => i -> i -> [n] -> Message
b_setn1 :: forall i n. (Integral i, Real n) => i -> i -> [n] -> Message
b_setn1 i
b i
i [n]
xs = forall i n. (Integral i, Real n) => i -> [(i, [n])] -> Message
b_setn i
b [(i
i,[n]
xs)]

-- | Segmented variant of 'b_setn1'.
b_setn1_segmented :: (Integral i,Real n) => i -> i -> i -> [n] -> [Message]
b_setn1_segmented :: forall i n. (Integral i, Real n) => i -> i -> i -> [n] -> [Message]
b_setn1_segmented i
k i
b i
i [n]
d =
    if forall i a. Num i => [a] -> i
genericLength [n]
d forall a. Ord a => a -> a -> Bool
< i
k
    then [forall i n. (Integral i, Real n) => i -> i -> [n] -> Message
b_setn1 i
b i
i [n]
d]
    else forall i n. (Integral i, Real n) => i -> i -> [n] -> Message
b_setn1 i
b i
i (forall i a. Integral i => i -> [a] -> [a]
genericTake i
k [n]
d) forall a. a -> [a] -> [a]
: forall i n. (Integral i, Real n) => i -> i -> i -> [n] -> [Message]
b_setn1_segmented i
k i
b (i
i forall a. Num a => a -> a -> a
+ i
k) (forall i a. Integral i => i -> [a] -> [a]
genericDrop i
k [n]
d)

-- | Get ranges of sample values.
c_getn1 :: Integral i => (i,i) -> Message
c_getn1 :: forall i. Integral i => (i, i) -> Message
c_getn1 = forall i. Integral i => [(i, i)] -> Message
c_getn forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Set single bus values.
c_set1 :: (Integral i,Real n) => i -> n -> Message
c_set1 :: forall i n. (Integral i, Real n) => i -> n -> Message
c_set1 i
i n
x = forall i n. (Integral i, Real n) => [(i, n)] -> Message
c_set [(i
i,n
x)]

-- | Set single range of bus values.
c_setn1 :: (Integral i,Real n) => (i,[n]) -> Message
c_setn1 :: forall i n. (Integral i, Real n) => (i, [n]) -> Message
c_setn1 = forall i n. (Integral i, Real n) => [(i, [n])] -> Message
c_setn forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. Monad m => a -> m a
return

-- | Turn a single node on or off.
n_run1 :: Integral i => i -> Bool -> Message
n_run1 :: forall i. Integral i => i -> Bool -> Message
n_run1 i
n Bool
k = forall i. Integral i => [(i, Bool)] -> Message
n_run [(i
n,Bool
k)]

-- | Set a single node control value.
n_set1 :: (Integral i,Real n) => i -> String -> n -> Message
n_set1 :: forall i n.
(Integral i, Real n) =>
i -> Address_Pattern -> n -> Message
n_set1 i
n Address_Pattern
k n
v = forall i n.
(Integral i, Real n) =>
i -> [(Address_Pattern, n)] -> Message
n_set i
n [(Address_Pattern
k,n
v)]

-- | @s_new@ with no parameters.
s_new0 :: Integral i => String -> i -> Server.Enum.AddAction -> i -> Message
s_new0 :: forall i.
Integral i =>
Address_Pattern -> i -> AddAction -> i -> Message
s_new0 Address_Pattern
n i
i AddAction
a i
t = forall i n.
(Integral i, Real n) =>
Address_Pattern
-> i -> AddAction -> i -> [(Address_Pattern, n)] -> Message
s_new Address_Pattern
n i
i AddAction
a i
t ([]::[(String,Double)])

-- * Buffer segmentation and indices

-- | Segment a request for /m/ places into sets of at most /n/.
--
-- > b_segment 1024 2056 == [8,1024,1024]
-- > b_segment 1 5 == replicate 5 1
b_segment :: Integral i => i -> i -> [i]
b_segment :: forall i. Integral i => i -> i -> [i]
b_segment i
n i
m =
    let (i
q,i
r) = i
m forall a. Integral a => a -> a -> (a, a)
`quotRem` i
n
        s :: [i]
s = forall i a. Integral i => i -> a -> [a]
genericReplicate i
q i
n
    in if i
r forall a. Eq a => a -> a -> Bool
== i
0 then [i]
s else i
r forall a. a -> [a] -> [a]
: [i]
s

-- | Variant of 'b_segment' that takes a starting index and returns
-- /(index,size)/ duples.
--
-- > b_indices 1 5 0 == zip [0..4] (replicate 5 1)
-- > b_indices 1024 2056 16 == [(16,8),(24,1024),(1048,1024)]
b_indices :: Integral i => i -> i -> i -> [(i,i)]
b_indices :: forall i. Integral i => i -> i -> i -> [(i, i)]
b_indices i
n i
m i
k =
    let s :: [i]
s = forall i. Integral i => i -> i -> [i]
b_segment i
n i
m
        i :: [i]
i = i
0 forall a. a -> [a] -> [a]
: forall n. Num n => [n] -> [n]
Common.Base.dx_d [i]
s
    in forall a b. [a] -> [b] -> [(a, b)]
zip (forall a b. (a -> b) -> [a] -> [b]
map (forall a. Num a => a -> a -> a
+ i
k) [i]
i) [i]
s

-- * Ugen commands.

-- | Generate accumulation buffer given time-domain IR buffer and FFT size.
partConv_preparePartConv :: Integral i => i -> i -> i -> Message
partConv_preparePartConv :: forall i. Integral i => i -> i -> i -> Message
partConv_preparePartConv i
b i
irb i
fft_size = forall i. Integral i => i -> Address_Pattern -> [Datum] -> Message
b_gen i
b Address_Pattern
"PreparePartConv" (forall a b. (a -> b) -> [a] -> [b]
map forall t. Integral t => t -> Datum
int32 [i
irb, i
fft_size])

-- * Unpack

-- | Result is null for non-conforming data, or has five or seven elements.
unpack_n_info_datum_plain :: Num i => [Datum] -> [i]
unpack_n_info_datum_plain :: forall i. Num i => [Datum] -> [i]
unpack_n_info_datum_plain [Datum]
m =
    let to_i :: Int32 -> i
to_i = forall a b. (Integral a, Num b) => a -> b
fromIntegral
    in case [Datum]
m of
         [Int32 Int32
i1,Int32 Int32
i2,Int32 Int32
i3,Int32 Int32
i4,Int32 Int32
i5] -> [Int32 -> i
to_i Int32
i1,Int32 -> i
to_i Int32
i2,Int32 -> i
to_i Int32
i3,Int32 -> i
to_i Int32
i4,Int32 -> i
to_i Int32
i5]
         [Int32 Int32
i1,Int32 Int32
i2,Int32 Int32
i3,Int32 Int32
i4,Int32 Int32
i5,Int32 Int32
i6,Int32 Int32
i7] -> [Int32 -> i
to_i Int32
i1,Int32 -> i
to_i Int32
i2,Int32 -> i
to_i Int32
i3,Int32 -> i
to_i Int32
i4,Int32 -> i
to_i Int32
i5,Int32 -> i
to_i Int32
i6,Int32 -> i
to_i Int32
i7]
         [Datum]
_ -> []

unpack_n_info_plain :: Num i => Message -> [i]
unpack_n_info_plain :: forall i. Num i => Message -> [i]
unpack_n_info_plain Message
m =
    case Message
m of
      Message Address_Pattern
"/n_info" [Datum]
dat -> forall i. Num i => [Datum] -> [i]
unpack_n_info_datum_plain [Datum]
dat
      Message
_ -> []

-- | Unpack @n_info@ message.
unpack_n_info :: Num i => Message -> Maybe (i,i,i,i,i,Maybe (i,i))
unpack_n_info :: forall i. Num i => Message -> Maybe (i, i, i, i, i, Maybe (i, i))
unpack_n_info Message
m =
    case forall i. Num i => Message -> [i]
unpack_n_info_plain Message
m of
      [i
i1,i
i2,i
i3,i
i4,i
i5] -> forall a. a -> Maybe a
Just (i
i1,i
i2,i
i3,i
i4,i
i5,forall a. Maybe a
Nothing)
      [i
i1,i
i2,i
i3,i
i4,i
i5,i
i6,i
i7] -> forall a. a -> Maybe a
Just (i
i1,i
i2,i
i3,i
i4,i
i5,forall a. a -> Maybe a
Just (i
i6,i
i7))
      [i]
_ -> forall a. Maybe a
Nothing

unpack_n_info_err :: Num i => Message -> (i,i,i,i,i,Maybe (i,i))
unpack_n_info_err :: forall i. Num i => Message -> (i, i, i, i, i, Maybe (i, i))
unpack_n_info_err = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => Address_Pattern -> a
error Address_Pattern
"unpack_n_info") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i. Num i => Message -> Maybe (i, i, i, i, i, Maybe (i, i))
unpack_n_info

-- | Unpack the '/tr' messages sent by 'sendTrig'.
unpack_tr :: (Num i,Fractional f) => Message -> Maybe (i,i,f)
unpack_tr :: forall i f. (Num i, Fractional f) => Message -> Maybe (i, i, f)
unpack_tr Message
m =
    let to_i :: Int32 -> i
to_i = forall a b. (Integral a, Num b) => a -> b
fromIntegral
        to_f :: Float -> f
to_f = forall a b. (Real a, Fractional b) => a -> b
realToFrac
    in case Message
m of
         Message Address_Pattern
"/tr" [Int32 Int32
p,Int32 Int32
q,Float Float
r] -> forall a. a -> Maybe a
Just (Int32 -> i
to_i Int32
p,Int32 -> i
to_i Int32
q,Float -> f
to_f Float
r)
         Message
_ -> forall a. Maybe a
Nothing

unpack_tr_err :: (Num i,Fractional f) => Message -> (i,i,f)
unpack_tr_err :: forall i f. (Num i, Fractional f) => Message -> (i, i, f)
unpack_tr_err = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => Address_Pattern -> a
error Address_Pattern
"unpack_tr") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i f. (Num i, Fractional f) => Message -> Maybe (i, i, f)
unpack_tr

unpack_b_setn :: (Num i,Fractional f) => Message -> Maybe (i,i,i,[f])
unpack_b_setn :: forall i f.
(Num i, Fractional f) =>
Message -> Maybe (i, i, i, [f])
unpack_b_setn Message
m =
    let to_i :: Int32 -> i
to_i = forall a b. (Integral a, Num b) => a -> b
fromIntegral
        to_f :: Datum -> b
to_f Datum
d = case Datum
d of
                    Float Float
n -> forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
n
                    Datum
_ -> forall a. HasCallStack => Address_Pattern -> a
error Address_Pattern
"unpack_b_setn: non-float data"
    in case Message
m of
         Message Address_Pattern
"/b_setn" (Int32 Int32
p:Int32 Int32
q:Int32 Int32
r:[Datum]
z) -> forall a. a -> Maybe a
Just (Int32 -> i
to_i Int32
p,Int32 -> i
to_i Int32
q,Int32 -> i
to_i Int32
r,forall a b. (a -> b) -> [a] -> [b]
map forall {b}. Fractional b => Datum -> b
to_f [Datum]
z)
         Message
_ -> forall a. Maybe a
Nothing

unpack_b_setn_err :: (Num i,Fractional f) => Message -> (i,i,i,[f])
unpack_b_setn_err :: forall i f. (Num i, Fractional f) => Message -> (i, i, i, [f])
unpack_b_setn_err = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => Address_Pattern -> a
error Address_Pattern
"unpack_b_setn") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i f.
(Num i, Fractional f) =>
Message -> Maybe (i, i, i, [f])
unpack_b_setn

-- | Unpack b_info message, fields are (id,frames,channels,sample-rate).
unpack_b_info :: (Num i,Fractional f) => Message -> Maybe (i,i,i,f)
unpack_b_info :: forall i f. (Num i, Fractional f) => Message -> Maybe (i, i, i, f)
unpack_b_info Message
m =
    let to_i :: Int32 -> i
to_i = forall a b. (Integral a, Num b) => a -> b
fromIntegral
        to_f :: Float -> f
to_f = forall a b. (Real a, Fractional b) => a -> b
realToFrac
    in case Message
m of
         Message Address_Pattern
"/b_info" [Int32 Int32
p,Int32 Int32
q,Int32 Int32
r,Float Float
s] -> forall a. a -> Maybe a
Just (Int32 -> i
to_i Int32
p,Int32 -> i
to_i Int32
q,Int32 -> i
to_i Int32
r,Float -> f
to_f Float
s)
         Message
_ -> forall a. Maybe a
Nothing

-- | Variant generating 'error'.
unpack_b_info_err :: (Num i,Fractional f) => Message -> (i,i,i,f)
unpack_b_info_err :: forall i f. (Num i, Fractional f) => Message -> (i, i, i, f)
unpack_b_info_err = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => Address_Pattern -> a
error Address_Pattern
"unpack_b_info") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall i f. (Num i, Fractional f) => Message -> Maybe (i, i, i, f)
unpack_b_info

-- Local Variables:
-- truncate-lines:t
-- End: