public boolean receive(final byte[] data, int length) { OSCByteArrayToJavaConverter c = new OSCByteArrayToJavaConverter(); OSCPacket p = c.convert(data, length); return receive(p); }
/** * Converts a byte array into an {@link OSCPacket} * (either an {@link OSCMessage} or {@link OSCBundle}). * @param bytes the storage containing the raw OSC packet * @param bytesLength indicates how many bytes the package consists of (<code><= bytes.length</code>) * @return the successfully parsed OSC packet; in case of a problem, * a <code>RuntimeException</code> is thrown */ public OSCPacket convert(byte[] bytes, int bytesLength) { final Input rawInput = new Input(bytes, bytesLength); final OSCPacket packet; if (isBundle(rawInput)) { packet = convertBundle(rawInput); } else { packet = convertMessage(rawInput); } return packet; }
/** * Reads an array from the byte stream. * @param types * @param pos at which position to start reading * @return the array that was read */ private List<Object> readArray(final Input rawInput, final CharSequence types, int pos) { int arrayLen = 0; while (types.charAt(pos + arrayLen) != ']') { arrayLen++; } final List<Object> array = new ArrayList<Object>(arrayLen); for (int ai = 0; ai < arrayLen; ai++) { array.add(readArgument(rawInput, types.charAt(pos + ai))); } return array; }
/** * Converts the byte array to a bundle. * Assumes that the byte array is a bundle. * @return a bundle containing the data specified in the byte stream */ private OSCBundle convertBundle(final Input rawInput) { // skip the "#bundle " stuff rawInput.addToStreamPosition(BUNDLE_START.length() + 1); final Date timestamp = readTimeTag(rawInput); final OSCBundle bundle = new OSCBundle(timestamp); final OSCByteArrayToJavaConverter myConverter = new OSCByteArrayToJavaConverter(); myConverter.setCharset(charset); while (rawInput.getStreamPosition() < rawInput.getBytesLength()) { // recursively read through the stream and convert packets you find final int packetLength = readInteger(rawInput); if (packetLength == 0) { throw new IllegalArgumentException("Packet length may not be 0"); } else if ((packetLength % 4) != 0) { throw new IllegalArgumentException("Packet length has to be a multiple of 4, is:" + packetLength); } final byte[] packetBytes = new byte[packetLength]; System.arraycopy(rawInput.getBytes(), rawInput.getStreamPosition(), packetBytes, 0, packetLength); rawInput.addToStreamPosition(packetLength); final OSCPacket packet = myConverter.convert(packetBytes, packetLength); bundle.addPacket(packet); } return bundle; }
/** * Converts the byte array to a simple message. * Assumes that the byte array is a message. * @return a message containing the data specified in the byte stream */ private OSCMessage convertMessage(final Input rawInput) { final OSCMessage message = new OSCMessage(); message.setAddress(readString(rawInput)); final CharSequence types = readTypes(rawInput); for (int ti = 0; ti < types.length(); ++ti) { if ('[' == types.charAt(ti)) { // we're looking at an array -- read it in message.addArgument(readArray(rawInput, types, ++ti)); // then increment i to the end of the array while (types.charAt(ti) != ']') { ti++; } } else { message.addArgument(readArgument(rawInput, types.charAt(ti))); } } return message; }
/** * Create an OSCPort that listens using a specified socket. * @param socket DatagramSocket to listen on. */ public OSCPortIn(final DatagramSocket socket) { super(socket, socket.getLocalPort()); this.converter = new OSCByteArrayToJavaConverter(); this.dispatcher = new OSCPacketDispatcher(); this.listeningThread = null; }
final OSCPacket oscPacket = converter.convert(buffer, packet.getLength()); dispatcher.dispatchPacket(oscPacket);
/** * Reads a string from the byte stream. * @return the next string in the byte stream */ private String readString(final Input rawInput) { final int strLen = lengthOfCurrentString(rawInput); final String res = new String(rawInput.getBytes(), rawInput.getStreamPosition(), strLen, charset); rawInput.addToStreamPosition(strLen); moveToFourByteBoundry(rawInput); return res; }
/** * Reads a binary blob from the byte stream. * @return the next blob in the byte stream */ private byte[] readBlob(final Input rawInput) { final int blobLen = readInteger(rawInput); final byte[] res = new byte[blobLen]; System.arraycopy(rawInput.getBytes(), rawInput.getStreamPosition(), res, 0, blobLen); rawInput.addToStreamPosition(blobLen); moveToFourByteBoundry(rawInput); return res; }
public boolean receive(final byte[] data, int length) { OSCByteArrayToJavaConverter c = new OSCByteArrayToJavaConverter(); OSCPacket p = c.convert(data, length); return receive(p); }