static LRESULT register_client(running_machine &machine, HWND hwnd, LPARAM id)
{
registered_client **client;
// find the end of the list; if we find ourself already registered,
// return 1
for (client = &clientlist; *client != nullptr; client = &(*client)->next)
if ((*client)->id == id)
{
(*client)->hwnd = hwnd;
machine.output().notify_all(notifier_callback, *client);
return 1;
}
// add us to the end
*client = global_alloc(registered_client);
(*client)->next = nullptr;
(*client)->id = id;
(*client)->hwnd = hwnd;
(*client)->machine = &machine;
// request a notification for all outputs
machine.output().notify_all(notifier_callback, *client);
return 0;
}
static LRESULT send_id_string(running_machine &machine, HWND hwnd, LPARAM id)
{
COPYDATASTRUCT copydata;
const char *name;
int datalen;
// id 0 is the name of the game
if (id == 0)
name = machine.system().name;
else
name = machine.output().id_to_name(id);
// a NULL name is an empty string
if (name == nullptr)
name = "";
// allocate memory for the message
datalen = sizeof(copydata_id_string) + strlen(name) + 1;
dynamic_buffer buffer(datalen);
copydata_id_string *temp = (copydata_id_string *)&buffer[0];
temp->id = id;
strcpy(temp->string, name);
// reply by using SendMessage with WM_COPYDATA
copydata.dwData = COPYDATA_MESSAGE_ID_STRING;
copydata.cbData = datalen;
copydata.lpData = temp;
SendMessage(hwnd, WM_COPYDATA, (WPARAM)output_hwnd, (LPARAM)©data);
return 0;
}
void awp_draw_reel(running_machine &machine, const char* reeltag, stepper_device &reel)
{
char rg[16];
int reelpos = reel.get_position();
if (reelpos == machine.output().get_value(reeltag))
{
// Not moved, no need to update.
}
else
{
machine.output().set_value(reeltag,(reelpos));
// if the reel isn't configured don't do this, otherwise you'll get DIV0
if (reel.get_max())
{
sprintf(rg,"s%s", reeltag); // our new scrolling reels are called 'sreel'
// normalize the value
int sreelpos = (reelpos * 0x10000) / reel.get_max();
machine.output().set_value(rg,sreelpos);
}
}
}
video_manager::video_manager(running_machine &machine)
: m_machine(machine),
m_screenless_frame_timer(nullptr),
m_output_changed(false),
m_throttle_last_ticks(0),
m_throttle_realtime(attotime::zero),
m_throttle_emutime(attotime::zero),
m_throttle_history(0),
m_speed_last_realtime(0),
m_speed_last_emutime(attotime::zero),
m_speed_percent(1.0),
m_overall_real_seconds(0),
m_overall_real_ticks(0),
m_overall_emutime(attotime::zero),
m_overall_valid_counter(0),
m_throttled(machine.options().throttle()),
m_throttle_rate(1.0f),
m_fastforward(false),
m_seconds_to_run(machine.options().seconds_to_run()),
m_auto_frameskip(machine.options().auto_frameskip()),
m_speed(original_speed_setting()),
m_empty_skip_count(0),
m_frameskip_level(machine.options().frameskip()),
m_frameskip_counter(0),
m_frameskip_adjust(0),
m_skipping_this_frame(false),
m_average_oversleep(0),
m_snap_target(nullptr),
m_snap_native(true),
m_snap_width(0),
m_snap_height(0),
m_mng_frame_period(attotime::zero),
m_mng_next_frame_time(attotime::zero),
m_mng_frame(0),
m_avi_file(nullptr),
m_avi_frame_period(attotime::zero),
m_avi_next_frame_time(attotime::zero),
m_avi_frame(0),
m_dummy_recording(false),
m_timecode_enabled(false),
m_timecode_write(false),
m_timecode_text(""),
m_timecode_start(attotime::zero),
m_timecode_total(attotime::zero)
{
// request a callback upon exiting
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(video_manager::exit), this));
machine.save().register_postload(save_prepost_delegate(FUNC(video_manager::postload), this));
// extract initial execution state from global configuration settings
update_refresh_speed();
// create a render target for snapshots
const char *viewname = machine.options().snap_view();
m_snap_native = (machine.first_screen() != nullptr && (viewname[0] == 0 || strcmp(viewname, "native") == 0));
// the native target is hard-coded to our internal layout and has all options disabled
if (m_snap_native)
{
m_snap_target = machine.render().target_alloc(layout_snap, RENDER_CREATE_SINGLE_FILE | RENDER_CREATE_HIDDEN);
m_snap_target->set_backdrops_enabled(false);
m_snap_target->set_overlays_enabled(false);
m_snap_target->set_bezels_enabled(false);
m_snap_target->set_cpanels_enabled(false);
m_snap_target->set_marquees_enabled(false);
m_snap_target->set_screen_overlay_enabled(false);
m_snap_target->set_zoom_to_screen(false);
}
// other targets select the specified view and turn off effects
else
{
m_snap_target = machine.render().target_alloc(nullptr, RENDER_CREATE_HIDDEN);
m_snap_target->set_view(m_snap_target->configured_view(viewname, 0, 1));
m_snap_target->set_screen_overlay_enabled(false);
}
// extract snap resolution if present
if (sscanf(machine.options().snap_size(), "%dx%d", &m_snap_width, &m_snap_height) != 2)
m_snap_width = m_snap_height = 0;
// start recording movie if specified
const char *filename = machine.options().mng_write();
if (filename[0] != 0)
begin_recording(filename, MF_MNG);
filename = machine.options().avi_write();
if (filename[0] != 0)
begin_recording(filename, MF_AVI);
#ifdef MAME_DEBUG
m_dummy_recording = machine.options().dummy_write();
#endif
// if no screens, create a periodic timer to drive updates
if (machine.first_screen() == nullptr)
{
m_screenless_frame_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(video_manager::screenless_update_callback), this));
m_screenless_frame_timer->adjust(screen_device::DEFAULT_FRAME_PERIOD, 0, screen_device::DEFAULT_FRAME_PERIOD);
machine.output().set_notifier(nullptr, video_notifier_callback, this);
}
}
void windows_osd_interface::init(running_machine &machine)
{
// call our parent
osd_common_t::init(machine);
const char *stemp;
windows_options &options = downcast<windows_options &>(machine.options());
// determine if we are benchmarking, and adjust options appropriately
int bench = options.bench();
std::string error_string;
if (bench > 0)
{
options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(OSDOPTION_SOUND, "none", OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(OSDOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM, error_string);
assert(error_string.empty());
}
// determine if we are profiling, and adjust options appropriately
int profile = options.profile();
if (profile > 0)
{
options.set_value(OPTION_THROTTLE, false, OPTION_PRIORITY_MAXIMUM, error_string);
options.set_value(OSDOPTION_NUMPROCESSORS, 1, OPTION_PRIORITY_MAXIMUM, error_string);
assert(error_string.empty());
}
// thread priority
if (!(machine.debug_flags & DEBUG_FLAG_OSD_ENABLED))
SetThreadPriority(GetCurrentThread(), options.priority());
// get number of processors
stemp = options.numprocessors();
osd_num_processors = 0;
if (strcmp(stemp, "auto") != 0)
{
osd_num_processors = atoi(stemp);
if (osd_num_processors < 1)
{
osd_printf_warning("Warning: numprocessors < 1 doesn't make much sense. Assuming auto ...\n");
osd_num_processors = 0;
}
}
// initialize the subsystems
osd_common_t::init_subsystems();
// notify listeners of screen configuration
for (auto info : osd_common_t::s_window_list)
{
machine.output().set_value(string_format("Orientation(%s)", info->monitor()->devicename()).c_str(), std::static_pointer_cast<win_window_info>(info)->m_targetorient);
}
// hook up the debugger log
if (options.oslog())
{
using namespace std::placeholders;
machine.add_logerror_callback(std::bind(&windows_osd_interface::output_oslog, this, _1));
}
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
// crank up the multimedia timer resolution to its max
// this gives the system much finer timeslices
timeresult = timeGetDevCaps(&timecaps, sizeof(timecaps));
if (timeresult == TIMERR_NOERROR)
timeBeginPeriod(timecaps.wPeriodMin);
#endif
// create and start the profiler
if (profile > 0)
{
diagnostics_module::get_instance()->start_profiler(1000, profile - 1);
}
// initialize sockets
win_init_sockets();
// note the existence of a machine
g_current_machine = &machine;
}
video_manager::video_manager(running_machine &machine)
: m_machine(machine)
, m_screenless_frame_timer(nullptr)
, m_output_changed(false)
, m_throttle_last_ticks(0)
, m_throttle_realtime(attotime::zero)
, m_throttle_emutime(attotime::zero)
, m_throttle_history(0)
, m_speed_last_realtime(0)
, m_speed_last_emutime(attotime::zero)
, m_speed_percent(1.0)
, m_overall_real_seconds(0)
, m_overall_real_ticks(0)
, m_overall_emutime(attotime::zero)
, m_overall_valid_counter(0)
, m_throttled(machine.options().throttle())
, m_throttle_rate(1.0f)
, m_fastforward(false)
, m_seconds_to_run(machine.options().seconds_to_run())
, m_auto_frameskip(machine.options().auto_frameskip())
, m_speed(original_speed_setting())
, m_empty_skip_count(0)
, m_frameskip_level(machine.options().frameskip())
, m_frameskip_counter(0)
, m_frameskip_adjust(0)
, m_skipping_this_frame(false)
, m_average_oversleep(0)
, m_snap_target(nullptr)
, m_snap_native(true)
, m_snap_width(0)
, m_snap_height(0)
, m_timecode_enabled(false)
, m_timecode_write(false)
, m_timecode_text("")
, m_timecode_start(attotime::zero)
, m_timecode_total(attotime::zero)
{
// request a callback upon exiting
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&video_manager::exit, this));
machine.save().register_postload(save_prepost_delegate(FUNC(video_manager::postload), this));
// extract initial execution state from global configuration settings
update_refresh_speed();
const unsigned screen_count(screen_device_iterator(machine.root_device()).count());
const bool no_screens(!screen_count);
// create a render target for snapshots
const char *viewname = machine.options().snap_view();
m_snap_native = !no_screens && (viewname[0] == 0 || strcmp(viewname, "native") == 0);
if (m_snap_native)
{
// the native target is hard-coded to our internal layout and has all options disabled
util::xml::file::ptr const root(util::xml::file::create());
if (!root)
throw emu_fatalerror("Couldn't create XML document??");
util::xml::data_node *const layoutnode(root->add_child("mamelayout", nullptr));
if (!layoutnode)
throw emu_fatalerror("Couldn't create XML node??");
layoutnode->set_attribute_int("version", 2);
for (unsigned i = 0; screen_count > i; ++i)
{
util::xml::data_node *const viewnode(layoutnode->add_child("view", nullptr));
if (!viewnode)
throw emu_fatalerror("Couldn't create XML node??");
viewnode->set_attribute("name", util::xml::normalize_string(util::string_format("s%1$u", i).c_str()));
util::xml::data_node *const screennode(viewnode->add_child("screen", nullptr));
if (!screennode)
throw emu_fatalerror("Couldn't create XML node??");
screennode->set_attribute_int("index", i);
util::xml::data_node *const boundsnode(screennode->add_child("bounds", nullptr));
if (!boundsnode)
throw emu_fatalerror("Couldn't create XML node??");
boundsnode->set_attribute_int("left", 0);
boundsnode->set_attribute_int("top", 0);
boundsnode->set_attribute_int("right", 1);
boundsnode->set_attribute_int("bottom", 1);
}
m_snap_target = machine.render().target_alloc(*root, RENDER_CREATE_SINGLE_FILE | RENDER_CREATE_HIDDEN);
m_snap_target->set_backdrops_enabled(false);
m_snap_target->set_overlays_enabled(false);
m_snap_target->set_bezels_enabled(false);
m_snap_target->set_cpanels_enabled(false);
m_snap_target->set_marquees_enabled(false);
m_snap_target->set_screen_overlay_enabled(false);
m_snap_target->set_zoom_to_screen(false);
}
else
{
// otherwise, non-default targets select the specified view and turn off effects
m_snap_target = machine.render().target_alloc(nullptr, RENDER_CREATE_HIDDEN);
m_snap_target->set_view(m_snap_target->configured_view(viewname, 0, 1));
m_snap_target->set_screen_overlay_enabled(false);
}
// extract snap resolution if present
if (sscanf(machine.options().snap_size(), "%dx%d", &m_snap_width, &m_snap_height) != 2)
m_snap_width = m_snap_height = 0;
// start recording movie if specified
const char *filename = machine.options().mng_write();
if (filename[0] != 0)
begin_recording(filename, MF_MNG);
filename = machine.options().avi_write();
if (filename[0] != 0)
begin_recording(filename, MF_AVI);
// if no screens, create a periodic timer to drive updates
if (no_screens)
{
m_screenless_frame_timer = machine.scheduler().timer_alloc(timer_expired_delegate(FUNC(video_manager::screenless_update_callback), this));
m_screenless_frame_timer->adjust(screen_device::DEFAULT_FRAME_PERIOD, 0, screen_device::DEFAULT_FRAME_PERIOD);
machine.output().set_notifier(nullptr, video_notifier_callback, this);
}
}
