News: 11 March 2016 - Forum Rules
Current Moderators - DarkSol, KingMike, MathOnNapkins, Azkadellia, Danke

Author Topic: IPS, BPS, UPS, PPS, ADS, xDelta, APS, MOD, PPF, VCDiff... My head is spinning!!  (Read 1181 times)

Minty_Meeo

  • Newbie
  • *
  • Posts: 1
    • View Profile
Hello.  I primarily hack GameCube games (1.5GB in size) and am considering a patch format for creations I'd like to share.  When searching online, however, it seems like there are countless different patch formats.  Where can I find information to compare the benefits and drawbacks of each?  Are there even more that I am not aware of?  Thanks!

KingMike

  • Forum Moderator
  • Hero Member
  • *****
  • Posts: 6907
  • *sigh* A changed avatar. Big deal.
    • View Profile
You can rule out IPS.
It only supports up to 16MB files (as the format was designed at a time when that probably seemed like it would be enough forever). :P
"My watch says 30 chickens" Google, 2018

FAST6191

  • Hero Member
  • *****
  • Posts: 2593
    • View Profile
IPS. Very old format. More or less limited to 16 megabytes minus a few bytes. Some incompatible patch makers and patch appliers, some extensions to the format only used by some. No input file, self or output verification. No data relocation options (bad if you have a file system). Limited ability to add new data. Used for countless patches for many things, many emulators and hardware devices will support it. No good for GC stuff.

BPS. One of many attempts at a successor format for IPS.

UPS. Another of the attempts at being the successor to IPS.

PPS. Been many years since I heard of this one I think.

ADS. Never heard of it.

Xdelta. Couple of versions/line of this, both of which have seen use in ROM hacking. Was the format many moved to for things when IPS became too long in the tooth.
Has input verification, has ability to scan for data location changes (not perfect).

APS. Never heard of it.

MOD. Isn't that an audio format?

PPF. Playstation Patching Format. Rose up during the playstation era (though it was not without drawbacks as the PS1 era had no set standards for isos so there were a billion formats). Has a few versions. Limited abilities in a lot of things but if you want to patch a big file then it will do it. Was mostly a legacy format for the PS1 but did see some use during the Wii, and I think I have seen some GC stuff with it as well.

VCDiff. Rings a bell. Is it a programming format?

Others.
Hacking wise then BSDiff. In non hacking world it is a fierce rival of sorts to xdelta. Once upon a time the Windows patcher/version for this was a bit limited. Common in DS Scene group patches (trainers, cracks/fixes and such), and a few ROM hacks on the DS to boot.

Fireflower I guess. Aimed at graphical changes for a few games.

File system aware stuff. Whether it be to reduce patch creation time, patching time, giving some options to the end user, lowering patch size, working around encryption/compression (typically it will be chained with a program but not always) or a few other things there are those that will make a tool to pull apart an ISO/ROM that has a file system, patch the individual files and then insert or rebuild the ROM/ISO.
Most here will either have a command line program to extract the files, another to do the patching (or have the end user do it*) and then rebuild/insert, however not all will. Most notable for me is probably DPS which the guy that made the released Jump Ultimate Stars patch on the DS ended up making, or maybe what the Wii IOS/CIOS installers ended up being after early stages where effectively full IOS modules were released (they were encrypted so it saw a change...).

*I did see some people during the 3ds era do this to 3ds games (the 3ds is encrypted, and tools to handle it were a bit thin on the ground for a while).

The gamecube is small isos (not necessarily 1.5 gigs as the Wii/emulators can and do expand on this a bit, and you can do interesting things with multi disc games). If you want to do the when in Rome thing then see what your particular game's scene do if you like -- gamecube stuff does not have as much attention in general as other Nintendo systems, though stuff like Mario Kart is very popular indeed but kind of insular**. If not then xdelta is good stuff, or you can do file system approaches.
I should also note quite a few people are playing such things on their phones these days and very few patching formats see fit to have an android port.

**I occasionally wander through their wikis, forums and such. Mostly to see if they made some nice tools I can bring to the wider world but some of the threads/methods/techniques the good hackers of said circles are promoting were often otherwise sorted happily with fairly automated (or at least 100 times simpler) tools some years before whatever page/thread/chat log I am reading.


As far as day to day hacking goes.

IPS is still commonly used. Some try to phase it out but it is in so many existing hacks, so many tools, so many emulators, so many flash carts... and ultimately works and its limitations tend not to show that hard for the sorts of things hackers looking to work within hardware limits for 16 bit and older mainstream US/non filesystem devices (to some extent also a lot of the GBA).
Only reason I would expect to see it for the gamecube is one of those "extract this file, patch with this patch, reinsert file"

UPS is probably the go to format for when IPS is not enough. I see it a lot on the GBA where people want to go above 16 megabytes. Some will do it on principle as well.

PPF. Legacy PS1 stuff, some Wii stuff, some other hacks still find it and use it.

Xdelta. My weapon of choice for what I do. Does it all, do note you can disable input verification but it will be on by default. If someone has trimmed a ROM, added a trainer/hardcoded a cheat or something then most times it will also change the hash and thus need input verification disabled. Depending upon what you are doing then you might have to increase the search window for relocated data, which means it will take longer to make the patch.

BSDiff. Some like it compared to xdelta. Much the same problems as it.

mziab

  • Sr. Member
  • ****
  • Posts: 308
    • View Profile
    • mteam
VCDiff. Rings a bell. Is it a programming format?

VCDIFF is the format/standard implemented by xdelta3. So essentially, they are one and the same. Not to be confused with earlier versions of xdelta, which have a different, incompatible format.
« Last Edit: February 18, 2019, 06:06:53 am by mziab »

Chronosplit

  • Hero Member
  • *****
  • Posts: 1393
    • View Profile
From my experience:

IPS: Yeah no, not for anything not in a cartridge.  This is still used today as a quick and easy patch for all things up to SNES and also the GBA with support for the format nearly everywhere, but the size limit is staggering.  I used it in Pokemon and FFTA because it was before BPS (at least I think so) and because the "tons of patches" setup for these meant that no file check could be used.  Looking back, this was pretty dumb.

BPS: I use this in my Chrono Trigger stuff because A) it made patches smaller, B) it told people when they were patching things wrong (which did save a lot of people from issues), C) it's applied with Floating IPS and most multi-format patchers, so it's easy to come by.  It's an especially common sight with SMW hacks nowadays.  I don't think this is what you're wanting to use however.

UPS: Has similar qualities to BPS but older, and I've mostly seen it used in the GBA realm when a patch changes the size of the file.  Commonly seen in patchers.  IMHO BPS outclasses this, but both are seen less.

PPF: You'll see this format for PS1 things mostly, I only used it for one project due to the tool having the ability to export changes to a PPF patch instead of writing it to the ISO.  XDelta I think surpasses it nowadays.

XDelta: My main choice for CD games, it's pretty well the best choice I can think of for what you're searching for.  Patchers are also nearly as common as IPS (I've seen the format used outside of romhacking on occasion), so it isn't difficult to get it going on the user's end.