module Sound.SC3.Server.Command.Generic where
import Data.List
import Data.Maybe
import Sound.OSC.Core
import qualified Sound.SC3.Common.Prelude as P
import qualified Sound.SC3.Server.Command.Enum as C
import qualified Sound.SC3.Server.Enum as E
import qualified Sound.SC3.Server.Graphdef as G
import qualified Sound.SC3.Server.Synthdef as S
b_alloc :: Integral i => i -> i -> i -> Message
b_alloc nid frames channels = message "/b_alloc" [int32 nid,int32 frames,int32 channels]
b_allocRead :: Integral i => i -> String -> i -> i -> Message
b_allocRead nid p f n = message "/b_allocRead" [int32 nid,string p,int32 f,int32 n]
b_allocReadChannel :: Integral i => i -> String -> i -> i -> [i] -> Message
b_allocReadChannel nid p f n cs = message "/b_allocReadChannel" ([int32 nid,string p,int32 f,int32 n] ++ map int32 cs)
b_close :: Integral i => i -> Message
b_close nid = message "/b_close" [int32 nid]
b_fill :: (Integral i,Real n) => i -> [(i,i,n)] -> Message
b_fill nid l = message "/b_fill" (int32 nid : P.mk_triples int32 int32 float l)
b_free :: Integral i => i -> Message
b_free nid = message "/b_free" [int32 nid]
b_gen :: Integral i => i -> String -> [Datum] -> Message
b_gen bid name arg = message "/b_gen" (int32 bid : string name : arg)
b_gen_sine1 :: (Integral i,Real n) => i -> [E.B_Gen] -> [n] -> Message
b_gen_sine1 z f n = b_gen z "sine1" (int32 (E.b_gen_flag f) : map float n)
b_gen_sine2 :: (Integral i,Real n) => i -> [E.B_Gen] -> [(n,n)] -> Message
b_gen_sine2 z f n = b_gen z "sine2" (int32 (E.b_gen_flag f) : P.mk_duples float float n)
b_gen_sine3 :: (Integral i,Real n) => i -> [E.B_Gen] -> [(n,n,n)] -> Message
b_gen_sine3 z f n = b_gen z "sine3" (int32 (E.b_gen_flag f) : P.mk_triples float float float n)
b_gen_cheby :: (Integral i,Real n) => i -> [E.B_Gen] -> [n] -> Message
b_gen_cheby z f n = b_gen z "cheby" (int32 (E.b_gen_flag f) : map float n)
b_gen_copy :: Integral i => i -> i -> i -> i -> Maybe i -> Message
b_gen_copy dst_b dst_ix src_b src_ix nf =
let nf' = fromMaybe (1) nf
in b_gen dst_b "copy" (map int32 [dst_ix,src_b,src_ix,nf'])
b_get :: Integral i => i -> [i] -> Message
b_get nid i = message "/b_get" (int32 nid : map int32 i)
b_getn :: Integral i => i -> [(i,i)] -> Message
b_getn nid l = message "/b_getn" (int32 nid : P.mk_duples int32 int32 l)
b_query :: Integral i => [i] -> Message
b_query = message "/b_query" . map int32
b_read :: Integral i => i -> String -> i -> i -> i -> Bool -> Message
b_read nid p f n f' z = message "/b_read" [int32 nid,string p,int32 f,int32 n,int32 f',int32 (fromEnum z)]
b_readChannel :: Integral i => i -> String -> i -> i -> i -> Bool -> [i] -> Message
b_readChannel nid p f n f' z cs = message "/b_readChannel" ([int32 nid,string p,int32 f,int32 n,int32 f',int32 (fromEnum z)] ++ map int32 cs)
b_set :: (Integral i,Real n) => i -> [(i,n)] -> Message
b_set nid l = message "/b_set" (int32 nid : P.mk_duples int32 float l)
b_setn :: (Integral i,Real n) => i -> [(i,[n])] -> Message
b_setn nid l =
let f (i,d) = int32 i : int32 (length d) : map float d
in message "/b_setn" (int32 nid : concatMap f l)
b_write :: Integral i => i -> String -> E.SoundFileFormat -> E.SampleFormat -> i -> i -> Bool -> Message
b_write nid p h t f s z =
let h' = string (E.soundFileFormatString h)
t' = string (E.sampleFormatString t)
in message "/b_write" [int32 nid,string p,h',t',int32 f,int32 s,int32 (fromEnum z)]
b_zero :: Integral i => i -> Message
b_zero nid = message "/b_zero" [int32 nid]
c_fill :: (Integral i,Real n) => [(i,i,n)] -> Message
c_fill = message "/c_fill" . P.mk_triples int32 int32 float
c_get :: Integral i => [i] -> Message
c_get = message "/c_get" . map int32
c_getn :: Integral i => [(i,i)] -> Message
c_getn = message "/c_getn" . P.mk_duples int32 int32
c_set :: (Integral i,Real n) => [(i,n)] -> Message
c_set = message "/c_set" . P.mk_duples int32 float
c_setn :: (Integral i,Real n) => [(i,[n])] -> Message
c_setn l =
let f (i,d) = int32 i : int32 (length d) : map float d
in message "/c_setn" (concatMap f l)
d_recv' :: G.Graphdef -> Message
d_recv' g = message "/d_recv" [Blob (G.encode_graphdef g)]
d_recv :: S.Synthdef -> Message
d_recv d = message "/d_recv" [Blob (S.synthdefData d)]
d_load :: String -> Message
d_load p = message "/d_load" [string p]
d_loadDir :: String -> Message
d_loadDir p = message "/d_loadDir" [string p]
d_free :: [String] -> Message
d_free = message "/d_free" . map string
g_deepFree :: Integral i => [i] -> Message
g_deepFree = message "/g_deepFree" . map int32
g_freeAll :: Integral i => [i] -> Message
g_freeAll = message "/g_freeAll" . map int32
g_head :: Integral i => [(i,i)] -> Message
g_head = message "/g_head" . P.mk_duples int32 int32
g_new :: Integral i => [(i,E.AddAction,i)] -> Message
g_new = message "/g_new" . P.mk_triples int32 (int32 . fromEnum) int32
g_tail :: Integral i => [(i,i)] -> Message
g_tail = message "/g_tail" . P.mk_duples int32 int32
g_dumpTree :: Integral i => [(i,Bool)] -> Message
g_dumpTree = message "/g_dumpTree" . P.mk_duples int32 (int32 . fromEnum)
g_queryTree :: Integral i => [(i,Bool)] -> Message
g_queryTree = message "/g_queryTree" . P.mk_duples int32 (int32 . fromEnum)
n_after :: Integral i => [(i,i)] -> Message
n_after = message "/n_after" . P.mk_duples int32 int32
n_before :: Integral i => [(i,i)] -> Message
n_before = message "/n_before" . P.mk_duples int32 int32
n_fill :: (Integral i,Real f) => i -> [(String,i,f)] -> Message
n_fill nid l = message "/n_fill" (int32 nid : P.mk_triples string int32 float l)
n_free :: Integral i => [i] -> Message
n_free = message "/n_free" . map int32
n_map :: Integral i => i -> [(String,i)] -> Message
n_map nid l = message "/n_map" (int32 nid : P.mk_duples string int32 l)
n_mapn :: Integral i => i -> [(String,i,i)] -> Message
n_mapn nid l = message "/n_mapn" (int32 nid : P.mk_triples string int32 int32 l)
n_mapa :: Integral i => i -> [(String,i)] -> Message
n_mapa nid l = message "/n_mapa" (int32 nid : P.mk_duples string int32 l)
n_mapan :: Integral i => i -> [(String,i,i)] -> Message
n_mapan nid l = message "/n_mapan" (int32 nid : P.mk_triples string int32 int32 l)
n_query :: Integral i => [i] -> Message
n_query = message "/n_query" . map int32
n_run :: Integral i => [(i,Bool)] -> Message
n_run = message "/n_run" . P.mk_duples int32 (int32 . fromEnum)
n_set :: (Integral i,Real n) => i -> [(String,n)] -> Message
n_set nid c = message "/n_set" (int32 nid : P.mk_duples string float c)
n_setn :: (Integral i,Real n) => i -> [(String,[n])] -> Message
n_setn nid l =
let f (s,d) = string s : int32 (length d) : map float d
in message "/n_setn" (int32 nid : concatMap f l)
n_trace :: Integral i => [i] -> Message
n_trace = message "/n_trace" . map int32
n_order :: Integral i => E.AddAction -> i -> [i] -> Message
n_order a n ns = message "/n_order" (int32 (fromEnum a) : int32 n : map int32 ns)
p_new :: Integral i => [(i,E.AddAction,i)] -> Message
p_new = message "/p_new" . P.mk_triples int32 (int32 . fromEnum) int32
s_get :: Integral i => i -> [String] -> Message
s_get nid i = message "/s_get" (int32 nid : map string i)
s_getn :: Integral i => i -> [(String,i)] -> Message
s_getn nid l = message "/s_getn" (int32 nid : P.mk_duples string int32 l)
s_new :: (Integral i,Real n) => String -> i -> E.AddAction -> i -> [(String,n)] -> Message
s_new n i a t c = message "/s_new" (string n : int32 i : int32 (fromEnum a) : int32 t : P.mk_duples string float c)
s_noid :: Integral i => [i] -> Message
s_noid = message "/s_noid" . map int32
u_cmd :: Integral i => i -> i -> String -> [Datum] -> Message
u_cmd nid uid name arg = message "/u_cmd" ([int32 nid,int32 uid,string name] ++ arg)
cmd :: String -> [Datum] -> Message
cmd name = message "/cmd" . (string name :)
clearSched :: Message
clearSched = message "/clearSched" []
dumpOSC :: E.PrintLevel -> Message
dumpOSC c = message "/dumpOSC" [int32 (fromEnum c)]
errorMode :: E.ErrorScope -> E.ErrorMode -> Message
errorMode scope mode =
let e = case scope of
E.Globally -> fromEnum mode
E.Locally -> 1 fromEnum mode
in message "/error" [int32 e]
notify :: Bool -> Message
notify c = message "/notify" [int32 (fromEnum c)]
nrt_end :: Message
nrt_end = message "/nrt_end" []
quit :: Message
quit = message "/quit" []
status :: Message
status = message "/status" []
sync :: Integral i => i -> Message
sync sid = message "/sync" [int32 sid]
with_completion_packet :: Message -> Packet -> Message
with_completion_packet (Message c xs) cm =
if c `elem` C.async_cmds
then let xs' = xs ++ [Blob (encodePacket cm)]
in Message c xs'
else error ("with_completion_packet: not async: " ++ c)
withCM :: Message -> Message -> Message
withCM m cm = with_completion_packet m (Packet_Message cm)
b_alloc_setn1 :: (Integral i,Real n) => i -> i -> [n] -> Message
b_alloc_setn1 nid i xs =
let k = i + genericLength xs
xs' = genericReplicate i 0 ++ xs
in withCM (b_alloc nid k 1) (b_setn1 nid 0 xs')
b_getn1 :: Integral i => i -> (i,i) -> Message
b_getn1 nid = b_getn nid . return
b_query1 :: Integral i => i -> Message
b_query1 = b_query . return
b_set1 :: (Integral i,Real n) => i -> i -> n -> Message
b_set1 nid i x = b_set nid [(i,x)]
b_setn1 :: (Integral i,Real n) => i -> i -> [n] -> Message
b_setn1 nid i xs = b_setn nid [(i,xs)]
b_setn1_segmented :: (Integral i,Real n) => i -> i -> i -> [n] -> [Message]
b_setn1_segmented k b i d =
if genericLength d < k
then [b_setn1 b i d]
else b_setn1 b i (genericTake k d) : b_setn1_segmented k b (i + k) (genericDrop k d)
c_getn1 :: Integral i => (i,i) -> Message
c_getn1 = c_getn . return
c_set1 :: (Integral i,Real n) => i -> n -> Message
c_set1 i x = c_set [(i,x)]
c_setn1 :: (Integral i,Real n) => (i,[n]) -> Message
c_setn1 = c_setn . return
n_run1 :: Integral i => i -> Bool -> Message
n_run1 nid k = n_run [(nid,k)]
n_set1 :: (Integral i,Real n) => i -> String -> n -> Message
n_set1 nid k n = n_set nid [(k,n)]
s_new0 :: Integral i => String -> i -> E.AddAction -> i -> Message
s_new0 n i a t = s_new n i a t ([]::[(String,Double)])
b_segment :: Integral i => i -> i -> [i]
b_segment n m =
let (q,r) = m `quotRem` n
s = genericReplicate q n
in if r == 0 then s else r : s
b_indices :: Integral i => i -> i -> i -> [(i,i)]
b_indices n m k =
let s = b_segment n m
i = 0 : P.dx_d s
in zip (map (+ k) i) s
pc_preparePartConv :: Integral i => i -> i -> i -> Message
pc_preparePartConv b irb fft_size =
b_gen b "PreparePartConv" (map int32 [irb, fft_size])
unpack_n_info_datum_plain :: Num i => [Datum] -> [i]
unpack_n_info_datum_plain m =
let to_i = fromIntegral
in case m of
[Int32 i1,Int32 i2,Int32 i3,Int32 i4,Int32 i5] -> [to_i i1,to_i i2,to_i i3,to_i i4,to_i i5]
[Int32 i1,Int32 i2,Int32 i3,Int32 i4,Int32 i5,Int32 i6,Int32 i7] -> [to_i i1,to_i i2,to_i i3,to_i i4,to_i i5,to_i i6,to_i i7]
_ -> []
unpack_n_info_plain :: Num i => Message -> [i]
unpack_n_info_plain m =
case m of
Message "/n_info" dat -> unpack_n_info_datum_plain dat
_ -> []
unpack_n_info :: Num i => Message -> Maybe (i,i,i,i,i,Maybe (i,i))
unpack_n_info m =
case unpack_n_info_plain m of
[i1,i2,i3,i4,i5] -> Just (i1,i2,i3,i4,i5,Nothing)
[i1,i2,i3,i4,i5,i6,i7] -> Just (i1,i2,i3,i4,i5,Just (i6,i7))
_ -> Nothing
unpack_n_info_err :: Num i => Message -> (i,i,i,i,i,Maybe (i,i))
unpack_n_info_err = fromMaybe (error "unpack_n_info") . unpack_n_info
unpack_tr :: (Num i,Fractional f) => Message -> Maybe (i,i,f)
unpack_tr m =
let to_i = fromIntegral
to_f = realToFrac
in case m of
Message "/tr" [Int32 p,Int32 q,Float r] -> Just (to_i p,to_i q,to_f r)
_ -> Nothing
unpack_tr_err :: (Num i,Fractional f) => Message -> (i,i,f)
unpack_tr_err = fromMaybe (error "unpack_tr") . unpack_tr
unpack_b_setn :: (Num i,Fractional f) => Message -> Maybe (i,i,i,[f])
unpack_b_setn m =
let to_i = fromIntegral
to_f d = case d of
Float n -> realToFrac n
_ -> error "unpack_b_setn: non-float data"
in case m of
Message "/b_setn" (Int32 p:Int32 q:Int32 r:z) -> Just (to_i p,to_i q,to_i r,map to_f z)
_ -> Nothing
unpack_b_setn_err :: (Num i,Fractional f) => Message -> (i,i,i,[f])
unpack_b_setn_err = fromMaybe (error "unpack_b_setn") . unpack_b_setn
unpack_b_info :: (Num i,Fractional f) => Message -> Maybe (i,i,i,f)
unpack_b_info m =
let to_i = fromIntegral
to_f = realToFrac
in case m of
Message "/b_info" [Int32 p,Int32 q,Int32 r,Float s] -> Just (to_i p,to_i q,to_i r,to_f s)
_ -> Nothing
unpack_b_info_err :: (Num i,Fractional f) => Message -> (i,i,i,f)
unpack_b_info_err = fromMaybe (error "unpack_b_info") . unpack_b_info