Category:FastFiles - Revision history

Jakes625 at 21:35, 15 June 2026

2026-06-15T21:35:23Z

@@ Line 226: / Line 226: @@
 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.
 == Insert Pointers ==
@@ Line 247: / Line 240: @@
 the original pointer field that contained -2
 the new inserted pointer cell in LARGE

Jakes625: /* flow */

2026-06-12T03:50:49Z

flow

← Older revision		Revision as of 03:50, 12 June 2026
Line 35:		Line 35:
	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.		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.

	=== ~~flow~~ ===		=== Block Stream Flow ===
			<div class="mw-collapsible mw-collapsed" style="border:1px solid #a2a9b1; padding:0.5em; margin:0.5em 0;">
			'''Show'''
			<div class="mw-collapsible-content">
	<pre>		<pre>
	START		START
Line 167:		Line 170:
	END		END
	</pre>		</pre>
			</div>
			</div>

	Pop behavior:		Pop behavior:

Jakes625: /* Stream Blocks */

2026-06-12T03:48:18Z

Stream Blocks

Show changes

Jakes625 at 03:39, 12 June 2026

2026-06-12T03:39:32Z

← Older revision		Revision as of 03:39, 12 June 2026
Line 77:		Line 77:
	\|Byte Alignment\|\|4\|\|4\|\|1\|\|1\|\|2\|\|4		\|Byte Alignment\|\|4\|\|4\|\|1\|\|1\|\|2\|\|4
	\|}		\|}

			== 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

Jakes625 at 02:01, 12 June 2026

2026-06-12T02:01:44Z

← Older revision		Revision as of 02:01, 12 June 2026
Line 72:		Line 72:

	=== Padding Rules ===		=== Padding Rules ===
	~~<code> to do <~~/~~code>~~		{\| class="wikitable"
			\| \|\|'''XStruct'''\|\|'''Pointers'''\|\|'''Byte'''\|\|'''Bool'''\|\|'''int16/uint16'''\|\|'''Default'''
			\|-
			\|Byte Alignment\|\|4\|\|4\|\|1\|\|1\|\|2\|\|4
			\|}

Jakes625: /* Stream Blocks */

2026-06-12T01:57:21Z

Stream Blocks

← Older revision		Revision as of 01:57, 12 June 2026
Line 32:		Line 32:

	One distinction is that PC uses virtual for a load of loading where PS3 mainly uses large.		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 in Zone Files ==

Jakes625: /* Pointers in Zone Files */

2026-06-12T01:54:19Z

Pointers in Zone Files

← Older revision		Revision as of 01:54, 12 June 2026
Line 35:		Line 35:
	== Pointers in Zone Files ==		== Pointers in Zone Files ==
	Pointers can be classified as one of the following:		Pointers can be classified as one of the following:
	* {{ 0 }}: null, no data follows		* <code> 0 </code>: null, no data follows
	* {{ -1 }}: inline, data follows after the struct, usually in order but '''NOT ALWAYS'''		* <code> -1 </code>: 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		* <code> -2 </code>: 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.		* <code> else </code>: 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.
			* <code> Direct </code>: It points directly to data, such as char, int, itemDef_t*
			* <code> Alias </code>: 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.		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.
Line 61:		Line 65:
	</pre>		</pre>

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

	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.		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 ===		=== Padding Rules ===
	{{ to do }}		<code> to do </code>

Jakes625: /* Pointers in Zone Files */

2026-06-12T01:50:40Z

Pointers in Zone Files

← Older revision		Revision as of 01:50, 12 June 2026
Line 35:		Line 35:
	== Pointers in Zone Files ==		== Pointers in Zone Files ==
	Pointers can be classified as one of the following:		Pointers can be classified as one of the following:
	* 0: null, no data follows		* {{ 0 }}: null, no data follows
	* -1: inline, data follows after the struct, usually in order but '''NOT ALWAYS'''		* {{ -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		* {{ -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.		* {{ else }}: everything else is an encoded offset, it contains which block and offset it's pointing too.

	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.		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.
Line 50:		Line 50:
	</pre>		</pre>

	The offset is only correct after the zone file has been loaded in memory. This is because ~~some~~ data is ~~relocated (~~aligned~~) which changes the size of the zone~~. ~~Some differences:~~		=== Decoding ===
	* strings are aligned by 4 bytes		<pre>
	* asset headers are stored in pools		XBlockAddress DecodeOffset(int value)
	* sound, image, and shader programs are stored in pools		{
	* zone header is removed		int block = (XFILE_BLOCK)(value >> 28);
			int offset = (int)(value & 0x0FFFFFFF) - 1;

			return new XBlockAddress(block, offset);
			}
			</pre>

			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 ===
			{{ to do }}

Jakes625: /* Encoding */

2026-06-12T01:40:02Z

Encoding

← Older revision		Revision as of 01:40, 12 June 2026
Line 42:		Line 42:
	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.		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 =		=== Encoding ===
	<~~code~~>		<pre>
	int EncodeOffset(int blockIndex, int offset)		int EncodeOffset(int blockIndex, int offset)
	{		{
	return (blockIndex << 28) \| (offset + 1);		return (blockIndex << 28) \| (offset + 1);
	}		}
	</~~code~~>		</pre>

	The offset is only correct after the zone file has been loaded in memory. This is because some data is relocated (aligned) which changes the size of the zone. Some differences:		The offset is only correct after the zone file has been loaded in memory. This is because some data is relocated (aligned) which changes the size of the zone. Some differences:

Jakes625: /* Pointers in Zone Files */

2026-06-12T01:39:32Z

Pointers in Zone Files

@@ Line 34: / Line 34: @@
 == Pointers in Zone Files ==
-Infinity Ward implemented their own way of loading data that can already be found earlier in the zone file. What should be an address in memory is instead stored either as -1, -2, or as an offset. If the pointer is -1 or -2, than the data follows, typically in order. If the pointer is not -1 or -2, 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. The offset is only correct after the zone file has been loaded in memory. This is because some data is relocated (aligned) which changes the size of the zone. Some differences:
+Pointers can be classified as one of the following:
 * strings are aligned by 4 bytes
 * asset headers are stored in pools
 * sound, image, and shader programs are stored in pools
 * zone header is removed