Skip to content

Commit 5ecc518

Browse files
author
Benjamin Dobell
committed
libpit (Java) 1.3
0 parents  commit 5ecc518

File tree

11 files changed

+702
-0
lines changed

11 files changed

+702
-0
lines changed

Diff for: ‎README

Whitespace-only changes.

Diff for: ‎libpit-1.3.jar

6.8 KB
Binary file not shown.

Diff for: ‎libpit/.classpath

+6
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
<?xml version="1.0" encoding="UTF-8"?>
2+
<classpath>
3+
<classpathentry kind="src" path="src"/>
4+
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
5+
<classpathentry kind="output" path="bin"/>
6+
</classpath>

Diff for: ‎libpit/.project

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
<?xml version="1.0" encoding="UTF-8"?>
2+
<projectDescription>
3+
<name>libpit</name>
4+
<comment></comment>
5+
<projects>
6+
</projects>
7+
<buildSpec>
8+
<buildCommand>
9+
<name>org.eclipse.jdt.core.javabuilder</name>
10+
<arguments>
11+
</arguments>
12+
</buildCommand>
13+
</buildSpec>
14+
<natures>
15+
<nature>org.eclipse.jdt.core.javanature</nature>
16+
</natures>
17+
</projectDescription>

Diff for: ‎libpit/src/au/com/glassechidna/libpit/PitData.java

+321
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,321 @@
1+
package au.com.glassechidna.libpit;
2+
3+
import java.io.DataOutputStream;
4+
import java.io.IOException;
5+
import java.util.ArrayList;
6+
7+
public class PitData
8+
{
9+
public static final int FILE_IDENTIFIER = 0x12349876;
10+
public static final int HEADER_DATA_SIZE = 28;
11+
12+
private int entryCount; // 0x04
13+
private int unknown1; // 0x08
14+
private int unknown2; // 0x0C
15+
16+
private short unknown3; // 0x10 (7508 = I9000, 7703 = I9100 & P1000)?
17+
private short unknown4; // 0x12 (Always 65, probably flags of some sort)
18+
19+
private short unknown5; // 0x14
20+
private short unknown6; // 0x16
21+
22+
private short unknown7; // 0x18
23+
private short unknown8; // 0x1A
24+
25+
// Entries start at 0x1C
26+
private ArrayList<PitEntry> entries = new ArrayList<PitEntry>();
27+
28+
public PitData()
29+
{
30+
}
31+
32+
public boolean unpack(PitInputStream pitInputStream)
33+
{
34+
try
35+
{
36+
if (pitInputStream.readInt() != FILE_IDENTIFIER)
37+
return (false);
38+
39+
entries.clear();
40+
41+
entryCount = pitInputStream.readInt();
42+
43+
entries.ensureCapacity(entryCount);
44+
45+
unknown1 = pitInputStream.readInt();
46+
unknown2 = pitInputStream.readInt();
47+
48+
unknown3 = pitInputStream.readShort();
49+
unknown4 = pitInputStream.readShort();
50+
51+
unknown5 = pitInputStream.readShort();
52+
unknown6 = pitInputStream.readShort();
53+
54+
unknown7 = pitInputStream.readShort();
55+
unknown8 = pitInputStream.readShort();
56+
57+
int integerValue;
58+
byte[] buffer = new byte[Math.max(PitEntry.PARTITION_NAME_MAX_LENGTH, PitEntry.FILENAME_MAX_LENGTH)];
59+
char[] partitionName = new char[PitEntry.PARTITION_NAME_MAX_LENGTH];
60+
char[] filename = new char[PitEntry.FILENAME_MAX_LENGTH];
61+
62+
for (int i = 0; i < entryCount; i++)
63+
{
64+
PitEntry entry = new PitEntry();
65+
entries.add(entry);
66+
67+
integerValue = pitInputStream.readInt();
68+
entry.setUnused((integerValue != 0) ? true : false);
69+
70+
integerValue = pitInputStream.readInt();
71+
entry.setPartitionType(integerValue);
72+
73+
integerValue = pitInputStream.readInt();
74+
entry.setPartitionIdentifier(integerValue);
75+
76+
integerValue = pitInputStream.readInt();
77+
entry.setPartitionFlags(integerValue);
78+
79+
integerValue = pitInputStream.readInt();
80+
entry.setUnknown1(integerValue);
81+
82+
integerValue = pitInputStream.readInt();
83+
entry.setPartitionBlockSize(integerValue);
84+
85+
integerValue = pitInputStream.readInt();
86+
entry.setPartitionBlockCount(integerValue);
87+
88+
integerValue = pitInputStream.readInt();
89+
entry.setUnknown2(integerValue);
90+
91+
integerValue = pitInputStream.readInt();
92+
entry.setUnknown3(integerValue);
93+
94+
pitInputStream.read(buffer, 0, PitEntry.PARTITION_NAME_MAX_LENGTH);
95+
96+
int length = 0;
97+
for (int j = 0; j < PitEntry.PARTITION_NAME_MAX_LENGTH; j++)
98+
{
99+
if (buffer[j] == 0)
100+
{
101+
length = j;
102+
break;
103+
}
104+
105+
partitionName[j] = (char)buffer[j];
106+
}
107+
108+
entry.setPartitionName(new String(partitionName, 0, length));
109+
110+
pitInputStream.read(buffer, 0, PitEntry.FILENAME_MAX_LENGTH);
111+
112+
length = 0;
113+
for (int j = 0; j < PitEntry.FILENAME_MAX_LENGTH; j++)
114+
{
115+
if (buffer[j] == 0)
116+
{
117+
length = j;
118+
break;
119+
}
120+
121+
filename[j] = (char)buffer[j];
122+
}
123+
124+
entry.setFilename(new String(filename, 0, length));
125+
}
126+
127+
return (true);
128+
}
129+
catch (IOException e)
130+
{
131+
e.printStackTrace();
132+
return (false);
133+
}
134+
}
135+
136+
public boolean pack(DataOutputStream dataOutputStream)
137+
{
138+
try
139+
{
140+
dataOutputStream.writeInt(FILE_IDENTIFIER);
141+
142+
dataOutputStream.writeInt(entryCount);
143+
144+
dataOutputStream.writeInt(unknown1);
145+
dataOutputStream.writeInt(unknown1);
146+
147+
dataOutputStream.writeShort(unknown3);
148+
dataOutputStream.writeShort(unknown4);
149+
150+
dataOutputStream.writeShort(unknown5);
151+
dataOutputStream.writeShort(unknown6);
152+
153+
dataOutputStream.writeShort(unknown7);
154+
dataOutputStream.writeShort(unknown8);
155+
156+
for (int i = 0; i < entryCount; i++)
157+
{
158+
PitEntry entry = entries.get(i);
159+
160+
dataOutputStream.writeInt((entry.getUnused()) ? 1 : 0);
161+
162+
dataOutputStream.writeInt(entry.getPartitionType());
163+
dataOutputStream.writeInt(entry.getPartitionIdentifier());
164+
dataOutputStream.writeInt(entry.getPartitionFlags());
165+
166+
dataOutputStream.writeInt(entry.getUnknown1());
167+
168+
dataOutputStream.writeInt(entry.getPartitionBlockSize());
169+
dataOutputStream.writeInt(entry.getPartitionBlockCount());
170+
171+
dataOutputStream.writeInt(entry.getUnknown2());
172+
dataOutputStream.writeInt(entry.getUnknown3());
173+
174+
byte[] partitionName = entry.getPartitionName().getBytes();
175+
dataOutputStream.write(partitionName);
176+
177+
if (partitionName.length < PitEntry.PARTITION_NAME_MAX_LENGTH - 1)
178+
{
179+
byte[] blankData = new byte[PitEntry.PARTITION_NAME_MAX_LENGTH - 1 - partitionName.length];
180+
dataOutputStream.write(blankData);
181+
}
182+
183+
byte[] filename = entry.getFilename().getBytes();
184+
dataOutputStream.write(filename);
185+
186+
if (filename.length < PitEntry.PARTITION_NAME_MAX_LENGTH - 1)
187+
{
188+
byte[] blankData = new byte[PitEntry.PARTITION_NAME_MAX_LENGTH - 1 - filename.length];
189+
dataOutputStream.write(blankData);
190+
}
191+
}
192+
193+
return (true);
194+
}
195+
catch (IOException e)
196+
{
197+
e.printStackTrace();
198+
return (false);
199+
}
200+
}
201+
202+
public boolean matches(PitData otherPitData)
203+
{
204+
if (entryCount == otherPitData.entryCount && unknown1 == otherPitData.unknown1 && unknown2 == otherPitData.unknown2
205+
&& unknown3 == otherPitData.unknown3 && unknown4 == otherPitData.unknown4 && unknown5 == otherPitData.unknown5
206+
&& unknown6 == otherPitData.unknown6 && unknown7 == otherPitData.unknown7 && unknown8 == otherPitData.unknown8)
207+
{
208+
for (int i = 0; i < entryCount; i++)
209+
{
210+
if (!entries.get(i).matches(otherPitData.entries.get(i)))
211+
return (false);
212+
}
213+
214+
return (true);
215+
}
216+
else
217+
{
218+
return (false);
219+
}
220+
}
221+
222+
public void clear()
223+
{
224+
entryCount = 0;
225+
226+
unknown1 = 0;
227+
unknown2 = 0;
228+
229+
unknown3 = 0;
230+
unknown4 = 0;
231+
232+
unknown5 = 0;
233+
unknown6 = 0;
234+
235+
unknown7 = 0;
236+
unknown8 = 0;
237+
238+
entries.clear();
239+
}
240+
241+
public PitEntry getEntry(int index)
242+
{
243+
return (entries.get(index));
244+
}
245+
246+
public PitEntry findEntry(String partitionName)
247+
{
248+
for (int i = 0; i < entries.size(); i++)
249+
{
250+
PitEntry entry = entries.get(i);
251+
252+
if (!entry.getUnused() && entry.getPartitionName().equals(partitionName))
253+
return (entry);
254+
}
255+
256+
return (null);
257+
}
258+
259+
public PitEntry findEntry(int partitionIdentifier)
260+
{
261+
for (int i = 0; i < entries.size(); i++)
262+
{
263+
PitEntry entry = entries.get(i);
264+
265+
if (!entry.getUnused() && entry.getPartitionIdentifier() == partitionIdentifier)
266+
return (entry);
267+
}
268+
269+
return (null);
270+
}
271+
272+
public void addEntry(PitEntry entry)
273+
{
274+
entries.add(entryCount++, entry);
275+
}
276+
277+
public int getEntryCount()
278+
{
279+
return (entryCount);
280+
}
281+
282+
public int getUnknown1()
283+
{
284+
return (unknown1);
285+
}
286+
287+
public int getUnknown2()
288+
{
289+
return (unknown2);
290+
}
291+
292+
public short getUnknown3()
293+
{
294+
return (unknown3);
295+
}
296+
297+
public short getUnknown4()
298+
{
299+
return (unknown4);
300+
}
301+
302+
public short getUnknown5()
303+
{
304+
return (unknown5);
305+
}
306+
307+
public short getUnknown6()
308+
{
309+
return (unknown6);
310+
}
311+
312+
public short getUnknown7()
313+
{
314+
return (unknown7);
315+
}
316+
317+
public short getUnknown8()
318+
{
319+
return (unknown8);
320+
}
321+
}

0 commit comments

Comments
 (0)