static void sdlwindow_modify_yuv(running_machine *machine, sdl_window_info *window, int dir)
{
int new_scale_mode = window->scale_mode;
worker_param wp;
const char *stemp;
if (dir > 0)
new_scale_mode = window->scale_mode + 1;
if (dir < 0)
new_scale_mode = window->scale_mode - 1;
stemp = drawsdl_scale_mode_str(new_scale_mode);
if (stemp==NULL)
return;
clear_worker_param(&wp);
wp.window = window;
wp.machine = machine;
sdlwindow_sync();
execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);
window->scale_mode = new_scale_mode;
ui_popup_time(1, "Scale mode %s", stemp);
mame_printf_verbose("Scale mode %s\n", stemp);
sdlwindow_sync();
execute_async_wait(&complete_create_wt, &wp);
sdlwindow_sync();
}
static void sdlwindow_exit(running_machine &machine)
{
ASSERT_MAIN_THREAD();
mame_printf_verbose("Enter sdlwindow_exit\n");
// free all the windows
while (sdl_window_list != NULL)
{
sdl_window_info *temp = sdl_window_list;
sdl_window_list = temp->next;
sdlwindow_video_window_destroy(machine, temp);
}
// if we're multithreaded, clean up the window thread
if (multithreading_enabled)
{
sdlwindow_sync();
}
// kill the drawers
(*draw.exit)();
execute_async_wait(&sdlwindow_exit_wt, NULL);
if (multithreading_enabled)
{
osd_work_queue_wait(work_queue, 1000000);
osd_work_queue_free(work_queue);
}
mame_printf_verbose("Leave sdlwindow_exit\n");
}
void sdl_window_info::destroy()
{
sdl_window_info **prevptr;
ASSERT_MAIN_THREAD();
if (multithreading_enabled)
{
sdlwindow_sync();
}
//osd_event_wait(window->rendered_event, osd_ticks_per_second()*10);
// remove us from the list
for (prevptr = &sdl_window_list; *prevptr != NULL; prevptr = &(*prevptr)->m_next)
if (*prevptr == this)
{
*prevptr = this->m_next;
break;
}
// free the textures etc
execute_async_wait(&sdlwindow_video_window_destroy_wt, worker_param(this));
// free the render target, after the textures!
this->machine().render().target_free(m_target);
// free the event
osd_event_free(m_rendered_event);
// free the lock
osd_lock_free(this->m_render_lock);
}
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 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;
}
static void sdlwindow_video_window_destroy(running_machine *machine, sdl_window_info *window)
{
sdl_window_info **prevptr;
worker_param wp;
ASSERT_MAIN_THREAD();
if (multithreading_enabled)
{
sdlwindow_sync();
}
//osd_event_wait(window->rendered_event, osd_ticks_per_second()*10);
// remove us from the list
for (prevptr = &sdl_window_list; *prevptr != NULL; prevptr = &(*prevptr)->next)
if (*prevptr == window)
{
*prevptr = window->next;
break;
}
// free the textures etc
clear_worker_param(&wp);
wp.window = window;
wp.machine = machine;
execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);
// free the render target, after the textures!
if (window->target != NULL)
render_target_free(window->target);
// free the event
osd_event_free(window->rendered_event);
// free the window itself
global_free(window);
}
void sdl_osd_interface::window_exit()
{
worker_param wp_dummy;
ASSERT_MAIN_THREAD();
osd_printf_verbose("Enter sdlwindow_exit\n");
// free all the windows
while (sdl_window_list != NULL)
{
sdl_window_info *temp = sdl_window_list;
sdl_window_list = temp->m_next;
temp->destroy();
// free the window itself
global_free(temp);
}
// if we're multithreaded, clean up the window thread
if (multithreading_enabled)
{
sdlwindow_sync();
}
// kill the drawers
(*draw.exit)();
execute_async_wait(&sdlwindow_exit_wt, wp_dummy);
if (multithreading_enabled)
{
osd_work_queue_wait(work_queue, 1000000);
osd_work_queue_free(work_queue);
}
osd_printf_verbose("Leave sdlwindow_exit\n");
}
int sdlwindow_video_window_create(running_machine &machine, int index, sdl_monitor_info *monitor, const sdl_window_config *config)
{
sdl_window_info *window;
worker_param *wp = (worker_param *) osd_malloc(sizeof(worker_param));
int result;
ASSERT_MAIN_THREAD();
clear_worker_param(wp);
// allocate a new window object
window = global_alloc_clear(sdl_window_info);
window->maxwidth = config->width;
window->maxheight = config->height;
window->depth = config->depth;
window->refresh = config->refresh;
window->monitor = monitor;
window->m_machine = &machine;
window->index = index;
//FIXME: these should be per_window in config-> or even better a bit set
window->fullscreen = !video_config.windowed;
window->prescale = video_config.prescale;
// set the initial maximized state
// FIXME: Does not belong here
sdl_options &options = downcast<sdl_options &>(machine.options());
window->startmaximized = options.maximize();
if (!window->fullscreen)
{
window->windowed_width = config->width;
window->windowed_height = config->height;
}
window->totalColors = config->totalColors;
// add us to the list
*last_window_ptr = window;
last_window_ptr = &window->next;
draw.attach(&draw, window);
// create an event that we can use to skip blitting
window->rendered_event = osd_event_alloc(FALSE, TRUE);
// load the layout
window->target = machine.render().target_alloc();
// set the specific view
set_starting_view(machine, index, window, options.view(), options.view(index));
// make the window title
if (video_config.numscreens == 1)
sprintf(window->title, "%s: %s [%s]", emulator_info::get_appname(), machine.system().description, machine.system().name);
else
sprintf(window->title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), machine.system().description, machine.system().name, index);
wp->window = window;
if (multithreading_enabled)
{
osd_work_item *wi;
wi = osd_work_item_queue(work_queue, &complete_create_wt, (void *) wp, 0);
sdlwindow_sync();
result = *((int *) (osd_work_item_result)(wi));
osd_work_item_release(wi);
}
else
result = *((int *) complete_create_wt((void *) wp, 0));
// handle error conditions
if (result == 1)
goto error;
return 0;
error:
sdlwindow_video_window_destroy(machine, window);
return 1;
}
INLINE void execute_async_wait(osd_work_callback callback, worker_param *wp)
{
execute_async(callback, wp);
sdlwindow_sync();
}
bool sdl_osd_interface::window_init()
{
osd_printf_verbose("Enter sdlwindow_init\n");
// determine if we are using multithreading or not
multithreading_enabled = options().multithreading();
// get the main thread ID before anything else
main_threadid = SDL_ThreadID();
// if multithreading, create a thread to run the windows
if (multithreading_enabled)
{
// create a thread to run the windows from
work_queue = osd_work_queue_alloc(WORK_QUEUE_FLAG_IO);
if (work_queue == NULL)
return false;
osd_work_item_queue(work_queue, &sdlwindow_thread_id, NULL, WORK_ITEM_FLAG_AUTO_RELEASE);
sdlwindow_sync();
}
else
{
// otherwise, treat the window thread as the main thread
//window_threadid = main_threadid;
sdlwindow_thread_id(NULL, 0);
}
// initialize the drawers
#if USE_OPENGL
if (video_config.mode == VIDEO_MODE_OPENGL)
{
if (drawogl_init(machine(), &draw))
video_config.mode = VIDEO_MODE_SOFT;
}
#endif
#if SDLMAME_SDL2
if (video_config.mode == VIDEO_MODE_SDL2ACCEL)
{
if (drawsdl2_init(machine(), &draw))
video_config.mode = VIDEO_MODE_SOFT;
}
#endif
#ifdef USE_BGFX
if (video_config.mode == VIDEO_MODE_BGFX)
{
if (drawbgfx_init(machine(), &draw))
video_config.mode = VIDEO_MODE_SOFT;
}
#endif
if (video_config.mode == VIDEO_MODE_SOFT)
{
if (drawsdl_init(&draw))
return false;
}
#if SDLMAME_SDL2
/* We may want to set a number of the hints SDL2 provides.
* The code below will document which hints were set.
*/
const char * hints[] = { SDL_HINT_FRAMEBUFFER_ACCELERATION,
SDL_HINT_RENDER_DRIVER, SDL_HINT_RENDER_OPENGL_SHADERS,
SDL_HINT_RENDER_SCALE_QUALITY,
SDL_HINT_RENDER_VSYNC,
SDL_HINT_VIDEO_X11_XVIDMODE, SDL_HINT_VIDEO_X11_XINERAMA,
SDL_HINT_VIDEO_X11_XRANDR, SDL_HINT_GRAB_KEYBOARD,
SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, SDL_HINT_IDLE_TIMER_DISABLED,
SDL_HINT_ORIENTATIONS,
SDL_HINT_XINPUT_ENABLED, SDL_HINT_GAMECONTROLLERCONFIG,
SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, SDL_HINT_ALLOW_TOPMOST,
SDL_HINT_TIMER_RESOLUTION,
#if SDL_VERSION_ATLEAST(2, 0, 2)
SDL_HINT_RENDER_DIRECT3D_THREADSAFE, SDL_HINT_VIDEO_ALLOW_SCREENSAVER,
SDL_HINT_ACCELEROMETER_AS_JOYSTICK, SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK,
SDL_HINT_VIDEO_WIN_D3DCOMPILER, SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT,
SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES, SDL_HINT_MOUSE_RELATIVE_MODE_WARP,
#endif
#if SDL_VERSION_ATLEAST(2, 0, 3)
SDL_HINT_RENDER_DIRECT3D11_DEBUG, SDL_HINT_VIDEO_HIGHDPI_DISABLED,
SDL_HINT_WINRT_PRIVACY_POLICY_URL, SDL_HINT_WINRT_PRIVACY_POLICY_LABEL,
SDL_HINT_WINRT_HANDLE_BACK_BUTTON,
#endif
NULL
};
osd_printf_verbose("\nHints:\n");
for (int i = 0; hints[i] != NULL; i++)
osd_printf_verbose("\t%-40s %s\n", hints[i], SDL_GetHint(hints[i]));
#endif
// set up the window list
last_window_ptr = &sdl_window_list;
osd_printf_verbose("Leave sdlwindow_init\n");
return true;
}
static inline void execute_async_wait(osd_work_callback callback, const worker_param &wp)
{
execute_async(callback, wp);
sdlwindow_sync();
}
int sdlwindow_video_window_create(running_machine *machine, int index, sdl_monitor_info *monitor, const sdl_window_config *config)
{
sdl_window_info *window;
worker_param *wp = malloc(sizeof(worker_param));
char option[20];
int result;
ASSERT_MAIN_THREAD();
clear_worker_param(wp);
// allocate a new window object
window = alloc_or_die(sdl_window_info);
memset(window, 0, sizeof(*window));
window->maxwidth = config->width;
window->maxheight = config->height;
window->depth = config->depth;
window->refresh = config->refresh;
window->monitor = monitor;
window->machine = machine;
window->index = index;
//FIXME: these should be per_window in config-> or even better a bit set
window->fullscreen = !video_config.windowed;
window->prescale = video_config.prescale;
window->prescale_effect = video_config.prescale_effect;
window->scale_mode = video_config.scale_mode;
// set the initial maximized state
// FIXME: Does not belong here
window->startmaximized = options_get_bool(mame_options(), SDLOPTION_MAXIMIZE);
if (!window->fullscreen)
{
window->windowed_width = config->width;
window->windowed_height = config->height;
}
window->totalColors = config->totalColors;
// add us to the list
*last_window_ptr = window;
last_window_ptr = &window->next;
draw.attach(&draw, window);
// create an event that we can use to skip blitting
window->rendered_event = osd_event_alloc(FALSE, TRUE);
// load the layout
window->target = render_target_alloc(machine, NULL, FALSE);
if (window->target == NULL)
goto error;
// set the specific view
sprintf(option, SDLOPTION_VIEW("%d"), index);
set_starting_view(machine, index, window, options_get_string(mame_options(), option));
// 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);
wp->window = window;
if (multithreading_enabled)
{
osd_work_item *wi;
wi = osd_work_item_queue(work_queue, &complete_create_wt, (void *) wp, 0);
sdlwindow_sync();
result = *((int *) (osd_work_item_result)(wi));
osd_work_item_release(wi);
}
else
result = *((int *) complete_create_wt((void *) wp, 0));
// handle error conditions
if (result == 1)
goto error;
return 0;
error:
sdlwindow_video_window_destroy(machine, window);
return 1;
}
static inline void execute_async_wait(osd_work_callback callback, std::unique_ptr<worker_param> wp)
{
execute_async(callback, std::move(wp));
sdlwindow_sync();
}
