def build(self) -> osc_message.OscMessage:
"""Builds an OscMessage from the current state of this builder.
Raises:
- BuildError: if the message could not be build or if the address
was empty.
Returns:
- an osc_message.OscMessage instance.
"""
if not self._address:
raise BuildError('OSC addresses cannot be empty')
dgram = b''
try:
# Write the address.
dgram += osc_types.write_string(self._address)
if not self._args:
dgram += osc_types.write_string(',')
return osc_message.OscMessage(dgram)
# Write the parameters.
arg_types = "".join([arg[0] for arg in self._args])
dgram += osc_types.write_string(',' + arg_types)
for arg_type, value in self._args:
if arg_type == self.ARG_TYPE_STRING:
dgram += osc_types.write_string(value)
elif arg_type == self.ARG_TYPE_INT:
dgram += osc_types.write_int(value)
elif arg_type == self.ARG_TYPE_INT64:
dgram += osc_types.write_int64(value)
elif arg_type == self.ARG_TYPE_FLOAT:
dgram += osc_types.write_float(value)
elif arg_type == self.ARG_TYPE_DOUBLE:
dgram += osc_types.write_double(value)
elif arg_type == self.ARG_TYPE_BLOB:
dgram += osc_types.write_blob(value)
elif arg_type == self.ARG_TYPE_RGBA:
dgram += osc_types.write_rgba(value)
elif arg_type == self.ARG_TYPE_MIDI:
dgram += osc_types.write_midi(value)
elif arg_type in (self.ARG_TYPE_TRUE,
self.ARG_TYPE_FALSE,
self.ARG_TYPE_ARRAY_START,
self.ARG_TYPE_ARRAY_STOP,
self.ARG_TYPE_NIL):
continue
else:
raise BuildError('Incorrect parameter type found {}'.format(
arg_type))
return osc_message.OscMessage(dgram)
except osc_types.BuildError as be:
raise BuildError('Could not build the message: {}'.format(be))
def test_all_non_standard_params(self):
msg = osc_message.OscMessage(_DGRAM_ALL_NON_STANDARD_TYPES_OF_PARAMS)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(2, len(msg.params))
self.assertEqual(True, msg.params[0])
self.assertEqual(False, msg.params[1])
self.assertEqual(2, len(list(msg)))
def _parse_contents(self, index: int) -> Any:
contents = []
try:
# An OSC Bundle Element consists of its size and its contents.
# The size is an int32 representing the number of 8-bit bytes in the
# contents, and will always be a multiple of 4. The contents are either
# an OSC Message or an OSC Bundle.
while self._dgram[index:]:
# Get the sub content size.
content_size, index = osc_types.get_int(self._dgram, index)
# Get the datagram for the sub content.
content_dgram = self._dgram[index:index + content_size]
# Increment our position index up to the next possible content.
index += content_size
# Parse the content into an OSC message or bundle.
if OscBundle.dgram_is_bundle(content_dgram):
contents.append(OscBundle(content_dgram))
elif osc_message.OscMessage.dgram_is_message(content_dgram):
contents.append(osc_message.OscMessage(content_dgram))
else:
logging.warning(
"Could not identify content type of dgram %s" %
content_dgram)
except (osc_types.ParseError, osc_message.ParseError, IndexError) as e:
raise ParseError("Could not parse a content datagram: %s" % e)
return contents
def __init__(self, dgram):
"""Initialize an OdpPacket with the given UDP datagram.
Args:
- dgram: the raw UDP datagram holding the OSC packet.
Raises:
- ParseError if the datagram could not be parsed.
"""
now = time.time() #calendar.timegm(time.gmtime())
try:
if osc_bundle.OscBundle.dgram_is_bundle(dgram):
#bund=osc_bundle.OscBundle(dgram)
self._messages = sorted(_timed_msg_of_bundle(
osc_bundle.OscBundle(dgram), now),
key=lambda x: x.time)
elif osc_message.OscMessage.dgram_is_message(dgram):
self._messages = (TimedMessage(
now, osc_message.OscMessage(dgram)), )
else:
# Empty packet, should not happen as per the spec but heh, UDP...
raise ParseError(
'OSC Packet should at least contain an OscMessage or an '
'OscBundle.')
except (osc_bundle.ParseError, osc_message.ParseError) as pe:
raise ParseError('Could not parse packet %s' % pe)
def test_complex_array_params(self):
msg = osc_message.OscMessage(_DGRAM_COMPLEX_ARRAY_PARAMS)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(3, len(msg.params))
self.assertEqual([1], msg.params[0])
self.assertEqual([["ABC", "DEF"]], msg.params[1])
self.assertEqual([[2], [3, ["GHI"]]], msg.params[2])
self.assertEqual(3, len(list(msg)))
def recv(self, dgram_size=1024, timeout=1):
'''Receive UDP OSC message from SC'''
ready = select.select([self._sock], [], [], timeout)[0]
if ready:
dgram = self._sock.recv(dgram_size)
msg = osc_message.OscMessage(dgram)
return msg.params
raise TimeoutError('socket timeout when receiving data from SC')
def test_all_standard_types_off_params(self):
msg = osc_message.OscMessage(_DGRAM_ALL_STANDARD_TYPES_OF_PARAMS)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(4, len(msg.params))
self.assertEqual(3, msg.params[0])
self.assertAlmostEqual(2.0, msg.params[1])
self.assertEqual("ABC", msg.params[2])
self.assertEqual(b"stuff\x00\x00\x00", msg.params[3])
self.assertEqual(4, len(list(msg)))
def test_all_non_standard_params(self):
msg = osc_message.OscMessage(_DGRAM_ALL_NON_STANDARD_TYPES_OF_PARAMS)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(5, len(msg.params))
self.assertEqual(True, msg.params[0])
self.assertEqual(False, msg.params[1])
self.assertEqual([], msg.params[2])
self.assertEqual((datetime(1900, 1, 1, 0, 0, 0), 0), msg.params[3])
self.assertEqual(1000000000000, msg.params[4])
self.assertEqual(5, len(list(msg)))
def process(self, data, sender):
now = time.time()
# TODO exception handling
if osc_bundle.OscBundle.dgram_is_bundle(data):
bundle = osc_bundle.OscBundle(data)
self.process_bundle(bundle, now, sender)
return True
elif osc_message.OscMessage.dgram_is_message(data):
msg = osc_message.OscMessage(data)
self.queue.put(([msg], now, sender))
return True
else:
return False
def process(dgram):
"""Process datagram to OSC bundle or message."""
try:
if osc_bundle.OscBundle.dgram_is_bundle(dgram):
bundle = osc_bundle.OscBundle(dgram)
if bundle.num_contents != 1 or \
not isinstance(bundle.content(0), osc_message.OscMessage):
raise ValueError("XIO OSC bundle should contain"
"a single OSC message.")
return bundle
elif osc_message.OscMessage.dgram_is_message(dgram):
return osc_message.OscMessage(dgram)
else:
# Empty packet, should not happen as per the spec but heh, UDP...
raise ParseError("Datagram should at least contain"
"an OscMessage or an OscBundle.")
except (osc_bundle.ParseError, osc_message.ParseError) as error:
raise ParseError("Could not parse packet {:s}".format(error))
def build_dgram(self):
"""Builds an OscMessage datagram from the current state of this builder.
Raises:
- BuildError: if the message could not be build or if the address
was empty.
Returns:
- an osc_message.OscMessage instance.
"""
if not self._address:
raise BuildError('OSC addresses cannot be empty')
dgram = b''
try:
# Write the address.
dgram += osc_types.write_string(self._address)
if not self._args:
dgram += osc_types.write_string(',')
return osc_message.OscMessage(dgram)
# Write the parameters.
arg_types = "".join([arg[0] for arg in self._args])
dgram += osc_types.write_string(',' + arg_types)
for arg_type, value in self._args:
if arg_type == self.ARG_TYPE_STRING:
dgram += osc_types.write_string(value)
elif arg_type == self.ARG_TYPE_INT:
dgram += osc_types.write_int(value)
elif arg_type == self.ARG_TYPE_FLOAT:
dgram += osc_types.write_float(value)
elif arg_type == self.ARG_TYPE_BLOB:
dgram += osc_types.write_blob(value)
elif arg_type == self.ARG_TYPE_TRUE or arg_type == self.ARG_TYPE_FALSE:
continue
else:
raise BuildError('Incorrect parameter type found {}'.format(
arg_type))
return dgram
except osc_types.BuildError as be:
raise BuildError('Could not build the message: {}'.format(be))
def handleMsg(self, msg, type, name, uuid, *args, **kwargs):
# Pop first frame as bytes, assumes single-frame message
frameBytes = msg.pop()
oscMsg = osc_message.OscMessage(frameBytes)
if len(oscMsg.params) == 2:
# Assume midi message
channel = int(oscMsg.params[0])
value = int(oscMsg.params[1])
if channel == 1:
# volume
self.volume = ((1 - (value / 127.0)) * 60 - 0.5)
elif channel == 11:
# pitch
self.pitch = (value / 127) * 2 - 1
else:
# Assume play cue
name = oscMsg.address[1:]
# alter pitch with pydub
sound = AudioSegment.from_file(name + '.wav', format="wav")
sound = sound - self.volume
octaves = self.pitch
newSampleRate = sound.frame_rate * (2.0**octaves)
hipitch_sound = sound._spawn(
sound.raw_data, overrides={'frame_rate': int(newSampleRate)})
hipitch_sound = hipitch_sound.set_frame_rate(44100)
# sound buffer with simpleaudio (non-blocking)
simpleaudio.play_buffer(
hipitch_sound.raw_data,
num_channels=hipitch_sound.channels,
bytes_per_sample=hipitch_sound.sample_width,
sample_rate=hipitch_sound.frame_rate)
return None
def cmd_rcvrtestfunc(self, sigstr):
"""..."""
msg = osc_message.OscMessage(sigstr)
print('In cmd_rcvrtestfunc, OSC address: {}'.format(msg.address))
for idx, param in enumerate(msg.params):
print('param[{0}]: {1}'.format(idx, param))
if msg.address == '/cue':
if msg.params[0] == "Next":
print('OSC msg.params[0]: {}'.format(msg.params[0]))
self.next_cue()
elif msg.address == '/cue/#':
print('cue # : {}'.format(msg.params[0]))
#self.execute_cue(msg.params[0])
The_Show.cues.currentcueindex = int(msg.params[0])
self.tableView.setCurrentIndex(
self.tablemodel.createIndex(The_Show.cues.currentcueindex, 0))
#self.tableView.showRow(The_Show.cues.currentcueindex)
elif msg.address == '/cue/uuid':
print('cue uuid : {}'.format(msg.params[0]))
#self.execute_cue_uuid(msg.params[0])
elif msg.address == '/cue/quit':
print('cue external quit')
self.externalclose = True
self.close()
def test_ignores_unknown_param(self):
msg = osc_message.OscMessage(_DGRAM_UNKNOWN_PARAM_TYPE)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(1, len(msg.params))
self.assertTrue(type(msg.params[0]) == float)
self.assertAlmostEqual(0.5, msg.params[0])
def test_parse_long_params_list(self):
msg = osc_message.OscMessage(_DGRAM_LONG_LIST)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(1, len(msg.params))
self.assertEqual(512, len(msg.params[0]))
def test_switch_goes_on(self):
msg = osc_message.OscMessage(_DGRAM_SWITCH_GOES_ON)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(1, len(msg.params))
self.assertTrue(type(msg.params[0]) == float)
self.assertAlmostEqual(0.5, msg.params[0])
def test_no_params(self):
msg = osc_message.OscMessage(_DGRAM_NO_PARAMS)
self.assertEqual("/SYNC", msg.address)
self.assertEqual(0, len(msg.params))
def test_knob_rotates(self):
msg = osc_message.OscMessage(_DGRAM_KNOB_ROTATES)
self.assertEqual("/FB", msg.address)
self.assertEqual(1, len(msg.params))
self.assertTrue(type(msg.params[0]) == float)
