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.

type Sc3_Address = OscSocketAddress

Hostname and port number. By default Tcp, 127.0.0.1 and 57110.

sc3_default_address :: Sc3_Address

Sc3 default address.

>>> sc3_default_address
(Tcp,"127.0.0.1",57110)

sc3_env_or_default_address :: IO Sc3_Address

Lookup ScSynth address at ScHostname and ScPort. If either is no set default values are used.

>>> import System.Environment
>>> setEnv "ScHostname" "192.168.1.53"
>>> sc3_env_or_default_address
(Udp,"192.168.1.53",57110)

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. Tcp is now the default transport mechanism for Hsc3.

withSc3At :: Sc3_Address -> Connection OscSocket a -> IO a

Bracket Sc3 communication at indicated host and port.

withSc3 :: Connection OscSocket a -> IO a

Bracket Sc3 communication, ie. withSc3At sc3_env_or_default_address.

import Sound.Sc3.Server.Command

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

withSc3_ :: Connection OscSocket a -> IO ()

void of withSc3.

withSc3_tm :: Double -> Connection OscSocket a -> IO (Maybe a)

timeout_r of withSc3

withSc3AtSeq :: Sc3_Address -> Int -> Connection OscSocket a -> IO [a]

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

withSc3AtSeq sc3_default_address 2 (sendMessage status >> waitReply "/status.reply")

withSc3AtSeq_ :: Sc3_Address -> Int -> Connection OscSocket a -> IO ()

void of withSc3AtSeq.

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

sc_latency :: IO Double

Read latency from environment, defaulting to 0.1 seconds.

run_bundle :: Transport m => Double -> Time -> BundleOf Message -> 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

playAt

Methods

playAt :: 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

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

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

Audible Synthdef

Defined in Sound.Sc3.Server.Transport.Monad

Methods

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

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

Audible Ugen

Defined in Sound.Sc3.Server.Transport.Monad

Methods

playAt :: Transport m => Play_Opt -> Ugen -> m ()

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

auditionAt :: Audible e => Sc3_Address -> Play_Opt -> e -> IO ()

withSc3At of playAt.

auditionAtSeq :: Audible e => Sc3_Address -> Play_Opt -> Int -> e -> IO ()

withSc3AtSeq of playAt.

def_play_opt :: Play_Opt

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

auditionOpt :: Audible e => Play_Opt -> e -> IO ()

auditionAt sc3_env_or_default_address

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

auditionOpt def_play_opt

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

auditionAtSeq 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