iso2god

Use iso2god to convert Xbox 360 and original Xbox ISO files into the Xbox 360 compatible Games-On-Demand (GOD) file format. This tool is an optimized rewrite of iso2god-cli.

iso2god [OPTIONS] <SOURCE_ISO> <DEST_DIR>

The iso2god command-line tool converts ISO images into GOD (Games on Demand) format. It extracts metadata from the source ISO, determines the content type (Games on Demand or Xbox Original), and writes the resulting part files and .con header to a destination directory.

Basic Usage:

iso2god <source_iso> <dest_dir>

Key Features:

• Metadata Extraction: Automatically identifies Title ID, Game Name, and Content Type.
• Trimming: Can trim unused space from the end of the ISO to reduce the size of the resulting GOD files.
• Parallel Processing: Uses multiple threads to speed up the writing of part files.
• Dry Run: Allows you to inspect the ISO metadata without performing any conversion.

iso2god my_game.iso ./output_folder

By default, iso2god uses 1 thread. On non-Windows systems or when using SSDs, you can significantly increase performance by specifying a higher number of threads using the -j or --num-threads flag.

Warning: On Windows or when using traditional hard drives, the default is set to 1 thread to avoid potential issues with file access and drive performance.

iso2god source.iso ./dest -j 8

The --trim flag controls how unused space is handled during conversion. This affects the final size of the generated GOD files.

Available Modes:

• from-end (default): Trims unallocated space from the end of the ISO image.
• none: Trims nothing; the size is calculated based on the volume descriptor's root offset.

Note: Passing no --trim flag at all is equivalent to using from-end.

iso2god source.iso ./dest --trim none

The iso2god CLI tool accepts a source ISO file and a destination directory as positional arguments. You can use several options to customize the conversion process.

Arguments:
  <SOURCE_ISO>  ISO file to convert
  <DEST_DIR>    A folder to write resulting GOD files to

Options:
      --dry-run             Do not convert anything, just print the title info
      --game-title <TITLE>  Set game title
      --trim                Trim off unused space from the ISO image
  -j, --num-threads <N>     Number of worker threads to use
  -h, --help                Print help
  -V, --version             Print version

To parse an Xbox 360 executable (XEX) header, use the XexHeader::read method. This method requires a reader that implements both std::io::Read and std::io::Seek. It validates the magic bytes (expecting XEX2) and extracts module flags, code offsets, certificate offsets, and various header fields.

If the header is invalid or missing the XEX2 magic bytes, it will return an error: missing 'XEX2' magic bytes in XEX header.

use crate::executable::xex::XexHeader;
use std::fs::File;

let mut file = File::open("path/to/executable.xex")?;
let header = XexHeader::read(&mut file)?;

println!("Module Flags: {:?}", header.module_flags);
println!("Code Offset: {}", header.code_offset);

To retrieve data from a HashList:

• digest(&self) -> [u8; 20]: Returns a single 20-byte SHA-1 digest of the entire internal buffer.
• bytes(&self) -> &[u8; 4096]: Returns a reference to the raw 4096-byte internal buffer.
• write<W: Write>(&self, mut writer: W): Writes the entire 4096-byte buffer to the provided writer.

Use get_entry(path: &WindowsPath) to locate a specific file or directory within the ISO.

• Path Format: Use WindowsPath which uses backslashes (\) as separators.
• Return Value: Returns Ok(Some(&mut R)) where the reader is positioned at the start of the requested entry's data, or Ok(None) if the path does not exist.
• Behavior: The method traverses the DirectoryTable hierarchy based on the provided path components.

use iso::WindowsPath;

// Access a file at 'folder\file.txt'
let path = WindowsPath::from("folder\\file.txt");
if let Some(entry_reader) = iso_reader.get_entry(&path)? {
    // entry_reader is now positioned at the start of the file data
}

Use get_max_used_prefix_size() to determine the minimum number of bytes required to represent the entire ISO structure. This calculation accounts for:

• The volume descriptor extent.
• The root directory table extent.
• The extents of all files and subdirectories within the DirectoryTable hierarchy.

This is useful for trimming images or determining how much data must be read to ensure a complete capture of the filesystem structure.

let min_size = iso_reader.get_max_used_prefix_size();

Use get_root() to seek the underlying reader to the start of the root directory table. This returns a mutable reference to the reader R, allowing you to read the raw bytes of the root directory.

let mut iso_reader = IsoReader::read(file)?;
let root_reader = iso_reader.get_root()?;
// Use root_reader to read directory data