netdev_pcap::netdev_pcap(const char *name, class device_network_interface *ifdev, int rate)
: osd_netdev(ifdev, rate)
{
char errbuf[PCAP_ERRBUF_SIZE];
#if defined(SDLMAME_WIN32) || defined(OSD_WINDOWS)
m_p = (*module->pcap_open_live_dl)(name, 65535, 1, -1, errbuf);
#else
m_p = (*module->pcap_open_live_dl)(name, 65535, 1, 1, errbuf);
#endif
if(!m_p)
{
osd_printf_error("Unable to open %s: %s\n", name, errbuf);
return;
}
if ((*module->pcap_set_datalink_dl)(m_p, DLT_EN10MB) == -1)
{
osd_printf_error("Unable to set %s to ethernet", name);
(*module->pcap_close_dl)(m_p);
m_p = nullptr;
return;
}
netdev_pcap::set_mac(get_mac());
#ifdef SDLMAME_MACOSX
m_ctx.head = 0;
m_ctx.tail = 0;
m_ctx.p = m_p;
pthread_create(&m_thread, nullptr, netdev_pcap_blocker, &m_ctx);
#endif
}
static int verify_length_and_hash(emu_file *file, const char *name, UINT32 explength, const util::hash_collection &hashes)
{
int retVal = 0;
if (file==nullptr) return 0;
// verify length
UINT32 actlength = file->size();
if (explength != actlength)
{
osd_printf_error("%s WRONG LENGTH (expected: %d found: %d)\n", name, explength, actlength);
retVal++;
}
// If there is no good dump known, write it
util::hash_collection &acthashes = file->hashes(hashes.hash_types().c_str());
if (hashes.flag(util::hash_collection::FLAG_NO_DUMP))
{
osd_printf_error("%s NO GOOD DUMP KNOWN\n", name);
}
// verify checksums
else if (hashes != acthashes)
{
// otherwise, it's just bad
osd_printf_error("%s WRONG CHECKSUMS:\n", name);
dump_wrong_and_correct_checksums(hashes, acthashes);
retVal++;
}
// If it matches, but it is actually a bad dump, write it
else if (hashes.flag(util::hash_collection::FLAG_BAD_DUMP))
{
osd_printf_error("%s NEEDS REDUMP\n",name);
}
return retVal;
}
void inifile_manager::load_ini_category(size_t file, size_t category, std::unordered_set<game_driver const *> &result) const
{
std::string const &filename(m_ini_index[file].first);
emu_file fp(m_options.categoryini_path(), OPEN_FLAG_READ);
if (fp.open(filename) != osd_file::error::NONE)
{
osd_printf_error("Failed to open category file %s for reading\n", filename.c_str());
return;
}
int64_t const offset(m_ini_index[file].second[category].second);
if (fp.seek(offset, SEEK_SET) || (fp.tell() != offset))
{
fp.close();
osd_printf_error("Failed to seek to category offset in file %s\n", filename.c_str());
return;
}
char rbuf[MAX_CHAR_INFO];
while (fp.gets(rbuf, MAX_CHAR_INFO) && rbuf[0] && ('[' != rbuf[0]))
{
auto const tail(std::find_if(std::begin(rbuf), std::prev(std::end(rbuf)), [] (char ch) { return !ch || ('\r' == ch) || ('\n' == ch); }));
*tail = '\0';
int const dfind(driver_list::find(rbuf));
if (0 <= dfind)
result.emplace(&driver_list::driver(dfind));
}
fp.close();
}
void software_list_device::display_matches(const machine_config &config, const char *interface, const char *name)
{
// check if there is at least one software list
software_list_device_iterator deviter(config.root_device());
if (deviter.first() != nullptr)
osd_printf_error("\n\"%s\" approximately matches the following\n"
"supported software items (best match first):\n\n", name);
// iterate through lists
for (software_list_device &swlistdev : deviter)
{
// get the top 16 approximate matches for the selected device interface (i.e. only carts for cartslot, etc.)
const software_info *matches[16] = { nullptr };
swlistdev.find_approx_matches(name, ARRAY_LENGTH(matches), matches, interface);
// if we found some, print them
if (matches[0] != nullptr)
{
// different output depending on original system or compatible
if (swlistdev.list_type() == SOFTWARE_LIST_ORIGINAL_SYSTEM)
osd_printf_error("* Software list \"%s\" (%s) matches: \n", swlistdev.list_name().c_str(), swlistdev.description());
else
osd_printf_error("* Compatible software list \"%s\" (%s) matches: \n", swlistdev.list_name().c_str(), swlistdev.description());
// print them out
for (auto &match : matches)
{
if (match != nullptr)
osd_printf_error("%-18s%s\n", match->shortname().c_str(), match->longname().c_str());
}
osd_printf_error("\n");
}
}
}
HRESULT sound_direct_sound::create_buffers(DWORD size, WAVEFORMATEX &format)
{
assert(m_dsound);
assert(!m_primary_buffer);
assert(!m_stream_buffer);
HRESULT result;
// create the primary buffer
result = m_primary_buffer.create(m_dsound);
if (result != DS_OK)
{
osd_printf_error("Error creating primary DirectSound buffer: %08x\n", (unsigned)result);
goto error;
}
// attempt to set the primary format
result = m_primary_buffer.set_format(format);
if (result != DS_OK)
{
osd_printf_error("Error setting primary DirectSound buffer format: %08x\n", (unsigned)result);
goto error;
}
// log the primary format
WAVEFORMATEX primary_format;
result = m_primary_buffer.get_format(primary_format);
if (result != DS_OK)
{
osd_printf_error("Error getting primary DirectSound buffer format: %08x\n", (unsigned)result);
goto error;
}
osd_printf_verbose(
"DirectSound: Primary buffer: %d Hz, %d bits, %d channels\n",
(int)primary_format.nSamplesPerSec,
(int)primary_format.wBitsPerSample,
(int)primary_format.nChannels);
// create the stream buffer
result = m_stream_buffer.create(m_dsound, size, format);
if (result != DS_OK)
{
osd_printf_error("Error creating DirectSound stream buffer: %08x\n", (unsigned)result);
goto error;
}
// clear the buffer
result = m_stream_buffer.clear();
if (result != DS_OK)
{
osd_printf_error("Error locking DirectSound stream buffer: %08x\n", (unsigned)result);
goto error;
}
return DS_OK;
// error handling
error:
destroy_buffers();
return result;
}
void device_video_interface::interface_validity_check(validity_checker &valid) const
{
// only look up screens if we haven't explicitly requested no screen
screen_device *screen = NULL;
if (m_screen_tag != NULL)
{
// find the screen device if explicitly configured
if (strcmp(m_screen_tag, s_unconfigured_screen_tag) != 0)
{
screen = device().siblingdevice<screen_device>(m_screen_tag);
if (screen == NULL)
osd_printf_error("Screen '%s' not found, explicitly set for device '%s'\n", m_screen_tag, device().tag());
}
// otherwise, look for a single match
else
{
screen_device_iterator iter(device().mconfig().root_device());
screen = iter.first();
if (iter.next() != NULL)
osd_printf_error("No screen specified for device '%s', but multiple screens found\n", device().tag());
}
}
// error if no screen is found
if (screen == NULL && m_screen_required)
osd_printf_error("Device '%s' requires a screen\n", device().tag());
}
void timer_device::device_validity_check(validity_checker &valid) const
{
// type based configuration
switch (m_type)
{
case TIMER_TYPE_GENERIC:
if (m_screen_tag != nullptr || m_first_vpos != 0 || m_start_delay != attotime::zero)
osd_printf_warning("Generic timer specified parameters for a scanline timer\n");
if (m_period != attotime::zero || m_start_delay != attotime::zero)
osd_printf_warning("Generic timer specified parameters for a periodic timer\n");
break;
case TIMER_TYPE_PERIODIC:
if (m_screen_tag != nullptr || m_first_vpos != 0)
osd_printf_warning("Periodic timer specified parameters for a scanline timer\n");
if (m_period <= attotime::zero)
osd_printf_error("Periodic timer specified invalid period\n");
break;
case TIMER_TYPE_SCANLINE:
if (m_period != attotime::zero || m_start_delay != attotime::zero)
osd_printf_warning("Scanline timer specified parameters for a periodic timer\n");
if (m_param != 0)
osd_printf_warning("Scanline timer specified parameter which is ignored\n");
// if (m_first_vpos < 0)
// osd_printf_error("Scanline timer specified invalid initial position\n");
// if (m_increment < 0)
// osd_printf_error("Scanline timer specified invalid increment\n");
break;
default:
osd_printf_error("Invalid type specified\n");
break;
}
}
void plugin_options::parse_json(std::string path)
{
// first try to open as a directory
osd_directory *directory = osd_opendir(path.c_str());
if (directory != nullptr)
{
// iterate over all files in the directory
for (const osd_directory_entry *entry = osd_readdir(directory); entry != nullptr; entry = osd_readdir(directory))
{
if (entry->type == ENTTYPE_FILE)
{
std::string name = entry->name;
if (name == "plugin.json")
{
std::string curfile = std::string(path).append(PATH_SEPARATOR).append(entry->name);
std::ifstream ifs(curfile);
rapidjson::IStreamWrapper isw(ifs);
rapidjson::Document document;
document.ParseStream<0>(isw);
if (document.HasParseError()) {
std::string error(GetParseError_En(document.GetParseError()));
osd_printf_error("Unable to parse plugin definition file %s. Errors returned:\n", curfile.c_str());
osd_printf_error("%s\n", error.c_str());
return;
}
if (document["plugin"].IsObject())
{
std::string name = document["plugin"]["name"].GetString();
std::string description = document["plugin"]["description"].GetString();
std::string type = document["plugin"]["type"].GetString();
bool start = false;
if (document["plugin"].HasMember("start") && (std::string(document["plugin"]["start"].GetString()) == "true"))
start = true;
if (type=="plugin")
{
add_entry(core_strdup(name.c_str()),core_strdup(description.c_str()), OPTION_BOOLEAN, start ? "1" : "0");
}
}
}
}
else if (entry->type == ENTTYPE_DIR)
{
std::string name = entry->name;
if (!(name == "." || name == ".."))
{
parse_json(path + PATH_SEPARATOR + name);
}
}
}
// close the directory and be done
osd_closedir(directory);
}
}
void gio64_slot_device::device_validity_check(validity_checker &valid) const
{
if (m_slot_type == GIO64_SLOT_COUNT)
osd_printf_error("Slot type not defined\n");
device_t *const card(get_card_device());
if (card && !dynamic_cast<device_gio64_card_interface *>(card))
osd_printf_error("Card device %s (%s) does not implement device_gio64_card_interface\n", card->tag(), card->name());
}
inline void tcp_server::on_uv_connection(int status)
{
if (m_is_closing)
return;
int err;
if (status)
{
osd_printf_error("error while receiving a new TCP connection: %s\n", uv_strerror(status));
return;
}
// Notify the subclass so it provides an allocated derived class of TCPConnection.
tcp_connection* connection = nullptr;
user_on_tcp_connection_alloc(&connection);
if (connection == nullptr)
osd_printf_error("tcp_server pointer was not allocated by the user\n");
try
{
connection->setup(m_loop, this, &(m_local_addr), m_local_ip, m_local_port);
}
catch (...)
{
delete connection;
return;
}
// Accept the connection.
err = uv_accept((uv_stream_t*)m_uv_handle, (uv_stream_t*)connection->get_uv_handle());
if (err)
throw emu_fatalerror("uv_accept() failed: %s\n", uv_strerror(err));
// Insert the TCPConnection in the set.
m_connections.insert(connection);
// Start receiving data.
try
{
connection->start();
}
catch (emu_exception &error)
{
osd_printf_error("cannot run the TCP connection, closing the connection: %s\n", error.what());
connection->close();
// NOTE: Don't return here so the user won't be notified about a "onclose" for a TCP connection
// for which there was not a previous "onnew" event.
}
osd_printf_verbose("new TCP connection:\n");
connection->dump();
// Notify the subclass.
user_on_new_tcp_connection(connection);
}
void eeprom_base_device::device_validity_check(validity_checker &valid) const
{
// ensure the number of cells is an even power of 2
if (m_cells != (1 << m_address_bits))
osd_printf_error("Invalid EEPROM size %d specified\n", m_cells);
// ensure only the sizes we support are requested
if (m_data_bits != 8 && m_data_bits != 16)
osd_printf_error("Invalid EEPROM data width %d specified\n", m_data_bits);
}
void address_map::configure(address_spacenum spacenum, u8 databits)
{
if (spacenum != m_spacenum)
osd_printf_error("Space %d configured as address space %d\n", m_spacenum, spacenum);
if (m_databits == 0xff)
m_databits = databits;
else if (databits != m_databits)
osd_printf_error("Space %d configured with %d data bits when %d expected\n", m_spacenum, databits, m_databits);
}
void video_manager::begin_recording_mng(const char *name, uint32_t index, screen_device *screen)
{
// stop any existing recording
end_recording_mng(index);
mng_info_t &info = m_mngs[index];
// reset the state
info.m_mng_frame = 0;
info.m_mng_next_frame_time = machine().time();
// create a new movie file and start recording
info.m_mng_file = std::make_unique<emu_file>(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
osd_file::error filerr;
if (name != nullptr)
{
std::string full_name(name);
if (index > 0)
{
char name_buf[256] = { 0 };
snprintf(name_buf, 256, "%s%d", name, index);
full_name = name_buf;
}
filerr = info.m_mng_file->open(full_name.c_str());
}
else
{
filerr = open_next(*info.m_mng_file, "mng");
}
if (filerr == osd_file::error::NONE)
{
// start the capture
int rate = int(screen->frame_period().as_hz());
png_error pngerr = mng_capture_start(*info.m_mng_file, m_snap_bitmap, rate);
if (pngerr != PNGERR_NONE)
{
osd_printf_error("Error capturing MNG, png_error=%d\n", pngerr);
return end_recording_mng(index);
}
// compute the frame time
info.m_mng_frame_period = attotime::from_hz(rate);
}
else
{
osd_printf_error("Error creating MNG, osd_file::error=%d\n", int(filerr));
info.m_mng_file.reset();
}
}
void device_vtlb_interface::interface_validity_check(validity_checker &valid) const
{
const device_memory_interface *intf;
if (!device().interface(intf))
osd_printf_error("Device does not have memory interface\n");
else
{
// validate CPU information
const address_space_config *spaceconfig = intf->space_config(m_space);
if (spaceconfig == nullptr)
osd_printf_error("No memory address space configuration found for space %d\n", m_space);
else if ((1 << spaceconfig->m_page_shift) <= VTLB_FLAGS_MASK || spaceconfig->m_logaddr_width <= spaceconfig->m_page_shift)
osd_printf_error("Invalid page shift %d for VTLB\n", spaceconfig->m_page_shift);
}
}
void cheat_manager::load_cheats(const char *filename)
{
std::string searchstr(machine().options().cheat_path());
std::string curpath;
for (path_iterator path(searchstr); path.next(curpath); )
{
searchstr.append(";").append(curpath).append(PATH_SEPARATOR).append("cheat");
}
emu_file cheatfile(std::move(searchstr), OPEN_FLAG_READ);
try
{
// loop over all instrances of the files found in our search paths
for (osd_file::error filerr = cheatfile.open(filename, ".xml"); filerr == osd_file::error::NONE; filerr = cheatfile.open_next())
{
osd_printf_verbose("Loading cheats file from %s\n", cheatfile.fullpath());
// read the XML file into internal data structures
xml_parse_options options = { nullptr };
xml_parse_error error;
options.error = &error;
std::unique_ptr<xml_data_node, void (*)(xml_data_node *)> rootnode(xml_data_node::file_read(cheatfile, &options), [] (xml_data_node *node) { node->file_free(); });
// if unable to parse the file, just bail
if (rootnode == nullptr)
throw emu_fatalerror("%s.xml(%d): error parsing XML (%s)\n", filename, error.error_line, error.error_message);
// find the layout node
xml_data_node *mamecheatnode = rootnode->get_child("mamecheat");
if (mamecheatnode == nullptr)
throw emu_fatalerror("%s.xml: missing mamecheatnode node", filename);
// validate the config data version
int version = mamecheatnode->get_attribute_int("version", 0);
if (version != CHEAT_VERSION)
throw emu_fatalerror("%s.xml(%d): Invalid cheat XML file: unsupported version", filename, mamecheatnode->line);
// parse all the elements
for (xml_data_node const *cheatnode = mamecheatnode->get_child("cheat"); cheatnode != nullptr; cheatnode = cheatnode->get_next_sibling("cheat"))
{
// load this entry
auto curcheat = std::make_unique<cheat_entry>(*this, m_symtable, filename, *cheatnode);
// make sure we're not a duplicate
if (REMOVE_DUPLICATE_CHEATS && curcheat->is_duplicate())
{
osd_printf_verbose("Ignoring duplicate cheat '%s' from file %s\n", curcheat->description(), cheatfile.fullpath());
}
else // add to the end of the list
m_cheatlist.push_back(std::move(curcheat));
}
}
}
// handle errors cleanly
catch (emu_fatalerror &err)
{
osd_printf_error("%s\n", err.string());
m_cheatlist.clear();
}
}
void osd_common_t::init_subsystems()
{
if (!video_init())
{
video_exit();
osd_printf_error("video_init: Initialization failed!\n\n\n");
fflush(stderr);
fflush(stdout);
exit(-1);
}
input_init();
// we need pause callbacks
machine().add_notifier(MACHINE_NOTIFY_PAUSE, machine_notify_delegate(FUNC(osd_common_t::input_pause), this));
machine().add_notifier(MACHINE_NOTIFY_RESUME, machine_notify_delegate(FUNC(osd_common_t::input_resume), this));
output_init();
m_font_module = select_module_options<font_module *>(options(), OSD_FONT_PROVIDER);
m_sound = select_module_options<sound_module *>(options(), OSD_SOUND_PROVIDER);
m_sound->m_sample_rate = options().sample_rate();
m_sound->m_audio_latency = options().audio_latency();
m_debugger = select_module_options<debug_module *>(options(), OSD_DEBUG_PROVIDER);
select_module_options<netdev_module *>(options(), OSD_NETDEV_PROVIDER);
m_midi = select_module_options<midi_module *>(options(), OSD_MIDI_PROVIDER);
m_mod_man.init(options());
}
static int ddraw_create(win_window_info *window)
{
dd_info *dd = (dd_info *)window->drawdata;
HRESULT result;
int verify;
// if a device exists, free it
if (dd->ddraw != NULL)
ddraw_delete(window);
// create the DirectDraw object
result = (*directdrawcreateex)(dd->adapter_ptr, (LPVOID *)&dd->ddraw, WRAP_REFIID(IID_IDirectDraw7), NULL);
if (result != DD_OK)
{
osd_printf_verbose(_WINDOWS("DirectDraw: Error %08X during DirectDrawCreateEx call\n"), (int)result);
goto error;
}
// verify the caps
verify = ddraw_verify_caps(dd);
if (verify == 2)
{
osd_printf_error(_WINDOWS("DirectDraw: Error - Device does not meet minimum requirements for DirectDraw rendering\n"));
goto error;
}
if (verify == 1)
osd_printf_verbose(_WINDOWS("DirectDraw: Warning - Device may not perform well for DirectDraw rendering\n"));
// set the cooperative level
// for non-window modes, we will use full screen here
result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, win_window_list->hwnd, DDSCL_SETFOCUSWINDOW);
if (result != DD_OK)
{
osd_printf_verbose(_WINDOWS("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(FOCUSWINDOW) call\n"), (int)result);
goto error;
}
result = IDirectDraw7_SetCooperativeLevel(dd->ddraw, window->hwnd, DDSCL_SETDEVICEWINDOW | (window->fullscreen ? DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE : DDSCL_NORMAL));
if (result != DD_OK)
{
osd_printf_verbose(_WINDOWS("DirectDraw: Error %08X during IDirectDraw7_SetCooperativeLevel(DEVICEWINDOW) call\n"), (int)result);
goto error;
}
// full screen mode: set the resolution
if (window->fullscreen && video_config.switchres)
{
result = IDirectDraw7_SetDisplayMode(dd->ddraw, dd->width, dd->height, 32, dd->refresh, 0);
if (result != DD_OK)
{
osd_printf_verbose(_WINDOWS("DirectDraw: Error %08X attempting to set video mode %dx%d@%d call\n"), (int)result, dd->width, dd->height, dd->refresh);
goto error;
}
}
return ddraw_create_surfaces(window);
error:
ddraw_delete(window);
return 1;
}
void lua_engine::resume(lua_State *L, int nparam, lua_State *root)
{
int s = lua_resume(L, NULL, nparam);
switch(s) {
case LUA_OK:
if(!root) {
std::map<lua_State *, std::pair<lua_State *, int> >::iterator i = thread_registry.find(L);
if(i != thread_registry.end()) {
luaL_unref(i->second.first, LUA_REGISTRYINDEX, i->second.second);
thread_registry.erase(i);
}
} else
lua_pop(root, 1);
break;
case LUA_YIELD:
if(root) {
int id = luaL_ref(root, LUA_REGISTRYINDEX);
thread_registry[L] = std::pair<lua_State *, int>(root, id);
}
break;
default:
osd_printf_error("[LUA ERROR] %s\n", lua_tostring(L, -1));
lua_pop(L, 1);
break;
}
}
void device_sound_interface::interface_validity_check(validity_checker &valid) const
{
// loop over all the routes
for (sound_route const &route : routes())
{
// find a device with the requested tag
device_t const *const target = route.m_base.get().subdevice(route.m_target.c_str());
if (!target)
osd_printf_error("Attempting to route sound to non-existent device '%s'\n", route.m_base.get().subtag(route.m_target.c_str()).c_str());
// if it's not a speaker or a sound device, error
device_sound_interface const *sound;
if (target && (target->type() != SPEAKER) && !target->interface(sound))
osd_printf_error("Attempting to route sound to a non-sound device '%s' (%s)\n", target->tag(), target->name());
}
}
void video_manager::end_recording(movie_format format)
{
screen_device_iterator device_iterator = screen_device_iterator(machine().root_device());
screen_device_iterator::auto_iterator iter = device_iterator.begin();
const uint32_t count = (uint32_t)device_iterator.count();
switch (format)
{
case MF_AVI:
for (uint32_t index = 0; index < count; index++, iter++)
{
end_recording_avi(index);
if (!m_snap_native)
{
break;
}
}
break;
case MF_MNG:
for (uint32_t index = 0; index < count; index++, iter++)
{
end_recording_mng(index);
if (!m_snap_native)
{
break;
}
}
break;
default:
osd_printf_error("Unknown movie format: %d\n", format);
break;
}
}
void device_sound_interface::interface_validity_check(validity_checker &valid) const
{
// loop over all the routes
for (const sound_route *route = first_route(); route != NULL; route = route->next())
{
// find a device with the requested tag
const device_t *target = device().siblingdevice(route->m_target.c_str());
if (target == NULL)
osd_printf_error("Attempting to route sound to non-existant device '%s'\n", route->m_target.c_str());
// if it's not a speaker or a sound device, error
const device_sound_interface *sound;
if (target != NULL && target->type() != SPEAKER && !target->interface(sound))
osd_printf_error("Attempting to route sound to a non-sound device '%s' (%s)\n", route->m_target.c_str(), target->name());
}
}
void video_manager::save_snapshot(screen_device *screen, emu_file &file)
{
// validate
assert(!m_snap_native || screen != nullptr);
// create the bitmap to pass in
create_snapshot_bitmap(screen);
// add two text entries describing the image
std::string text1 = std::string(emulator_info::get_appname()).append(" ").append(build_version);
std::string text2 = std::string(machine().system().manufacturer).append(" ").append(machine().system().description);
png_info pnginfo = { nullptr };
png_add_text(&pnginfo, "Software", text1.c_str());
png_add_text(&pnginfo, "System", text2.c_str());
// now do the actual work
const rgb_t *palette = (screen != nullptr && screen->has_palette()) ? screen->palette().palette()->entry_list_adjusted() : nullptr;
int entries = (screen != nullptr && screen->has_palette()) ? screen->palette().entries() : 0;
png_error error = png_write_bitmap(file, &pnginfo, m_snap_bitmap, entries, palette);
if (error != PNGERR_NONE)
osd_printf_error("Error generating PNG for snapshot: png_error = %d\n", error);
// free any data allocated
png_free(&pnginfo);
}
bool cheat_manager::save_all(const char *filename)
{
// open the file with the proper name
emu_file cheatfile(machine().options().cheat_path(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
osd_file::error filerr = cheatfile.open(filename, ".xml");
// if that failed, return nothing
if (filerr != osd_file::error::NONE)
return false;
// wrap the rest of catch errors
try
{
// output the outer layers
cheatfile.printf("<?xml version=\"1.0\"?>\n");
cheatfile.printf("<!-- This file is autogenerated; comments and unknown tags will be stripped -->\n");
cheatfile.printf("<mamecheat version=\"%d\">\n", CHEAT_VERSION);
// iterate over cheats in the list and save them
for (auto &cheat : m_cheatlist)
cheat->save(cheatfile);
// close out the file
cheatfile.printf("</mamecheat>\n");
return true;
}
// catch errors and cleanup
catch (emu_fatalerror &err)
{
osd_printf_error("%s\n", err.string());
cheatfile.remove_on_close();
}
return false;
}
void interpro_mouse_port_device::device_validity_check(validity_checker &valid) const
{
device_t *const card(get_card_device());
if (card && !dynamic_cast<device_interpro_mouse_port_interface *>(card))
osd_printf_error("Device %s (%s) does not implement device_interpro_mouse_port_interface\n", card->tag(), card->name());
}
int pcap_module::init(const osd_options &options)
{
pcap_if_t *devs;
char errbuf[PCAP_ERRBUF_SIZE];
// FIXME: bridge between pcap_module and netdev_pcap
module = this;
if ((*pcap_findalldevs_dl)(&devs, errbuf) == -1)
{
osd_printf_error("Unable to get network devices: %s\n", errbuf);
return 1;
}
while(devs)
{
if(devs->description) {
add_netdev(devs->name, devs->description, create_pcap);
} else {
add_netdev(devs->name, devs->name, create_pcap);
}
devs = devs->next;
}
return 0;
}
void device_execute_interface::interface_validity_check(validity_checker &valid) const
{
// validate the interrupts
if (!m_vblank_interrupt.isnull())
{
screen_device_iterator iter(device().mconfig().root_device());
if (iter.first() == NULL)
osd_printf_error("VBLANK interrupt specified, but the driver is screenless\n");
else if (m_vblank_interrupt_screen != NULL && device().siblingdevice(m_vblank_interrupt_screen) == NULL)
osd_printf_error("VBLANK interrupt references a non-existant screen tag '%s'\n", m_vblank_interrupt_screen);
}
if (!m_timed_interrupt.isnull() && m_timed_interrupt_period == attotime::zero)
osd_printf_error("Timed interrupt handler specified with 0 period\n");
else if (m_timed_interrupt.isnull() && m_timed_interrupt_period != attotime::zero)
osd_printf_error("No timer interrupt handler specified, but has a non-0 period given\n");
}
void netdev_pcap::set_mac(const char *mac)
{
char filter[256];
struct bpf_program fp;
if(!m_p) return;
#ifdef SDLMAME_MACOSX
sprintf(filter, "not ether src %.2X:%.2X:%.2X:%.2X:%.2X:%.2X and (ether dst %.2X:%.2X:%.2X:%.2X:%.2X:%.2X or ether multicast or ether broadcast or ether dst 09:00:07:ff:ff:ff)", (unsigned char)mac[0], (unsigned char)mac[1], (unsigned char)mac[2],(unsigned char)mac[3], (unsigned char)mac[4], (unsigned char)mac[5], (unsigned char)mac[0], (unsigned char)mac[1], (unsigned char)mac[2],(unsigned char)mac[3], (unsigned char)mac[4], (unsigned char)mac[5]);
#else
sprintf(filter, "ether dst %.2X:%.2X:%.2X:%.2X:%.2X:%.2X or ether multicast or ether broadcast", (unsigned char)mac[0], (unsigned char)mac[1], (unsigned char)mac[2],(unsigned char)mac[3], (unsigned char)mac[4], (unsigned char)mac[5]);
#endif
if ((*module->pcap_compile_dl)(m_p, &fp, filter, 1, 0) == -1) {
osd_printf_error("Error with pcap_compile\n");
}
if ((*module->pcap_setfilter_dl)(m_p, &fp) == -1) {
osd_printf_error("Error with pcap_setfilter\n");
}
}
void avi_write::audio_frame(const int16_t *buffer, int samples_this_frame)
{
// only record if we have a file
if (m_output_file != nullptr)
{
// write the next frame
avi_file::error avierr = m_output_file->append_sound_samples(0, buffer + 0, samples_this_frame, 1);
if (avierr == avi_file::error::NONE)
avierr = m_output_file->append_sound_samples(1, buffer + 1, samples_this_frame, 1);
if (avierr != avi_file::error::NONE)
{
osd_printf_error("Error while logging AVI audio frame: %s\n", avi_file::error_string(avierr));
osd_printf_error("Stopping AVI recording.\n");
end_avi_recording();
}
}
}
void watchdog_timer_device::device_validity_check(validity_checker &valid) const
{
if (m_vblank_count != 0)
{
screen_device *screen = dynamic_cast<screen_device *>(siblingdevice(m_screen_tag));
if (screen == nullptr)
osd_printf_error("Invalid screen tag specified\n");
}
}
static void get_resolution(const char *defdata, const char *data, osd_window_config *config, int report_error)
{
config->width = config->height = config->depth = config->refresh = 0;
if (strcmp(data, OSDOPTVAL_AUTO) == 0)
{
if (strcmp(defdata, OSDOPTVAL_AUTO) == 0)
return;
data = defdata;
}
if (sscanf(data, "%dx%dx%d", &config->width, &config->height, &config->depth) < 2 && report_error)
osd_printf_error("Illegal resolution value = %s\n", data);
const char * at_pos = strchr(data, '@');
if (at_pos)
if (sscanf(at_pos + 1, "%d", &config->refresh) < 1 && report_error)
osd_printf_error("Illegal refresh rate in resolution value = %s\n", data);
}
