Category:FastFiles: Difference between revisions

FastFiles are the CoD engine's way of storing Zone files. FastFiles (FFs) almost always have some sort of RSA2048 signature, a zlib compression along the way, and then on later CoDs some encryption. The Zones are a library of assets. Every FF in every CoD game starts the same way...

So by reading the version of the input FF, you can tell what system and game the FF is from. Note that pre-alpha versions of Call of Duty 4 are missing the version integer, and must be handled specially. Also keep in mind that the Quantum of Solace FFs are missing the magic in the struct above.

Stream Blocks

After the Zone (XFile) is extracted from the fastfile, you read the block sizes of each g_streamBlock allocation. This determines how much memory to allocate to each stream to read data into. Each block stream has a specific role in the data that is read and it goes as follows:

One distinction is that PC uses virtual for a load of loading where PS3 mainly uses large.

Stream blocks exist within a stack, when a loader is using a block, it pops the requested block onto the stack, reads data into it, then when complete, pops that block off the stack, and returns to the previous block at the block stream cursor position.

Pointers in Zone Files

Pointers can be classified as one of the following:

• 0 : null, no data follows
• -1 : inline, data follows after the struct, usually in order but NOT ALWAYS
• -2 : insert, space is allocated in the stream block and inserted into later
• else : everything else is an encoded offset, it contains which block and offset it's pointing too.

Pointers have different types as well, depending on the type the data is loaded differently.

• Direct : It points directly to data, such as char*, int*, itemDef_t*
• Alias : It pointers to shared assets, such as Material*

For encoded offsets the first 4 bits (or 3 bits in BO2) are extracted and used as an index for the g_streamBlocks array. The other bits are the offset and is added to the data pointer in g_streamBlocks.

Encoding

int EncodeOffset(int blockIndex, int offset)
{
    return (blockIndex << 28) | (offset + 1);
}

Decoding

XBlockAddress DecodeOffset(int value)
{
    int block = (XFILE_BLOCK)(value >> 28);
    int offset = (int)(value & 0x0FFFFFFF) - 1;

    return new XBlockAddress(block, offset);
}

For example a pointer with a value of 0x40001689 means that the data belongs in block stream 4 (large) at offset 0x1688 .

The offset is only correct after the zone file has been loaded into the respective g_streamBlocks/memory. This is because data gets loaded into different blocks depending on how each executable loader works. In addition, data is aligned based on data type.

Padding Rules

Insert Pointers

For -2 pointers, the flow goes as follows: 1. ReadPointer reads raw -2, writes that 4-byte value into the active emitted block, and remembers that cell as PatchAddress.

2. Later, when the pointer is materialized it recognizes -2 (insert)

3. For insert, it allocates one extra 4-byte pointer cell in the LARGE block, aligned to 4, initialized to 0

4. It resolves the actual payload address according to the plan: current block position, allocated block position, or current stream position.

5. It patches two cells to the encoded payload address: the original pointer field that contained -2 the new inserted pointer cell in LARGE