Safe Haskell	None
Language	Haskell2010

Sound.OSC

Description

Composite of Sound.OSC.Core and Sound.OSC.Transport.Monad.

Synopsis

class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
type UT = Double
type Time = Double
type NTP64 = Word64
immediately :: Time
ntpr_to_ntpi :: Time -> NTP64
ntpi_to_ntpr :: NTP64 -> Time
ntp_ut_epoch_diff :: Num n => n
ut_to_ntpi :: UT -> NTP64
ut_to_ntpr :: Num n => n -> n
ntpr_to_ut :: Num n => n -> n
ntpi_to_ut :: NTP64 -> UT
ntpr_to_posixtime :: Time -> POSIXTime
posixtime_to_ntpr :: POSIXTime -> Time
ut_epoch :: UTCTime
utc_to_ut :: Fractional n => UTCTime -> n
time :: MonadIO m => m Time
pauseThreadLimit :: Fractional n => n
pauseThread :: (MonadIO m, RealFrac n) => n -> m ()
wait :: MonadIO m => Double -> m ()
pauseThreadUntil :: MonadIO m => Time -> m ()
sleepThread :: (RealFrac n, MonadIO m) => n -> m ()
sleepThreadUntil :: MonadIO m => Time -> m ()
iso_8601_fmt :: String
iso_8601_to_utctime :: String -> Maybe UTCTime
utctime_to_iso_8601 :: UTCTime -> String
ntpr_to_iso_8601 :: Time -> String
iso_8601_to_ntpr :: String -> Maybe Time
time_pp :: Time -> String
type FP_Precision = Maybe Int
data Datum
- = Int32 {
  - d_int32 :: !Int32
  }
- | Int64 {
  - d_int64 :: !Int64
  }
- | Float {
  - d_float :: !Float
  }
- | Double {
  - d_double :: !Double
  }
- | ASCII_String {
  - d_ascii_string :: !ASCII
  }
- | Blob {
  - d_blob :: !BLOB
  }
- | TimeStamp {
  - d_timestamp :: !Time
  }
- | Midi {
  - d_midi :: !MIDI
  }
data MIDI = MIDI !Word8 !Word8 !Word8 !Word8
type BLOB = ByteString
type ASCII = ByteString
type Datum_Type = Char
ascii :: String -> ASCII
ascii_to_string :: ASCII -> String
blob_pack :: [Word8] -> BLOB
blob_unpack :: BLOB -> [Word8]
osc_types_required :: [(Datum_Type, String)]
osc_types_optional :: [(Datum_Type, String)]
osc_types :: [(Datum_Type, String)]
osc_type_name :: Datum_Type -> Maybe String
osc_type_name_err :: Datum_Type -> String
datum_tag :: Datum -> Datum_Type
datum_type_name :: Datum -> (Datum_Type, String)
datum_integral :: Integral i => Datum -> Maybe i
datum_floating :: Floating n => Datum -> Maybe n
int32 :: Integral n => n -> Datum
int64 :: Integral n => n -> Datum
float :: Real n => n -> Datum
double :: Real n => n -> Datum
string :: String -> Datum
midi :: (Word8, Word8, Word8, Word8) -> Datum
blob :: [Word8] -> Datum
descriptor :: [Datum] -> ASCII
descriptor_tags :: ASCII -> ASCII
floatPP :: RealFloat n => FP_Precision -> n -> String
timePP :: FP_Precision -> Time -> String
vecPP :: (a -> String) -> [a] -> String
blobPP :: BLOB -> String
stringPP :: String -> String
datumPP :: FP_Precision -> Datum -> String
datum_pp_typed :: FP_Precision -> Datum -> String
parse_datum :: Datum_Type -> String -> Maybe Datum
parse_datum_err :: Datum_Type -> String -> Datum
data Packet
- = Packet_Message {
  - packetMessage :: !Message
  }
- | Packet_Bundle {
  - packetBundle :: !Bundle
  }
data Bundle = Bundle {
- bundleTime :: !Time
- bundleMessages :: ![Message]
}
data Message = Message {
- messageAddress :: !Address_Pattern
- messageDatum :: ![Datum]
}
type Address_Pattern = String
message :: Address_Pattern -> [Datum] -> Message
bundle :: Time -> [Message] -> Bundle
p_bundle :: Time -> [Message] -> Packet
p_message :: Address_Pattern -> [Datum] -> Packet
packetTime :: Packet -> Time
packetMessages :: Packet -> [Message]
packet_to_bundle :: Packet -> Bundle
packet_to_message :: Packet -> Maybe Message
packet_is_immediate :: Packet -> Bool
at_packet :: (Message -> a) -> (Bundle -> a) -> Packet -> a
message_has_address :: Address_Pattern -> Message -> Bool
bundle_has_address :: Address_Pattern -> Bundle -> Bool
packet_has_address :: Address_Pattern -> Packet -> Bool
messagePP :: FP_Precision -> Message -> String
bundlePP :: FP_Precision -> Bundle -> String
packetPP :: FP_Precision -> Packet -> String
build_packet :: Packet -> Builder
encodePacket :: Packet -> ByteString
encodeMessage :: Message -> ByteString
encodeBundle :: Bundle -> ByteString
encodePacket_strict :: Packet -> ByteString
get_packet :: Get Packet
decodeMessage :: ByteString -> Message
decodeBundle :: ByteString -> Bundle
decodePacket :: ByteString -> Packet
decodePacket_strict :: ByteString -> Packet
timeout_r :: Double -> IO a -> IO (Maybe a)
untilPredicate :: Monad m => (a -> Bool) -> m a -> m a
untilMaybe :: Monad m => (a -> Maybe b) -> m a -> m b
type Connection t a = ReaderT t IO a
class (DuplexOSC m, MonadIO m) => Transport m
class (SendOSC m, RecvOSC m) => DuplexOSC m
class Monad m => RecvOSC m where
- recvPacket :: m Packet
class Monad m => SendOSC m where
- sendPacket :: Packet -> m ()
withTransport :: Transport t => IO t -> Connection t r -> IO r
withTransport_ :: Transport t => IO t -> Connection t r -> IO ()
sendMessage :: SendOSC m => Message -> m ()
sendBundle :: SendOSC m => Bundle -> m ()
recvBundle :: RecvOSC m => m Bundle
recvMessage :: RecvOSC m => m (Maybe Message)
recvMessage_err :: RecvOSC m => m Message
recvMessages :: RecvOSC m => m [Message]
waitUntil :: RecvOSC m => (Packet -> Bool) -> m Packet
waitFor :: RecvOSC m => (Packet -> Maybe a) -> m a
waitImmediate :: RecvOSC m => m Packet
waitMessage :: RecvOSC m => m Message
waitAddress :: RecvOSC m => Address_Pattern -> m Packet
waitReply :: RecvOSC m => Address_Pattern -> m Message
waitDatum :: RecvOSC m => Address_Pattern -> m [Datum]
newtype UDP = UDP {
- udpSocket :: Socket
}
udpPort :: Integral n => UDP -> IO n
upd_send_packet :: UDP -> Packet -> IO ()
udp_recv_packet :: UDP -> IO Packet
udp_close :: UDP -> IO ()
with_udp :: IO UDP -> (UDP -> IO t) -> IO t
udp_socket :: (Socket -> SockAddr -> IO ()) -> String -> Int -> IO UDP
set_udp_opt :: SocketOption -> Int -> UDP -> IO ()
get_udp_opt :: SocketOption -> UDP -> IO Int
openUDP :: String -> Int -> IO UDP
udpServer :: String -> Int -> IO UDP
udp_server :: Int -> IO UDP
sendTo :: UDP -> Packet -> SockAddr -> IO ()
recvFrom :: UDP -> IO (Packet, SockAddr)
newtype TCP = TCP {
- tcpHandle :: Handle
}
tcp_send_packet :: TCP -> Packet -> IO ()
tcp_recv_packet :: TCP -> IO Packet
tcp_close :: TCP -> IO ()
with_tcp :: IO TCP -> (TCP -> IO t) -> IO t
tcp_socket :: (Socket -> SockAddr -> IO ()) -> Maybe String -> Int -> IO Socket
socket_to_tcp :: Socket -> IO TCP
tcp_handle :: (Socket -> SockAddr -> IO ()) -> String -> Int -> IO TCP
openTCP :: String -> Int -> IO TCP
tcp_server_f :: Socket -> (TCP -> IO ()) -> IO ()
repeatM_ :: Monad m => m a -> m ()
tcp_server :: Int -> (TCP -> IO ()) -> IO ()

Documentation

class Monad m => MonadIO (m :: Type -> Type) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a #

Lift a computation from the IO monad.

Instances

Instances details

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #

type UT = Double Source #

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

type Time = Double Source #

NTP time in real-valued (fractional) form (ie. ntpr). This is the primary form of timestamp used by hosc.

type NTP64 = Word64 Source #

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

immediately :: Time Source #

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

ntpr_to_ntpi :: Time -> NTP64 Source #

Convert a real-valued NTP timestamp to an NTPi timestamp.

ntpr_to_ntpi immediately == 1
fmap ntpr_to_ntpi time

ntpi_to_ntpr :: NTP64 -> Time Source #

Convert an NTPi timestamp to a real-valued NTP timestamp.

ntp_ut_epoch_diff :: Num n => n Source #

Difference (in seconds) between NTP and UT epochs.

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

ut_to_ntpi :: UT -> NTP64 Source #

Convert a UT timestamp to an NTPi timestamp.

ut_to_ntpr :: Num n => n -> n Source #

Convert Unix/Posix to NTP.

ntpr_to_ut :: Num n => n -> n Source #

Convert NTP to Unix/Posix.

ntpi_to_ut :: NTP64 -> UT Source #

Convert NTPi to Unix/Posix.

ntpr_to_posixtime :: Time -> POSIXTime Source #

Convert Time to POSIXTime.

posixtime_to_ntpr :: POSIXTime -> Time Source #

Convert POSIXTime to Time.

ut_epoch :: UTCTime Source #

The time at 1970-01-01:00:00:00.

utc_to_ut :: Fractional n => UTCTime -> n Source #

Convert UTCTime to Unix/Posix.

time :: MonadIO m => m Time Source #

Read current real-valued NTP timestamp.

get_ct = fmap utc_to_ut T.getCurrentTime
get_pt = fmap realToFrac T.getPOSIXTime
(ct,pt) <- get_ct >>= \t0 -> get_pt >>= \t1 -> return (t0,t1)
print (pt - ct,pt - ct < 1e-5)

pauseThreadLimit :: Fractional n => n Source #

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.

pauseThread :: (MonadIO m, RealFrac n) => n -> m () Source #

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

wait :: MonadIO m => Double -> m () Source #

Type restricted pauseThread.

pauseThreadUntil :: MonadIO m => Time -> m () Source #

Pause current thread until the given Time, see pauseThreadLimit.

sleepThread :: (RealFrac n, MonadIO m) => n -> m () Source #

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

sleepThreadUntil :: MonadIO m => Time -> m () Source #

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

iso_8601_fmt :: String Source #

Detailed 37-character ISO 8601 format, including fractional seconds and '+0000' suffix.

iso_8601_to_utctime :: String -> Maybe UTCTime Source #

Parse time according to iso_8601_fmt

iso_8601_to_utctime "2015-11-26T00:29:37,145875000000+0000"

utctime_to_iso_8601 :: UTCTime -> String Source #

UTC time in iso_8601_fmt.

tm <- fmap (utctime_to_iso_8601 . T.posixSecondsToUTCTime) T.getPOSIXTime
(length tm,sum [4+1+2+1+2,1,2+1+2+1+2,1,12,1,4],sum [10,1,8,1,12,1,4]) == (37,37,37)

ntpr_to_iso_8601 :: Time -> String Source #

ISO 8601 of Time.

tm <- fmap ntpr_to_iso_8601 time
import System.Process {- process -}
rawSystem "date" ["-d",tm]

t = 15708783354150518784
s = "2015-11-26T00:22:19,366058349609+0000"
ntpr_to_iso_8601 (ntpi_to_ntpr t) == s

iso_8601_to_ntpr :: String -> Maybe Time Source #

Time of ISO 8601.

t = 15708783354150518784
s = "2015-11-26T00:22:19,366058349609+0000"
fmap ntpr_to_ntpi (iso_8601_to_ntpr s) == Just t

time_pp :: Time -> String Source #

Alias for ntpr_to_iso_8601.

time_pp immediately == "1900-01-01T00:00:00,000000000000+0000"
fmap time_pp time

type FP_Precision = Maybe Int Source #

Perhaps a precision value for floating point numbers.

data Datum Source #

The basic elements of OSC messages.

Constructors

Int32
Fields d_int32 :: !Int32
Int64
Fields d_int64 :: !Int64
Float
Fields d_float :: !Float
Double
Fields d_double :: !Double
ASCII_String
Fields d_ascii_string :: !ASCII
Blob
Fields d_blob :: !BLOB
TimeStamp
Fields d_timestamp :: !Time
Midi
Fields d_midi :: !MIDI

Instances

Instances details

Eq Datum Source #
Instance details Defined in Sound.OSC.Datum Methods (==) :: Datum -> Datum -> Bool # (/=) :: Datum -> Datum -> Bool #
Read Datum Source #
Instance details Defined in Sound.OSC.Datum Methods readsPrec :: Int -> ReadS Datum # readList :: ReadS [Datum] # readPrec :: ReadPrec Datum # readListPrec :: ReadPrec [Datum] #
Show Datum Source #
Instance details Defined in Sound.OSC.Datum Methods showsPrec :: Int -> Datum -> ShowS # show :: Datum -> String # showList :: [Datum] -> ShowS #

data MIDI Source #

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

Constructors

MIDI !Word8 !Word8 !Word8 !Word8

Instances

Instances details

Eq MIDI Source #
Instance details Defined in Sound.OSC.Datum Methods (==) :: MIDI -> MIDI -> Bool # (/=) :: MIDI -> MIDI -> Bool #
Read MIDI Source #
Instance details Defined in Sound.OSC.Datum Methods readsPrec :: Int -> ReadS MIDI # readList :: ReadS [MIDI] # readPrec :: ReadPrec MIDI # readListPrec :: ReadPrec [MIDI] #
Show MIDI Source #
Instance details Defined in Sound.OSC.Datum Methods showsPrec :: Int -> MIDI -> ShowS # show :: MIDI -> String # showList :: [MIDI] -> ShowS #

type BLOB = ByteString Source #

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

type ASCII = ByteString Source #

Type for ASCII strings (strict Char8 ByteString).

type Datum_Type = Char Source #

Type enumerating Datum categories.

ascii :: String -> ASCII Source #

Type-specialised pack.

ascii_to_string :: ASCII -> String Source #

Type-specialised unpack.

blob_pack :: [Word8] -> BLOB Source #

Type-specialised pack.

blob_unpack :: BLOB -> [Word8] Source #

Type-specialised unpack.

osc_types_required :: [(Datum_Type, String)] Source #

List of required data types (tag,name).

osc_types_optional :: [(Datum_Type, String)] Source #

List of optional data types (tag,name).

osc_types :: [(Datum_Type, String)] Source #

List of all data types (tag,name).

osc_type_name :: Datum_Type -> Maybe String Source #

Lookup name of type.

osc_type_name_err :: Datum_Type -> String Source #

Erroring variant.

datum_tag :: Datum -> Datum_Type Source #

Single character identifier of an OSC datum.

datum_type_name :: Datum -> (Datum_Type, String) Source #

Type and name of Datum.

datum_integral :: Integral i => Datum -> Maybe i Source #

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_floating :: Floating n => Datum -> Maybe n Source #

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)

int32 :: Integral n => n -> Datum Source #

Type generalised Int32.

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

int64 :: Integral n => n -> Datum Source #

Type generalised Int64.

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

float :: Real n => n -> Datum Source #

Type generalised Float.

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

double :: Real n => n -> Datum Source #

Type generalised Double.

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

string :: String -> Datum Source #

ASCII_String of pack.

string "string" == ASCII_String (Char8.pack "string")

midi :: (Word8, Word8, Word8, Word8) -> Datum Source #

Four-tuple variant of Midi . MIDI.

midi (0,0,0,0) == Midi (MIDI 0 0 0 0)

blob :: [Word8] -> Datum Source #

Blob of blob_pack.

descriptor :: [Datum] -> ASCII Source #

Message argument types are given by a descriptor.

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

descriptor_tags :: ASCII -> ASCII Source #

Descriptor tags are comma prefixed.

floatPP :: RealFloat n => FP_Precision -> n -> String Source #

Variant of showFFloat that deletes trailing zeros.

map (floatPP (Just 4)) [1,pi] == ["1.0","3.1416"]

timePP :: FP_Precision -> Time -> String Source #

Pretty printer for Time.

timePP (Just 4) (1/3) == "0.3333"

vecPP :: (a -> String) -> [a] -> String Source #

Pretty printer for vectors.

vecPP show [1::Int,2,3] == "<1,2,3>"

blobPP :: BLOB -> String Source #

Pretty printer for blobs, two-digit zero-padded hexadecimal.

stringPP :: String -> String Source #

Print strings in double quotes iff they contain white space.

datumPP :: FP_Precision -> Datum -> String Source #

Pretty printer for Datum.

let d = [Int32 1,Float 1.2,string "str",midi (0,0x90,0x40,0x60),blob [12,16]]
map (datumPP (Just 5)) d==  ["1","1.2","str","M<0,144,64,96>","B<0C,10>"]

datum_pp_typed :: FP_Precision -> Datum -> String Source #

Variant of datumPP that appends the datum_type_name.

parse_datum :: Datum_Type -> String -> Maybe Datum Source #

Given Datum_Type attempt to parse Datum at String.

parse_datum 'i' "42" == Just (Int32 42)
parse_datum 'h' "42" == Just (Int64 42)
parse_datum 'f' "3.14159" == Just (Float 3.14159)
parse_datum 'd' "3.14159" == Just (Double 3.14159)
parse_datum 's' "\"pi\"" == Just (string "pi")
parse_datum 'b' "[112,105]" == Just (Blob (blob_pack [112,105]))
parse_datum 'm' "(0,144,60,90)" == Just (midi (0,144,60,90))

parse_datum_err :: Datum_Type -> String -> Datum Source #

Erroring variant of parse_datum.

data Packet Source #

An OSC Packet is either a Message or a Bundle.

Constructors

Packet_Message
Fields packetMessage :: !Message
Packet_Bundle
Fields packetBundle :: !Bundle

Instances

Instances details

Eq Packet Source #
Instance details Defined in Sound.OSC.Packet Methods (==) :: Packet -> Packet -> Bool # (/=) :: Packet -> Packet -> Bool #
Read Packet Source #
Instance details Defined in Sound.OSC.Packet Methods readsPrec :: Int -> ReadS Packet # readList :: ReadS [Packet] # readPrec :: ReadPrec Packet # readListPrec :: ReadPrec [Packet] #
Show Packet Source #
Instance details Defined in Sound.OSC.Packet Methods showsPrec :: Int -> Packet -> ShowS # show :: Packet -> String # showList :: [Packet] -> ShowS #

data Bundle Source #

An OSC bundle, a Time and a sequence of Messages.

Constructors

Bundle
Fields bundleTime :: !Time bundleMessages :: ![Message]

Instances

Instances details

Eq Bundle Source #
Instance details Defined in Sound.OSC.Packet Methods (==) :: Bundle -> Bundle -> Bool # (/=) :: Bundle -> Bundle -> Bool #
Ord Bundle Source #	OSC `Bundle`s can be ordered (time ascending).
Instance details Defined in Sound.OSC.Packet Methods compare :: Bundle -> Bundle -> Ordering # (<) :: Bundle -> Bundle -> Bool # (<=) :: Bundle -> Bundle -> Bool # (>) :: Bundle -> Bundle -> Bool # (>=) :: Bundle -> Bundle -> Bool # max :: Bundle -> Bundle -> Bundle # min :: Bundle -> Bundle -> Bundle #
Read Bundle Source #
Instance details Defined in Sound.OSC.Packet Methods readsPrec :: Int -> ReadS Bundle # readList :: ReadS [Bundle] # readPrec :: ReadPrec Bundle # readListPrec :: ReadPrec [Bundle] #
Show Bundle Source #
Instance details Defined in Sound.OSC.Packet Methods showsPrec :: Int -> Bundle -> ShowS # show :: Bundle -> String # showList :: [Bundle] -> ShowS #

data Message Source #

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

Constructors

Message
Fields messageAddress :: !Address_Pattern messageDatum :: ![Datum]

Instances

Instances details

Eq Message Source #
Instance details Defined in Sound.OSC.Packet Methods (==) :: Message -> Message -> Bool # (/=) :: Message -> Message -> Bool #
Read Message Source #
Instance details Defined in Sound.OSC.Packet Methods readsPrec :: Int -> ReadS Message # readList :: ReadS [Message] # readPrec :: ReadPrec Message # readListPrec :: ReadPrec [Message] #
Show Message Source #
Instance details Defined in Sound.OSC.Packet Methods showsPrec :: Int -> Message -> ShowS # show :: Message -> String # showList :: [Message] -> ShowS #

type Address_Pattern = String Source #

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.

message :: Address_Pattern -> [Datum] -> Message Source #

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

bundle :: Time -> [Message] -> Bundle Source #

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

p_bundle :: Time -> [Message] -> Packet Source #

Packet_Bundle of bundle.

p_message :: Address_Pattern -> [Datum] -> Packet Source #

Packet_Message of message.

packetTime :: Packet -> Time Source #

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

packetMessages :: Packet -> [Message] Source #

Retrieve the set of Messages from a Packet.

packet_to_bundle :: Packet -> Bundle Source #

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

packet_to_message :: Packet -> Maybe Message Source #

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

packet_is_immediate :: Packet -> Bool Source #

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

at_packet :: (Message -> a) -> (Bundle -> a) -> Packet -> a Source #

Variant of either for Packet.

message_has_address :: Address_Pattern -> Message -> Bool Source #

Does Message have the specified Address_Pattern.

bundle_has_address :: Address_Pattern -> Bundle -> Bool Source #

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

packet_has_address :: Address_Pattern -> Packet -> Bool Source #

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

messagePP :: FP_Precision -> Message -> String Source #

Pretty printer for Message.

messagePP Nothing (Message "/m" [int32 0,float 1.0,string "s",midi (1,2,3,4),blob [1,2,3]])

bundlePP :: FP_Precision -> Bundle -> String Source #

Pretty printer for Bundle.

packetPP :: FP_Precision -> Packet -> String Source #

Pretty printer for Packet.

build_packet :: Packet -> Builder Source #

Builder for an OSC Packet.

encodePacket :: Packet -> ByteString Source #

Encode an OSC Packet.

encodeMessage :: Message -> ByteString Source #

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

encodeBundle :: Bundle -> ByteString Source #

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

encodePacket_strict :: Packet -> ByteString Source #

Encode an OSC Packet to a strict ByteString.

get_packet :: Get Packet Source #

Get an OSC Packet.

decodeMessage :: ByteString -> Message Source #

Decode an OSC Message from a lazy ByteString.

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

decodeBundle :: ByteString -> Bundle Source #

Decode an OSC Bundle from a lazy ByteString.

decodePacket :: ByteString -> Packet Source #

Decode an OSC packet from a lazy ByteString.

let b = B.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])

decodePacket_strict :: ByteString -> Packet Source #

Decode an OSC packet from a strict Char8 ByteString.

timeout_r :: Double -> IO a -> IO (Maybe a) Source #

Variant of timeout where time is given in fractional seconds.

untilPredicate :: Monad m => (a -> Bool) -> m a -> m a Source #

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

untilMaybe :: Monad m => (a -> Maybe b) -> m a -> m b Source #

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

type Connection t a = ReaderT t IO a Source #

Transport connection.

class (DuplexOSC m, MonadIO m) => Transport m Source #

Transport is DuplexOSC with a MonadIO constraint.

Instances

Instances details

(Transport t, MonadIO io) => Transport (ReaderT t io) Source #	`Transport` over `ReaderT`.
Instance details Defined in Sound.OSC.Transport.Monad

class (SendOSC m, RecvOSC m) => DuplexOSC m Source #

DuplexOSC is the union of SendOSC and RecvOSC.

Instances

Instances details

(Transport t, MonadIO io) => DuplexOSC (ReaderT t io) Source #	`DuplexOSC` over `ReaderT`.
Instance details Defined in Sound.OSC.Transport.Monad

class Monad m => RecvOSC m where Source #

Receiver monad.

Methods

recvPacket :: m Packet Source #

Receive and decode an OSC packet.

Instances

Instances details

(Transport t, MonadIO io) => RecvOSC (ReaderT t io) Source #	`RecvOSC` over `ReaderT`.
Instance details Defined in Sound.OSC.Transport.Monad Methods recvPacket :: ReaderT t io Packet Source #

class Monad m => SendOSC m where Source #

Sender monad.

Methods

sendPacket :: Packet -> m () Source #

Encode and send an OSC packet.

Instances

Instances details

(Transport t, MonadIO io) => SendOSC (ReaderT t io) Source #	`SendOSC` over `ReaderT`.
Instance details Defined in Sound.OSC.Transport.Monad Methods sendPacket :: Packet -> ReaderT t io () Source #

withTransport :: Transport t => IO t -> Connection t r -> IO r Source #

Bracket Open Sound Control communication.

withTransport_ :: Transport t => IO t -> Connection t r -> IO () Source #

void of withTransport.

sendMessage :: SendOSC m => Message -> m () Source #

Type restricted synonym for sendOSC.

sendBundle :: SendOSC m => Bundle -> m () Source #

Type restricted synonym for sendOSC.

recvBundle :: RecvOSC m => m Bundle Source #

Variant of recvPacket that runs packet_to_bundle.

recvMessage :: RecvOSC m => m (Maybe Message) Source #

Variant of recvPacket that runs packet_to_message.

recvMessage_err :: RecvOSC m => m Message Source #

Erroring variant.

recvMessages :: RecvOSC m => m [Message] Source #

Variant of recvPacket that runs packetMessages.

waitUntil :: RecvOSC m => (Packet -> Bool) -> m Packet Source #

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

waitFor :: RecvOSC m => (Packet -> Maybe a) -> m a Source #

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

waitImmediate :: RecvOSC m => m Packet Source #

waitUntil packet_is_immediate.

waitMessage :: RecvOSC m => m Message Source #

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

waitAddress :: RecvOSC m => Address_Pattern -> m Packet Source #

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

waitReply :: RecvOSC m => Address_Pattern -> m Message Source #

Variant on waitAddress that returns matching Message.

waitDatum :: RecvOSC m => Address_Pattern -> m [Datum] Source #

Variant of waitReply that runs messageDatum.

newtype UDP Source #

The UDP transport handle data type.

Constructors

UDP
Fields udpSocket :: Socket

Instances

Instances details

Transport UDP Source #	`UDP` is an instance of `Transport`.
Instance details Defined in Sound.OSC.Transport.FD.UDP Methods sendPacket :: UDP -> Packet -> IO () Source # recvPacket :: UDP -> IO Packet Source # close :: UDP -> IO () Source #

udpPort :: Integral n => UDP -> IO n Source #

Return the port number associated with the UDP socket.

upd_send_packet :: UDP -> Packet -> IO () Source #

Send packet over UDP using sendAll.

udp_recv_packet :: UDP -> IO Packet Source #

Receive packet over UDP.

udp_close :: UDP -> IO () Source #

Close UDP.

with_udp :: IO UDP -> (UDP -> IO t) -> IO t Source #

Bracket UDP communication.

udp_socket :: (Socket -> SockAddr -> IO ()) -> String -> Int -> IO UDP Source #

Create and initialise UDP socket.

set_udp_opt :: SocketOption -> Int -> UDP -> IO () Source #

Set option, ie. Broadcast or RecvTimeOut.

get_udp_opt :: SocketOption -> UDP -> IO Int Source #

Get option.

openUDP :: String -> Int -> IO UDP Source #

Make a UDP connection.

udpServer :: String -> Int -> IO UDP Source #

Trivial UDP server socket.

import Control.Concurrent

let u0 = udpServer "127.0.0.1" 57300
t0 <- forkIO (FD.withTransport u0 (\fd -> forever (FD.recvMessage fd >>= print)))

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

udp_server :: Int -> IO UDP Source #

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

sendTo :: UDP -> Packet -> SockAddr -> IO () Source #

Send to specified address using 'C.sendAllTo.

recvFrom :: UDP -> IO (Packet, SockAddr) Source #

Recv variant to collect message source address.

newtype TCP Source #

The TCP transport handle data type.

Constructors

TCP
Fields tcpHandle :: Handle

Instances

Instances details

Transport TCP Source #	`TCP` is an instance of `Transport`.
Instance details Defined in Sound.OSC.Transport.FD.TCP Methods sendPacket :: TCP -> Packet -> IO () Source # recvPacket :: TCP -> IO Packet Source # close :: TCP -> IO () Source #

tcp_send_packet :: TCP -> Packet -> IO () Source #

Send packet over TCP.

tcp_recv_packet :: TCP -> IO Packet Source #

Receive packet over TCP.

tcp_close :: TCP -> IO () Source #

Close TCP.

with_tcp :: IO TCP -> (TCP -> IO t) -> IO t Source #

Bracket UDP communication.

tcp_socket :: (Socket -> SockAddr -> IO ()) -> Maybe String -> Int -> IO Socket Source #

Create and initialise TCP socket.

socket_to_tcp :: Socket -> IO TCP Source #

Convert Socket to TCP.

tcp_handle :: (Socket -> SockAddr -> IO ()) -> String -> Int -> IO TCP Source #

Create and initialise TCP.

openTCP :: String -> Int -> IO TCP Source #

Make a TCP connection.

import Sound.OSC.Datum 
import Sound.OSC.Time 
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)

tcp_server_f :: Socket -> (TCP -> IO ()) -> IO () Source #

accept connection at s and run f.

repeatM_ :: Monad m => m a -> m () Source #

sequence_ of repeat.

tcp_server :: Int -> (TCP -> IO ()) -> IO () Source #

A trivial TCP OSC server.