ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Formatting of changes 

As per the style guide
This commit is contained in:
x1nixmzeng 2016-01-07 20:51:28 +00:00
parent effe241a11
commit e4cef38d95
4 changed files with 192 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
src/xenia/emulator.cc
View File

@ -514,28 +514,29 @@ X_STATUS Emulator::CompleteLaunch(const std::wstring& path,
if (!main_xthread) { if (!main_xthread) {
return X_STATUS_UNSUCCESSFUL; return X_STATUS_UNSUCCESSFUL;
} }
// Try and load the resource database (xex only)
char title[9] = { 0 };
sprintf(title, "%08X", module->title_id());
uint32_t resource_data = 0;
uint32_t resource_size = 0;
if (XSUCCEEDED(module->GetSection(title, &resource_data, &resource_size))) {
auto xdb_ptr = module->memory()->TranslateVirtual(resource_data);
if (xdb_ptr != nullptr) {
xe::xdbf::XdbfWrapper db;
if (db.initialize(xdb_ptr, static_cast<size_t>(resource_size))) {
std::wstring title(xe::to_wstring(xe::xdbf::get_title(db)));
display_window_->set_title(title);
xe::xdbf::XdbfBlock icon_block = xe::xdbf::get_icon(db); // Try and load the resource database (xex only)
if (icon_block.buffer != nullptr) { char title[9] = {0};
display_window_->set_icon_from_buffer(icon_block.buffer, icon_block.size); sprintf(title, "%08X", module->title_id());
}
} uint32_t resource_data = 0;
} uint32_t resource_size = 0;
} if (XSUCCEEDED(module->GetSection(title, &resource_data, &resource_size))) {
auto xdb_ptr = module->memory()->TranslateVirtual(resource_data);
if (xdb_ptr != nullptr) {
xe::xdbf::XdbfWrapper db;
if (db.initialize(xdb_ptr, static_cast<size_t>(resource_size))) {
std::wstring title(xe::to_wstring(xe::xdbf::get_title(db)));
display_window_->set_title(title);
xe::xdbf::XdbfBlock icon_block = xe::xdbf::get_icon(db);
if (icon_block.buffer != nullptr) {
display_window_->set_icon_from_buffer(icon_block.buffer,
icon_block.size);
}
}
}
}
main_thread_ = main_xthread->thread(); main_thread_ = main_xthread->thread();
WaitUntilExit(); WaitUntilExit();

27
src/xenia/ui/window_win.cc
View File

@ -167,22 +167,23 @@ bool Win32Window::set_title(const std::wstring& title) {
return true; return true;
} }
bool Win32Window::set_icon_from_buffer(void *buffer, size_t size) { bool Win32Window::set_icon_from_buffer(void* buffer, size_t size) {
if (icon_ != nullptr) {
DestroyIcon(icon_);
}
if (icon_ != nullptr) { HICON icon = CreateIconFromResourceEx(reinterpret_cast<BYTE*>(buffer),
DestroyIcon(icon_); static_cast<DWORD>(size), TRUE,
} 0x00030000, 0, 0, LR_DEFAULTCOLOR);
HICON icon = CreateIconFromResourceEx(reinterpret_cast<BYTE *>(buffer), static_cast<DWORD>(size), TRUE, 0x00030000, 0, 0, LR_DEFAULTCOLOR);
if (icon != nullptr) { if (icon != nullptr) {
icon_ = icon; icon_ = icon;
SendMessage(hwnd_, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(icon)); SendMessage(hwnd_, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(icon));
SendMessage(hwnd_, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(icon)); SendMessage(hwnd_, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(icon));
} }
return false; return false;
} }
bool Win32Window::is_fullscreen() const { return fullscreen_; } bool Win32Window::is_fullscreen() const { return fullscreen_; }

163
src/xenia/xdbf/xdbf_utils.cc
View File

@ -12,121 +12,114 @@
namespace xe { namespace xe {
namespace xdbf { namespace xdbf {
XdbfWrapper::XdbfWrapper() = default; XdbfWrapper::XdbfWrapper() = default;
XBDF_HEADER& XdbfWrapper::get_header() const XBDF_HEADER& XdbfWrapper::get_header() const { return *state_.header; }
{
return *state_.header;
}
XBDF_ENTRY& XdbfWrapper::get_entry(uint32_t n) const
{
return state_.entries[n];
}
XBDF_FILE_LOC& XdbfWrapper::get_file(uint32_t n) const XBDF_ENTRY& XdbfWrapper::get_entry(uint32_t n) const {
{ return state_.entries[n];
return state_.files[n]; }
}
bool XdbfWrapper::initialize(uint8_t* buffer, size_t length) XBDF_FILE_LOC& XdbfWrapper::get_file(uint32_t n) const {
{ return state_.files[n];
if (length <= sizeof(XBDF_HEADER)) { }
return false;
}
XdbfState state; bool XdbfWrapper::initialize(uint8_t* buffer, size_t length) {
if (length <= sizeof(XBDF_HEADER)) {
return false;
}
state.data = buffer; XdbfState state;
state.size = length;
uint8_t* ptr = state.data; state.data = buffer;
state.size = length;
state.header = reinterpret_cast<XBDF_HEADER*>(ptr); uint8_t* ptr = state.data;
ptr += sizeof(XBDF_HEADER);
state.entries = reinterpret_cast<XBDF_ENTRY*>(ptr); state.header = reinterpret_cast<XBDF_HEADER*>(ptr);
ptr += (sizeof(XBDF_ENTRY) * state.header->entry_max); ptr += sizeof(XBDF_HEADER);
state.files = reinterpret_cast<XBDF_FILE_LOC*>(ptr); state.entries = reinterpret_cast<XBDF_ENTRY*>(ptr);
ptr += (sizeof(XBDF_FILE_LOC) * state.header->free_max); ptr += (sizeof(XBDF_ENTRY) * state.header->entry_max);
state.offset = ptr; state.files = reinterpret_cast<XBDF_FILE_LOC*>(ptr);
ptr += (sizeof(XBDF_FILE_LOC) * state.header->free_max);
if (state.header->magic == 'XDBF') { state.offset = ptr;
state_ = state;
return true;
}
return false; if (state.header->magic == 'XDBF') {
} state_ = state;
return true;
}
XdbfBlock XdbfWrapper::get_entry(XdbfSection section, uint64_t id) const { return false;
}
XdbfBlock block = { nullptr,0 };
uint32_t x = 0;
while( x < get_header().entry_current ) { XdbfBlock XdbfWrapper::get_entry(XdbfSection section, uint64_t id) const {
auto &entry = get_entry(x); XdbfBlock block = {nullptr, 0};
uint32_t x = 0;
if (entry.section == section && entry.id == id) { while (x < get_header().entry_current) {
block.buffer = state_.offset + entry.offset; auto& entry = get_entry(x);
block.size = entry.size;
break;
}
++x; if (entry.section == section && entry.id == id) {
} block.buffer = state_.offset + entry.offset;
block.size = entry.size;
break;
}
return block; ++x;
} }
XdbfBlock get_icon(XdbfWrapper& ref) return block;
{ }
return ref.get_entry(kSectionImage, 0x8000);
}
std::string get_title(XdbfWrapper& ref) XdbfBlock get_icon(XdbfWrapper& ref) {
{ return ref.get_entry(kSectionImage, 0x8000);
std::string title_str; }
XdbfBlock block = ref.get_entry(kSectionMetadata, 0x58535443); std::string get_title(XdbfWrapper& ref) {
if (block.buffer != nullptr) { std::string title_str;
XDBF_XSTC* xstc = reinterpret_cast<XDBF_XSTC*>(block.buffer);
assert_true(xstc->magic == 'XSTC'); XdbfBlock block = ref.get_entry(kSectionMetadata, 0x58535443);
uint32_t def_language = xstc->default_language; if (block.buffer != nullptr) {
XDBF_XSTC* xstc = reinterpret_cast<XDBF_XSTC*>(block.buffer);
XdbfBlock lang_block = ref.get_entry(kSectionStringTable, static_cast<uint64_t>(def_language)); assert_true(xstc->magic == 'XSTC');
uint32_t def_language = xstc->default_language;
if (lang_block.buffer != nullptr) { XdbfBlock lang_block =
XDBF_XSTR_HEADER* xstr_head = reinterpret_cast<XDBF_XSTR_HEADER*>(lang_block.buffer); ref.get_entry(kSectionStringTable, static_cast<uint64_t>(def_language));
assert_true(xstr_head->magic == 'XSTR'); if (lang_block.buffer != nullptr) {
assert_true(xstr_head->version == 1); XDBF_XSTR_HEADER* xstr_head =
reinterpret_cast<XDBF_XSTR_HEADER*>(lang_block.buffer);
uint16_t str_count = xstr_head->string_count; assert_true(xstr_head->magic == 'XSTR');
uint8_t *currentAddress = lang_block.buffer + sizeof(XDBF_XSTR_HEADER); assert_true(xstr_head->version == 1);
uint16_t s = 0; uint16_t str_count = xstr_head->string_count;
while( s < str_count && title_str.empty() ) { uint8_t* currentAddress = lang_block.buffer + sizeof(XDBF_XSTR_HEADER);
XDBF_STRINGTABLE_ENTRY* entry = reinterpret_cast<XDBF_STRINGTABLE_ENTRY*>(currentAddress);
currentAddress += sizeof(XDBF_STRINGTABLE_ENTRY);
uint16_t len = entry->string_length;
if (entry->id == 0x00008000) { uint16_t s = 0;
title_str.resize(static_cast<size_t>(len)); while (s < str_count && title_str.empty()) {
std::copy(currentAddress, currentAddress + len, title_str.begin()); XDBF_STRINGTABLE_ENTRY* entry =
} reinterpret_cast<XDBF_STRINGTABLE_ENTRY*>(currentAddress);
currentAddress += sizeof(XDBF_STRINGTABLE_ENTRY);
uint16_t len = entry->string_length;
currentAddress += len; if (entry->id == 0x00008000) {
} title_str.resize(static_cast<size_t>(len));
} std::copy(currentAddress, currentAddress + len, title_str.begin());
} }
return title_str; currentAddress += len;
} }
}
}
return title_str;
}
} // namespace xdbf } // namespace xdbf
} // namespace xe } // namespace xe

157
src/xenia/xdbf/xdbf_utils.h
View File

@ -17,104 +17,103 @@
namespace xe { namespace xe {
namespace xdbf { namespace xdbf {
// http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/XEX/SPA.h
// http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/XEX/SPA.cpp
enum XdbfSection : uint16_t { // http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/XEX/SPA.h
kSectionMetadata = 0x0001, // http://freestyledash.googlecode.com/svn/trunk/Freestyle/Tools/XEX/SPA.cpp
kSectionImage = 0x0002,
kSectionStringTable = 0x0003,
};
enum XdbfLocale : uint32_t { enum XdbfSection : uint16_t {
kLocaleDefault = 0, kSectionMetadata = 0x0001,
kLocaleEnglish = 1, kSectionImage = 0x0002,
kLocaleJapanese = 2, kSectionStringTable = 0x0003,
}; };
struct XBDF_HEADER { enum XdbfLocale : uint32_t {
xe::be<uint32_t> magic; kLocaleDefault = 0,
xe::be<uint32_t> version; kLocaleEnglish = 1,
xe::be<uint32_t> entry_max; kLocaleJapanese = 2,
xe::be<uint32_t> entry_current; };
xe::be<uint32_t> free_max;
xe::be<uint32_t> free_current; struct XBDF_HEADER {
}; xe::be<uint32_t> magic;
static_assert_size(XBDF_HEADER, 24); xe::be<uint32_t> version;
xe::be<uint32_t> entry_max;
xe::be<uint32_t> entry_current;
xe::be<uint32_t> free_max;
xe::be<uint32_t> free_current;
};
static_assert_size(XBDF_HEADER, 24);
#pragma pack(push, 1) #pragma pack(push, 1)
struct XBDF_ENTRY { struct XBDF_ENTRY {
xe::be<uint16_t> section; xe::be<uint16_t> section;
xe::be<uint64_t> id; xe::be<uint64_t> id;
xe::be<uint32_t> offset; xe::be<uint32_t> offset;
xe::be<uint32_t> size; xe::be<uint32_t> size;
}; };
static_assert_size(XBDF_ENTRY, 18); static_assert_size(XBDF_ENTRY, 18);
#pragma pack(pop) #pragma pack(pop)
struct XBDF_FILE_LOC { struct XBDF_FILE_LOC {
xe::be<uint32_t> offset; xe::be<uint32_t> offset;
xe::be<uint32_t> size; xe::be<uint32_t> size;
}; };
static_assert_size(XBDF_FILE_LOC, 8); static_assert_size(XBDF_FILE_LOC, 8);
struct XDBF_XSTC { struct XDBF_XSTC {
xe::be<uint32_t> magic; xe::be<uint32_t> magic;
xe::be<uint32_t> version; xe::be<uint32_t> version;
xe::be<uint32_t> size; xe::be<uint32_t> size;
xe::be<uint32_t> default_language; xe::be<uint32_t> default_language;
}; };
static_assert_size(XDBF_XSTC, 16); static_assert_size(XDBF_XSTC, 16);
#pragma pack(push, 1) #pragma pack(push, 1)
struct XDBF_XSTR_HEADER { struct XDBF_XSTR_HEADER {
xe::be<uint32_t> magic; xe::be<uint32_t> magic;
xe::be<uint32_t> version; xe::be<uint32_t> version;
xe::be<uint32_t> size; xe::be<uint32_t> size;
xe::be<uint16_t> string_count; xe::be<uint16_t> string_count;
}; };
static_assert_size(XDBF_XSTR_HEADER, 14); static_assert_size(XDBF_XSTR_HEADER, 14);
#pragma pack(pop) #pragma pack(pop)
struct XDBF_STRINGTABLE_ENTRY { struct XDBF_STRINGTABLE_ENTRY {
xe::be<uint16_t> id; xe::be<uint16_t> id;
xe::be<uint16_t> string_length; xe::be<uint16_t> string_length;
}; };
static_assert_size(XDBF_STRINGTABLE_ENTRY, 4); static_assert_size(XDBF_STRINGTABLE_ENTRY, 4);
struct XdbfState { struct XdbfState {
XBDF_HEADER* header; XBDF_HEADER* header;
XBDF_ENTRY* entries; XBDF_ENTRY* entries;
XBDF_FILE_LOC* files; XBDF_FILE_LOC* files;
uint8_t* offset; uint8_t* offset;
uint8_t* data; uint8_t* data;
size_t size; size_t size;
}; };
struct XdbfBlock { struct XdbfBlock {
uint8_t* buffer; uint8_t* buffer;
size_t size; size_t size;
}; };
class XdbfWrapper { class XdbfWrapper {
public: public:
XdbfWrapper(); XdbfWrapper();
bool initialize(uint8_t* buffer, size_t length); bool initialize(uint8_t* buffer, size_t length);
XdbfBlock get_entry(XdbfSection section, uint64_t id) const; XdbfBlock get_entry(XdbfSection section, uint64_t id) const;
private: private:
XBDF_HEADER& get_header() const; XBDF_HEADER& get_header() const;
XBDF_ENTRY& get_entry(uint32_t n) const; XBDF_ENTRY& get_entry(uint32_t n) const;
XBDF_FILE_LOC& get_file(uint32_t n) const; XBDF_FILE_LOC& get_file(uint32_t n) const;
XdbfState state_; XdbfState state_;
}; };
XdbfBlock get_icon(XdbfWrapper& ref);
std::string get_title(XdbfWrapper& ref);
XdbfBlock get_icon(XdbfWrapper& ref);
std::string get_title(XdbfWrapper& ref);
} // namespace xdbf } // namespace xdbf
} // namespace xe } // namespace xe