public static OSCPacket CopyPacket(OSCPacket packet)
{
var size = 0;
var buffer = OSCConverter.Pack(packet, out size);
return(OSCConverter.Unpack(buffer, size));
}
public void Send(OSCPacket packet)
{
if (useBundle && packet != null && (packet is OSCMessage))
{
_packetPool.Add(packet);
return;
}
if (!transmitterBackend.IsAvailable)
{
return;
}
if (mapBundle != null)
{
mapBundle.Map(packet);
}
var length = 0;
var buffer = OSCConverter.Pack(packet, out length);
transmitterBackend.Send(buffer, length);
OSCConsole.Transmitted(this, packet);
}
public static OSCPacket LoadPacket(string filePath)
{
if (!File.Exists(filePath))
{
return(null);
}
//TODO: Omg
try
{
return(OSCConverter.Unpack(File.ReadAllBytes(filePath)));
}
catch (Exception e)
{
Debug.LogFormat("[OSCEditorUtils] Load Packet error: {0}", e);
try
{
var document = new XmlDocument();
document.Load(filePath);
return(OSCPacket.FromBase64String(document.FirstChild.InnerText));
}
catch (Exception e2)
{
Debug.LogFormat("[OSCEditorUtils] Load Old Format Packet Error: {0}", e2);
}
}
return(null);
}
public static IOSCPacket LoadPacket(string filePath)
{
if (!File.Exists(filePath))
{
return(null);
}
try
{
return(OSCConverter.Unpack(File.ReadAllBytes(filePath)));
}
catch (Exception e)
{
Debug.LogFormat("[extOSC:OSCEditorUtils] Load packet exception: {0}", e);
try
{
var document = new XmlDocument();
document.Load(filePath);
return(OSCUtilities.FromBase64String(document.FirstChild.InnerText));
}
catch (Exception e2)
{
Debug.LogFormat("[extOSC:OSCEditorUtils] Old format unpack exception: {0}", e2);
}
}
return(null);
}
public void Send(OSCPacket packet)
{
if (useBundle && packet != null && (packet is OSCMessage))
{
_packetPool.Add(packet);
return;
}
if (!transmitterBackend.IsAvaible)
{
return;
}
if (mapBundle != null)
{
mapBundle.Map(packet);
}
var data = OSCConverter.Pack(packet);
transmitterBackend.Send(data);
OSCConsole.Transmitted(this, packet);
}
protected OSCPacket Receive(UdpClient receivedClient, IAsyncResult result)
{
try
{
IPEndPoint ip = null;
var bytes = receivedClient.EndReceive(result, ref ip);
if (bytes != null && bytes.Length > 0)
{
var packet = OSCConverter.Unpack(bytes);
packet.Ip = ip.Address;
packet.Port = ip.Port;
return(packet);
}
}
catch (ObjectDisposedException)
{ }
catch (Exception e)
{
Debug.LogErrorFormat("[OSCReceiver] Receive error: " + e);
}
return(null);
}
public static void SavePacket(string filePath, IOSCPacket packet)
{
using (var fileWriter = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
{
var length = OSCConverter.Pack(packet, out var buffer);
fileWriter.Write(buffer, 0, length);
}
}
protected void ParseOSCPacket(byte[] bytes)
{
OSCConverter c = new OSCConverter();
OSCPacket oscPacket = c.GetOSCPacket(bytes);
SendToConsumer(oscPacket);
return;
}
private static void Log(OSCConsolePacket message)
{
// COPY PACKET
var rawData = OSCConverter.Pack(message.Packet);
message.Packet = OSCConverter.Unpack(rawData);
OSCConsole.ConsoleBuffer.Add(message);
}
private static void Log(OSCConsolePacket message)
{
#if UNITY_EDITOR
// COPY PACKET
var rawData = OSCConverter.Pack(message.Packet);
message.Packet = OSCConverter.Unpack(rawData);
_consoleBuffer.Add(message);
#else
if (_logConsole)
{
Debug.LogFormat("[OSCConsole] Packed {0}: {1}", message.PacketType, message.Packet);
}
#endif
}
private async void InitMessage()
{
using (var dataWriter = new DataWriter(await _datagramSocket.GetOutputStreamAsync(new HostName("255.255.255.255"), _localPort)))
{
try
{
dataWriter.WriteBytes(OSCConverter.Pack(new OSCMessage("/wsainit")));
await dataWriter.StoreAsync();
}
catch (Exception exception)
{
Debug.LogWarningFormat("[OSCReceiver] Error: {0}", exception);
}
}
}
private OSCPacket ReadPacket()
{
var ip = (IPAddress)null;
var ipSize = _reader.ReadInt32();
if (ipSize > 0)
{
var ipBytes = _reader.ReadBytes(ipSize);
ip = new IPAddress(ipBytes);
}
var port = (int)_reader.ReadUInt16();
var size = _reader.ReadInt32();
var bytes = _reader.ReadBytes(size);
var message = OSCConverter.Unpack(bytes);
message.Ip = ip;
message.Port = port;
return(message);
}
private void WritePacket(OSCPacket packet)
{
if (packet.Ip != null)
{
var ipBuffer = packet.Ip.GetAddressBytes();
var ipSize = ipBuffer.Length;
_writer.Write(ipSize);
_writer.Write(ipBuffer);
}
else
{
_writer.Write(0);
}
_writer.Write((ushort)packet.Port);
var size = 0;
var buffer = OSCConverter.Pack(packet, out size);
_writer.Write(size);
_writer.Write(buffer, 0, size);
}
private void Receive(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
try
{
using (var dataReader = args.GetDataReader())
{
var data = new byte[dataReader.UnconsumedBufferLength];
dataReader.ReadBytes(data);
var packet = OSCConverter.Unpack(data);
packet.Ip = IPAddress.Parse(args.RemoteAddress.ToString());
packet.Port = int.Parse(args.RemotePort);
if (_receivedCallback != null)
{
_receivedCallback.Invoke(packet);
}
}
}
catch (Exception e)
{
Debug.LogErrorFormat("[OSCReceiver] Receive error: " + e);
}
}
public static string ToBase64String(IOSCPacket packet)
{
var length = OSCConverter.Pack(packet, out var buffer);
return(Convert.ToBase64String(buffer, 0, length));
}
public static IOSCPacket FromBase64String(string value)
{
return(OSCConverter.Unpack(Convert.FromBase64String(value)));
}
public static OSCPacket CopyPacket(OSCPacket packet)
{
return(OSCConverter.Unpack(OSCConverter.Pack(packet)));
}
public static void SavePacket(string filePath, OSCPacket packet)
{
File.WriteAllBytes(filePath, OSCConverter.Pack(packet));
}
public virtual void ControlRequest(string address)
{
SendToProtocol(this, OSCConverter.Inquire(address));
}
