// ******************************************************************
// * 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;
}

          
// ******************************************************************
// * 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);
        }
    }
}

// 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;
}