resource_pool::resource_pool()
: m_listlock(osd_lock_alloc()),
m_ordered_head(NULL),
m_ordered_tail(NULL)
{
memset(m_hash, 0, sizeof(m_hash));
}
resource_pool::resource_pool(int hash_size)
: m_hash_size(hash_size),
m_listlock(osd_lock_alloc()),
m_hash(hash_size, 0),
m_ordered_head(NULL),
m_ordered_tail(NULL)
{
}
osd_scalable_lock *osd_scalable_lock_alloc(void)
{
osd_scalable_lock *lock;
lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
lock->lock = osd_lock_alloc();
return lock;
}
resource_pool::resource_pool(int hash_size)
: m_hash_size(hash_size),
m_listlock(osd_lock_alloc()),
m_hash(new resource_pool_item *[hash_size]),
m_ordered_head(NULL),
m_ordered_tail(NULL)
{
memset(m_hash, 0, hash_size * sizeof(m_hash[0]));
}
osd_scalable_lock *osd_scalable_lock_alloc(void)
{
osd_scalable_lock *lock = (osd_scalable_lock *)calloc(1, sizeof(*lock));
#ifdef WIN32
memset(lock, 0, sizeof(*lock));
InitializeCriticalSection(&lock->critsect);
#else
lock->lock = osd_lock_alloc();
#endif
return lock;
}
void memory_entry::acquire_lock()
{
// allocate a lock on first usage
// note that osd_lock_alloc() may re-enter this path, so protect against recursion!
if (s_lock == NULL)
{
if (s_lock_alloc)
return;
s_lock_alloc = true;
s_lock = osd_lock_alloc();
s_lock_alloc = false;
}
osd_lock_acquire(s_lock);
}
lua_engine::lua_engine()
{
m_machine = NULL;
luaThis = this;
m_lua_state = luaL_newstate(); /* create state */
output_notifier_set = false;
luaL_checkversion(m_lua_state);
lua_gc(m_lua_state, LUA_GCSTOP, 0); /* stop collector during initialization */
luaL_openlibs(m_lua_state); /* open libraries */
luaopen_lsqlite3(m_lua_state);
luaopen_ioport(m_lua_state);
lua_gc(m_lua_state, LUA_GCRESTART, 0);
msg.ready = 0;
msg.status = 0;
msg.done = 0;
lock = osd_lock_alloc();
}
int winwindow_video_window_create(int index, win_monitor_info *monitor, const win_window_config *config)
{
win_window_info *window, *win;
char option[20];
assert(GetCurrentThreadId() == main_threadid);
// allocate a new window object
window = malloc_or_die(sizeof(*window));
memset(window, 0, sizeof(*window));
window->maxwidth = config->width;
window->maxheight = config->height;
window->refresh = config->refresh;
window->monitor = monitor;
window->fullscreen = !video_config.windowed;
// see if we are safe for fullscreen
window->fullscreen_safe = TRUE;
for (win = win_window_list; win != NULL; win = win->next)
if (win->monitor == monitor)
window->fullscreen_safe = FALSE;
// add us to the list
*last_window_ptr = window;
last_window_ptr = &window->next;
// create a lock that we can use to skip blitting
window->render_lock = osd_lock_alloc();
// load the layout
window->target = render_target_alloc(NULL, 0);
if (window->target == NULL)
goto error;
render_target_set_orientation(window->target, video_orientation);
render_target_set_layer_config(window->target, video_config.layerconfig);
// set the specific view
sprintf(option, "view%d", index);
set_starting_view(index, window, options_get_string(option));
// remember the current values in case they change
window->targetview = render_target_get_view(window->target);
window->targetorient = render_target_get_orientation(window->target);
window->targetlayerconfig = render_target_get_layer_config(window->target);
// make the window title
if (video_config.numscreens == 1)
sprintf(window->title, APPNAME ": %s [%s]", Machine->gamedrv->description, Machine->gamedrv->name);
else
sprintf(window->title, APPNAME ": %s [%s] - Screen %d", Machine->gamedrv->description, Machine->gamedrv->name, index);
// set the initial maximized state
window->startmaximized = options_get_bool("maximize");
// finish the window creation on the window thread
if (multithreading_enabled)
{
// wait until the window thread is ready to respond to events
WaitForSingleObject(window_thread_ready_event, INFINITE);
PostThreadMessage(window_threadid, WM_USER_FINISH_CREATE_WINDOW, 0, (LPARAM)window);
while (window->init_state == 0)
Sleep(1);
}
else
window->init_state = complete_create(window) ? -1 : 1;
// handle error conditions
if (window->init_state == -1)
goto error;
return 0;
error:
winwindow_video_window_destroy(window);
return 1;
}
int sdl_window_info::window_init()
{
worker_param *wp = (worker_param *) osd_malloc(sizeof(worker_param));
int result;
ASSERT_MAIN_THREAD();
// set the initial maximized state
// FIXME: Does not belong here
sdl_options &options = downcast<sdl_options &>(m_machine.options());
m_startmaximized = options.maximize();
// add us to the list
*last_window_ptr = this;
last_window_ptr = &this->m_next;
set_renderer(draw.create(this));
// create a lock that we can use to skip blitting
m_render_lock = osd_lock_alloc();
// create an event that we can use to skip blitting
m_rendered_event = osd_event_alloc(FALSE, TRUE);
// load the layout
m_target = m_machine.render().target_alloc();
// set the specific view
set_starting_view(m_index, options.view(), options.view(m_index));
// make the window title
if (video_config.numscreens == 1)
sprintf(m_title, "%s: %s [%s]", emulator_info::get_appname(), m_machine.system().description, m_machine.system().name);
else
sprintf(m_title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), m_machine.system().description, m_machine.system().name, m_index);
wp->set_window(this);
// FIXME: pass error back in a different way
if (multithreading_enabled)
{
osd_work_item *wi;
wi = osd_work_item_queue(work_queue, &sdl_window_info::complete_create_wt, (void *) wp, 0);
sdlwindow_sync();
result = *((int *) (osd_work_item_result)(wi));
osd_work_item_release(wi);
}
else
result = *((int *) sdl_window_info::complete_create_wt((void *) wp, 0));
// handle error conditions
if (result == 1)
goto error;
return 0;
error:
destroy();
return 1;
}
