.STR Archive Structure (EA Stream File)

Version: 1.0
Last Updated: 2025-02-17
Author(s): samarixum

The .str file is EA's streaming container format used by the RenderWare engine on PS3/Xbox 360. It contains a metadata header pointing to section descriptors and data, with support for compression (Refpack) and lazy-loading of resources.

Endianness: Big-Endian throughout.

Parsing Algorithm Overview

1. Read and validate file header at offset 0x00
2. Navigate to StreamFile struct at header offset pStreamFile
3. Navigate to Section array at header offset pSectionArr
4. For each section:
   1. Read section descriptor (6 × UInt32)
   2. Decompress data if CompressorID indicates Refpack (0xB9F0B9EC)
   3. Scan decompressed/raw section data for chunk markers (0x1607, 0x2207, 0x2307, 0x10FB)
   4. Parse each chunk based on its type

File Header Structure

Located at offset 0x00. Size: 16 bytes.

StreamFile Struct

Located at file offset = header.pStreamFile. Size: ~48+ bytes (variable due to string).

Section Descriptor Array

Located at file offset = header.pSectionArr. Array of nSections entries, each 24 bytes.

To parse: For i = 0 to nSections-1, seek to (pSectionArr + i*24) and read 24 bytes.

Section Data Decompression

Algorithm:

1. Seek to file offset = ReadOffset
2. Read ReadSize bytes into a buffer
3. If CompressorID == 0xB9F0B9EC:
   • Decompress using Refpack algorithm. Output buffer size should be DataSize.
   • Validate: decompressed output must be exactly DataSize bytes.
4. If CompressorID == 0x0EAC15C8:
   • Data is uncompressed; use buffer directly (which has ReadSize == DataSize).
5. If CompressorID is any other value:
   • Can attempt to treat as uncompressed, or abort with error.

Chunk Scanning and Parsing

After decompression/acquisition of section data, scan the data for embedded chunks. Chunks are identified by 2-byte type identifiers (Big-Endian UInt16).

Chunk Scanning Algorithm:

1. current_pos = 0
2. While current_pos < data.length:
   • Read UInt16 BE at current_pos as chunk_type
   • If chunk_type is a known type (see table below):
     • Handle this chunk (read size, parse data, extract resources)
     • Advance current_pos appropriately (depends on chunk type)
   • Else:
     • Advance current_pos by 1 and continue scanning

Known Chunk Types

Embedded Asset Chunk (0x1607)

Location: Within section data, identified by type marker 0x1607.

Structure:

1. Offset +0x00: UInt16 BE = 0x1607 (type, already read during scan)
2. Offset +0x02: UInt16 BE = padding (0x0000)
3. Offset +0x04: UInt32 BE = chunk_payload_size (total size of data following this field)
4. Offset +0x08: **Embedded Asset Header** (variable structure)
   • Read resource filename (null-terminated UTF-8 string)
   • Skip padding to align to next 4-byte boundary
   • Read resource type identifier (can be any of: graph, lh2, meta.xml, lighttoc, dff, rws, txd, cec.ps3, dat, shk, tob, etc.)
   • Skip metadata/flags as needed
   • Read remaining bytes until payload_size boundary as binary resource data

Parsing Pseudocode:

// At chunk start (0x00 = type marker 0x1607)
current = 0;
type = read_u16_be(current);  // Expect 0x1607
current += 2;
padding = read_u16_be(current);
current += 2;
chunk_size = read_u32_be(current);
current += 4;
chunk_end = current + chunk_size;

// Read filename
filename = read_null_terminated_string(current);
current += strlen(filename) + 1;

// Align to 4-byte boundary
while (current % 4 != 0) current++;

// Read resource type (varies, can peek ahead)
// Many resources have a magic/header at this point
resource_data_start = current;
resource_data_size = chunk_end - current;

// Extract and store resource (filename, type, binary data)
        

Summary: Parsing Workflow

1. Validate magic: Read header, verify "SToc"
2. Read header fields: nSections, pStreamFile, pSectionArr
3. Iterate sections:
   1. Seek to section descriptor at (pSectionArr + i*24)
   2. Read descriptor (MemPolicyID, CompressorID, DataSize, AllocSize, ReadSize, ReadOffset)
   3. Seek to ReadOffset, read ReadSize bytes
   4. If Refpack: decompress to DataSize bytes
   5. If uncompressed: use buffer as-is
4. Scan decompressed section data:
   1. Scan for chunk type markers (0x1607, 0x2207, 0x2307, 0x10FB)
   2. For each chunk found, parse based on type
5. Validate and store results: Build list of extracted resources (filenames, types, binary data)