private void CompleteRead(IAsyncResult ar)
{
var size = m_socket.EndReceive(ar);
if (size > 0 &&
ar.AsyncState is byte[] data)
{
Scheduler.Schedule(() =>
{
var start = 0;
OscPacket packet = null;
try
{
packet = OscPacket.FromByteArray(data, ref start, size);
}
catch (Exception e)
{
if (!SuppressParsingExceptions)
{
throw new Exception("Error deserialising packet", e);
}
packet = null;
}
if (packet != null)
{
ForwardPacket(packet);
}
});
}
}
private void ListenLoop()
{
try {
while (_receiver.State != OscSocketState.Closed)
{
// if we are in a state to recieve
if (_receiver.State == OscSocketState.Connected)
{
// get the next message
// this will block until one arrives or the socket is closed
OscPacket packet = _receiver.Receive();
if (packet is OscMessage msg)
{
_messages.Enqueue(msg);
}
else if (packet is OscBundle bnd)
{
foreach (OscMessage m in bnd)
{
_messages.Enqueue(m);
}
}
}
}
}
catch (Exception ex) {
if (_receiver.State == OscSocketState.Connected)
{
_exceptions.Enqueue(ex);
}
}
}
private void ListenerWork()
{
while (_receiver.State != OscSocketState.Closed)
{
// if we are in a state to recieve
if (_receiver.State == OscSocketState.Connected)
{
// get the next message
// this will block until one arrives or the socket is closed
OscPacket packet = _receiver.Receive();
// parse the message
string[] msg = OscDeserializer.ParseOscPacket(packet);
string[] msgAddress = OscDeserializer.GetMessageAddress(msg);
var ip = OscDeserializer.GetMessageIp(msg);
var port = OscDeserializer.GetMessagePort(msg);
var binSeq = OscDeserializer.GetMessageBinSeq(msg);
// if the sessionWorker already exists, update config. Otherwise, create a new sessionWorker
SessionWorker session = CheckSession(ip, port);
if (session == null)
{
session = new SessionWorker(ip, port, _dataPub, _sessionManager);
_sessionManager.AddConnection(session);
session.SetTimers();
}
session.SetLookupFlags(binSeq);
}
}
}
private void DeconstructPacket(OscPacket oscPacket)
{
if (oscPacket is OscBundle)
{
OscBundle oscBundle = (OscBundle)oscPacket;
oscTimeTagStack.Push(oscBundle.Timestamp);
foreach (OscPacket bundleElement in oscBundle)
{
DeconstructPacket(bundleElement);
}
oscTimeTagStack.Pop();
}
else if (oscPacket is OscMessage)
{
OscMessage oscMessage = (OscMessage)oscPacket;
if (oscTimeTagStack.Count > 0)
{
OscTimeTag oscTimeTag = oscTimeTagStack.Peek();
textBoxBuffer.WriteLine(oscTimeTag.ToString() + " " + oscMessage.ToString());
}
else
{
textBoxBuffer.WriteLine(oscMessage.ToString());
}
receiveCounter.Increment();
}
}
private void ReceiveLoop()
{
try
{
while (oscReceiver.State != OscSocketState.Closed)
{
// if we are in a state to receive
if (oscReceiver.State == OscSocketState.Connected)
{
// get the next callback
// this will block until one arrives or the socket is closed
OscPacket packet = oscReceiver.Receive();
connection.PacketReceived(packet);
}
}
}
catch (Exception ex)
{
if (oscReceiver.State != OscSocketState.Closed &&
oscReceiver.State != OscSocketState.Closing)
{
connection.OnException(Strings.UdpConnectionImplementation_ErrorReceiving, ex);
}
}
}
public void Send(OscPacket packet)
{
var messageBytes = packet.GetBytes();
this._udpClient.Send(messageBytes, messageBytes.Count());
Thread.Sleep(50);
}
private static OscPacket CreateFromJson(JsonReader reader)
{
OscPacket ret = null;
{
while (reader.TokenType != JsonToken.StartObject)
{
var done = reader.Read(); // read obejct start
if (!done)
{
break;
}
}
if (reader.TokenType != JsonToken.None)
{
reader.Read(); // read property name for address
var address = reader.ReadAsString(); // read address;
if (address.StartsWith("#"))
{
ret = DeserialiseBundle(reader);
}
else
{
ret = DeserialiseMessage(reader, address);
}
reader.Read(); // read end object
}
}
return(ret);
}
public static string CreateJson(this OscPacket value)
{
var ret = string.Empty;
if (value != null)
{
var json = new StringBuilder();
var sw = new StringWriter(json);
using (var writer = new JsonTextWriter(sw))
{
writer.WriteStartObject();
var msg = value as OscMessage;
var bundle = value as OscBundle;
if (msg != null)
{
Serialise(msg, writer);
}
else if (bundle != null)
{
Serialise(bundle, writer);
}
writer.WriteEndObject();
}
ret = json.ToString();
}
return(ret);
}
public void Start(OscPacket packet)
{
Assert.ParamIsNotNull(packet);
mCancellationTokenSource = new CancellationTokenSource();
mSendPacketsTask = Task.Run(() => SendPacketsAsync(packet, mCancellationTokenSource.Token));
}
private async Task SendPacketsAsync(OscPacket packet, CancellationToken cancellationToken)
{
try
{
int transmissionCount = 0;
while (cancellationToken.IsCancellationRequested == false)
{
IPEndPoint sourceEndPoint = new IPEndPoint(Program.ipAddress, Properties.Settings.Default.Port);
OscMessage labelMessage = new OscMessage(sourceEndPoint, "/NuvoControl/ZoneName", String.Format("Hello {0}", transmissionCount));
labelMessage.Send(sourceEndPoint);
Console.Clear();
Console.WriteLine("Osc Transmitter: Udp");
Console.WriteLine("with IP Address={0} on Port={1}", sourceEndPoint.Address, sourceEndPoint.Port);
Console.WriteLine("IsBundle={0}", labelMessage.IsBundle);
if (!packet.IsBundle)
{
Console.WriteLine("Packet={0}", labelMessage.ToString());
}
Console.WriteLine("Transmission Count: {0}\n", ++transmissionCount);
Console.WriteLine("Press any key to exit.");
await Task.Delay(1000);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void timer1_Tick(object sender, EventArgs e)
{
try
{
// parse the message
OscPacket msg = OscPacket.Parse(m_MessageBox.Text);
// write the parsed message
AppendLine(msg.ToString());
// if the sender exists
if (m_Sender != null)
{
for (int i = 0, j = (int)m_SendCount.Value; i < j; i++)
{
// send
m_Sender.Send(msg);
}
}
else
{
AppendLine("Sender is not connected");
}
}
catch (Exception ex)
{
// explicitly tell the user why the message failed to parse
AppendLine("Error parsing message");
AppendLine(ex.Message);
AppendLine("");
}
}
void OnOSCMessageReceived(OscPacket packet)
{
var msg = (OscMessage)packet;
if (!typeMap.ContainsKey(msg.Address))
{
return;
}
// Debug.Log("Got packet from: " + msg.Address);
// Debug.Log("Arguments: ");
// foreach (var a in msg.Arguments) {
// Debug.Log(a.ToString());
// }
try {
var data = msg.Arguments.ConvertAll <double>(converter).ToArray();
var type = typeMap[msg.Address];
// Debug.Log("EEGType: " + type);
// Debug.Log("Converted Args: ");
// foreach (var d in data) {
// Debug.Log(d.ToString());
// }
EmitData(new EEGEvent(DateTime.UtcNow, type, data));
} catch (Exception e) {
Logger.Error("Could not convert/emit data from EEGDeviceAdapter: " + e);
}
}
private OscPacket FindMatchingSubject(OscPacket indata, int x, int y)
{
var data = (OscMessage)indata;
int numPkgs = (int)data[1];
filteredPLayerIndexes.Clear();
for (int i = 0; i < numPkgs; i++)
{
//Tuple<int, int> oldPos;
//if (oldTrackingValues.TryGetValue((int)data[2 + (i * 8)], out oldPos))
//{
// x = (int)(x * 0.2 + oldPos.Item1 * 0.8);
// y = (int)(y * 0.2 + oldPos.Item2 * 0.8);
// oldTrackingValues[(int)data[2 + (i * 8)]] = new Tuple<int, int>(x, y);
//}
//else
//{
// oldTrackingValues.Add((int)data[2 + (i * 8)], new Tuple<int, int>(x, y));
//}
if ((int)data[dtdtX + (i * 8)] == x &&
(int)data[dtdtY + (i * 8)] == y)
{
filteredPLayerIndexes.Add(i);
}
}
//var outboundPackage = new object[2 + filteredPLayerIndexes.Count *8];
var outboundPackage = new List <object>();
outboundPackage.Add(data[0]);
outboundPackage.Add(filteredPLayerIndexes.Count);
//TODO: This is still wrong =]
for (int i = 0; i < filteredPLayerIndexes.Count; i++)
{
var selectedIndex = filteredPLayerIndexes[i];
for (int j = 2 + selectedIndex * 8; j < 10 + 8 * selectedIndex; j++)
{
outboundPackage.Add(data[j]);
}
}
//foreach (var selectedIndex in filteredPLayerIndexes)
//{
// for (int i = ; i < 10; i++)
// {
// outboundPackage[i] = data[i + (selectedIndex * 8)];
// }
//}
//outboundPackage[0] = data[0];
//outboundPackage[1] = filteredPLayerIndexes.Count;
var outbound = new OscMessage(data.Address, outboundPackage.ToArray());
return(outbound);
}
// Process Data Frame OscBundle
private void FrameParser(OscPacket packet)
{
//LogPacket(packet); //Used for debugging to see all received packets
if (packet.IsBundle)
{
foreach (OscMessage message in ((OscBundle)packet).Messages)
{
if (String.Compare(message.Address, "/ExampleOSCAddressOfMessage/") == 0)
{
// Without using any of the fancy OSC stuff that lets you know what type of data is in each message,
// you can get the data in the message by accessing packet.Data[index], as long as you know how many indices there are.
// essentially, i've set this up with the assumption that you're doing both the sending and receiving, so you know what is what and how much data
// so, for example:
string theStringMessageIKnowIsBeingSent = (string)message.Data[0];
Debug.Log("received example message string: " + theStringMessageIKnowIsBeingSent);
}
if (String.Compare(message.Address, "/ExampleOSCAddressOfMessageHeader/Position/") == 0)
{
Vector3 position = new Vector3();;
position.x = (float)message.Data[0];
position.y = (float)message.Data[1];
position.z = (float)message.Data[1];
Debug.Log("received example position: " + position);
}
}
}
else // if the packet is not a bundle and is just one message
{
if (String.Compare(((OscMessage)packet).Address, "/ExampleOSCAddressOfMessage/") == 0)
{
//string theStringMessageIKnowIsBeingSent = (string)message.Data[0];
//Debug.Log ("received example message string: " + theStringMessageIKnowIsBeingSent);
}
}
}
private void onPacketReceived(OscPacket packet)
{
if (PacketReceived != null)
{
PacketReceived(this, new OscPacketReceivedEventArgs(packet));
}
}
private void SendMessageBox_TextChanged(object sender, EventArgs e)
{
if (m_SendMessageBox.Text == m_HelpText)
{
m_SendMessageBox.Font = m_BackupFont;
m_SendMessageBox.ForeColor = Color.LightGray;
m_HasValidSendString = false;
return;
}
m_SendMessageBox.Font = m_InputFont;
if (File.Exists(NgimuApi.Helper.ResolvePath(m_SendMessageBox.Text)) == true)
{
m_HasValidSendString = true;
m_SendMessageBox.ForeColor = Control.DefaultForeColor;
}
else
{
OscPacket packet;
m_HasValidSendString = OscPacket.TryParse(m_SendMessageBox.Text.Trim(), out packet);
m_SendMessageBox.ForeColor = m_HasValidSendString ? Control.DefaultForeColor : Color.Red;
}
}
private void ReceiverMethod()
{
try
{
while (oscReceiver.State != OscSocketState.Closed)
{
if (oscReceiver.State == OscSocketState.Connected)
{
ReceiverSemaphore.WaitOne();
data = oscReceiver.Receive();
if (((OscMessage)data).Address == "/DTDT")
{
OnDataReceived?.Invoke(data);
}
ReceiverSemaphore.Release();
}
}
}
catch (Exception ex)
{
if (oscReceiver.State == OscSocketState.Connected)
{
Console.WriteLine("Exception in listen loop");
Console.WriteLine(ex.Message);
}
}
}
/**
* Listen is spawned by a thread in the Connect() method. It remains
* in a loop receiving data as the connection is alive.
*
* @see Esc.StateListener.Connect
*/
private void Listen()
{
while (connected)
{
try {
OscPacket packet = receiver.Receive();
if (null != packet)
{
// UnityMainThreadDispatcher.Instance ().Enqueue (ExsecuteOnMainThread_TimeCheck ());
lock (processQueue) {
if (packet.IsBundle())
{
ArrayList messages = packet.Values;
for (int i = 0; i < messages.Count; i++)
{
processQueue.Add((OscMessage)messages [i]);
}
}
else
{
processQueue.Add((OscMessage)packet);
}
}
}
} catch (Exception e) {
Debug.LogError(e.Message);
}
}
}
public void TestByteCallback()
{
bool cbCalled = false;
// The cabllback function
HandleBytePacket cb = delegate(byte[] packet)
{
var msg = (OscMessage)OscPacket.GetPacket(packet);
Assert.AreEqual(2, msg.Arguments.Count);
Assert.AreEqual(23, msg.Arguments[0]);
Assert.AreEqual("hello world", msg.Arguments[1]);
cbCalled = true;
};
var l1 = new UDPListener(55555, cb);
var sender = new SharpOSC.UDPSender("localhost", 55555);
var msg1 = new SharpOSC.OscMessage("/test/address", 23, "hello world");
sender.Send(msg1);
// Wait until callback processes its message
var start = DateTime.Now;
while (cbCalled == false && start.AddSeconds(2) > DateTime.Now)
{
Thread.Sleep(1);
}
Assert.IsTrue(cbCalled);
l1.Close();
}
//パケットを処理して、bundleとMessageに振り分け
private void ProcessPacket(OscPacket packet)
{
PacketCounter++;
switch (packet)
{
//bundleを受信した
case OscBundle bundle:
try
{
OnBundle?.Invoke(bundle);
}
catch (Exception e)
{
Console.WriteLine("# Callback : " + e);
}
break;
//Messageを受信した
case OscMessage msg:
try
{
OnMessage?.Invoke(msg);
}
catch (Exception e)
{
Console.WriteLine("# Callback : " + e);
}
break;
default:
//Do noting
break;
}
}
static void ListenLoop()
{
try
{
while (receiver.State != OscSocketState.Closed)
{
// if we are in a state to recieve
if (receiver.State == OscSocketState.Connected)
{
// get the next message
// this will block until one arrives or the socket is closed
OscPacket packet = receiver.Receive();
// Write the packet to the console
Console.WriteLine(packet.ToString());
// DO SOMETHING HERE!
}
}
}
catch (Exception ex)
{
// if the socket was connected when this happens
// then tell the user
if (receiver.State == OscSocketState.Connected)
{
Console.WriteLine("Exception in listen loop");
Console.WriteLine(ex.Message);
}
}
}
void UnpackRecursivelyAndDispatch(OscPacket packet)
{
if (packet is OscBundle)
{
OscBundle bundle = packet as OscBundle;
foreach (OscPacket subPacket in bundle.packets)
{
if (_addTimeTagsToBundledMessages && subPacket is OscMessage)
{
OscMessage message = subPacket as OscMessage;
message.Add(bundle.timeTag);
}
UnpackRecursivelyAndDispatch(subPacket);
}
OscPool.Recycle(bundle);
}
else
{
OscMessage message = packet as OscMessage;
if (_filterDuplicates)
{
if (_uniqueAddresses.Contains(message.address))
{
OscPool.Recycle(message);
return;
}
_uniqueAddresses.Add(message.address);
}
Dispatch(packet as OscMessage);
_messageCount++; // Influenced by _filterDuplicates.
}
}
public void UpdateDataAt(int index, object value)
{
Debug.Log("UpdateDataAt");
if (_OSCpkg is OscMessage)
{
((OscMessage)_OSCpkg).UpdateDataAt(index, value);
}
else if (_OSCpkg is OscBundle)
{
// _OSCpkg = new OscBundle();
if (value is OscBundle)
{
_OSCpkg = value as OscBundle;
}
else
{
//Debug.Log("Data is not a Bundle");
if (value is OscMessage)
{
if (((OscBundle)_OSCpkg).Messages.Count >= index)
{
((OscBundle)_OSCpkg).Messages[index] = value as OscMessage;
}
}
else
{
Debug.Log("You can only add a OSCMessage to a OSCBundle");
}
}
}
}
protected override void DeliverPacket(OscPacket packet)
{
if (m_pipe.IsConnected &&
packet != null)
{
Scheduler.Schedule(packet,
(oscPacket, action) =>
{
byte[] data;
using (var ms = new MemoryStream())
{
ms.Write(BitConverter.GetBytes(0),
0,
4);
m_formatter.Serialize(ms, oscPacket);
var ps = ms.Position - 4;
ms.Seek(0, SeekOrigin.Begin);
ms.Write(BitConverter.GetBytes(ps),
0,
4);
data = ms.ToArray();
}
if (data.Length > 0)
{
m_pipe.WaitForPipeDrain();
m_pipe.BeginWrite(data, 0, data.Length, DataWriteFinished, null);
}
});
}
}
private void ProcessOscPacket(string bundlePrefix, OscPacket packet)
{
switch (packet)
{
case OscBundle b:
_logger.LogTrace($"┌Start bundle");
foreach (OscPacket m in b)
{
try
{
ProcessOscPacket(bundlePrefix + "│", m);
}
catch { }
}
_logger.LogTrace($"└End bundle");
break;
case OscMessage m:
try
{
ProcessOscMessage(bundlePrefix, m);
}
catch { }
break;
}
}
private void ListenLoop()
{
try
{
while (_server.State != OscSocketState.Closed)
{
if (_server.State == OscSocketState.Connected)
{
// get the next message
// this will block until one arrives or the socket is closed
OscPacket packet = _server.Receive();
if (packet.Error != OscPacketError.None)
{
continue;
}
ProcessOscPacket(string.Empty, packet);
}
}
}
catch (Exception ex)
{
// if the socket was connected when this happens
// then tell the user
if (_server.State == OscSocketState.Connected)
{
_logger.LogError(ex, "Exception in OSC listen loop");
}
}
}
// Update is called once per frame
void Update()
{
if (dataReceived)
{
dataReceived = false;
FrameParser(OscPacket.FromByteArray(receivedEndPoint, bytePacket));
}
}
public void DisplayPacketInfo(OscPacket packet)
{
CUI.DrawString("Source: " + packet.SourceEndPoint.ToString());
CUI.MoveCursorDown(2);
CUI.DrawString("IsBundle: " + packet.IsBundle.ToString());
CUI.MoveCursorDown(2);
CUI.DrawString("Arguments:");
CUI.MoveCursorDown(2);
CUI.MoveCursorRight();
CUI.MoveCursorRight();
if (packet.Data.Count == 0)
{
CUI.DrawString("none");
}
else
{
foreach (var arg in packet.Data)
{
if (arg is string)
{
CUI.DrawString("(string) " + (string)arg);
}
else if (arg is Int32)
{
CUI.DrawString("(int32) " + (Int32)arg);
}
else if (arg is Int64)
{
CUI.DrawString("(int64) " + (Int64)arg);
}
else if (arg is float)
{
CUI.DrawString("(float) " + (float)arg);
}
else if (arg is double)
{
CUI.DrawString("(double) " + (double)arg);
}
else if (arg is byte[])
{
CUI.DrawString("(byte[]) " + ((byte[])arg).Length + " bytes");
}
else if (arg is char)
{
CUI.DrawString("(char) " + (char)arg);
}
else if (arg is bool)
{
CUI.DrawString("(bool) " + (bool)arg);
}
else
{
CUI.DrawString("(????) " + "unknown");
}
CUI.MoveCursorDown();
}
}
}
public void StartListening()
{
StopListening();
this.Client = new UdpClient(Port);
Task.Run(async() => {
var endpoint = new IPEndPoint(IPAddress.Any, Port);
try
{
//TODO: this is an initial version, i feel like this can be done more elegant? (atleast async, not thread blocking like now)
while (true)
{
try
{
var result = await Client.ReceiveAsync();
var bytes = result.Buffer;
var message = OscPacket.GetPacket(bytes) as OscMessage;
var musePacket = ParsePacket(message);
if (musePacket.Address == SignalAddress.Unknown)
{
Console.WriteLine($"unknown packet with address '{message.Address}', skipping it...");
continue;
}
PacketReceived?.Invoke(this, musePacket);
}
catch (ObjectDisposedException)
{
Console.WriteLine("disposed early");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Corrupt packet received: '{ex.Message}'");
}
}
}
catch (ObjectDisposedException) {
//is fine, atm this is the escape condition when the listener needs to stop listening to the port. far from elegant but it works i suppose :)
Console.WriteLine("exited");
}
catch (SocketException e)
{
Console.WriteLine(e);
}
catch (Exception ex)
{
Console.WriteLine("something else threw an exception... " + ex.Message);
}
finally
{
this.Client?.Dispose();
this.Client = null;
}
});
}
// Process Data Frame OscBundle
private void FrameParser(OscPacket packet)
{
//LogPacket(packet); //Used for debugging to see all received packets
if (packet.IsBundle)
{
foreach (OscMessage message in ((OscBundle)packet).Messages)
{
if (String.Compare(message.Address, "/NewUserIndexCreated/") == 0)
{
int clientIndex = (int)message.Data[0];
int newUserIndex = (int)message.Data[1];
UnityEngine.Debug.Log("OSCInterface received new user index from server: " + newUserIndex);
// call all methods that have been registered to listen for it
NewUserIndexReceivedEventArgs args = new NewUserIndexReceivedEventArgs();
args.newUserIndex = newUserIndex;
OnNewUserIndexReceivedEvent(args);
List <object> oscMessage = new List <object>();
string oscMessageAddress = "/NewUserIndexReceived/";
oscMessage.Add(newUserIndex);
AppendMessage(oscMessageAddress, oscMessage);
}
if (String.Compare(message.Address, "/UserDataToClients/") == 0)
{
int clientIndex = (int)message.Data[0];
UnityEngine.Debug.Log("received user data from server from client Index: " + clientIndex);
int userIndex = (int)message.Data[1];
double timeInMS = (double)message.Data[2];
float positionX = (float)message.Data[3];
float positionY = (float)message.Data[4];
float positionZ = (float)message.Data[5];
float hue = (float)message.Data[6];
// call all methods that have been registered to listen for it
OtherUserDataReceivedEventArgs args = new OtherUserDataReceivedEventArgs();
args.clientIndex = clientIndex;
args.position = new Vector3(positionX, positionY, positionZ);
args.hue = hue;
OnOtherUserDataReceivedEvent(args);
// FIX THIS TO FIRE AN EVENT WHEN PARTICLE DATA FOR OTHER USERS ARE RECEIVED
//if (clientIndex != newUserCreator.clientIndex)
//{
// otherUserParticleEmissionControl.EmitOtherUserParticles(new Vector3(positionX, positionY, positionZ));
//}
//UnityEngine.Debug.Log("received other position: " + positionX + ", " + positionY + ", " + positionZ);
}
}
}
else
{ // if the packet is not a bundle and is just one message
if (String.Compare(((OscMessage)packet).Address, "/ExampleOSCAddressOfMessage/") == 0)
{
//string theStringMessageIKnowIsBeingSent = (string)(OscBundle)packet[0].Messages.Data[0];
//UnityEngine.Debug.Log("received example message string: " + theStringMessageIKnowIsBeingSent);
}
}
}
public void Send(OscPacket packet)
{
Assert.ParamIsNotNull(packet);
mPacket = packet;
mTransmitterThread = new Thread(RunWorker);
mTransmitterThread.Start();
}
public void Send(OscPacket packet)
{
byte[] data = packet.ToByteArray();
try
{
udpClient.Send(data, data.Length);
} catch
{
throw new Exception(string.Format("Error sending an OSC packet to {0}:{1}", IPAddress, Port));
}
}
public void Send(OscPacket packet)
{
Assert.ParamIsNotNull(packet);
mOscClient = new OscClient(Destination);
mOscClient.Connect();
mPacket = packet;
mPacket.Client = mOscClient;
mTransmitterThread = new Thread(RunWorker);
mTransmitterThread.Start();
}
public void Start(OscPacket packet)
{
Assert.ParamIsNotNull(packet);
mOscClient = new OscClient(Destination);
mOscClient.Connect();
Console.WriteLine("Sending to: " + Destination.Address.ToString() + ":" + Destination.Port.ToString());
mPacket = packet;
mPacket.Client = mOscClient;
mSendMessages = true;
mTransmitterThread = new Thread(RunWorker);
mTransmitterThread.Start();
}
public static new bool FromBytes( byte[] data, ref int pos, int end, out OscPacket packet )
{
// Check header size
int bundleByteSize = end - pos;
if( bundleByteSize < headerByteSize ){
Debug.LogWarning( "[OSC io] OscBundle with invalid header was ignored." + Environment.NewLine );
packet = null;
return false;
}
// Check prefix
string prefixInput = Encoding.ASCII.GetString( data, pos, prefixByteSize );
if( prefixInput != prefix ){
Debug.LogWarning( "[OSC io] OscBundle with invalid header was ignored." + Environment.NewLine );
packet = null;
return false;
}
pos += prefixByteSize + 1; // + 1 to ensure bytes multiple of 4
// Get timetag
byte[] oscNtpBytes = new byte[OscTimeTag.byteSize];
Array.Copy( data, pos, oscNtpBytes, 0, OscTimeTag.byteSize );
OscTimeTag timeTag = new OscTimeTag( oscNtpBytes );
pos += OscTimeTag.byteSize;
// Create and fill bundle
packet = new OscBundle( timeTag );
OscBundle bundle = packet as OscBundle;
while( pos < end )
{
int length = BitConverter.ToInt32( data, 0 );
pos += 4;
int packetEnd = pos + length;
OscPacket subPacket;
if( pos < end && OscPacket.FromBytes( data, ref pos, packetEnd, out subPacket ) ) bundle.Add( subPacket );
}
return true;
}
void InvokeAnyMessageEventRecursively( OscPacket packet )
{
if( packet is OscBundle ){
OscBundle bundle = packet as OscBundle;
foreach( OscPacket subPacket in bundle.packets ) InvokeAnyMessageEventRecursively( subPacket );
} else {
onAnyMessage.Invoke( packet as OscMessage );
_messageCount++;
}
}
/// <summary>
/// Send an OscPacket over the connection.
/// </summary>
/// <param name="packet">The <see cref="OscPacket"/> to send.</param>
public void Send(OscPacket packet)
{
byte[] packetData = packet.ToByteArray();
mTcpConnection.Writer.Write(OscPacket.ValueToByteArray(packetData));
}
public static string[] ParseOscPacket(OscPacket packet)
{
string[] msg = packet.ToString().Split(new string[] { ", " }, StringSplitOptions.None); ;
return msg;
}
public static bool FromBytes( byte[] data, ref int pos, out OscPacket packet )
{
// Get address
string address = StringFromBytes( data, ref pos );
if( address.Length == 0 || address[0] != addressPrefix ){
Debug.LogWarning( "[OscMessage] Ignoring message because address \"" + address + "\" is not starting with \"" + addressPrefix + "\"." + Environment.NewLine + ( "pos: " + pos + ", data: " + data.Length ) );
packet = null;
return false;
}
// Get type tags
char[] tags = StringFromBytes( data, ref pos ).ToCharArray();
int tagCount = tags.Length; // including prefix
if( tags.Length == 0 || tags[0] != tagPrefix ){
Debug.LogWarning( "[OscMessage] Ignoring message because typetag is missing." + Environment.NewLine );
packet = null;
return false;
}
// Construct message
packet = new OscMessage( address, tagCount );
OscMessage message = packet as OscMessage;
// Get and add arguments
for( int i=1; i<tagCount; i++ )
{
char tag = tags[i];
object value;
switch( tag )
{
case tagFloat:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 4 );
value = BitConverter.ToSingle( data, pos );
pos += 4;
break;
case tagDouble:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 8 );
value = BitConverter.ToDouble( data, pos );
pos += 8;
break;
case tagInt:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 4 );
value = BitConverter.ToInt32( data, pos );
pos += 4;
break;
case tagLong:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 8 );
value = BitConverter.ToInt64( data, pos );
pos += 8;
break;
case tagString:
case tagSymbol:
value = StringFromBytes( data, ref pos );
break;
case tagChar:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 4 );
int charInt = BitConverter.ToInt32( data, pos );
value = Convert.ToChar( charInt );
break;
case tagBlob:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 4 );
int length = BitConverter.ToInt32( data, pos );
pos += 4;
byte[] blob = new byte[length];
Array.Copy( data, pos, blob, 0, length );
value = blob;
pos += length;
pos += 4 - ( pos % 4 );
break;
case tagTimetag:
byte[] oscNtpBytes = new byte[OscTimeTag.byteSize];
Array.Copy( data, pos, oscNtpBytes, 0, OscTimeTag.byteSize );
value = new OscTimeTag( oscNtpBytes ); // OscTimeTag ensures big-endin byte oder internally.
pos += 8;
break;
case tagColor:
if( BitConverter.IsLittleEndian ) Array.Reverse( data, pos, 4 );
value = new Color32( data[pos], data[pos+1], data[pos+2], data[pos+3] );
pos += 4;
break;
case tagTrue:
value = true;
break;
case tagFalse:
value = false;
break;
case tagNull:
value = null;
break;
case tagImpulse:
value = new OscImpulse();
break;
default:
Debug.LogWarning( "[OscMessage] FromBytes failed. Argument tag '" + tag + "' is not supported." + Environment.NewLine );
return false;
}
message.args.Add( value );
}
return true;
}
public OscPacketReceivedEventArgs(OscPacket packet)
{
Packet = packet;
}
/// <summary>
/// Creates a new instance of OscPacketReceivedEventArgs
/// </summary>
/// <param name="packet">The OscPacket received.</param>
public OscPacketReceivedEventArgs(OscPacket packet)
{
Assert.ParamIsNotNull(packet);
mPacket = packet;
}
/// <summary>
/// Send an OscMessage or OscBundle.
/// Returns success status.
/// </summary>
public bool Send( OscPacket packet )
{
if( !isOpen ) return false;
if( _bundleMessagesOnEndOfFrame && packet is OscMessage ){
_endOfFrameBundle.Add( packet );
return true;
}
// try to pack the message
byte[] data;
if( !packet.ToBytes( out data ) ) return false;
//Debug.Log( "Packet size: " + data.Length + " bytes" + Environment.NewLine );
try {
// Send!!
_udpClient.Send( data, data.Length, _endPoint );
// Socket error reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms740668(v=vs.85).aspx
} catch( SocketException ex )
{
if( ex.ErrorCode == 10051 ){ // "Network is unreachable"
// Ignore. We get this when broadcasting while having no access to a network.
} else if( ex.ErrorCode == 10065 ){ // "No route to host"
// Ignore. We get this sometimes when unicasting.
} else if( ex.ErrorCode == 10049 ){ // "The requested address is not valid in this context"
// Ignore. We get this when we broadcast and have no access to the local network. For example if we are using a VPN.
} else if( ex.ErrorCode == 10040 ){ // "Message too long"
Debug.LogWarning( "[OscOut] Failed to send message. Packet is too big (" + data.Length + " bytes)." );
} else {
Debug.LogWarning( "[OscOut] Failed to send message to " + ipAddress + " on port " + port + Environment.NewLine + ex.ErrorCode + ": " + ex.ToString() );
}
return false;
} catch( Exception ex ) {
Debug.LogWarning( "[OscOut] Failed to send message to " + ipAddress + " on port " + port + Environment.NewLine + ex.ToString() );
return false;
}
InvokeAnyMessageEventRecursively( packet );
return true;
}
/// <summary>
/// Add a OscMessage or OscBundle to this bundle. Shorthand for bundle.packets.Add.
/// </summary>
public void Add( OscPacket packet )
{
_packets.Add( packet );
}
/// <summary>
/// Raises the PacketreceivedEvent.
/// </summary>
/// <param name="packet">The packet to include in the event arguments.</param>
private void OnPacketReceived(OscPacket packet)
{
if (PacketReceived != null)
{
PacketReceived(this, new OscPacketReceivedEventArgs(packet));
}
}
