Documentation

The Udp transport handle data type.

The Tcp transport handle data type.

The basic elements of Osc messages.

An Osc Packet is either a Message or a Bundle.

A real-valued time stamp. For Osc proper this is an Ntp64 time in real-valued (fractional) form. For SuperCollider Nrt programs this is elapsed time since the start of the score. This is the primary form of timestamp used by hosc.

Type enumerating Datum categories.

Osc address pattern. This is strictly an Ascii value, however it is very common to pattern match on addresses and matching on Data.ByteString.Char8 requires OverloadedStrings.

Type for binary (integeral) representation of a 64-bit Ntp timestamp (ie. ntpi). The Ntp epoch is January 1, 1900. Ntp v4 also includes a 128-bit format, which is not used by Osc.

Transport is DuplexOsc with a MonadIO constraint.

Type for Ascii strings (strict Char8 ByteString)

Type for Word8 arrays, these are stored with an Datum length prefix.

Four-byte midi message: port-id, status-byte, data, data.

An Osc message, an Address_Pattern and a sequence of Datum.

An Osc bundle, a Time and a sequence of Messages. Do not allow recursion, all contents must be messages.

Ntp time in real-valued (fractional) form.

Unix/Posix time in real-valued (fractional) form. The Unix/Posix epoch is January 1, 1970.

Sender monad.

Receiver monad.

DuplexOsc is the union of SendOsc and RecvOsc.

Transport connection.

Decode an Osc Message from a lazy ByteString.

let b = ByteString.Lazy.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
decodeMessage b == Message "/g_free" [Int32 0]

Decode an Osc Bundle from a lazy ByteString.

Decode an Osc packet from a lazy ByteString.

let b = ByteString.Lazy.pack [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
decodePacket b == Packet_Message (Message "/g_free" [Int32 0])

Get an Osc Packet.

Decode an Osc packet from a strict Char8 ByteString.

Builder for an Osc Packet.

Encode an Osc Message, ie. encodePacket of Packet_Message.

let m = [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
encodeMessage (Message "/g_free" [Int32 0]) == L.pack m

Encode an Osc Bundle, ie. encodePacket of Packet_Bundle.

let m = [47,103,95,102,114,101,101,0,44,105,0,0,0,0,0,0]
let b = [35,98,117,110,100,108,101,0,0,0,0,0,0,0,0,1,0,0,0,16] ++ m
encodeBundle (Bundle immediately [Message "/g_free" [Int32 0]]) == L.pack b

Encode an Osc Packet.

Encode an Osc Packet to a strict ByteString.

Get the system time, epoch start of 1970 UTC, leap-seconds ignored. getSystemTime is typically much faster than getCurrentTime, however it is not available in Hugs.

The pauseThread limit (in seconds). Values larger than this require a different thread delay mechanism, see sleepThread. The value is the number of microseconds in maxBound::Int.

Repeat action until predicate f is True when applied to result.

Type generalised Float.

float (1::Int) == float (1::Double)
floatRange (undefined::Float) == (-125,128)
isInfinite (d_float (float (encodeFloat 1 256 :: Double))) == True

Type-specialised pack.

Type-specialised unpack.

Type-specialised pack.

Type-specialised unpack.

Type-specialised unpack.

Type-specialised unpack.

List of required data types (tag, name).

List of optional data types (tag,name).

List of all data types (tag,name).

Lookup name of type.

Erroring variant.

Single character identifier of an Osc datum.

Type and name of Datum.

Datum as Integral if Int32 or Int64.

let d = [Int32 5,Int64 5,Float 5.5,Double 5.5]
map datum_integral d == [Just (5::Int),Just 5,Nothing,Nothing]

Datum as Floating if Int32, Int64, Float, Double or TimeStamp.

let d = [Int32 5,Int64 5,Float 5,Double 5,TimeStamp 5]
mapMaybe datum_floating d == replicate 5 (5::Double)

Type generalised Datum.

int32 (1::Int32) == int32 (1::Integer)
d_int32 (int32 (maxBound::Int32)) == maxBound
int32 (((2::Int) ^ (64::Int))::Int) == Int32 0

Type generalised Int64.

int64 (1::Int32) == int64 (1::Integer)
d_int64 (int64 (maxBound::Int64)) == maxBound

Type generalised Double.

double (1::Int) == double (1::Double)
double (encodeFloat 1 256 :: Double) == Double 1.157920892373162e77

AsciiString of pack.

string "string" == AsciiString (ByteString.Char8.pack "string")

Four-tuple variant of Midi . MidiData.

midi (0,0,0,0) == Midi (MidiData 0 0 0 0)

Blob of blob_pack.

Message argument types are given by a signature.

signatureFor [Int32 1,Float 1,string "1"] == ",ifs"

The descriptor is an Ascii encoded signature.

descriptor [Int32 1,Float 1,string "1"] == ascii ",ifs"

Descriptor tags are comma prefixed.

Message constructor. It is an error if the Address_Pattern doesn't conform to the Osc specification.

Bundle constructor. It is an error if the Message list is empty.

Packet_Bundle of bundle.

Packet_Message of message.

Constant indicating a bundle to be executed immediately. It has the Ntp64 representation of 1.

ntpr_to_ntpi immediately == 1

The Time of Packet, if the Packet is a Message this is immediately.

Variant of either for Packet.

Retrieve the set of Messages from a Packet.

If Packet is a Message add immediately timestamp, else id.

If Packet is a Message or a Bundle with an immediate time tag and with one element, return the Message, else Nothing.

Is Packet immediate, ie. a Bundle with timestamp immediately, or a plain Message.

Does Message have the specified Address_Pattern.

Do any of the Messages at Bundle have the specified Address_Pattern.

Does Packet have the specified Address_Pattern, ie. message_has_address or bundle_has_address.

Convert an NtpReal timestamp to an Ntp64 timestamp.

ntpr_to_ntpi 0 == 0
fmap ntpr_to_ntpi time

Convert an Ntp64 timestamp to a real-valued Ntp timestamp.

ntpi_to_ntpr 0 == 0.0

Difference (in seconds) between Ntp and Posix epochs.

ntp_posix_epoch_diff / (24 * 60 * 60) == 25567
25567 `div` 365 == 70

Convert a PosixReal timestamp to an Ntp64 timestamp.

Convert Unix/Posix to Ntp.

Convert Ntp to Unix/Posix.

Convert Ntp64 to Unix/Posix.

Convert Time to POSIXTime.

Convert POSIXTime to Time.

The time at 1970-01-01:00:00:00 which is the Unix/Posix epoch.

Convert UTCTime to Unix/Posix.

utc_to_posix of Clock.getCurrentTime.

realToFrac of Clock.Posix.getPOSIXTime

get_ct = getCurrentTimeAsPosix
get_pt = getPosixTimeAsPosix
(ct,pt) <- get_ct >>= \t0 -> get_pt >>= \t1 -> return (t0,t1)
print (pt - ct,pt - ct < 1e-5)

Read current real-valued Ntp timestamp.

System time with fractional part in microseconds (us) instead of nanoseconds (ns).

Pause current thread for the indicated duration (in seconds), see pauseThreadLimit.

Pause current thread until the given time, see pauseThreadLimit.

Sleep current thread for the indicated duration (in seconds). Divides long sleeps into parts smaller than pauseThreadLimit.

Sleep current thread until the given time. Divides long sleeps into parts smaller than pauseThreadLimit.

Repeat action until f does not give Nothing when applied to result.

Bracket Open Sound Control communication.

Type restricted synonym for sendOsc.

Type restricted synonym for sendOsc.

Variant of recvPacket that runs packet_to_bundle.

Variant of recvPacket that runs packet_to_message.

Variant of recvPacket that runs packetMessages.

Wait for a Packet where the supplied predicate is True, discarding intervening packets.

Wait for a Packet where the supplied function does not give Nothing, discarding intervening packets.

waitUntil packet_is_immediate.

waitFor packet_to_message, ie. an incoming Message or immediate mode Bundle with one element.

A waitFor for variant using packet_has_address to match on the Address_Pattern of incoming Packets.

Variant on waitAddress that returns matching Message.

Variant of waitReply that runs messageDatum.

void of withTransport.

Erroring variant.

Return the port number associated with the Udp socket.

Send data over Udp using send.

Send data over Udp using sendAll.

Send packet over Udp.

Receive packet over Udp.

Close Udp.

Bracket Udp communication.

Create and initialise Udp socket.

Set option, ie. Broadcast or RecvTimeOut.

Get option.

Make a Udp connection.

Trivial Udp server socket.

import Control.Concurrent {- base -}

let u0 = udpServer "127.0.0.1" 57300
t0 <- forkIO (Fd.withTransport u0 (\fd -> forever (Fd.recvMessage fd >>= print >> print "Received message, continuing")))
killThread t0

let u1 = openUdp "127.0.0.1" 57300
Fd.withTransport u1 (\fd -> Fd.sendMessage fd (Packet.message "/n" []))

Variant of udpServer that doesn't require the host address.

Send to specified address using 'C.sendAllTo.

Recv variant to collect message source address.

Send data over Tcp.

Send packet over Tcp.

Receive packet over Tcp.

Close Tcp.

Bracket UDP communication.

Create and initialise Tcp socket.

Convert Socket to Tcp.

Create and initialise Tcp.

Make a Tcp connection.

import Sound.Osc.Datum {- hosc -}
import Sound.Osc.Time {- hosc -}
let t = openTcp "127.0.0.1" 57110
let m1 = Packet.message "/dumpOsc" [Int32 1]
let m2 = Packet.message "/g_new" [Int32 1]
Fd.withTransport t (\fd -> let f = Fd.sendMessage fd in f m1 >> pauseThread 0.25 >> f m2)

accept connection at s and run f.

A trivial Tcp Osc server.