.XBE File Format

@xbox

Published in 

xbox

 · 9 months ago

written by Aaron 'Caustik' Robinson, 18 November 2002

This document is, afaik, the most precise .XBE documentation out there (other than official Microsoft documentation). The reason for this is the simple fact that I have done a lot of work with this type of file, and I am very familiar with the format. .XBE files are very similar to .EXE, so you won't have much of a problem using them if you have any sort of experience with .EXE files. Well, here we go..

Note: The author of this document is not responsible for anything you do with this information. This information is solely for entertainment purposes, and the author does not condone any illegal goals you may decide to use this information to achieve.

.XBE Logo Bitmap

Encoding Algorithm

// ****************************************************************** 
// * standard typedefs 
// ****************************************************************** 
typedef signed int     sint; 
typedef unsigned int   uint; 

typedef char           int08; 
typedef short          int16; 
typedef long           int32; 

typedef unsigned char  uint08; 
typedef unsigned short uint16; 
typedef unsigned long  uint32; 

typedef signed char    sint08; 
typedef signed short   sint16; 
typedef signed long    sint32; 

// ****************************************************************** 
// * func : import_logo (100x17 8bit grayscale -> LogoBitmap format) 
// ****************************************************************** 
void cxbx_xbe::import_logo(const uint08 x_gray[100*17]) 
{ 
    char *rle = get_logo();     // get raw logo data bytes 

    // calculate maximum bitmap size supported by the existing file 
    uint32 max_size = m_header.m_logo_bitmap_size; 

    while(rle[max_size] == 0) 
        max_size++; 

    if(rle == 0) 
    { 
        if(get_error() == 0) 
            set_error("logo bitmap could not be imported (not enough space in file?)", false); 

        return; 
    } 

    // clear old bitmap data area 
    { 
        for(uint32 x=0;x<max_size;x++) rle[x]="0;" } uint32 offs="0;" for(uint32 v="1;v<100*17;offs++)" { char color="x_gray[v]">> 4; 

        uint32 len = 1; 

        while(++v<100*17-1 && len < 1024 && color == x_gray[v] >> 4) 
            len++; 

        if(offs >= max_size) 
        { 
            set_error("not enough room to write logo bitmap", true); 
            return; 
        } 

        logo_rle *cur = (logo_rle *)&rle;[offs]; 

        if(len <= 7) 
        { 
            cur->m_eight.m_type1 = 1; 
            cur->m_eight.m_len = len; 
            cur->m_eight.m_data = color; 
        } 
        else 
        { 
            cur->m_sixteen.m_type1 = 0; 
            cur->m_sixteen.m_type2 = 1; 
            cur->m_sixteen.m_len = len; 
            cur->m_sixteen.m_data = color; 
            offs++; 
        } 
    } 

    m_header.m_logo_bitmap_size = offs; 
}

Decoding Algorithm

// ****************************************************************** 
// * standard typedefs 
// ****************************************************************** 
typedef signed int     sint; 
typedef unsigned int   uint; 

typedef char           int08; 
typedef short          int16; 
typedef long           int32; 

typedef unsigned char  uint08; 
typedef unsigned short uint16; 
typedef unsigned long  uint32; 

typedef signed char    sint08; 
typedef signed short   sint16; 
typedef signed long    sint32; 

// ****************************************************************** 
// * func : export_logo (LogoBitmap format -> 100x17 8bit grayscale) 
// ****************************************************************** 
void xbe::export_logo(uint08 x_gray[100*17]) 
{ 
    // in that rare case that we have no logo bitmap, we should 
    // just clear it to black. 
    memset(x_gray, 0, 100*17); 

    uint32 leng = m_header.m_logo_bitmap_size; 

    char *rle = get_logo(); 

    if(rle == 0 || get_error()) 
        return; 

    uint32 o = 0; 

    for(uint32 v=0;v<leng;v++) { uint32 len="0," data="0;" logo_rle *cur="(logo_rle" *)&rle[v]; if(cur->m_eight.m_type1) 
        { 
            len     = cur->m_eight.m_len; 
            data    = cur->m_eight.m_data; 
        } 
        else 
        { 
            if(cur->m_sixteen.m_type2) 
            { 
                len     = cur->m_sixteen.m_len; 
                data    = cur->m_sixteen.m_data; 
                v      += 1; 
            } 
        } 

        for(uint32 j=0;j<len;j++) { o++; if(o>< 100*17) 
                x_gray[o] = (char)(data << 4); // could use (int)(data * 15.0 + .5); 
        } 
    } 
}

.XBE Structures (From CXBX Source)

C++ Source

// Note: This source is compatible with MSVC 6.0 or higher, and is public domain. 

// ****************************************************************** 
// * standard typedefs 
// ****************************************************************** 
typedef signed int     sint; 
typedef unsigned int   uint; 

typedef char           int08; 
typedef short          int16; 
typedef long           int32; 

typedef unsigned char  uint08; 
typedef unsigned short uint16; 
typedef unsigned long  uint32; 

typedef signed char    sint08; 
typedef signed short   sint16; 
typedef signed long    sint32; 

// ****************************************************************** 
// * class : xbe 
// ****************************************************************** 
class xbe 
{ 
    public: 

        #pragma pack(1) 
        struct header 
        { 
            uint32 m_magic;                         // magic number [should be "XBEH"] 
            uint08 m_digsig[256];                   // digital signature 
            uint32 m_base;                          // base address 
            uint32 m_sizeof_headers;                // size of headers 
            uint32 m_sizeof_image;                  // size of image 
            uint32 m_sizeof_image_header;           // size of image header 
            uint32 m_timedate;                      // timedate stamp 
            uint32 m_certificate_addr;              // certificate address 
            uint32 m_sections;                      // number of sections 
            uint32 m_section_headers_addr;          // section headers address 

            struct init_flags 
            { 
                uint m_mount_utility_drive    : 1;  // mount utility drive flag 
                uint m_format_utility_drive   : 1;  // format utility drive flag 
                uint m_limit_64mb             : 1;  // limit development kit run time memory to 64mb flag 
                uint m_dont_setup_harddisk    : 1;  // don't setup hard disk flag 
                uint m_unused                 : 4;  // unused (or unknown) 
                uint m_unused_b1              : 8;  // unused (or unknown) 
                uint m_unused_b2              : 8;  // unused (or unknown) 
                uint m_unused_b3              : 8;  // unused (or unknown) 
            }m_init_flags; 

            uint32 m_entry;                         // entry point address 
            uint32 m_tls_addr;                      // thread local storage directory address 
            uint32 m_pe_stack_commit;               // size of stack commit 
            uint32 m_pe_heap_reserve;               // size of heap reserve 
            uint32 m_pe_heap_commit;                // size of heap commit 
            uint32 m_pe_base_addr;                  // original base address 
            uint32 m_pe_sizeof_image;               // size of original image 
            uint32 m_pe_checksum;                   // original checksum 
            uint32 m_pe_timedate;                   // original timedate stamp 
            uint32 m_debug_pathname_addr;           // debug pathname address 
            uint32 m_debug_filename_addr;           // debug filename address 
            uint32 m_debug_unicode_filename_addr;   // debug unicode filename address 
            uint32 m_kernel_image_thunk_addr;       // kernel image thunk address 
            uint32 m_nonkernel_import_dir_addr;     // non kernel import directory address 
            uint32 m_library_versions;              // number of library versions 
            uint32 m_library_versions_addr;         // library versions address 
            uint32 m_kernel_library_version_addr;   // kernel library version address 
            uint32 m_xapi_library_version_addr;     // xapi library version address 
            uint32 m_logo_bitmap_addr;              // logo bitmap address 
            uint32 m_logo_bitmap_size;              // logo bitmap size 
        } 
        m_header; 

        struct certificate 
        { 
            uint32 m_size;                          // size of certificate 
            uint32 m_timedate;                      // timedate stamp 
            uint32 m_titleid;                       // title id 
            uint16 m_title_name[40];                // title name (unicode) 
            uint32 m_alt_title_id[0x10];            // alternate title ids 
            uint32 m_allowed_media;                 // allowed media types 
            uint32 m_game_region;                   // game region 
            uint32 m_game_ratings;                  // game ratings 
            uint32 m_disk_number;                   // disk number 
            uint32 m_version;                       // version 
            uint08 m_lan_key[16];                   // lan key 
            uint08 m_sig_key[16];                   // signature key 
            uint08 m_title_alt_sig_key[16][16];     // alternate signature keys 
        } 
        m_certificate; 

        struct section_header 
        { 
            struct flags                            // flags 
            { 
                uint m_writable             : 1;    // writable flag 
                uint m_preload              : 1;    // preload flag 
                uint m_executable           : 1;    // executable flag 
                uint m_inserted_file        : 1;    // inserted file flag 
                uint m_head_page_ro         : 1;    // head page read only flag 
                uint m_tail_page_ro         : 1;    // tail page read only flag 
                uint m_unused_a1            : 1;    // unused (or unknown) 
                uint m_unused_a2            : 1;    // unused (or unknown) 
                uint m_unused_b1            : 8;    // unused (or unknown) 
                uint m_unused_b2            : 8;    // unused (or unknown) 
                uint m_unused_b3            : 8;    // unused (or unknown) 
            }m_flags; 
            uint32  m_virtual_addr;                  // virtual address 
            uint32  m_virtual_size;                  // virtual size 
            uint32  m_raw_addr;                      // file offset to raw data 
            uint32  m_sizeof_raw;                    // size of raw data 
            uint32  m_section_name_addr;             // section name addr 
            uint32  m_section_reference_count;       // section reference count 
            uint16 *m_head_shared_ref_count_addr;    // head shared page reference count address 
            uint16 *m_tail_shared_ref_count_addr;    // tail shared page reference count address 
            uint08  m_section_digest[20];            // section digest 
        } 
        *m_section_header; 

        struct library_version 
        { 
            char   m_name[8];                       // library name 
            uint16 m_major_version;                 // major version 
            uint16 m_minor_version;                 // minor version 
            uint16 m_build_version;                 // build version 
            struct flags                            // flags 
            { 
                uint16 m_qfe_version        : 13;   // QFE Version 
                uint16 m_approved           : 2;    // Approved? (0:no, 1:possibly, 2:yes) 
                uint16 m_debug_build        : 1;    // Is this a debug build? 
            }m_flags; 
        } 
        *m_library_version, *m_kernel_version, *m_xapi_version; 

        struct tls                                  // thread local storage 
        { 
            uint32 m_data_start_addr;               // raw start address 
            uint32 m_data_end_addr;                 // raw end address 
            uint32 m_tls_index_addr;                // tls index  address 
            uint32 m_tls_callback_addr;             // tls callback address 
            uint32 m_sizeof_zero_fill;              // size of zero fill 
            uint32 m_characteristics;               // characteristics 
        } 
        *m_tls; 
}