1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
package org.bukkit.craftbukkit;
import java.util.HashMap;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.zip.Deflater;
import net.minecraft.server.EntityPlayer;
import net.minecraft.server.Packet;
import net.minecraft.server.Packet51MapChunk;
public final class ChunkCompressionThread implements Runnable {
private static final ChunkCompressionThread instance = new ChunkCompressionThread();
private static boolean isRunning = false;
private final int QUEUE_CAPACITY = 1024 * 10;
private final HashMap<EntityPlayer, Integer> queueSizePerPlayer = new HashMap<EntityPlayer, Integer>();
private final BlockingQueue<QueuedPacket> packetQueue = new LinkedBlockingQueue<QueuedPacket>(QUEUE_CAPACITY);
private final int CHUNK_SIZE = 16 * 128 * 16 * 5 / 2;
private final int REDUCED_DEFLATE_THRESHOLD = CHUNK_SIZE / 4;
private final int DEFLATE_LEVEL_CHUNKS = 6;
private final int DEFLATE_LEVEL_PARTS = 1;
private final Deflater deflater = new Deflater();
private byte[] deflateBuffer = new byte[CHUNK_SIZE + 100];
public static void startThread() {
if (!isRunning) {
isRunning = true;
new Thread(instance).start();
}
}
public void run() {
while (true) {
try {
handleQueuedPacket(packetQueue.take());
} catch (InterruptedException ie) {
} catch (Exception e) {
e.printStackTrace();
}
}
}
private void handleQueuedPacket(QueuedPacket queuedPacket) {
addToPlayerQueueSize(queuedPacket.player, -1);
// Compress the packet if necessary.
if (queuedPacket.compress) {
handleMapChunk(queuedPacket);
}
sendToNetworkQueue(queuedPacket);
}
private void handleMapChunk(QueuedPacket queuedPacket) {
Packet51MapChunk packet = (Packet51MapChunk) queuedPacket.packet;
// If 'packet.g' is set then this packet has already been compressed.
if (packet.buffer != null) {
return;
}
int dataSize = packet.rawData.length;
if (deflateBuffer.length < dataSize + 100) {
deflateBuffer = new byte[dataSize + 100];
}
deflater.reset();
deflater.setLevel(dataSize < REDUCED_DEFLATE_THRESHOLD ? DEFLATE_LEVEL_PARTS : DEFLATE_LEVEL_CHUNKS);
deflater.setInput(packet.rawData);
deflater.finish();
int size = deflater.deflate(deflateBuffer);
if (size == 0) {
size = deflater.deflate(deflateBuffer);
}
// copy compressed data to packet
packet.buffer = new byte[size];
packet.size = size;
System.arraycopy(deflateBuffer, 0, packet.buffer, 0, size);
}
private void sendToNetworkQueue(QueuedPacket queuedPacket) {
queuedPacket.player.netServerHandler.networkManager.queue(queuedPacket.packet);
}
public static void sendPacket(EntityPlayer player, Packet packet) {
if (packet instanceof Packet51MapChunk) {
// MapChunk Packets need compressing.
instance.addQueuedPacket(new QueuedPacket(player, packet, true));
} else {
// Other Packets don't.
instance.addQueuedPacket(new QueuedPacket(player, packet, false));
}
}
private void addToPlayerQueueSize(EntityPlayer player, int amount) {
synchronized (queueSizePerPlayer) {
Integer count = queueSizePerPlayer.get(player);
amount += (count == null) ? 0 : count;
if (amount == 0) {
queueSizePerPlayer.remove(player);
} else {
queueSizePerPlayer.put(player, amount);
}
}
}
public static int getPlayerQueueSize(EntityPlayer player) {
synchronized (instance.queueSizePerPlayer) {
Integer count = instance.queueSizePerPlayer.get(player);
return count == null ? 0 : count;
}
}
private void addQueuedPacket(QueuedPacket task) {
addToPlayerQueueSize(task.player, +1);
while (true) {
try {
packetQueue.put(task);
return;
} catch (InterruptedException e) {
}
}
}
private static class QueuedPacket {
final EntityPlayer player;
final Packet packet;
final boolean compress;
QueuedPacket(EntityPlayer player, Packet packet, boolean compress) {
this.player = player;
this.packet = packet;
this.compress = compress;
}
}
}
|
