Sound.SC3.Server.Transport.Monad

Monad variant of interaction with the scsynth server.

hosc variants

async :: DuplexOSC m => Message -> m Message

sendMessage and waitReply for a /done reply.

async_ :: DuplexOSC m => Message -> m ()

void of async.

maybe_async :: DuplexOSC m => Message -> m ()

If isAsync then async_ else sendMessage.

maybe_async_at :: DuplexOSC m => Time -> Message -> m ()

Variant that timestamps synchronous messages.

sc3_default_udp :: (String, Int)

Local host (ie. 127.0.0.1) at port sc3_port_def

sc3_udp_limit :: Num n => n

Maximum packet size, in bytes, that can be sent over UDP. However, see also https://tools.ietf.org/html/rfc2675

withSC3At :: (String, Int) -> Connection UDP a -> IO a

Bracket SC3 communication at indicated host and port.

withSC3 :: Connection UDP a -> IO a

Bracket SC3 communication, ie. withSC3At sc3_default_udp.

import Sound.SC3.Server.Command

withSC3 (sendMessage status >> waitReply "/status.reply")

withSC3_ :: Connection UDP a -> IO ()

void of withSC3.

withSC3_tm :: Double -> Connection UDP a -> IO (Maybe a)

timeout_r of withSC3

withSC3At_seq :: (String, Int) -> Int -> Connection UDP a -> IO [a]

Run f at k scsynth servers with sequential port numbers starting at sc3_port_def.

withSC3At_seq sc3_default_udp 2 (sendMessage status >> waitReply "/status.reply")

withSC3At_seq_ :: (String, Int) -> Int -> Connection UDP a -> IO ()

void of withSC3_seq.

Server control

stop :: SendOSC m => m ()

Free all nodes (g_freeAll) at group 1.

Composite

reset :: SendOSC m => m ()

Runs clearSched and then frees and re-creates groups 1 and 2.

type Play_Opt = (Node_Id, AddAction, Group_Id, [(String, Double)])

(node-id,add-action,group-id,parameters)

play_graphdef_msg :: Play_Opt -> Graphdef -> Message

Make s_new message to play Graphdef.

recv_or_load_graphdef :: Transport m => Graphdef -> m Message

If the graph size is less than sc3_udp_limit encode and send using d_recv_bytes, else write to temporary directory and read using d_load.

playGraphdef :: Transport m => Play_Opt -> Graphdef -> m ()

Send d_recv and s_new messages to scsynth.

playSynthdef :: Transport m => Play_Opt -> Synthdef -> m ()

Send d_recv and s_new messages to scsynth.

playUGen :: Transport m => Play_Opt -> UGen -> m ()

Send an anonymous instrument definition using playSynthdef.

NRT

run_bundle :: Transport m => Time -> Bundle -> m ()

Wait (pauseThreadUntil) until bundle is due to be sent relative to the initial Time, then send each message, asynchronously if required.

nrt_play :: Transport m => NRT -> m ()

Play an NRT score (as would be rendered by writeNRT).

let sc = NRT [bundle 1 [s_new0 "default" (-1) AddToHead 1]
             ,bundle 2 [n_set1 (-1) "gate" 0]]
in withSC3 (nrt_play sc)

nrt_play_reorder :: Transport m => NRT -> m ()

Variant where asynchronous commands at time 0 are separated out and run before the initial time-stamp is taken. This re-orders synchronous commands in relation to asynchronous at time 0.

nrt_audition :: NRT -> IO ()

withSC3 of nrt_play.

Audible

class Audible e where

Class for values that can be encoded and send to scsynth for audition.

Minimal complete definition

play_at

Methods

play_at :: Transport m => Play_Opt -> e -> m ()

play :: Transport m => e -> m ()

Variant where id is -1.

Instances

Audible Graphdef

Defined in Sound.SC3.Server.Transport.Monad

Methods

play_at :: Transport m => Play_Opt -> Graphdef -> m ()

play :: Transport m => Graphdef -> m ()

Audible UGen

Defined in Sound.SC3.Server.Transport.Monad

Methods

play_at :: Transport m => Play_Opt -> UGen -> m ()

play :: Transport m => UGen -> m ()

Audible Synthdef

Defined in Sound.SC3.Server.Transport.Monad

Methods

play_at :: Transport m => Play_Opt -> Synthdef -> m ()

play :: Transport m => Synthdef -> m ()

audition_at :: Audible e => (String, Int) -> Play_Opt -> e -> IO ()

withSC3At of play_at.

audition_at_seq :: Audible e => (String, Int) -> Play_Opt -> Int -> e -> IO ()

withSC3_seq of play_at.

def_play_opt :: Play_Opt

Default Play_Opt, ie. (-1,addToHead,1,[])

audition :: Audible e => e -> IO ()

audition_at def_play_opt

audition_seq :: Audible e => Int -> e -> IO ()

audition_at_seq def_play_opt

Notifications

withNotifications :: DuplexOSC m => m a -> m a

Turn on notifications, run f, turn off notifications, return result.

Buffer & control & node variants.

b_getn1_data :: DuplexOSC m => Int -> (Int, Int) -> m [Double]

Variant of b_getn1 that waits for return message and unpacks it.

withSC3_tm 1.0 (b_getn1_data 0 (0,5))

b_getn1_data_segment :: DuplexOSC m => Int -> Int -> (Int, Int) -> m [Double]

Variant of b_getn1_data that segments individual b_getn messages to n elements.

withSC3_tm 1.0 (b_getn1_data_segment 1 0 (0,5))

b_fetch :: DuplexOSC m => Int -> Int -> m [[Double]]

Variant of b_getn1_data_segment that gets the entire buffer.

b_fetch1 :: DuplexOSC m => Int -> Int -> m [Double]

First channel of b_fetch, errors if there is no data.

withSC3 (b_fetch1 512 123456789)

b_fetch_hdr :: Transport m => Int -> Int -> m ((Int, Int, Int, Double), [[Double]])

Combination of b_query1_unpack and b_fetch.

b_query1_unpack_generic :: (DuplexOSC m, Num n, Fractional r) => Int -> m (n, n, n, r)

b_info_unpack_err of b_query1.

b_query1_unpack :: DuplexOSC m => Buffer_Id -> m (Int, Int, Int, Double)

Type specialised b_query1_unpack_generic.

withSC3 (b_query1_unpack 0)

c_getn1_data :: (DuplexOSC m, Floating t) => (Int, Int) -> m [t]

Variant of c_getn1 that waits for the reply and unpacks the data.

n_query1_unpack_f :: DuplexOSC m => (Message -> t) -> Node_Id -> m t

Apply f to result of n_query.

n_query1_unpack :: DuplexOSC m => Node_Id -> m (Maybe (Int, Int, Int, Int, Int, Maybe (Int, Int)))

Variant of n_query that waits for and unpacks the reply.

n_query1_unpack_plain :: DuplexOSC m => Node_Id -> m [Int]

Variant of n_query1_unpack that returns plain (un-lifted) result.

g_queryTree1_unpack :: DuplexOSC m => Group_Id -> m Query_Node

Variant of g_queryTree that waits for and unpacks the reply.

Status

serverStatus :: DuplexOSC m => m [String]

Collect server status information.

withSC3 serverStatus >>= mapM putStrLn

server_status_concise :: DuplexOSC m => m String

Collect server status information.

withSC3 server_status_concise >>= putStrLn

serverSampleRateNominal :: DuplexOSC m => m Double

Read nominal sample rate of server.

withSC3 serverSampleRateNominal

serverSampleRateActual :: DuplexOSC m => m Double

Read actual sample rate of server.

withSC3 serverSampleRateActual

serverStatusData :: DuplexOSC m => m [Datum]

Retrieve status data from server.

Tree

serverTree :: DuplexOSC m => m [String]

Collect server node tree information.

withSC3 serverTree >>= mapM_ putStrLn