Welcome

Software

We want to be independent from third party coders and present you the tools written by some members from our very own staff.
All programs are freeware.

GBATA

GBATA (GBA TOOL ADVANCE) is a great freeware program coded by coolhj. It's a powerfoul set of tools in one little program.
Download v0.7a English

NDSTS

NDSTS (NDS TOOL SYSTEM) is another great piece of code by coolhj, dedicated to NDS console.
Download public beta 0.2 English

eNDryptS Advanced

eNDryptS Advanced (by SolidSnake) encrypts / decrypts the secure area of commercial NDS dumps.
Download v1.2 English

MGSE

MGSE (by SolidSnake) extracts gameserials and more from different systems into a .csv file.
Download v0.6 English

GBX-NDS Header Viewer

GBX-NDS Header Viewer (by massin) Reads NDS and GB/C headers, and lists other information.
You need .NET 2.0 framework for the tool.
Download v0.4.0.1 English

How to create & apply IPS patches


A nice tiny tool useful for creating and applying IPS patches is Smart IPS 1.0 by Hartec/DEXTROSE.
Download Smart IPS 1.0.

To apply "patch.ips" on the file "bad.aaa" load the IPS into field "IPS/IPS2 File" and the archive to be patched into field "Original File".
Click "Apply" button to apply the patch.

To create an IPS, load the original file into the field "Original File" and the destination file into the field "Patched File".
Type the name of the IPS you want to create into the field "IPS/IPS2 File".
Click "Create" button to create the patch.

Limits
Files can be larger than 16 MB, but IPS format cannot record changes beyond the 16 MB mark due to 24-bit addressing. The IPS file itself can be any size.

How to create & apply BDF patches


You can use a couple of command-line tools bsdiff and bspatch.
Download bsdiff/bspatch.

To apply "patch.bdf" on the file "bad.aaa", generating "good.aaa" just type: bspatch bad.aaa good.aaa patch.bdf

To create ""patch.bdf" that generates "good.aaa" from original "bad.aaa", just type: bsdiff bad.aaa good.aaa patch.bdf

How to create & apply xdelta3 patches


Get the command-line tool xdelta from http://xdelta.org/.
Download xdelta30u.

To apply "patch.xdelta3" on the file "bad.aaa", generating "good.aaa" just type: xdelta30u.exe -d -s bad.aaa patch.xdelta3 good.aaa

To create "patch.xdelta3" that generates "good.aaa" from original "bad.aaa", just type: xdelta30u.exe -e -s bad.aaa good.aaa patch.xdelta3

Note:
xDelta only really works well at the default settings if the data hasn't moved around much in the file: by default it will look ahead and behind 8 MB to find a match, if not it will add the data to the patch.
You can get around this by changing the buffer size with the -B option (this increases memory usage when making the patch!).
It will take a few minutes for the patching creation to start as xDelta has to read the entire file into memory.
This works great for making transfer patches as sometimes the files in the archives are in different positions.
PSP:
ISO example, to create the pach, type: xdelta.exe -9 -S djw -B 1812725760 -e -vfs "old.iso" "new.iso" "SERIAL_Old-CRC_to_New-CRC.xdelta3"
This uses a 1.8 GB buffer maximum, enough to read ahead an entire dual layer UMD into memory. If the ISO is smaller, say 200 MB, then it will only use a maximum of 200 MB of memory and not 1.8 GB.
You have to use the 64bit version of xDelta otherwise you may get an out of memory error. 32bit users will be able to apply the patch with no problems, because no huge buffer size is used.
The buffer limit when using 32bit xDelta should be about 1073741824 bytes (which is 1gb).
NDS:
For NDS, you can use 512 MB (size of the biggest ROM), but only if the default settings make a big patch.
NDS example, to create the pach, type: xdelta.exe -9 -S djw -B 536870912 -e -vfs "old.nds" "new.nds" "NUMBER_Old-CRC_to_New-CRC.xdelta3"

PPF info


PPF can include undo data but it can't add bytes or remove bytes from a file, so it can't fix over/underdumps...

PAR2 info


PAR2 files can be used on any source ISO to get a destination ISO.
How it works: is it splits the source ISO into certain sized blocks and stores checksums of all those blocks. Also included with those blocks is a certain amount of parity data that can repair bad/missing blocks.

When the PAR2 file is used, it scans the bad ISO file for matching blocks and uses the parity data to repair the bad and missing blocks. You can use PAR2 to convert different version ISOs like v1.00 to v1.01 (and even between different regions EUR>USA) if the game data is mostly the same.

PAR2 doesn't take into account file LBA positions if you have an ISO that contains a LOT of small files but they are in a different order (like a rebuilt ISO) then the original ISO you won't get many blocks matching...
Maybe a default PAR2 of say 25 blocks at 262144 bytes (25 * 256kb = 6.25mb parity data) or maybe even 50 blocks at 131072 bytes (50 * 128kb = 6.25mb parity data) can be uploaded. This should be enough to fix most scene bad dumps ISOs and if people need more blocks they can always request them.

The only problem I see with PAR2 patches is they are quite big, a 25 block @ 262144 byte PAR2 can easily reach 8 MB. If you multiply that 8 MB PAR2 by 3000 isos, that is almost 24 GB of patches...

How it works:
We have 'File A' with CRC 2499FFAA and 'File B' with CRC 91FABC04
(lets say File A is a bad dump and file B is a good dump)
and we have File C with CRC 4466FABC (an iso with a corrupt file) that is almost the same as file A but with a few wrong bytes.

When you make a PAR2, it scans 'File B' and stores checksums of each block.
Let's say File B is 1024kb long and we decide to use 256kb blocks and store 1 block of parity data.
This means we will have 4 blocks of checksums (1024 / 256 = 4 block) and 1 block of parity data where we can fix 1 block ANYWHERE in the file.

So this would the layout of the PAR2 file:
Block 1 = AB3413FF
Block 2 = 56FC1067
Block 3 = 1245AACC
Block 4 = 7724FDD3
Parity Data Block 1 = <256kb of parity data stored here>

This is the checksums of Blocks in File A:
Block 1 = AB3413FF
Block 2 = 56FC1067
Block 3 = 1245AACC
Block 4 = AA223388 = 6144 bytes missing data, so this block has a different CRC.

This is the checksums of blocks in File C:
Block 1 = AB3413FF
Block 2 = ABC36562 = bad data - corrupted file... so this block CRC doesn't match
Block 3 = 7724FDD3
Block 4 = 1245AACC

When you load the PAR2 and add 'File A', Quickpar scans the file and compares the checksums in the PAR2 file. It sees Block 1,2 and 3 match but block 4 checksum does not match, it then checks how many blocks of parity data are available, it finds 1 block, so it can repair the bad block using the Parity data and get the good ISO.

If you load the PAR2 and add 'File C', Quickpar scans the file and compares the checksums in the PAR2 file. It sees Block 1, 3 and 4 checksums match (but blocks 3 and 4 are switched, so it switches them back) but block 2 checksum doesn't match, quickpar then checks how many blocks of parity data are available, it finds 1 block, so it can repair the bad block using the Parity data and get the good ISO.

Even though the two files have corruption in different places, they can both be repaired and converted to 'File B'. If there were 2 blocks that didn't match the checksum, we can't repair the file and would need to get additional parity blocks.