fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[XConfig] Implementation of XConfig

Browse Source
This commit is contained in:
Gliniak
2026-05-17 21:30:10 +02:00
committed by Radosław Gliński
parent f88bfbe41e
commit 99ea6da18a
31 changed files with 2020 additions and 846 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/xenia/kernel/xboxkrnl/xboxkrnl_audio.cc
View File

@@ -21,7 +21,9 @@ namespace kernel {
namespace xboxkrnl {
dword_result_t XAudioGetSpeakerConfig_entry(lpdword_t config_ptr) {
*config_ptr = cvars::audio_flag;
kernel_state()->xconfig()->ReadSetting(
XCONFIG_USER_CATEGORY,
XCONFIG_USER_CATEGORY_ENTRIES::XCONFIG_USER_AUDIO_FLAGS, config_ptr);
return X_ERROR_SUCCESS;
}
DECLARE_XBOXKRNL_EXPORT1(XAudioGetSpeakerConfig, kAudio, kImplemented);

2
src/xenia/kernel/xboxkrnl/xboxkrnl_strings.cc
View File

@@ -12,7 +12,7 @@
#include "xenia/kernel/xboxkrnl/xboxkrnl_private.h"
DEFINE_bool(log_string_format_kernel_calls, false,
"Log kernel calls with the kHighFrequency tag.", "Logging");
"Log usage of print formatters like sprintf.", "Logging");
namespace xe {
namespace kernel {

124
src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
View File

@@ -16,21 +16,10 @@
#include "xenia/kernel/util/shim_utils.h"
#include "xenia/kernel/xboxkrnl/xboxkrnl_private.h"
#include "xenia/kernel/xboxkrnl/xboxkrnl_rtl.h"
#include "xenia/kernel/xconfig.h"
#include "xenia/xbox.h"
DEFINE_int32(
video_standard, 1,
"Enables switching between different video signals.\n 1=NTSC\n "
"2=NTSC-J\n 3=PAL\n",
"Video");
DEFINE_bool(use_50Hz_mode, false, "Enables usage of PAL-50 mode.", "Video");
DEFINE_bool(interlaced, false, "Toggles interlaced mode.", "Video");
// TODO: This is stored in XConfig somewhere, probably in video flags.
DEFINE_bool(widescreen, true, "Toggles between 16:9 and 4:3 aspect ratio.",
"Video");
// BT.709 on modern monitors and TVs looks the closest to the Xbox 360 connected
// to an HDTV.
DEFINE_uint32(kernel_display_gamma_type, 2,
@@ -42,37 +31,22 @@ DEFINE_double(kernel_display_gamma_power, 2.22222233,
"Display gamma to use with kernel_display_gamma_type 3.",
"Kernel");
inline const static uint32_t GetVideoStandard() {
if (cvars::video_standard < 1 || cvars::video_standard > 3) {
return 1;
}
return cvars::video_standard;
}
inline const static float GetVideoRefreshRate() {
return cvars::use_50Hz_mode ? 50.0f : 60.0f;
}
inline const static std::pair<uint16_t, uint16_t> GetDisplayAspectRatio() {
if (cvars::widescreen) {
return {16, 9};
}
return {4, 3};
}
static std::pair<uint32_t, uint32_t> CalculateScaledAspectRatio(uint32_t fb_x,
uint32_t fb_y) {
static std::pair<uint32_t, uint32_t> CalculateScaledAspectRatio(
uint32_t fb_x, uint32_t fb_y, bool forced_widescreen) {
// Calculate the game's final aspect ratio as it would appear on a physical
// TV.
auto dar = GetDisplayAspectRatio();
uint32_t display_x = dar.first;
uint32_t display_y = dar.second;
const auto res = xe::kernel::Resolution(fb_x, fb_y);
auto res = xe::gpu::GraphicsSystem::GetInternalDisplayResolution();
uint32_t res_x = res.first;
uint32_t res_y = res.second;
uint32_t display_x = res.aspect_ratio().first;
uint32_t display_y = res.aspect_ratio().second;
if (forced_widescreen) {
display_x = 16;
display_y = 9;
}
uint32_t res_x = res.width_.get();
uint32_t res_y = res.height_.get();
uint32_t x_factor = std::gcd(fb_x, res_x);
res_x /= x_factor;
@@ -103,6 +77,47 @@ namespace xe {
namespace kernel {
namespace xboxkrnl {
bool IsWidescreen(KernelState* kernel_state, Resolution res) {
if (res.is_widescreen()) {
return true;
}
return kernel_state->xconfig()->ReadSetting<uint32_t>(
XCONFIG_USER_CATEGORY, XCONFIG_USER_VIDEO_FLAGS) &
X_VIDEO_FLAGS::Widescreen;
}
// Video standard only supports value from 1 to 3. PAL50 is not included here
// and PAL50 is converted to PAL with 50Hz in GetVideoRefreshRate.
X_AV_VIDEO_STANDARD GetVideoStandard(KernelState* kernel_state) {
auto av_region = static_cast<X_AV_VIDEO_STANDARD>(
(kernel_state->xconfig()->ReadSetting<uint32_t>(
XCONFIG_SECURED_CATEGORY, XCONFIG_SECURED_AV_REGION) &
0xFF00) >>
8);
if (av_region == X_AV_VIDEO_STANDARD::PAL_50) {
av_region = X_AV_VIDEO_STANDARD::PAL;
}
if (av_region < X_AV_VIDEO_STANDARD::NTSCM ||
av_region > X_AV_VIDEO_STANDARD::PAL_50) {
return X_AV_VIDEO_STANDARD::NTSCM;
}
return av_region;
}
float GetVideoRefreshRate(KernelState* kernel_state) {
const bool is_50Hz =
(kernel_state->xconfig()->ReadSetting<uint32_t>(
XCONFIG_SECURED_CATEGORY, XCONFIG_SECURED_AV_REGION) >>
23) &
0x1;
return !is_50Hz ? 60.0f : 50.0f;
}
// https://web.archive.org/web/20150805074003/https://www.tweakoz.com/orkid/
// http://www.tweakoz.com/orkid/dox/d3/d52/xb360init_8cpp_source.html
// https://github.com/Free60Project/xenosfb/
@@ -205,17 +220,25 @@ void VdQueryVideoMode(X_VIDEO_MODE* video_mode,
// TODO(benvanik): get info from actual display.
std::memset(video_mode, 0, sizeof(X_VIDEO_MODE));
auto display_res = gpu::GraphicsSystem::GetInternalDisplayResolution();
// Later calculate if resolution is widescreen or not and apply flag
// accordingly. Technically possible resolutions should depend on av_pack, but
// we can ignore it.
const auto resolution =
Resolution(kernel_state()->xconfig()->ReadSetting<uint32_t>(
XCONFIG_USER_CATEGORY, XCONFIG_USER_AV_COMPOSITE_SCREENSZ));
video_mode->display_width = display_res.first;
video_mode->display_height = display_res.second;
const auto is_widescreen = IsWidescreen(kernel_state(), resolution);
video_mode->display_width = resolution.width_.get();
video_mode->display_height = resolution.height_.get();
video_mode->is_interlaced = cvars::interlaced;
video_mode->is_widescreen = cvars::widescreen;
video_mode->is_widescreen = is_widescreen;
video_mode->is_hi_def = video_mode->display_width >= 0x500;
video_mode->refresh_rate = GetVideoRefreshRate();
video_mode->video_standard = GetVideoStandard();
video_mode->refresh_rate = GetVideoRefreshRate(kernel_state());
video_mode->video_standard =
static_cast<uint32_t>(GetVideoStandard(kernel_state()));
video_mode->pixel_rate = 0x8A;
video_mode->widescreen_flag = cvars::widescreen ? 0x01 : 0x03;
video_mode->widescreen_flag = is_widescreen ? 0x01 : 0x03;
}
void VdQueryRealVideoMode_entry(pointer_t<X_VIDEO_MODE> video_mode) {
@@ -370,7 +393,12 @@ dword_result_t VdInitializeScalerCommandBuffer_entry(
uint32_t fb_x = (scaled_output_wh >> 16) & 0xFFFF;
uint32_t fb_y = scaled_output_wh & 0xFFFF;
auto aspect = CalculateScaledAspectRatio(fb_x, fb_y);
const bool forced_widescreen =
kernel_state()->xconfig()->ReadSetting<uint32_t>(
XCONFIG_USER_CATEGORY, XCONFIG_USER_VIDEO_FLAGS) &
X_VIDEO_FLAGS::Widescreen;
auto aspect = CalculateScaledAspectRatio(fb_x, fb_y, forced_widescreen);
auto graphics_system = kernel_state()->emulator()->graphics_system();
graphics_system->SetScaledAspectRatio(aspect.first, aspect.second);

296
src/xenia/kernel/xboxkrnl/xboxkrnl_xconfig.cc
View File

@@ -7,295 +7,35 @@
******************************************************************************
*/
#include "xenia/kernel/xboxkrnl/xboxkrnl_xconfig.h"
#include "xenia/base/logging.h"
#include "xenia/kernel/kernel_state.h"
#include "xenia/kernel/util/shim_utils.h"
#include "xenia/kernel/xboxkrnl/xboxkrnl_private.h"
#include "xenia/kernel/xconfig.h"
#include "xenia/xbox.h"
DEFINE_int32(user_language, 1,
"User language ID.\n"
" 1=en 2=ja 3=de 4=fr 5=es 6=it 7=ko 8=zh\n"
" 9=pt 11=pl 12=ru 13=sv 14=tr 15=nb 16=nl 17=zh",
"XConfig");
DEFINE_int32(user_country, 103,
"User country ID.\n"
" 1=AE 2=AL 3=AM 4=AR 5=AT 6=AU 7=AZ 8=BE 9=BG\n"
" 10=BH 11=BN 12=BO 13=BR 14=BY 15=BZ 16=CA 18=CH 19=CL\n"
" 20=CN 21=CO 22=CR 23=CZ 24=DE 25=DK 26=DO 27=DZ 28=EC\n"
" 29=EE 30=EG 31=ES 32=FI 33=FO 34=FR 35=GB 36=GE 37=GR\n"
" 38=GT 39=HK 40=HN 41=HR 42=HU 43=ID 44=IE 45=IL 46=IN\n"
" 47=IQ 48=IR 49=IS 50=IT 51=JM 52=JO 53=JP 54=KE 55=KG\n"
" 56=KR 57=KW 58=KZ 59=LB 60=LI 61=LT 62=LU 63=LV 64=LY\n"
" 65=MA 66=MC 67=MK 68=MN 69=MO 70=MV 71=MX 72=MY 73=NI\n"
" 74=NL 75=NO 76=NZ 77=OM 78=PA 79=PE 80=PH 81=PK 82=PL\n"
" 83=PR 84=PT 85=PY 86=QA 87=RO 88=RU 89=SA 90=SE 91=SG\n"
" 92=SI 93=SK 95=SV 96=SY 97=TH 98=TN 99=TR 100=TT 101=TW\n"
" 102=UA 103=US 104=UY 105=UZ 106=VE 107=VN 108=YE 109=ZA\n",
"XConfig");
DEFINE_uint32(
audio_flag, 0x00010001,
"Audio Mode Analog.\n"
" 0x00000001 = Dolby Pro Logic\n"
" 0x00000002 = Analog Mono\n"
"Audio Mode Digital.\n"
" 0x00000000 = Digital Stereo (choose one of the above by itself)\n"
" 0x00010000 = Dolby Digital\n"
" 0x00030000 = Dolby Digital with WMA PRO\n"
"Special Flags.\n"
" 0x00000003 = Stereo Bypass\n"
" 0x80000000 = Low Latency\n"
" This Config requires you to pair an analog and digitial flag together\n"
" while digital stereo only requires an analog flag. Bonus flags are\n"
" optional. Ex) 0x00010001\n",
"XConfig");
DECLARE_bool(widescreen);
DECLARE_bool(use_50Hz_mode);
DECLARE_int32(video_standard);
DECLARE_uint32(internal_display_resolution);
namespace xe {
namespace kernel {
namespace xboxkrnl {
X_STATUS xeExGetXConfigSetting(X_CONFIG_CATEGORY category, uint16_t setting,
void* buffer, uint16_t buffer_size,
uint16_t* required_size) {
uint16_t setting_size = 0;
alignas(uint32_t) uint8_t value[4];
// TODO(benvanik): have real structs here that just get copied from.
// https://free60project.github.io/wiki/XConfig.html
// https://github.com/oukiar/freestyledash/blob/master/Freestyle/Tools/Generic/ExConfig.h
switch (category) {
case XCONFIG_SECURED_CATEGORY:
switch (setting) {
case XCONFIG_SECURED_AV_REGION:
setting_size = 4;
switch (cvars::video_standard) {
case 1: // NTSCM
xe::store_and_swap<uint32_t>(value, X_AV_REGION::NTSCM);
break;
case 2: // NTSCJ
xe::store_and_swap<uint32_t>(value, X_AV_REGION::NTSCJ);
break;
case 3: // PAL
xe::store_and_swap<uint32_t>(value, cvars::use_50Hz_mode
? X_AV_REGION::PAL_50
: X_AV_REGION::PAL);
break;
default:
xe::store_and_swap<uint32_t>(value, 0);
break;
}
break;
default:
XELOGW(
"An unimplemented setting 0x{:04X} in XCONFIG SECURED CATEGORY",
static_cast<uint16_t>(setting));
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
case XCONFIG_USER_CATEGORY:
switch (setting) {
case XCONFIG_USER_TIME_ZONE_BIAS:
case XCONFIG_USER_TIME_ZONE_STD_NAME:
case XCONFIG_USER_TIME_ZONE_DLT_NAME:
case XCONFIG_USER_TIME_ZONE_STD_DATE:
case XCONFIG_USER_TIME_ZONE_DLT_DATE:
case XCONFIG_USER_TIME_ZONE_STD_BIAS:
case XCONFIG_USER_TIME_ZONE_DLT_BIAS:
setting_size = 4;
// TODO(benvanik): get this value.
xe::store_and_swap<uint32_t>(value, 0);
break;
case XCONFIG_USER_LANGUAGE:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, cvars::user_language);
break;
case XCONFIG_USER_VIDEO_FLAGS:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, cvars::widescreen
? X_VIDEO_FLAGS::Widescreen
: X_VIDEO_FLAGS::RatioNormal);
break;
case XCONFIG_USER_AUDIO_FLAGS:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, cvars::audio_flag);
break;
case XCONFIG_USER_RETAIL_FLAGS:
setting_size = 4;
// TODO(benvanik): get this value.
xe::store_and_swap<uint32_t>(value, 0x40);
break;
case XCONFIG_USER_COUNTRY:
setting_size = 1;
value[0] = static_cast<uint8_t>(cvars::user_country);
break;
case XCONFIG_USER_PC_FLAGS:
setting_size = 1;
// All related flags must be set for PC to function
// Both flags set even when PC are off
value[0] =
X_PC_FLAGS::XBLAllowed | X_PC_FLAGS::XBLMembershipCreationAllowed;
break;
case XCONFIG_USER_AV_COMPONENT_SCREENSZ:
setting_size = 4;
// int16_t* value[2];
if (XHDTVResolution.find(cvars::internal_display_resolution) !=
XHDTVResolution.cend()) {
xe::store_and_swap<int32_t>(
value, XHDTVResolution.at(cvars::internal_display_resolution));
} else {
XELOGW("Resolution not supported for AV Component");
xe::store_and_swap<int32_t>(value, 0);
}
break;
case XCONFIG_USER_AV_VGA_SCREENSZ:
setting_size = 4;
// int16_t* value[2];
if (XVGAResolution.find(cvars::internal_display_resolution) !=
XVGAResolution.cend()) {
xe::store_and_swap<int32_t>(
value, XVGAResolution.at(cvars::internal_display_resolution));
} else {
XELOGW("Resolution not supported for VGA");
xe::store_and_swap<int32_t>(value, 0);
}
break;
case XCONFIG_USER_PC_GAME:
setting_size = 4;
xe::store_and_swap<uint32_t>(value,
X_PC_GAMES_FLAGS::NoGameRestrictions);
break;
case XCONFIG_USER_PC_PASSWORD:
setting_size = 4;
std::memset(value, 0, 4);
break;
case XCONFIG_USER_PC_MOVIE:
setting_size = 4;
xe::store_and_swap<uint32_t>(value,
X_PC_MOVIE_FLAGS::NoMovieRestrictions);
break;
case XCONFIG_USER_PC_GAME_RATING:
setting_size = 4;
xe::store_and_swap<uint32_t>(value,
X_PC_GAME_RATING_FLAGS::DefaultGame);
break;
case XCONFIG_USER_PC_MOVIE_RATING:
setting_size = 4;
xe::store_and_swap<uint32_t>(value,
X_PC_MOVIE_RATING_FLAGS::DefaultMovie);
break;
case XCONFIG_USER_PC_HINT:
// ExSetXConfigSetting and ExGetXConfigSetting request size of 0x40
setting_size = 0x40;
store_and_swap<std::string>(value, "");
break;
case XCONFIG_USER_PC_HINT_ANSWER:
setting_size = 0x20;
store_and_swap<std::string>(value, "");
break;
case XCONFIG_USER_ARCADE_FLAGS:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, X_ARCADE_FLAGS::AutoDownloadOff);
break;
case XCONFIG_USER_PC_VERSION:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, X_PC_VERSION::VersionOne);
break;
case XCONFIG_USER_PC_TV:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, X_PC_TV::NoTVRestrictions);
break;
case XCONFIG_USER_PC_TV_RATING:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, X_PC_TV_RATING::DefaultTV);
break;
case XCONFIG_USER_PC_EXPLICIT_VIDEO:
setting_size = 4;
xe::store_and_swap<uint32_t>(
value, X_PC_EXPLICIT_VIDEO::ExplicitVideoAllowed);
break;
case XCONFIG_USER_PC_EXPLICIT_VIDEO_RATING:
setting_size = 4;
xe::store_and_swap<uint32_t>(
value, X_PC_EXPLICIT_VIDEO_RATING::ExplicitAllowed);
break;
case XCONFIG_USER_PC_UNRATED_VIDEO:
setting_size = 4;
xe::store_and_swap<uint32_t>(value,
X_PC_EXPLICIT_UNRATED::UnratedALL);
break;
case XCONFIG_USER_PC_UNRATED_VIDEO_RATING:
setting_size = 4;
xe::store_and_swap<uint32_t>(
value, X_PC_EXPLICIT_UNRATED_RATING::DefaultExplicitUnrated);
break;
case XCONFIG_USER_VIDEO_OUTPUT_BLACK_LEVELS:
setting_size = 4;
xe::store_and_swap<uint32_t>(value, X_BLACK_LEVEL::LevelNormal);
break;
default:
XELOGW("An unimplemented setting 0x{:04X} in XCONFIG USER CATEGORY",
static_cast<uint16_t>(setting));
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
case XCONFIG_CONSOLE_CATEGORY:
switch (setting) {
case XCONFIG_CONSOLE_SCREEN_SAVER:
setting_size = 2;
xe::store_and_swap<int16_t>(value, X_SCREENSAVER::ScreensaverOff);
break;
case XCONFIG_CONSOLE_AUTO_SHUT_OFF:
setting_size = 2;
xe::store_and_swap<int16_t>(value, X_AUTO_SHUTDOWN::AutoShutdownOff);
break;
case XCONFIG_CONSOLE_CAMERA_SETTINGS:
// Camera Flags are added together and last byte is always 0x1
setting_size = 4;
xe::store_and_swap<uint32_t>(value, X_CAMERA_FLAGS::AutoAll);
break;
case XCONFIG_CONSOLE_KEYBOARD_LAYOUT:
setting_size = 2;
xe::store_and_swap<int16_t>(value,
X_KEYBOARD_LAYOUT::KeyboardDefault);
break;
default:
XELOGW(
"An unimplemented setting 0x{:04X} in XCONFIG CONSOLE CATEGORY",
static_cast<uint16_t>(setting));
assert_unhandled_case(setting);
return X_STATUS_INVALID_PARAMETER_2;
}
break;
default:
XELOGW("An unimplemented category 0x{:04X}",
static_cast<uint16_t>(category));
assert_unhandled_case(category);
return X_STATUS_INVALID_PARAMETER_1;
X_STATUS xeExGetXConfigSetting(X_CONFIG_CATEGORY category,
const uint16_t setting_id, void* buffer,
uint16_t buffer_size, uint16_t* required_size) {
if (!buffer && buffer_size) {
return X_STATUS_INVALID_PARAMETER_3;
}
if (buffer) {
if (buffer_size < setting_size) {
if (buffer_size <
kernel_state()->xconfig()->GetSettingSize(category, setting_id)) {
return X_STATUS_BUFFER_TOO_SMALL;
}
std::memcpy(buffer, value, setting_size);
} else {
if (buffer_size) {
return X_STATUS_INVALID_PARAMETER_3;
}
kernel_state()->xconfig()->ReadSetting(category, setting_id, buffer);
}
if (required_size) {
*required_size = setting_size;
*required_size = static_cast<uint16_t>(
kernel_state()->xconfig()->GetSettingSize(category, setting_id));
}
return X_STATUS_SUCCESS;
@@ -325,7 +65,11 @@ dword_result_t ExSetXConfigSetting_entry(word_t category, word_t setting,
Handles settings the only have a single flag/value like
XCONFIG_USER_VIDEO_FLAGS to swap
*/
XELOGI("ExSetXConfigSetting: category: 0X{:04x}, setting: 0X{:04x}",
kernel_state()->xconfig()->WriteSetting(
static_cast<X_CONFIG_CATEGORY>(category.value()), setting.value(),
kernel_memory()->TranslateVirtual<void*>(buffer_ptr));
XELOGI("ExSetXConfigSetting: category: 0x{:04x}, setting: 0x{:04x}",
static_cast<uint16_t>(category), static_cast<uint16_t>(setting));
return X_STATUS_SUCCESS;
}
@@ -339,6 +83,14 @@ dword_result_t ExReadModifyWriteXConfigSettingUlong_entry(word_t category,
Handles settings with multiple flags like XCONFIG_USER_RETAIL_FLAGS and
XCONFIG_CONSOLE_RETAIL_EX_FLAGS
*/
uint32_t value = kernel_state()->xconfig()->ReadSetting<uint32_t>(
static_cast<X_CONFIG_CATEGORY>(category.value()), setting);
value = xe::byte_swap((value & bit_affected) | flag);
kernel_state()->xconfig()->WriteSetting(
static_cast<X_CONFIG_CATEGORY>(category.value()), setting, &value);
XELOGI(
"ExReadModifyWriteXConfigSettingUlong: category: 0x{:04x}, setting: "
"{:04x}, changed bits: 0X{:08x}, setting flag 0X{:08x}",

395
src/xenia/kernel/xboxkrnl/xboxkrnl_xconfig.h
View File

@@ -1,395 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2025 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_KERNEL_XBOXKRNL_XBOXKRNL_XCONFIG_H_
#define XENIA_KERNEL_XBOXKRNL_XBOXKRNL_XCONFIG_H_
#include <cstdint>
#include <map>
namespace xe {
namespace kernel {
namespace xboxkrnl {
enum X_CONFIG_CATEGORY : uint16_t {
XCONFIG_STATIC_CATEGORY = 0x00,
XCONFIG_STATISTIC_CATEGORY = 0x01,
XCONFIG_SECURED_CATEGORY = 0x02,
XCONFIG_USER_CATEGORY = 0x03,
XCONFIG_XNET_MACHINE_ACCOUNT_CATEGORY = 0x04,
XCONFIG_XNET_PARAMETERS_CATEGORY = 0x05,
XCONFIG_MEDIA_CENTER_CATEGORY = 0x06,
XCONFIG_CONSOLE_CATEGORY = 0x07,
XCONFIG_DVD_CATEGORY = 0x08,
XCONFIG_IPTV_CATEGORY = 0x09,
XCONFIG_SYSTEM_CATEGORY = 0x0A,
XCONFIG_DEVKIT_CATEGORY = 0x0B
};
enum XCONFIG_STATIC_CATEGORY_ENTRIES : uint8_t {
XCONFIG_STATIC_FIRST_POWER_ON_DATE = 0x01,
XCONFIG_STATIC_SMC_CONFIG = 0x02
};
enum XCONFIG_STATISTIC_CATEGORY_ENTRIES : uint8_t {
XCONFIG_STATISTICS_XUID_MAC_ADDRESS = 0x01,
XCONFIG_STATISTICS_XUID_COUNT = 0x02,
XCONFIG_STATISTICS_ODD_FAILURES = 0x03,
XCONFIG_STATISTICS_HDD_SMART_DATA = 0x04,
XCONFIG_STATISTICS_UEM_ERRORS = 0x05,
XCONFIG_STATISTICS_FPM_ERRORS = 0x06,
XCONFIG_STATISTICS_LAST_REPORT_TIME = 0x07,
XCONFIG_STATISTICS_BUG_CHECK_DATA = 0x08,
XCONFIG_STATISTICS_TEMPERATURE = 0x09,
XCONFIG_STATISTICS_XEKEYS_WRITE_FAILURE = 0x0A
};
enum XCONFIG_SECURED_CATEGORY_ENTRIES : uint8_t {
XCONFIG_SECURED_MAC_ADDRESS = 0x01,
XCONFIG_SECURED_AV_REGION = 0x02,
XCONFIG_SECURED_GAME_REGION = 0x03,
XCONFIG_SECURED_DVD_REGION = 0x04,
XCONFIG_SECURED_RESET_KEY = 0x05,
XCONFIG_SECURED_SYSTEM_FLAGS = 0x06,
XCONFIG_SECURED_POWER_MODE = 0x07,
XCONFIG_SECURED_ONLINE_NETWORK_ID = 0x08,
XCONFIG_SECURED_POWER_VCS_CONTROL = 0x09
};
enum XCONFIG_USER_CATEGORY_ENTRIES : uint8_t {
XCONFIG_USER_TIME_ZONE_BIAS = 0x01,
XCONFIG_USER_TIME_ZONE_STD_NAME = 0x02,
XCONFIG_USER_TIME_ZONE_DLT_NAME = 0x03,
XCONFIG_USER_TIME_ZONE_STD_DATE = 0x04,
XCONFIG_USER_TIME_ZONE_DLT_DATE = 0x05,
XCONFIG_USER_TIME_ZONE_STD_BIAS = 0x06,
XCONFIG_USER_TIME_ZONE_DLT_BIAS = 0x07,
XCONFIG_USER_DEFAULT_PROFILE = 0x08,
XCONFIG_USER_LANGUAGE = 0x09,
XCONFIG_USER_VIDEO_FLAGS = 0x0A,
XCONFIG_USER_AUDIO_FLAGS = 0x0B,
XCONFIG_USER_RETAIL_FLAGS = 0x0C,
XCONFIG_USER_DEVKIT_FLAGS = 0x0D,
XCONFIG_USER_COUNTRY = 0x0E,
XCONFIG_USER_PC_FLAGS = 0x0F,
XCONFIG_USER_SMB_CONFIG = 0x10,
XCONFIG_USER_LIVE_PUID = 0x11,
XCONFIG_USER_LIVE_CREDENTIALS = 0x12,
XCONFIG_USER_AV_COMPOSITE_SCREENSZ = 0x13,
XCONFIG_USER_AV_COMPONENT_SCREENSZ = 0x14,
XCONFIG_USER_AV_VGA_SCREENSZ = 0x15,
XCONFIG_USER_PC_GAME = 0x16,
XCONFIG_USER_PC_PASSWORD = 0x17,
XCONFIG_USER_PC_MOVIE = 0x18,
XCONFIG_USER_PC_GAME_RATING = 0x19,
XCONFIG_USER_PC_MOVIE_RATING = 0x1A,
XCONFIG_USER_PC_HINT = 0x1B,
XCONFIG_USER_PC_HINT_ANSWER = 0x1C,
XCONFIG_USER_PC_OVERRIDE = 0x1D,
XCONFIG_USER_MUSIC_PLAYBACK_MODE = 0x1E,
XCONFIG_USER_MUSIC_VOLUME = 0x1F,
XCONFIG_USER_MUSIC_FLAGS = 0x20,
XCONFIG_USER_ARCADE_FLAGS = 0x21,
XCONFIG_USER_PC_VERSION = 0x22,
XCONFIG_USER_PC_TV = 0x23,
XCONFIG_USER_PC_TV_RATING = 0x24,
XCONFIG_USER_PC_EXPLICIT_VIDEO = 0x25,
XCONFIG_USER_PC_EXPLICIT_VIDEO_RATING = 0x26,
XCONFIG_USER_PC_UNRATED_VIDEO = 0x27,
XCONFIG_USER_PC_UNRATED_VIDEO_RATING = 0x28,
XCONFIG_USER_VIDEO_OUTPUT_BLACK_LEVELS = 0x29,
XCONFIG_USER_VIDEO_PLAYER_DISPLAY_MODE = 0x2A,
XCONFIG_USER_ALTERNATE_VIDEO_TIMING_ID = 0x2B,
XCONFIG_USER_VIDEO_DRIVER_OPTIONS = 0x2C,
XCONFIG_USER_MUSIC_UI_FLAGS = 0x2D,
XCONFIG_USER_VIDEO_MEDIA_SOURCE_TYPE = 0x2E,
XCONFIG_USER_MUSIC_MEDIA_SOURCE_TYPE = 0x2F,
XCONFIG_USER_PHOTO_MEDIA_SOURCE_TYPE = 0x30
};
enum XCONFIG_XNET_CATEGORY_ENTRIES : uint8_t { XCONFIG_XNET_DATA = 0x01 };
enum XCONFIG_MEDIA_CENTER_CATEGORY_ENTRIES : uint8_t {
XCONFIG_MEDIA_CENTER_MEDIA_PLAYER = 0x01,
XCONFIG_MEDIA_CENTER_XESLED_VERSION = 0x02,
XCONFIG_MEDIA_CENTER_XESLED_TRUST_SECRET = 0x03,
XCONFIG_MEDIA_CENTER_XESLED_TRUST_CODE = 0x04,
XCONFIG_MEDIA_CENTER_XESLED_HOST_ID = 0x05,
XCONFIG_MEDIA_CENTER_XESLED_KEY = 0x06,
XCONFIG_MEDIA_CENTER_XESLED_HOST_MAC_ADDRESS = 0x07,
XCONFIG_MEDIA_CENTER_SERVER_UUID = 0x08,
XCONFIG_MEDIA_CENTER_SERVER_NAME = 0x09,
XCONFIG_MEDIA_CENTER_SERVER_FLAG = 0x0A
};
enum XCONFIG_CONSOLE_CATEGORY_ENTRIES : uint8_t {
XCONFIG_CONSOLE_SCREEN_SAVER = 0x01,
XCONFIG_CONSOLE_AUTO_SHUT_OFF = 0x02,
XCONFIG_CONSOLE_WIRELESS_SETTINGS = 0x03,
XCONFIG_CONSOLE_CAMERA_SETTINGS = 0x04,
XCONFIG_CONSOLE_PLAYTIMERDATA = 0x05,
XCONFIG_CONSOLE_MEDIA_DISABLEAUTOLAUNCH = 0x06,
XCONFIG_CONSOLE_KEYBOARD_LAYOUT = 0x07,
XCONFIG_CONSOLE_PC_TITLE_EXEMPTIONS = 0x08,
XCONFIG_CONSOLE_NUI = 0x09,
XCONFIG_CONSOLE_VOICE = 0x0A,
XCONFIG_CONSOLE_RETAIL_EX_FLAGS = 0x0B,
XCONFIG_CONSOLE_DASH_FIRST_USE_TUTORIAL_FLAGS = 0x0C,
XCONFIG_CONSOLE_TV_DIAGONAL_SIZE_IN_CM = 0x0D,
XCONFIG_CONSOLE_NETWORKSTORAGEDEVICE_SERIALNUMBER = 0x0E,
XCONFIG_CONSOLE_DISCOVERABLE = 0x0F,
XCONFIG_CONSOLE_LIVE_TV_PROVIDER = 0x10
};
enum XCONFIG_DVD_CATEGORY_ENTRIES : uint8_t {
XCONFIG_DVD_VOLUME_ID = 0x01,
XCONFIG_DVD_BOOKMARK = 0x02
};
enum XCONFIG_IPTV_CATEGORY_ENTRIES : uint8_t {
XCONFIG_IPTV_SERVICE_PROVIDER_NAME = 0x01,
XCONFIG_IPTV_PROVISIONING_SERVER_URL = 0x02,
XCONFIG_IPTV_SUPPORT_INFO = 0x03,
XCONFIG_IPTV_BOOTSTRAP_SERVER_URL = 0x04
};
enum XCONFIG_SYSTEM_CATEGORY_ENTRIES : uint8_t {
XCONFIG_SYSTEM_ALARM_TIME = 0x01,
XCONFIG_SYSTEM_PREVIOUS_FLASH_VERSION = 0x02
};
enum XCONFIG_DEVKIT_CATEGORY_ENTRIES : uint8_t {
XCONFIG_DEVKIT_USBD_ROOT_HUB_PORT_DISABLE_MASK = 0x01,
XCONFIG_DEVKIT_XAM_FEATURE_ENABLE_DISABLE_MASK = 0x02,
XCONFIG_DEVKIT_KIOSK_ID = 0x03
};
// XCONFIG_SECURED_AV_REGION
enum X_AV_REGION : uint32_t {
NTSCM = 0x00400100,
NTSCJ = 0x00400200,
PAL = 0x00400400,
PAL_50 = 0x00800300,
};
// XCONFIG_USER_VIDEO_FLAGS
enum X_VIDEO_FLAGS : uint32_t {
RatioNormal = 0x00000000,
Widescreen = 0x00010000,
};
// XCONFIG_USER_AV_COMPONENT_SCREENSZ
const static std::map<uint32_t, int32_t> XHDTVResolution = {
{0, 0x028001E0}, // 480p
{8, 0x050002D0}, // 720p, always widescreen
{16, 0x07800438}, // 1080, interlaced added in 1888, always widescreen
};
// XCONFIG_USER_AV_COMPONENT_SCREENSZ
const static std::map<uint32_t, int32_t> XVGAResolution = {
// Existed since 1888
{0, 0x028001E0}, // 680x480
{5, 0x035001E0}, // 848x480
{6, 0x04000300}, // 1024x768
{8, 0x050002D0}, // 1280x720
{9, 0x05000300}, // 1280x768
{12, 0x05500300}, // 1360x768
// added in later Versions
{11, 0x05000400}, // 1280x1024
{13, 0x05A00384}, // 1440x900
{14, 0x0690041A}, // 1680x1050
{16, 0x07800438}, // 1920x1080
};
// XCONFIG_USER_AUDIO_FLAGS
enum X_AUDIO_FLAGS : uint32_t {
// Audio Mode Analog
DolbyProLogic = 0x00000001,
AnalogMono = 0x00000002,
// Audio Mode Digital
DigitalStereo = 0x00000000,
DolbyDigital = 0x00010000,
DolbyDigitalWithWMAPRO = 0x00030000,
// Special Flags
StereoBypass = 0x00000003,
LowLatency = 0x80000000,
};
// XCONFIG_USER_RETAIL_FLAGS
enum X_RETAIL_FLAGS : uint32_t {
// Clock
DSTOff = 0x00000002,
TwentyFourHourClock = 0x00000008,
// Startup
DashboardStartup = 0x00000080,
IPTVStartup = 0x00000800,
DiscStartup = 0x00002000,
MCXDownloaderStartup = 0x00020000,
// IPTV
IPTVEnabled = 0x00001000,
IPTVDVRENABLED = 0x00080000,
IPTVDisabled = 0x02000000,
// Kinect
KinectInitialized = 0x20000000,
KinectDisabled = 0x80000000,
// Other
DashboardInitialized = 0x00000040,
BackgroundDownloadOn = 0x00010000,
};
// XCONFIG_USER_PC_FLAGS
enum X_PC_FLAGS : uint8_t {
XBLAllowed = 0x01,
XBLMembershipCreationAllowed = 0x02,
XboxOneGameAllowed = 0x04,
PCEnabled = 0x80,
};
// XCONFIG_USER_PC_GAMES
enum X_PC_GAMES_FLAGS : uint32_t {
EarlyChildhoodMax = 0x00000000,
EveryoneMax = 0x00000002,
Everyone_10Max = 0x00000004,
TeenMax = 0x00000006,
MatureMax = 0x00000008,
NoGameRestrictions = 0x000000FF,
};
// XCONFIG_USER_PC_PASSWORD
enum X_PC_PASSWORD_FLAGS : uint32_t {
XButton = 0x00000001,
YButton = 0x00000002,
LeftButton = 0x00000003,
RightButton = 0x00000004,
UPButton = 0x00000005,
DownButton = 0x00000006,
LTButton = 0x00000009,
RTButton = 0x0000000A,
LBButton = 0x0000000B,
RBButton = 0x0000000C,
};
// XCONFIG_USER_PC_MOVIE
enum X_PC_MOVIE_FLAGS : uint32_t {
GeneralAudiences = 0x00000001,
ParentalGuidance = 0x00000003,
ParentalGuidance13 = 0x00000004,
Restricted = 0x00000006,
NoMovieRestrictions = 0x000000FF,
};
// XCONFIG_USER_PC_GAME_RATING
enum X_PC_GAME_RATING_FLAGS : uint32_t {
DefaultGame = 0x00000000,
};
// XCONFIG_USER_PC_MOVIE_RATING
enum X_PC_MOVIE_RATING_FLAGS : uint32_t {
DefaultMovie = 0x00000000,
};
// XCONFIG_USER_ARCADE_FLAGS
enum X_ARCADE_FLAGS : uint32_t {
AutoDownloadOff = 0x00000000,
AutoDownloadNewReleases = 0x00000001,
};
// XCONFIG_USER_PC_VERSION
enum X_PC_VERSION : uint32_t {
VersionOne = 0x00000001,
};
// XCONFIG_USER_PC_TV
enum X_PC_TV : uint32_t {
TVG = 0X00000006,
TVPG = 0X00000008,
TV14 = 0X0000000a,
TVMatureAudience = 0x0000000C,
NoTVRestrictions = 0X000000FF,
};
// XCONFIG_USER_PC_TV_RATING
enum X_PC_TV_RATING : uint32_t {
DefaultTV = 0X00000000,
};
// XCONFIG_USER_PC_EXPLICIT_VIDEO
enum X_PC_EXPLICIT_VIDEO : uint32_t {
ExplicitVideoAllowed = 0X000000FF,
ExplicitVideoBanned = 0X00000000,
};
// XCONFIG_USER_PC_EXPLICIT_VIDEO_RATING
enum X_PC_EXPLICIT_VIDEO_RATING : uint32_t {
ExplicitAllowed = 0X00000000,
};
// XCONFIG_USER_PC_UNRATED_VIDEO
enum X_PC_EXPLICIT_UNRATED : uint32_t {
ExplicitUnratedBanned = 0X00000000,
UnratedALL = 0X000000FF,
};
// XCONFIG_USER_PC_UNRATED_VIDEO_RATING
enum X_PC_EXPLICIT_UNRATED_RATING : uint32_t {
DefaultExplicitUnrated = 0X00000000,
};
// XCONFIG_USER_VIDEO_OUTPUT_BLACK_LEVELS
enum X_BLACK_LEVEL : uint32_t {
High = 0x00000100,
Intermediate = 0x00000200,
LevelNormal = 0x00000300,
};
// XCONFIG_CONSOLE_SCREENSAVER
enum X_SCREENSAVER : uint32_t {
ScreensaverOn = 0x000A,
ScreensaverOff = 0x1000,
};
// XCONFIG_CONSOLE_AUTO_SHUTDOWN
enum X_AUTO_SHUTDOWN : uint32_t {
AutoShutdownOff = 0x0000,
AutoShutdownOneHr = 0x003C,
AutoShutdownSixHr = 0x0168,
};
// XCONFIG_CONSOLE_CAMERA_SETTINGS
enum X_CAMERA_FLAGS : uint32_t {
// Room
RoomAuto = 0x00000000,
DarkWall = 0x00000001,
LightWall = 0x00000002,
// Lighting
LightingAuto = 0x00000000,
Incandescent = 0x00000004,
Flourescent = 0x00000008,
Daylight = 0x0000000C,
// Flourescent Anti-Flicker
AntiFlickerAuto = 0x00000000,
AntiFlickerOn = 0x00000001,
AntiFlickerOff = 0x00000002,
// Default
AutoAll = 0x00000001,
};
// XCONFIG_CONSOLE_KEYBOARD_LAYOUT
enum X_KEYBOARD_LAYOUT : uint16_t {
KeyboardDefault = 0x0000,
EnglishQWERTY = 0x0001,
};
} // namespace xboxkrnl
} // namespace kernel
} // namespace xe
#endif // XENIA_KERNEL_XBOXKRNL_XBOXKRNL_XCONFIG_H_