// fill in the data on the last played pilot (callsign and is_multi or not)
int player_select_get_last_pilot_info()
{
// TODO: Replace this with a function that does this properly for the new pilot code.
const char *last_player = os_config_read_string( NULL, "LastPlayer", NULL);
if (last_player == NULL) {
return 0;
} else {
strcpy_s(Player_select_last_pilot, last_player);
}
// handle changing from pre-pilot code to post-pilot code
if (Player_select_last_pilot[strlen(Player_select_last_pilot)-1] == 'M' || Player_select_last_pilot[strlen(Player_select_last_pilot)-1] == 'S') {
Player_select_last_pilot[strlen(Player_select_last_pilot)-1]='\0'; // chop off last char, M|P
}
if ( !Pilot.load_player(Player_select_last_pilot, Player) ) {
Player_select_last_is_multi = 0;
} else {
Player_select_last_is_multi = Player->player_was_multi;
}
return 1;
}
static void find_capture_device(OpenALInformation* info)
{
const char *user_device = os_config_read_string( "Sound", "CaptureDevice", NULL );
const char *default_device = info->default_capture_device.c_str();
// in case they are the same, we only want to test it once
if ( (user_device && default_device) && !strcmp(user_device, default_device) ) {
user_device = NULL;
}
for (auto& device : info->capture_devices) {
OALdevice new_device(device.c_str());
if (user_device && !strcmp(device.c_str(), user_device)) {
new_device.type = OAL_DEVICE_USER;
} else if (default_device && !strcmp(device.c_str(), default_device)) {
new_device.type = OAL_DEVICE_DEFAULT;
}
CaptureDevices.push_back( new_device );
}
if ( CaptureDevices.empty() ) {
return;
}
std::sort( CaptureDevices.begin(), CaptureDevices.end(), openal_device_sort_func );
// for each device that we have available, try and figure out which to use
for (size_t idx = 0; idx < CaptureDevices.size(); idx++) {
const ALCchar *device_name = CaptureDevices[idx].device_name.c_str();
ALCdevice *device = alcCaptureOpenDevice(device_name, 22050, AL_FORMAT_MONO8, 22050 * 2);
if (device == NULL) {
continue;
}
if (alcGetError(device) != ALC_NO_ERROR) {
alcCaptureCloseDevice(device);
continue;
}
// ok, we should be good with this one
Capture_device = CaptureDevices[idx].device_name;
alcCaptureCloseDevice(device);
break;
}
}
// initialize localization, if no language is passed - use the language specified in the registry
void lcl_init(int lang_init)
{
atexit(lcl_xstr_close);
char lang_string[128];
char *ret;
int lang, idx;
// initialize encryption
encrypt_init();
// read the language from the registry
if(lang_init < 0){
memset(lang_string, 0, 128);
// default to DEFAULT_LANGUAGE (which should be english so we dont have to put German text
// in tstrings in the #default section
ret = os_config_read_string(NULL, "Language", DEFAULT_LANGUAGE);
if(ret == NULL){
Int3();
strcpy(lang_string, DEFAULT_LANGUAGE);
} else {
strcpy(lang_string, ret);
}
// look it up
lang = -1;
for(idx=0; idx<LCL_NUM_LANGUAGES; idx++){
if(!stricmp(Lcl_languages[idx].lang_name, lang_string)){
lang = idx;
break;
}
}
if(lang < 0){
lang = 0;
}
} else {
Assert((lang_init >= 0) && (lang_init < LCL_NUM_LANGUAGES));
lang = lang_init;
}
// language markers
Lcl_pointer_count = 0;
// associate the table string file
lcl_ext_associate(TABLE_STRING_FILENAME);
// set the language (this function takes care of setting up file pointers)
lcl_set_language(lang);
}
// If app_name is NULL or ommited, then TITLE is used
// for the app name, which is where registry keys are stored.
void os_init(const char * wclass, const char * title, const char *app_name, const char *version_string )
{
// create default ini entries for the user
if (os_config_read_string(NULL, NOX("VideocardFs2open"), NULL) == NULL)
os_config_write_string(NULL, NOX("VideocardFs2open"), NOX("OGL -(640x480)x16 bit"));
os_init_registry_stuff(Osreg_company_name, title, version_string);
strcpy_s( szWinTitle, title );
strcpy_s( szWinClass, wclass );
INITIALIZE_CRITICAL_SECTION( Os_lock );
unix_process(0);
// initialized
Os_inited = 1;
atexit(os_deinit);
}
// initialize localization, if no language is passed - use the language specified in the registry
void lcl_init(int lang_init)
{
char lang_string[128];
const char *ret;
int lang, idx, i;
// initialize encryption
encrypt_init();
// setup English
Lcl_languages.push_back(Lcl_builtin_languages[FS2_OPEN_DEFAULT_LANGUAGE]);
// check string.tbl to see which languages we support
try
{
parse_stringstbl_quick("strings.tbl");
}
catch (const parse::ParseException& e)
{
mprintf(("TABLES: Unable to parse '%s'! Error message = %s.\n", "strings.tbl", e.what()));
}
parse_modular_table(NOX("*-lcl.tbm"), parse_stringstbl_quick);
// if the only language we have at this point is English, we need to setup the builtin languages as we might be dealing with an old style strings.tbl
// which doesn't support anything beyond the builtin languages. Note, we start at i = 1 because we added English above.
if ((int)Lcl_languages.size() == 1) {
for (i=1; i<NUM_BUILTIN_LANGUAGES; i++) {
Lcl_languages.push_back(Lcl_builtin_languages[i]);
}
}
// read the language from the registry
if(lang_init < 0){
memset(lang_string, 0, 128);
// default to DEFAULT_LANGUAGE (which should be English so we don't have to put German text
// in tstrings in the #default section)
ret = os_config_read_string(NULL, "Language", Lcl_languages[FS2_OPEN_DEFAULT_LANGUAGE].lang_name);
if(ret == NULL){
Error(LOCATION, "Default language not found.");
}
strcpy_s(lang_string, ret);
// look it up
lang = -1;
for(idx = 0; idx < (int)Lcl_languages.size(); idx++){
if(!stricmp(Lcl_languages[idx].lang_name, lang_string)){
lang = idx;
break;
}
}
if(lang < 0){
lang = 0;
}
} else {
Assert((lang_init >= 0) && (lang_init < (int)Lcl_languages.size()));
lang = lang_init;
}
// set the language (this function takes care of setting up file pointers)
lcl_set_language(lang);
}
static void find_capture_device()
{
const char *user_device = os_config_read_string( "Sound", "CaptureDevice", NULL );
const char *default_device = (const char*) alcGetString( NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER );
// in case they are the same, we only want to test it once
if ( (user_device && default_device) && !strcmp(user_device, default_device) ) {
user_device = NULL;
}
if ( alcIsExtensionPresent(NULL, (const ALCchar*)"ALC_ENUMERATION_EXT") == AL_TRUE ) {
const char *all_devices = (const char*) alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
const char *str_list = all_devices;
int ext_length = 0;
if ( (str_list != NULL) && ((ext_length = strlen(str_list)) > 0) ) {
while (ext_length) {
OALdevice new_device(str_list);
if (user_device && !strcmp(str_list, user_device)) {
new_device.type = OAL_DEVICE_USER;
} else if (default_device && !strcmp(str_list, default_device)) {
new_device.type = OAL_DEVICE_DEFAULT;
}
CaptureDevices.push_back( new_device );
str_list += (ext_length + 1);
ext_length = strlen(str_list);
}
}
} else {
if (default_device) {
OALdevice new_device(default_device);
new_device.type = OAL_DEVICE_DEFAULT;
CaptureDevices.push_back( new_device );
}
if (user_device) {
OALdevice new_device(user_device);
new_device.type = OAL_DEVICE_USER;
CaptureDevices.push_back( new_device );
}
}
if ( CaptureDevices.empty() ) {
return;
}
std::sort( CaptureDevices.begin(), CaptureDevices.end(), openal_device_sort_func );
// for each device that we have available, try and figure out which to use
for (size_t idx = 0; idx < CaptureDevices.size(); idx++) {
const ALCchar *device_name = CaptureDevices[idx].device_name.c_str();
ALCdevice *device = alcCaptureOpenDevice(device_name, 22050, AL_FORMAT_MONO8, 22050 * 2);
if (device == NULL) {
continue;
}
if (alcGetError(device) != ALC_NO_ERROR) {
alcCaptureCloseDevice(device);
continue;
}
// ok, we should be good with this one
Capture_device = CaptureDevices[idx].device_name;
alcCaptureCloseDevice(device);
break;
}
}
static void find_playback_device()
{
const char *user_device = os_config_read_string( "Sound", "PlaybackDevice", NULL );
const char *default_device = (const char*) alcGetString( NULL, ALC_DEFAULT_DEVICE_SPECIFIER );
// in case they are the same, we only want to test it once
if ( (user_device && default_device) && !strcmp(user_device, default_device) ) {
user_device = NULL;
}
if ( alcIsExtensionPresent(NULL, (const ALCchar*)"ALC_ENUMERATION_EXT") == AL_TRUE ) {
const char *all_devices = NULL;
if ( alcIsExtensionPresent(NULL, (const ALCchar*)"ALC_ENUMERATE_ALL_EXT") == AL_TRUE ) {
all_devices = (const char*) alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
} else {
all_devices = (const char*) alcGetString(NULL, ALC_DEVICE_SPECIFIER);
}
const char *str_list = all_devices;
int ext_length = 0;
if ( (str_list != NULL) && ((ext_length = strlen(str_list)) > 0) ) {
while (ext_length) {
OALdevice new_device(str_list);
if (user_device && !strcmp(str_list, user_device)) {
new_device.type = OAL_DEVICE_USER;
} else if (default_device && !strcmp(str_list, default_device)) {
new_device.type = OAL_DEVICE_DEFAULT;
}
PlaybackDevices.push_back( new_device );
str_list += (ext_length + 1);
ext_length = strlen(str_list);
}
}
} else {
if (default_device) {
OALdevice new_device(default_device);
new_device.type = OAL_DEVICE_DEFAULT;
PlaybackDevices.push_back( new_device );
}
if (user_device) {
OALdevice new_device(user_device);
new_device.type = OAL_DEVICE_USER;
PlaybackDevices.push_back( new_device );
}
}
if ( PlaybackDevices.empty() ) {
return;
}
std::sort( PlaybackDevices.begin(), PlaybackDevices.end(), openal_device_sort_func );
ALCdevice *device = NULL;
ALCcontext *context = NULL;
// for each device that we have available, try and figure out which to use
for (size_t idx = 0; idx < PlaybackDevices.size(); idx++) {
OALdevice *pdev = &PlaybackDevices[idx];
// open our specfic device
device = alcOpenDevice( (const ALCchar*) pdev->device_name.c_str() );
if (device == NULL) {
continue;
}
context = alcCreateContext(device, NULL);
if (context == NULL) {
alcCloseDevice(device);
continue;
}
alcMakeContextCurrent(context);
alcGetError(device);
// check how many sources we can create
static const int MIN_SOURCES = 48; // MAX_CHANNELS + 16 spare
int si = 0;
for (si = 0; si < MIN_SOURCES; si++) {
ALuint source_id = 0;
alGenSources(1, &source_id);
if (alGetError() != AL_NO_ERROR) {
break;
}
alDeleteSources(1, &source_id);
}
if (si == MIN_SOURCES) {
// ok, it supports our minimum requirements
pdev->usable = true;
// need this for the future
Playback_device = pdev->device_name;
// done
break;
} else {
// clean up for next pass
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
alcCloseDevice(device);
context = NULL;
device = NULL;
}
}
alcMakeContextCurrent(NULL);
if (context) {
alcDestroyContext(context);
}
if (device) {
alcCloseDevice(device);
}
}
static void find_playback_device(OpenALInformation* info)
{
const char *user_device = os_config_read_string( "Sound", "PlaybackDevice", NULL );
const char *default_device = info->default_playback_device.c_str();
// in case they are the same, we only want to test it once
if ( (user_device && default_device) && !strcmp(user_device, default_device) ) {
user_device = NULL;
}
for (auto& device : info->playback_devices) {
OALdevice new_device(device.c_str());
if (user_device && !strcmp(device.c_str(), user_device)) {
new_device.type = OAL_DEVICE_USER;
} else if (default_device && !strcmp(device.c_str(), default_device)) {
new_device.type = OAL_DEVICE_DEFAULT;
}
PlaybackDevices.push_back( new_device );
}
if ( PlaybackDevices.empty() ) {
return;
}
std::sort( PlaybackDevices.begin(), PlaybackDevices.end(), openal_device_sort_func );
ALCdevice *device = NULL;
ALCcontext *context = NULL;
// for each device that we have available, try and figure out which to use
for (size_t idx = 0; idx < PlaybackDevices.size(); idx++) {
OALdevice *pdev = &PlaybackDevices[idx];
// open our specfic device
device = alcOpenDevice( (const ALCchar*) pdev->device_name.c_str() );
if (device == NULL) {
continue;
}
context = alcCreateContext(device, NULL);
if (context == NULL) {
alcCloseDevice(device);
continue;
}
alcMakeContextCurrent(context);
alcGetError(device);
// check how many sources we can create
static const int MIN_SOURCES = 48; // MAX_CHANNELS + 16 spare
int si = 0;
for (si = 0; si < MIN_SOURCES; si++) {
ALuint source_id = 0;
alGenSources(1, &source_id);
if (alGetError() != AL_NO_ERROR) {
break;
}
alDeleteSources(1, &source_id);
}
if (si == MIN_SOURCES) {
// ok, it supports our minimum requirements
pdev->usable = true;
// need this for the future
Playback_device = pdev->device_name;
// done
break;
} else {
// clean up for next pass
alcMakeContextCurrent(NULL);
alcDestroyContext(context);
alcCloseDevice(device);
context = NULL;
device = NULL;
}
}
alcMakeContextCurrent(NULL);
if (context) {
alcDestroyContext(context);
}
if (device) {
alcCloseDevice(device);
}
}
