private void HandleInvitation(DataInputStream dataInputStream, model.RtpMidiServer rtpMidiServer)
{
int protocolVersion = dataInputStream.ReadInt();
if (protocolVersion != PROTOCOL_VERSION)
{
Log.Info("RtpMidi", "Protocol version: {} did not match version {}", protocolVersion, PROTOCOL_VERSION);
return;
}
int initiatorToken = dataInputStream.ReadInt();
int ssrc = dataInputStream.ReadInt();
//Scanner scanner = new Scanner(dataInputStream).UseDelimiter(NUL_TERMINATOR);
//if (!scanner.HasNext)
//{
// Log.Info("RtpMidi","Could not find \\0 terminating string");
// return;
//}
//string name = scanner.Next();
string name = dataInputStream.ReadLine();
foreach (IRtpMidiCommandListener listener in listeners)
{
listener.OnMidiInvitation(new RtpMidiInvitationRequest(protocolVersion, initiatorToken, ssrc, name), rtpMidiServer);
}
}
public RtpMidiSessionConnection(RtpMidiSession rtpMidiSession, model.RtpMidiServer rtpMidiServer, int ssrc, IRtpMidiMessageSender rtpMidiMessageSender)
{
RtpMidiSession = rtpMidiSession;
RtpMidiServer = rtpMidiServer;
Ssrc = ssrc;
RtpMidiMessageSender = rtpMidiMessageSender;
}
public void OnEndSession(RtpMidiEndSession rtpMidiEndSession, model.RtpMidiServer rtpMidiServer)
{
Log.Info("RtpMidi", "Session ended with: {}", rtpMidiServer);
acceptedServers.Remove(rtpMidiServer);
foreach (IEndSessionListener listener in endSessionListeners)
{
listener.OnEndSession(rtpMidiEndSession, rtpMidiServer);
}
}
private void SendMidiInvitationAnswer(model.RtpMidiServer rtpMidiServer, string type, RtpMidiInvitation midiInvitation)
{
try {
Log.Info("RtpMidi", "Sending invitation {} to: {}", type, rtpMidiServer);
Send(midiInvitation, rtpMidiServer);
}
catch (IOException e) {
Log.Error("RtpMidi", "IOException while sending invitation {}", type, e);
}
}
public void handle(byte[] data, model.RtpMidiServer appleMidiServer)
{
DataInputStream dataInputStream = new DataInputStream(new MemoryStream(data));
try {
byte header1 = (byte)dataInputStream.ReadByte();
if (header1 != RtpMidiCommand.MIDI_COMMAND_HEADER1)
{
Log.Info("RtpMidi", "Header did not contain first MIDI command header");
return;
}
byte header2 = (byte)dataInputStream.ReadByte();
if (header2 != RtpMidiCommand.MIDI_COMMAND_HEADER2)
{
Log.Info("RtpMidi", "Header did not contain second MIDI command header");
return;
}
byte[] commandBuffer = new byte[COMMAND_BUFFER_LENGTH];
int commandBytesRead = dataInputStream.Read(commandBuffer);
if (commandBytesRead != COMMAND_BUFFER_LENGTH)
{
Log.Info("RtpMidi", "The number of command bytes: {} did not match: {}", commandBytesRead, COMMAND_BUFFER_LENGTH);
return;
}
string command = Encoding.UTF8.GetString(commandBuffer);
CommandWord commandWord;
try
{
commandWord = (CommandWord)System.Enum.Parse(typeof(CommandWord), command);
}
catch (IllegalArgumentException e) {
Log.Info("RtpMidi", "Could not parse command word from: {}", command);
return;
}
switch (commandWord)
{
case CommandWord.IN:
HandleInvitation(dataInputStream, appleMidiServer);
break;
case CommandWord.CK:
HandleSynchronization(dataInputStream, appleMidiServer);
break;
case CommandWord.BY:
HandleEndSession(dataInputStream, appleMidiServer);
break;
}
}
catch (System.IO.IOException e)
{
Log.Error("RtpMidi", "IOException while parsing message", e);
}
}
private void HandleEndSession(DataInputStream dataInputStream, model.RtpMidiServer rtpMidiServer)
{
int protocolVersion = dataInputStream.ReadInt();
if (protocolVersion != PROTOCOL_VERSION)
{
Log.Info("RtpMidi", "Protocol version: {} did not match version {}", protocolVersion, PROTOCOL_VERSION);
return;
}
int initiatorToken = dataInputStream.ReadInt();
int ssrc = dataInputStream.ReadInt();
foreach (IRtpMidiCommandListener listener in listeners)
{
listener.OnEndSession(new RtpMidiEndSession(protocolVersion, initiatorToken, ssrc), rtpMidiServer);
}
}
public void OnMidiInvitation(RtpMidiInvitationRequest invitation, model.RtpMidiServer rtpMidiServer)
{
Log.Info("RtpMidi", "MIDI invitation from: {}", rtpMidiServer);
if (GetSessionServerState() == State.ACCEPT_INVITATIONS)
{
SendMidiInvitationAnswer(rtpMidiServer, "accept",
new RtpMidiInvitationAccepted(invitation.ProtocolVersion, invitation.InitiatorToken, Ssrc, Name));
RtpMidiSession rtpMidiSession = sessions.Last; // Pop()
RtpMidiSessionConnection connection =
new RtpMidiSessionConnection(rtpMidiSession, rtpMidiServer, Ssrc, this);
rtpMidiSession.Sender = connection;
currentSessions.Add(invitation.Ssrc, connection);
NotifyMaxNumberOfSessions();
}
else
{
SendMidiInvitationAnswer(rtpMidiServer, "decline",
new RtpMidiInvitationDeclined(invitation.ProtocolVersion, invitation.InitiatorToken, Ssrc, Name));
}
}
public void OnEndSession(RtpMidiEndSession rtpMidiEndSession, model.RtpMidiServer rtpMidiServer)
{
Log.Info("RtpMidi", "Session end from: {}", rtpMidiServer);
RtpMidiSessionConnection midiServer = currentSessions.GetValueOrDefault(rtpMidiEndSession.Ssrc);
if (midiServer != null)
{
RtpMidiSession RtpMidiSession = midiServer.RtpMidiSession;
RtpMidiSession.Sender = null;
RtpMidiSession.OnEndSession(rtpMidiEndSession, rtpMidiServer);
}
currentSessions.Remove(rtpMidiEndSession.Ssrc);
RtpMidiSessionConnection sessionTuple = currentSessions.GetValueOrDefault(rtpMidiEndSession.Ssrc);
if (sessionTuple != null)
{
sessions.AddLast(sessionTuple.RtpMidiSession);
NotifyMaxNumberOfSessions();
}
}
private void HandleSynchronization(DataInputStream dataInputStream, model.RtpMidiServer rtpMidiServer)
{
int ssrc = dataInputStream.ReadInt();
byte count = (byte)dataInputStream.ReadByte();
int paddingBytes = dataInputStream.Read(new byte[NUMBER_OF_PADDING_BYTES]);
if (paddingBytes != NUMBER_OF_PADDING_BYTES)
{
Log.Info("RtpMidi", "The number of padding bytes: {} did not match: {}", paddingBytes, NUMBER_OF_PADDING_BYTES);
return;
}
long timestamp1 = dataInputStream.ReadLong();
long timestamp2 = dataInputStream.ReadLong();
long timestamp3 = dataInputStream.ReadLong();
foreach (IRtpMidiCommandListener listener in listeners)
{
listener.OnClockSynchronization(new RtpMidiClockSynchronization(ssrc, count, timestamp1, timestamp2, timestamp3), rtpMidiServer);
}
}
public void OnMidiInvitation(RtpMidiInvitationRequest invitation, model.RtpMidiServer rtpMidiServer)
{
Log.Info("RtpMidi", "MIDI invitation from: {}", rtpMidiServer);
bool contains = acceptedServers.Contains(rtpMidiServer);
if (contains)
{
Log.Info("RtpMidi", "Server {} was still in accepted servers list. Removing old entry.", rtpMidiServer);
OnEndSession(new RtpMidiEndSession(invitation.ProtocolVersion, invitation.InitiatorToken, invitation.Ssrc), rtpMidiServer);
}
if (getServerState() == State.ACCEPT_INVITATIONS)
{
SendMidiInvitationAnswer(rtpMidiServer, "accept",
new RtpMidiInvitationAccepted(invitation.ProtocolVersion, invitation.InitiatorToken, Ssrc, Name));
acceptedServers.Add(rtpMidiServer);
}
else
{
SendMidiInvitationAnswer(rtpMidiServer, "decline",
new RtpMidiInvitationDeclined(invitation.ProtocolVersion, invitation.InitiatorToken, Ssrc, Name));
}
}
public void OnMidiInvitation(RtpMidiInvitationRequest invitation, model.RtpMidiServer rtpMidiServer)
{
}
private void Send(RtpMidiCommand midiCommand, model.RtpMidiServer rtpMidiServer)
{
Send(midiCommand.ToByteArray(), rtpMidiServer);
}
public void OnEndSession(RtpMidiEndSession rtpMidiEndSession, model.RtpMidiServer rtpMidiServer)
{
OnEndSession();
}
public void OnClockSynchronization(RtpMidiClockSynchronization clockSynchronization, model.RtpMidiServer rtpMidiServer)
{
}
public void OnClockSynchronization(RtpMidiClockSynchronization clockSynchronization, model.RtpMidiServer rtpMidiServer)
{
if (clockSynchronization.Count == (byte)0)
{
RtpMidiSessionConnection sessionTuple = currentSessions.GetValueOrDefault(clockSynchronization.Ssrc);
long currentTimestamp;
if (sessionTuple != null)
{
long sessionTimestamp = sessionTuple.RtpMidiSession.GetCurrentTimestamp();
if (sessionTimestamp != -1)
{
currentTimestamp = sessionTimestamp;
}
else
{
currentTimestamp = GetFallbackTimestamp();
}
}
else
{
currentTimestamp = GetFallbackTimestamp();
}
Log.Debug("RtpMidi", "Answering with timestamp: {}", currentTimestamp);
RtpMidiClockSynchronization clockSynchronizationAnswer =
new RtpMidiClockSynchronization(Ssrc, (byte)1, clockSynchronization.Timestamp1,
currentTimestamp, 0L);
try
{
Send(clockSynchronizationAnswer, rtpMidiServer);
}
catch (IOException e)
{
Log.Error("RtpMidi", "IOException while sending clock synchronization", e);
}
}
else
if (clockSynchronization.Count == (byte)2)
{
long offsetEstimate =
(clockSynchronization.Timestamp3 + clockSynchronization.Timestamp1) / 2 -
clockSynchronization.Timestamp2;
RtpMidiSessionConnection midiServer = currentSessions.GetValueOrDefault(clockSynchronization.Ssrc);
if (midiServer != null)
{
midiServer.RtpMidiSession.OffsetEstimate = offsetEstimate;
}
}
}
public void OnClockSynchronization(RtpMidiClockSynchronization clockSynchronization, model.RtpMidiServer rtpMidiServer)
{
Log.Debug("RtpMidi", "MIDI clock synchronization: clockSynchronization: {}, appleMidiServer: {}", clockSynchronization, rtpMidiServer);
}
public void OnEndSession(RtpMidiEndSession rtpMidiEndSession, model.RtpMidiServer rtpMidiServer)
{
Log.Debug("RtpMidi", "MIDI end session: rtpMidiEndSession: {}, rtpMidiServer: {}", rtpMidiEndSession,
rtpMidiServer);
}
public void OnMidiInvitation(RtpMidiInvitationRequest invitation, model.RtpMidiServer rtpMidiServer)
{
Log.Debug("RtpMidi", "MIDI invitation: invitation: {}, appleMidiServer: {}", invitation, rtpMidiServer);
}
public void Send(RtpMidiMessage rtpMidiMessage, model.RtpMidiServer rtpMidiServer)
{
Send(rtpMidiMessage.ToByteArray(), rtpMidiServer);
}
private void Send(byte[] data, model.RtpMidiServer rtpMidiServer)
{
Log.Debug("RtpMidi", "Sending data {} to server {}", BitConverter.ToString(data).Replace("-", ""), rtpMidiServer);
socket.Send(new DatagramPacket(data, data.Length, rtpMidiServer.InetAddress, rtpMidiServer.Port));
}
private void Send(RtpMidiCommand midiCommand, model.RtpMidiServer rtpMidiServer)
{
byte[] invitationAcceptedBytes = midiCommand.ToByteArray();
socket.Send(new DatagramPacket(invitationAcceptedBytes, invitationAcceptedBytes.Length, rtpMidiServer.InetAddress, rtpMidiServer.Port));
}
