public void run() {
while (true) {
LinkedList<PacketCallbackStruct> list = null;
try {
queuedPacketCallbacksLock.lock();
try {
queuedPacketCallbacksNotEmpty.await();
} catch (Exception e) {
Log.error(
"RDPServer.PacketCallbackThread: queuedPacketCallbacksNotEmpty.await() caught exception "
+ e.getMessage());
}
list = queuedPacketCallbacks;
queuedPacketCallbacks = new LinkedList<PacketCallbackStruct>();
} finally {
queuedPacketCallbacksLock.unlock();
}
if (Log.loggingNet)
Log.net("RDPServer.PacketCallbackThread: Got " + list.size() + " queued packets");
for (PacketCallbackStruct pcs : list) {
try {
callbackProcessPacket(pcs.cb, pcs.con, pcs.packet);
} catch (Exception e) {
Log.exception("RDPServer.PacketCallbackThread: ", e);
}
}
}
}
public void handleMessage(Message msg, int flags) {
try {
lock.lock();
if (activated == false) return; // return true;
if (msg.getMsgType() == Behavior.MSG_TYPE_COMMAND) {
Behavior.CommandMessage cmdMsg = (Behavior.CommandMessage) msg;
String command = cmdMsg.getCmd();
// Remove the executor, because anything we do will
// end the current execution.
Engine.getExecutor().remove(this);
if (Log.loggingDebug)
Log.debug(
"BaseBehavior.onMessage: command = "
+ command
+ "; oid = "
+ obj.getOid()
+ "; name "
+ obj.getName());
if (command.equals(MSG_CMD_TYPE_GOTO)) {
GotoCommandMessage gotoMsg = (GotoCommandMessage) msg;
Point destination = gotoMsg.getDestination();
mode = MSG_CMD_TYPE_GOTO;
roamingBehavior = true;
gotoSetup(destination, gotoMsg.getSpeed());
} else if (command.equals(MSG_CMD_TYPE_STOP)) {
followTarget = null;
pathState.clear();
obj.getWorldNode().setDir(new MVVector(0, 0, 0));
obj.updateWorldNode();
mode = MSG_CMD_TYPE_STOP;
// If roamingBehavior is set, that means that we
// used formerly had a roaming behavior, so send
// an ArrivedEventMessage so that the other
// behavior starts up again.
if (roamingBehavior) {
try {
Engine.getAgent().sendBroadcast(new ArrivedEventMessage(obj));
} catch (Exception e) {
Log.error(
"BaseBehavior.onMessage: Error sending ArrivedEventMessage, error was '"
+ e.getMessage()
+ "'");
throw new RuntimeException(e);
}
}
} else if (command.equals(BaseBehavior.MSG_CMD_TYPE_FOLLOW)) {
FollowCommandMessage followMsg = (FollowCommandMessage) msg;
mode = MSG_CMD_TYPE_FOLLOW;
followSetup(followMsg.getTarget(), followMsg.getSpeed());
}
} else if (msg.getMsgType() == WorldManagerClient.MSG_TYPE_MOB_PATH_CORRECTION) {
Engine.getExecutor().remove(this);
interpolatePath();
interpolatingPath = false;
}
// return true;
} finally {
lock.unlock();
}
}
static void callbackProcessPacket(
ClientConnection.MessageCallback pcb, ClientConnection clientCon, RDPPacket packet) {
if (packet.isNul()) {
return;
}
byte[] data = packet.getData();
MVByteBuffer buf = new MVByteBuffer(data);
RDPConnection con = (RDPConnection) clientCon;
// If this is a multiple-message message . . .
if (buf.getLong() == -1 && buf.getInt() == RDPConnection.aggregatedMsgId) {
con.aggregatedReceives++;
PacketAggregator.allAggregatedReceives++;
// Get the count of sub buffers
int size = buf.getInt();
con.receivedMessagesAggregated += size;
PacketAggregator.allReceivedMessagesAggregated += size;
if (Log.loggingNet)
Log.net(
"RDPServer.callbackProcessPacket: processing aggregated message with "
+ size
+ " submessages");
MVByteBuffer subBuf = null;
for (int i = 0; i < size; i++) {
try {
subBuf = buf.getByteBuffer();
} catch (Exception e) {
Log.error("In CallbackThread, error getting aggregated subbuffer: " + e.getMessage());
}
if (subBuf != null) pcb.processPacket(con, subBuf);
}
} else {
con.unaggregatedReceives++;
PacketAggregator.allUnaggregatedReceives++;
buf.rewind();
pcb.processPacket(con, buf);
}
}
/**
* Send data to all participants registered as receivers, using the current timeStamp and payload
* type. The RTP timestamp will be the same for all the packets.
*
* @param buffers A buffer of bytes, should not bed padded and less than 1500 bytes on most
* networks.
* @param csrcArray an array with the SSRCs of contributing sources
* @param markers An array indicating what packets should be marked. Rarely anything but the first
* one
* @param rtpTimestamp The RTP timestamp to be applied to all packets
* @param seqNumbers An array with the sequence number associated with each byte[]
* @return null if there was a problem sending the packets, 2-dim array with {RTP Timestamp,
* Sequence number}
*/
public long[][] sendData(
byte[][] buffers, long[] csrcArray, boolean[] markers, long rtpTimestamp, long[] seqNumbers) {
logger.debug("-> RTPSession.sendData(byte[])");
// Same RTP timestamp for all
if (rtpTimestamp < 0) rtpTimestamp = System.currentTimeMillis();
// Return values
long[][] ret = new long[buffers.length][2];
for (int i = 0; i < buffers.length; i++) {
byte[] buf = buffers[i];
boolean marker = false;
if (markers != null) marker = markers[i];
if (buf.length > 1500) {
System.out.println(
"RTPSession.sendData() called with buffer exceeding 1500 bytes (" + buf.length + ")");
}
// Get the return values
ret[i][0] = rtpTimestamp;
if (seqNumbers == null) {
ret[i][1] = getNextSeqNum();
} else {
ret[i][1] = seqNumbers[i];
}
// Create a new RTP Packet
RtpPkt pkt = new RtpPkt(rtpTimestamp, this.ssrc, (int) ret[i][1], this.payloadType, buf);
if (csrcArray != null) pkt.setCsrcs(csrcArray);
pkt.setMarked(marker);
// Creates a raw packet
byte[] pktBytes = pkt.encode();
// System.out.println(Integer.toString(StaticProcs.bytesToUIntInt(pktBytes, 2)));
// Pre-flight check, are resolving an SSRC conflict?
if (this.conflict) {
System.out.println("RTPSession.sendData() called while trying to resolve conflict.");
return null;
}
if (this.mcSession) {
DatagramPacket packet = null;
try {
packet =
new DatagramPacket(pktBytes, pktBytes.length, this.mcGroup, this.rtpMCSock.getPort());
} catch (Exception e) {
System.out.println("RTPSession.sendData() packet creation failed.");
e.printStackTrace();
return null;
}
try {
rtpMCSock.send(packet);
// Debug
if (this.debugAppIntf != null) {
this.debugAppIntf.packetSent(
1,
(InetSocketAddress) packet.getSocketAddress(),
new String(
"Sent multicast RTP packet of size "
+ packet.getLength()
+ " to "
+ packet.getSocketAddress().toString()
+ " via "
+ rtpMCSock.getLocalSocketAddress().toString()));
}
} catch (Exception e) {
System.out.println("RTPSession.sendData() multicast failed.");
e.printStackTrace();
return null;
}
} else {
// Loop over recipients
Iterator<Participant> iter = partDb.getUnicastReceivers();
while (iter.hasNext()) {
InetSocketAddress receiver = iter.next().rtpAddress;
DatagramPacket packet = null;
logger.debug(" Sending to {}", receiver);
try {
packet = new DatagramPacket(pktBytes, pktBytes.length, receiver);
} catch (Exception e) {
System.out.println("RTPSession.sendData() packet creation failed.");
e.printStackTrace();
return null;
}
// Actually send the packet
try {
rtpSock.send(packet);
// Debug
if (this.debugAppIntf != null) {
this.debugAppIntf.packetSent(
0,
(InetSocketAddress) packet.getSocketAddress(),
new String(
"Sent unicast RTP packet of size "
+ packet.getLength()
+ " to "
+ packet.getSocketAddress().toString()
+ " via "
+ rtpSock.getLocalSocketAddress().toString()));
}
} catch (Exception e) {
System.out.println("RTPSession.sendData() unicast failed.");
e.printStackTrace();
return null;
}
}
}
// Update our stats
this.sentPktCount++;
this.sentOctetCount++;
logger.info("<- RTPSession.sendData(byte[])", pkt.getSeqNumber());
}
return ret;
}
