void nesapu_device::calculate_rates() { int rate = clock() / 4; screen_device *screen = machine().first_screen(); if (screen != nullptr) { m_samps_per_sync = rate / ATTOSECONDS_TO_HZ(machine().first_screen()->frame_period().attoseconds()); m_real_rate = m_samps_per_sync * ATTOSECONDS_TO_HZ(machine().first_screen()->frame_period().attoseconds()); } else { m_samps_per_sync = rate / screen_device::DEFAULT_FRAME_RATE; m_real_rate = m_samps_per_sync * screen_device::DEFAULT_FRAME_RATE; } m_buffer_size = m_samps_per_sync; m_apu_incsize = float(clock() / (float) m_real_rate); create_vbltimes(m_vbl_times,vbl_length,m_samps_per_sync); create_syncs(m_samps_per_sync); /* Adjust buffer size if 16 bits */ m_buffer_size+=m_samps_per_sync; if (m_stream != nullptr) m_stream->set_sample_rate(rate); else m_stream = machine().sound().stream_alloc(*this, 0, 1, rate); }
void k053252_device::res_change() { if(m_hc && m_vc && m_hbp && m_hfp && m_vbp && m_vfp && m_hsw && m_vsw) //safety checks { rectangle visarea; //(HC+1) - HFP - HBP - 8*(HSW+1) //VC - VFP - VBP - (VSW+1) attoseconds_t refresh = HZ_TO_ATTOSECONDS(clock()) * (m_hc) * m_vc; visarea.min_x = m_offsx; visarea.min_y = m_offsy; visarea.max_x = m_offsx + m_hc - m_hfp - m_hbp - 8*(m_hsw) - 1; visarea.max_y = m_offsy + m_vc - m_vfp - m_vbp - (m_vsw) - 1; m_screen->configure(m_hc, m_vc, visarea, refresh); if (m_slave_screen.found()) m_slave_screen->configure(m_hc, m_vc, visarea, refresh); #if 0 attoseconds_t hsync = HZ_TO_ATTOSECONDS(clock()) * (m_hc); printf("H %d HFP %d HSW %d HBP %d\n",m_hc,m_hfp,m_hsw*8,m_hbp); printf("V %d VFP %d VSW %d VBP %d\n",m_vc,m_vfp,m_vsw,m_vbp); // L stands for Legacy ... printf("L %d %d\n",m_offsx,m_offsy); printf("Screen params: Clock: %u V-Sync %.2f H-Sync %.f\n",clock(),ATTOSECONDS_TO_HZ(refresh),ATTOSECONDS_TO_HZ(hsync)); printf("visible screen area: %d x %d\n\n",(visarea.max_x - visarea.min_x) + 1,(visarea.max_y - visarea.min_y) + 1); #endif } }
void video_manager::update_refresh_speed() { // only do this if the refreshspeed option is used if (machine().options().refresh_speed()) { double minrefresh = machine().render().max_update_rate(); if (minrefresh != 0) { // find the screen with the shortest frame period (max refresh rate) // note that we first check the token since this can get called before all screens are created attoseconds_t min_frame_period = ATTOSECONDS_PER_SECOND; screen_device_iterator iter(machine().root_device()); for (screen_device *screen = iter.first(); screen != nullptr; screen = iter.next()) { attoseconds_t period = screen->frame_period().attoseconds(); if (period != 0) min_frame_period = MIN(min_frame_period, period); } // compute a target speed as an integral percentage // note that we lop 0.25Hz off of the minrefresh when doing the computation to allow for // the fact that most refresh rates are not accurate to 10 digits... UINT32 target_speed = floor((minrefresh - 0.25) * 1000.0 / ATTOSECONDS_TO_HZ(min_frame_period)); UINT32 original_speed = original_speed_setting(); target_speed = MIN(target_speed, original_speed); // if we changed, log that verbosely if (target_speed != m_speed) { osd_printf_verbose("Adjusting target speed to %.1f%% (hw=%.2fHz, game=%.2fHz, adjusted=%.2fHz)\n", target_speed / 10.0, minrefresh, ATTOSECONDS_TO_HZ(min_frame_period), ATTOSECONDS_TO_HZ(min_frame_period * 1000.0 / target_speed)); m_speed = target_speed; } } } }
void avi_write::begin_avi_recording(const char *name) { // stop any existing recording end_avi_recording(); // reset the state m_frame = 0; m_next_frame_time = m_machine.time(); const screen_device *primary_screen = screen_device_iterator(m_machine.root_device()).first(); // build up information about this new movie avi_file::movie_info info; info.video_format = 0; info.video_timescale = 1000 * (primary_screen ? ATTOSECONDS_TO_HZ(primary_screen->frame_period().m_attoseconds) : screen_device::DEFAULT_FRAME_RATE); info.video_sampletime = 1000; info.video_numsamples = 0; info.video_width = m_width; info.video_height = m_height; info.video_depth = 24; info.audio_format = 0; info.audio_timescale = m_machine.sample_rate(); info.audio_sampletime = 1; info.audio_numsamples = 0; info.audio_channels = 2; info.audio_samplebits = 16; info.audio_samplerate = m_machine.sample_rate(); // compute the frame time m_frame_period = attotime::from_seconds(1000) / info.video_timescale; // create a new temporary movie file emu_file tempfile(m_machine.options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); const osd_file::error filerr = (!name || !name[0] || !std::strcmp(name, OSDOPTVAL_AUTO)) ? m_machine.video().open_next(tempfile, "avi") : tempfile.open(name); // if we succeeded, make a copy of the name and create the real file over top if (filerr == osd_file::error::NONE) { const std::string fullpath = tempfile.fullpath(); tempfile.close(); // create the file and free the string avi_file::error avierr = avi_file::create(fullpath, info, m_output_file); if (avierr != avi_file::error::NONE) { osd_printf_error("Error creating AVI: %s\n", avi_file::error_string(avierr)); } else { m_recording = true; } } }
static TIMER_CALLBACK( senjyo_sh_update ) { /* ctc2 timer single tone generator frequency */ attotime period = z80ctc_getperiod (0, 2); if (attotime_compare(period, attotime_zero) != 0 ) single_rate = ATTOSECONDS_TO_HZ(period.attoseconds); else single_rate = 0; sample_set_freq(0,single_rate); }
static INTERRUPT_GEN( vblank_callback ) { /* also update the speaker on the European version */ beep_device *beep = device->machine->device<beep_device>("beep"); if (beep != NULL) { z80ctc_device *ctc = device->machine->device<z80ctc_device>("ctc"); beep_set_state(beep, 1); beep_set_frequency(beep, ATTOSECONDS_TO_HZ(ctc->period(0).attoseconds)); } }
menu_autofire::menu_autofire(mame_ui_manager &mui, render_container &container) : menu(mui, container), last_toggle(false) { const screen_device *screen = mui.machine().first_screen(); if (screen == nullptr) { refresh = 60.0; } else { refresh = ATTOSECONDS_TO_HZ(screen->refresh_attoseconds()); } }
ui_menu_autofire::ui_menu_autofire(running_machine &machine, render_container *container) : ui_menu(machine, container), last_toggle(false) { const screen_device *screen = machine.first_screen(); if (screen == nullptr) { refresh = 60.0; } else { refresh = ATTOSECONDS_TO_HZ(screen->refresh_attoseconds()); } }
ui_menu_autofire::ui_menu_autofire(running_machine &machine, render_container *container) : ui_menu(machine, container) { screen_device_iterator iter(machine.root_device()); const screen_device *screen = iter.first(); if (screen == nullptr) { refresh = 60.0; } else { refresh = ATTOSECONDS_TO_HZ(screen->refresh_attoseconds()); } }
static TIMER_CALLBACK( senjyo_sh_update ) { running_device *samples = machine->device("samples"); /* ctc2 timer single tone generator frequency */ z80ctc_device *ctc = machine->device<z80ctc_device>("z80ctc"); attotime period = ctc->period(2); if (attotime_compare(period, attotime_zero) != 0 ) single_rate = ATTOSECONDS_TO_HZ(period.attoseconds); else single_rate = 0; sample_set_freq(samples, 0,single_rate); }
static TIMER_CALLBACK( senjyo_sh_update ) { device_t *samples = machine->device("samples"); senjyo_state *state = machine->driver_data<senjyo_state>(); /* ctc2 timer single tone generator frequency */ z80ctc_device *ctc = machine->device<z80ctc_device>("z80ctc"); attotime period = ctc->period(2); if (period != attotime::zero) state->single_rate = ATTOSECONDS_TO_HZ(period.attoseconds); else state->single_rate = 0; sample_set_freq(samples, 0, state->single_rate); }
static void pick_best_mode(win_window_info *window) { dd_info *dd = (dd_info *)window->drawdata; mode_enum_info einfo; HRESULT result; // determine the minimum width/height for the selected target // note: technically we should not be calling this from an alternate window // thread; however, it is only done during init time, and the init code on // the main thread is waiting for us to finish, so it is safe to do so here window->target->compute_minimum_size(einfo.minimum_width, einfo.minimum_height); // use those as the target for now einfo.target_width = einfo.minimum_width * MAX(1, video_config.prescale); einfo.target_height = einfo.minimum_height * MAX(1, video_config.prescale); // determine the refresh rate of the primary screen einfo.target_refresh = 60.0; const screen_device *primary_screen = window->machine().config().first_screen(); if (primary_screen != NULL) einfo.target_refresh = ATTOSECONDS_TO_HZ(primary_screen->refresh_attoseconds()); printf("Target refresh = %f\n", einfo.target_refresh); // if we're not stretching, allow some slop on the minimum since we can handle it if (!video_config.hwstretch) { einfo.minimum_width -= 4; einfo.minimum_height -= 4; } // if we are stretching, aim for a mode approximately 2x the game's resolution else if (video_config.prescale <= 1) { einfo.target_width *= 2; einfo.target_height *= 2; } // fill in the rest of the data einfo.window = window; einfo.best_score = 0.0f; // enumerate the modes mame_printf_verbose("DirectDraw: Selecting video mode...\n"); result = IDirectDraw7_EnumDisplayModes(dd->ddraw, DDEDM_REFRESHRATES, NULL, &einfo, enum_modes_callback); if (result != DD_OK) mame_printf_verbose("DirectDraw: Error %08X during EnumDisplayModes call\n", (int)result); mame_printf_verbose("DirectDraw: Mode selected = %4dx%4d@%3dHz\n", dd->width, dd->height, dd->refresh); }
uint8_t z80ctc_device::ctc_channel::read() { // if we're in counter mode, just return the count if ((m_mode & MODE) == MODE_COUNTER || (m_mode & WAITING_FOR_TRIG)) return m_down; // else compute the down counter value else { attotime period = ((m_mode & PRESCALER) == PRESCALER_16) ? m_device->m_period16 : m_device->m_period256; VPRINTF_CHANNEL(("CTC clock %f\n",ATTOSECONDS_TO_HZ(period.attoseconds()))); if (m_timer != nullptr) return ((int)(m_timer->remaining().as_double() / period.as_double()) + 1) & 0xff; else return 0; } }
std::string machine_info::game_info_string() { std::ostringstream buf; // print description, manufacturer, and CPU: util::stream_format(buf, _("%1$s\n%2$s %3$s\nDriver: %4$s\n\nCPU:\n"), m_machine.system().description, m_machine.system().year, m_machine.system().manufacturer, core_filename_extract_base(m_machine.system().source_file)); // loop over all CPUs execute_interface_iterator execiter(m_machine.root_device()); std::unordered_set<std::string> exectags; for (device_execute_interface &exec : execiter) { if (!exectags.insert(exec.device().tag()).second) continue; // get cpu specific clock that takes internal multiplier/dividers into account int clock = exec.device().clock(); // count how many identical CPUs we have int count = 1; const char *name = exec.device().name(); for (device_execute_interface &scan : execiter) { if (exec.device().type() == scan.device().type() && strcmp(name, scan.device().name()) == 0 && exec.device().clock() == scan.device().clock()) if (exectags.insert(scan.device().tag()).second) count++; } // if more than one, prepend a #x in front of the CPU name // display clock in kHz or MHz util::stream_format(buf, (count > 1) ? "%1$d" UTF8_MULTIPLY "%2$s %3$d.%4$0*5$d%6$s\n" : "%2$s %3$d.%4$0*5$d%6$s\n", count, name, (clock >= 1000000) ? (clock / 1000000) : (clock / 1000), (clock >= 1000000) ? (clock % 1000000) : (clock % 1000), (clock >= 1000000) ? 6 : 3, (clock >= 1000000) ? _("MHz") : _("kHz")); } // loop over all sound chips sound_interface_iterator snditer(m_machine.root_device()); std::unordered_set<std::string> soundtags; bool found_sound = false; for (device_sound_interface &sound : snditer) { if (!soundtags.insert(sound.device().tag()).second) continue; // append the Sound: string if (!found_sound) buf << _("\nSound:\n"); found_sound = true; // count how many identical sound chips we have int count = 1; for (device_sound_interface &scan : snditer) { if (sound.device().type() == scan.device().type() && sound.device().clock() == scan.device().clock()) if (soundtags.insert(scan.device().tag()).second) count++; } // if more than one, prepend a #x in front of the CPU name // display clock in kHz or MHz int clock = sound.device().clock(); util::stream_format(buf, (count > 1) ? ((clock != 0) ? "%1$d" UTF8_MULTIPLY "%2$s %3$d.%4$0*5$d%6$s\n" : "%1$d" UTF8_MULTIPLY "%2$s\n") : ((clock != 0) ? "%2$s %3$d.%4$0*5$d%6$s\n" : "%2$s\n"), count, sound.device().name(), (clock >= 1000000) ? (clock / 1000000) : (clock / 1000), (clock >= 1000000) ? (clock % 1000000) : (clock % 1000), (clock >= 1000000) ? 6 : 3, (clock >= 1000000) ? _("MHz") : _("kHz")); } // display screen information buf << _("\nVideo:\n"); screen_device_iterator scriter(m_machine.root_device()); int scrcount = scriter.count(); if (scrcount == 0) buf << _("None\n"); else { for (screen_device &screen : scriter) { std::string detail; if (screen.screen_type() == SCREEN_TYPE_VECTOR) detail = _("Vector"); else { const rectangle &visarea = screen.visible_area(); detail = string_format("%d " UTF8_MULTIPLY " %d (%s) %f" UTF8_NBSP "Hz", visarea.width(), visarea.height(), (m_machine.system().flags & ORIENTATION_SWAP_XY) ? "V" : "H", ATTOSECONDS_TO_HZ(screen.frame_period().attoseconds())); } util::stream_format(buf, (scrcount > 1) ? _("%1$s: %2$s\n") : _("%2$s\n"), get_screen_desc(screen), detail); } } return buf.str(); }
static int is_ntsc(running_machine *machine) { return ATTOSECONDS_TO_HZ(video_screen_get_frame_period(machine->primary_screen).attoseconds) > 55; }
void ui_menu_device_config::populate() { astring string; device_t *dev; string.printf("[This option is%s currently mounted in the running system]\n\n", m_mounted ? "" : " NOT"); string.catprintf("Option: %s\n", m_option->name()); dev = const_cast<machine_config &>(machine().config()).device_add(&machine().config().root_device(), m_option->name(), m_option->devtype(), 0); string.catprintf("Device: %s\n", dev->name()); if (!m_mounted) string.cat("\nIf you select this option, the following items will be enabled:\n"); else string.cat("\nThe selected option enables the following items:\n"); // loop over all CPUs execute_interface_iterator execiter(*dev); if (execiter.count() > 0) { string.cat("* CPU:\n"); tagmap_t<UINT8> exectags; for (device_execute_interface *exec = execiter.first(); exec != NULL; exec = execiter.next()) { if (exectags.add(exec->device().tag(), 1, FALSE) == TMERR_DUPLICATE) continue; // get cpu specific clock that takes internal multiplier/dividers into account int clock = exec->device().clock(); // count how many identical CPUs we have int count = 1; const char *name = exec->device().name(); execute_interface_iterator execinneriter(*dev); for (device_execute_interface *scan = execinneriter.first(); scan != NULL; scan = execinneriter.next()) { if (exec->device().type() == scan->device().type() && strcmp(name, scan->device().name()) == 0 && exec->device().clock() == scan->device().clock()) if (exectags.add(scan->device().tag(), 1, FALSE) != TMERR_DUPLICATE) count++; } // if more than one, prepend a #x in front of the CPU name if (count > 1) string.catprintf(" %d" UTF8_MULTIPLY, count); else string.cat(" "); string.cat(name); // display clock in kHz or MHz if (clock >= 1000000) string.catprintf(" %d.%06d" UTF8_NBSP "MHz\n", clock / 1000000, clock % 1000000); else string.catprintf(" %d.%03d" UTF8_NBSP "kHz\n", clock / 1000, clock % 1000); } } // display screen information screen_device_iterator scriter(*dev); if (scriter.count() > 0) { string.cat("* Video:\n"); for (screen_device *screen = scriter.first(); screen != NULL; screen = scriter.next()) { string.catprintf(" Screen '%s': ", screen->tag()); if (screen->screen_type() == SCREEN_TYPE_VECTOR) string.cat("Vector\n"); else { const rectangle &visarea = screen->visible_area(); string.catprintf("%d " UTF8_MULTIPLY " %d (%s) %f" UTF8_NBSP "Hz\n", visarea.width(), visarea.height(), (machine().system().flags & ORIENTATION_SWAP_XY) ? "V" : "H", ATTOSECONDS_TO_HZ(screen->frame_period().attoseconds)); } } } // loop over all sound chips sound_interface_iterator snditer(*dev); if (snditer.count() > 0) { string.cat("* Sound:\n"); tagmap_t<UINT8> soundtags; for (device_sound_interface *sound = snditer.first(); sound != NULL; sound = snditer.next()) { if (soundtags.add(sound->device().tag(), 1, FALSE) == TMERR_DUPLICATE) continue; // count how many identical sound chips we have int count = 1; sound_interface_iterator sndinneriter(*dev); for (device_sound_interface *scan = sndinneriter.first(); scan != NULL; scan = sndinneriter.next()) { if (sound->device().type() == scan->device().type() && sound->device().clock() == scan->device().clock()) if (soundtags.add(scan->device().tag(), 1, FALSE) != TMERR_DUPLICATE) count++; } // if more than one, prepend a #x in front of the CPU name if (count > 1) string.catprintf(" %d" UTF8_MULTIPLY, count); else string.cat(" "); string.cat(sound->device().name()); // display clock in kHz or MHz int clock = sound->device().clock(); if (clock >= 1000000) string.catprintf(" %d.%06d" UTF8_NBSP "MHz\n", clock / 1000000, clock % 1000000); else if (clock != 0) string.catprintf(" %d.%03d" UTF8_NBSP "kHz\n", clock / 1000, clock % 1000); else string.cat("\n"); } } // scan for BIOS settings int bios = 0; if (dev->rom_region()) { astring bios_str; // first loop through roms in search of default bios (shortname) for (const rom_entry *rom = dev->rom_region(); !ROMENTRY_ISEND(rom); rom++) if (ROMENTRY_ISDEFAULT_BIOS(rom)) bios_str.cpy(ROM_GETNAME(rom)); // then loop again to count bios options and to get the default bios complete name for (const rom_entry *rom = dev->rom_region(); !ROMENTRY_ISEND(rom); rom++) { if (ROMENTRY_ISSYSTEM_BIOS(rom)) { bios++; if (bios_str == ROM_GETNAME(rom)) bios_str.cpy(ROM_GETHASHDATA(rom)); } } if (bios) string.catprintf("* BIOS settings:\n %d options [default: %s]\n", bios, bios_str.cstr()); } int input = 0, input_mj = 0, input_hana = 0, input_gamble = 0, input_analog = 0, input_adjust = 0; int input_keypad = 0, input_keyboard = 0, dips = 0, confs = 0; astring errors, dips_opt, confs_opt; ioport_list portlist; device_iterator iptiter(*dev); for (device_t *iptdev = iptiter.first(); iptdev != NULL; iptdev = iptiter.next()) portlist.append(*iptdev, errors); // check if the device adds inputs to the system for (ioport_port *port = portlist.first(); port != NULL; port = port->next()) for (ioport_field *field = port->first_field(); field != NULL; field = field->next()) { if (field->type() >= IPT_MAHJONG_FIRST && field->type() < IPT_MAHJONG_LAST) input_mj++; else if (field->type() >= IPT_HANAFUDA_FIRST && field->type() < IPT_HANAFUDA_LAST) input_hana++; else if (field->type() >= IPT_GAMBLING_FIRST && field->type() < IPT_GAMBLING_LAST) input_gamble++; else if (field->type() >= IPT_ANALOG_FIRST && field->type() < IPT_ANALOG_LAST) input_analog++; else if (field->type() == IPT_ADJUSTER) input_adjust++; else if (field->type() == IPT_KEYPAD) input_keypad++; else if (field->type() == IPT_KEYBOARD) input_keyboard++; else if (field->type() >= IPT_START1 && field->type() < IPT_UI_FIRST) input++; else if (field->type() == IPT_DIPSWITCH) { dips++; dips_opt.cat(" ").cat(field->name()); for (ioport_setting *setting = field->first_setting(); setting != NULL; setting = setting->next()) { if (setting->value() == field->defvalue()) { dips_opt.catprintf(" [default: %s]\n", setting->name()); break; } } } else if (field->type() == IPT_CONFIG) { confs++; confs_opt.cat(" ").cat(field->name()); for (ioport_setting *setting = field->first_setting(); setting != NULL; setting = setting->next()) { if (setting->value() == field->defvalue()) { confs_opt.catprintf(" [default: %s]\n", setting->name()); break; } } } } if (dips) string.cat("* Dispwitch settings:\n").cat(dips_opt); if (confs) string.cat("* Configuration settings:\n").cat(confs_opt); if (input + input_mj + input_hana + input_gamble + input_analog + input_adjust + input_keypad + input_keyboard) string.cat("* Input device(s):\n"); if (input) string.catprintf(" User inputs [%d inputs]\n", input); if (input_mj) string.catprintf(" Mahjong inputs [%d inputs]\n", input_mj); if (input_hana) string.catprintf(" Hanafuda inputs [%d inputs]\n", input_hana); if (input_gamble) string.catprintf(" Gambling inputs [%d inputs]\n", input_gamble); if (input_analog) string.catprintf(" Analog inputs [%d inputs]\n", input_analog); if (input_adjust) string.catprintf(" Adjuster inputs [%d inputs]\n", input_adjust); if (input_keypad) string.catprintf(" Keypad inputs [%d inputs]\n", input_keypad); if (input_keyboard) string.catprintf(" Keyboard inputs [%d inputs]\n", input_keyboard); image_interface_iterator imgiter(*dev); if (imgiter.count() > 0) { string.cat("* Media Options:\n"); for (const device_image_interface *imagedev = imgiter.first(); imagedev != NULL; imagedev = imgiter.next()) string.catprintf(" %s [tag: %s]\n", imagedev->image_type_name(), imagedev->device().tag()); } slot_interface_iterator slotiter(*dev); if (slotiter.count() > 0) { string.cat("* Slot Options:\n"); for (const device_slot_interface *slot = slotiter.first(); slot != NULL; slot = slotiter.next()) string.catprintf(" %s [default: %s]\n", slot->device().tag(), slot->default_option() ? slot->default_option() : "----"); } if ((execiter.count() + scriter.count() + snditer.count() + imgiter.count() + slotiter.count() + bios + dips + confs + input + input_mj + input_hana + input_gamble + input_analog + input_adjust + input_keypad + input_keyboard) == 0) string.cat("[None]\n"); const_cast<machine_config &>(machine().config()).device_remove(&machine().config().root_device(), m_option->name()); item_append(string, NULL, MENU_FLAG_MULTILINE, NULL); }
void video_manager::begin_recording(const char *name, movie_format format) { // create a snapshot bitmap so we know what the target size is create_snapshot_bitmap(nullptr); // start up an AVI recording if (format == MF_AVI) { // stop any existing recording end_recording(format); // reset the state m_avi_frame = 0; m_avi_next_frame_time = machine().time(); // build up information about this new movie screen_device *screen = machine().first_screen(); avi_file::movie_info info; info.video_format = 0; info.video_timescale = 1000 * ((screen != nullptr) ? ATTOSECONDS_TO_HZ(screen->frame_period().attoseconds()) : screen_device::DEFAULT_FRAME_RATE); info.video_sampletime = 1000; info.video_numsamples = 0; info.video_width = m_snap_bitmap.width(); info.video_height = m_snap_bitmap.height(); info.video_depth = 24; info.audio_format = 0; info.audio_timescale = machine().sample_rate(); info.audio_sampletime = 1; info.audio_numsamples = 0; info.audio_channels = 2; info.audio_samplebits = 16; info.audio_samplerate = machine().sample_rate(); // create a new temporary movie file osd_file::error filerr; std::string fullpath; { emu_file tempfile(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); if (name != nullptr) filerr = tempfile.open(name); else filerr = open_next(tempfile, "avi"); // if we succeeded, make a copy of the name and create the real file over top if (filerr == osd_file::error::NONE) fullpath = tempfile.fullpath(); } if (filerr == osd_file::error::NONE) { // compute the frame time m_avi_frame_period = attotime::from_seconds(1000) / info.video_timescale; // create the file and free the string avi_file::error avierr = avi_file::create(fullpath, info, m_avi_file); if (avierr != avi_file::error::NONE) { osd_printf_error("Error creating AVI: %s\n", avi_file::error_string(avierr)); return end_recording(format); } } } // start up a MNG recording else if (format == MF_MNG) { // stop any existing recording end_recording(format); // reset the state m_mng_frame = 0; m_mng_next_frame_time = machine().time(); // create a new movie file and start recording 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) filerr = m_mng_file->open(name); else filerr = open_next(*m_mng_file, "mng"); if (filerr == osd_file::error::NONE) { // start the capture screen_device *screen = machine().first_screen(); int rate = (screen != nullptr) ? ATTOSECONDS_TO_HZ(screen->frame_period().attoseconds()) : screen_device::DEFAULT_FRAME_RATE; png_error pngerr = mng_capture_start(*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(format); } // compute the frame time m_mng_frame_period = attotime::from_hz(rate); } else { osd_printf_error("Error creating MNG, osd_file::error=%d\n", int(filerr)); m_mng_file.reset(); } } }
void video_manager::begin_recording(const char *name, movie_format format) { // stop any existign recording end_recording(); // create a snapshot bitmap so we know what the target size is create_snapshot_bitmap(NULL); // reset the state m_movie_frame = 0; m_movie_next_frame_time = machine().time(); // start up an AVI recording if (format == MF_AVI) { // build up information about this new movie avi_movie_info info; info.video_format = 0; info.video_timescale = 1000 * ((machine().primary_screen != NULL) ? ATTOSECONDS_TO_HZ(machine().primary_screen->frame_period().attoseconds) : screen_device::DEFAULT_FRAME_RATE); info.video_sampletime = 1000; info.video_numsamples = 0; info.video_width = m_snap_bitmap.width(); info.video_height = m_snap_bitmap.height(); info.video_depth = 24; info.audio_format = 0; info.audio_timescale = machine().sample_rate(); info.audio_sampletime = 1; info.audio_numsamples = 0; info.audio_channels = 2; info.audio_samplebits = 16; info.audio_samplerate = machine().sample_rate(); // create a new temporary movie file file_error filerr; astring fullpath; { emu_file tempfile(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS); if (name != NULL) filerr = tempfile.open(name); else filerr = open_next(tempfile, "avi"); // compute the frame time m_movie_frame_period = attotime::from_seconds(1000) / info.video_timescale; // if we succeeded, make a copy of the name and create the real file over top if (filerr == FILERR_NONE) fullpath = tempfile.fullpath(); } if (filerr == FILERR_NONE) { // create the file and free the string avi_error avierr = avi_create(fullpath, &info, &m_avifile); if (avierr != AVIERR_NONE) mame_printf_error("Error creating AVI: %s\n", avi_error_string(avierr)); } } // start up a MNG recording else if (format == MF_MNG) { // create a new movie file and start recording m_mngfile = auto_alloc(machine(), emu_file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS)); file_error filerr; if (name != NULL) filerr = m_mngfile->open(name); else filerr = open_next(*m_mngfile, "mng"); if (filerr == FILERR_NONE) { // start the capture int rate = (machine().primary_screen != NULL) ? ATTOSECONDS_TO_HZ(machine().primary_screen->frame_period().attoseconds) : screen_device::DEFAULT_FRAME_RATE; png_error pngerr = mng_capture_start(*m_mngfile, m_snap_bitmap, rate); if (pngerr != PNGERR_NONE) return end_recording(); // compute the frame time m_movie_frame_period = attotime::from_hz(rate); } else { mame_printf_error("Error creating MNG\n"); global_free(m_mngfile); m_mngfile = NULL; } } }
int load_driver_mameinfo(const game_driver *drv, char *buffer, int bufsize, int filenum) { machine_config config(*drv, MameUIGlobal()); const game_driver *parent = NULL; char name[512]; int mameinfo = 0; int is_bios = 0; *buffer = 0; if (filenum) snprintf(filename, ARRAY_LENGTH(filename), "%s\\messinfo.dat", GetDatsDir()); else snprintf(filename, ARRAY_LENGTH(filename), "%s\\mameinfo.dat", GetDatsDir()); if (filenum) strcat(buffer, "\n**** MESSINFO: ****\n\n"); else strcat(buffer, "\n**** MAMEINFO: ****\n\n"); /* List the game info 'flags' */ if (drv->flags & MACHINE_NOT_WORKING) strcat(buffer, "THIS GAME DOESN'T WORK PROPERLY\n"); if (drv->flags & MACHINE_UNEMULATED_PROTECTION) strcat(buffer, "The game has protection which isn't fully emulated.\n"); if (drv->flags & MACHINE_IMPERFECT_GRAPHICS) strcat(buffer, "The video emulation isn't 100% accurate.\n"); if (drv->flags & MACHINE_WRONG_COLORS) strcat(buffer, "The colors are completely wrong.\n"); if (drv->flags & MACHINE_IMPERFECT_COLORS) strcat(buffer, "The colors aren't 100% accurate.\n"); if (drv->flags & MACHINE_NO_SOUND) strcat(buffer, "The game lacks sound.\n"); if (drv->flags & MACHINE_IMPERFECT_SOUND) strcat(buffer, "The sound emulation isn't 100% accurate.\n"); if (drv->flags & MACHINE_SUPPORTS_SAVE) strcat(buffer, "Save state support.\n"); if (drv->flags & MACHINE_MECHANICAL) strcat(buffer, "The game contains mechanical parts.\n"); strcat(buffer, "\n"); if (drv->flags & MACHINE_IS_BIOS_ROOT) is_bios = 1; /* try to open mameinfo datafile */ if (ParseOpen(filename)) { if (filenum) { /* create index if necessary */ if (mess_idx) mameinfo = 1; else mameinfo = (index_datafile (&mess_idx, 0) != 0); /* load informational text (append) */ if (mess_idx) { int len = strlen(buffer); int err = 0; const game_driver *gdrv; gdrv = drv; do { err = load_datafile_text(gdrv, buffer + len, bufsize - len, mess_idx, DATAFILE_TAG_MAME, 0, 1); int g = driver_list::clone(*gdrv); if (g!=-1) gdrv = &driver_list::driver(g); else gdrv = NULL; } while (err && gdrv); if (err) mameinfo = 0; } } else { /* create index if necessary */ if (mame_idx) mameinfo = 1; else mameinfo = (index_datafile (&mame_idx, 0) != 0); /* load informational text (append) */ if (mame_idx) { int len = strlen(buffer); int err = 0; const game_driver *gdrv; gdrv = drv; do { err = load_datafile_text(gdrv, buffer + len, bufsize - len, mame_idx, DATAFILE_TAG_MAME, 0, 1); int g = driver_list::clone(*gdrv); if (g!=-1) gdrv = &driver_list::driver(g); else gdrv = NULL; } while (err && gdrv); if (err) mameinfo = 0; } } ParseClose(); } /* GAME INFORMATIONS */ snprintf(name, ARRAY_LENGTH(name), "\nGAME: %s\n", drv->name); strcat(buffer, name); snprintf(name, ARRAY_LENGTH(name), "%s", drv->description); strcat(buffer, name); snprintf(name, ARRAY_LENGTH(name), " (%s %s)\n\nCPU:\n", drv->manufacturer, drv->year); strcat(buffer, name); /* iterate over CPUs */ execute_interface_iterator iter(config.root_device()); device_execute_interface *cpu = iter.first(); while (cpu) { if (cpu->device().clock() >= 1000000) snprintf(name, ARRAY_LENGTH(name), "%s %d.%06d MHz\n", cpu->device().name(), cpu->device().clock() / 1000000, cpu->device().clock() % 1000000); else snprintf(name, ARRAY_LENGTH(name), "%s %d.%03d kHz\n", cpu->device().name(), cpu->device().clock() / 1000, cpu->device().clock() % 1000); strcat(buffer, name); cpu = iter.next(); } strcat(buffer, "\nSOUND:\n"); int has_sound = 0; /* iterate over sound chips */ sound_interface_iterator sounditer(config.root_device()); const device_sound_interface *sound = sounditer.first(); while(sound) { int clock = 0; int count = 0; device_type sound_type_; char tmpname[1024]; snprintf(tmpname, ARRAY_LENGTH(tmpname), "%s", sound->device().name()); sound_type_ = sound->device().type(); clock = sound->device().clock(); has_sound = 1; count = 1; sound = sounditer.next(); /* Matching chips at the same clock are aggregated */ while (sound && sound->device().type() == sound_type_ && sound->device().clock() == clock) { count++; sound = sounditer.next(); } if (count > 1) { snprintf(name, ARRAY_LENGTH(name), "%dx ",count); strcat(buffer, name); } strcat(buffer, tmpname); if (clock) { if (clock >= 1000000) snprintf(name, ARRAY_LENGTH(name), " %d.%06d MHz", clock / 1000000, clock % 1000000); else snprintf(name, ARRAY_LENGTH(name), " %d.%03d kHz", clock / 1000, clock % 1000); strcat(buffer, name); } strcat(buffer, "\n"); } if (has_sound) { speaker_device_iterator iter(config.root_device()); int channels = iter.count(); if(channels == 1) snprintf(name, ARRAY_LENGTH(name), "%d Channel\n",channels); else snprintf(name, ARRAY_LENGTH(name), "%dx Channels\n",channels); strcat(buffer, name); } strcat(buffer, "\nVIDEO:\n"); screen_device_iterator screeniter(config.root_device()); const screen_device *screen = screeniter.first(); if (screen == nullptr) strcat(buffer, "Screenless\n"); else if (screen->screen_type() == SCREEN_TYPE_VECTOR) strcat(buffer,"Vector\n"); else { for (; screen != nullptr; screen = screeniter.next()) { if (drv->flags & ORIENTATION_SWAP_XY) snprintf(name, ARRAY_LENGTH(name), "%d x %d (V)", screen->visible_area().height(), screen->visible_area().width()); else snprintf(name, ARRAY_LENGTH(name), "%d x %d (H)", screen->visible_area().width(), screen->visible_area().height()); strcat(buffer, name); snprintf(name, ARRAY_LENGTH(name), " %f Hz", ATTOSECONDS_TO_HZ(screen->refresh_attoseconds())); strcat(buffer, name); strcat(buffer, "\n"); } } strcat(buffer, "\nROM REGION:\n"); int g = driver_list::clone(*drv); if (g!=-1) parent = &driver_list::driver(g); device_iterator deviter(config.root_device()); for (device_t *device = deviter.first(); device; device = deviter.next()) { for (const rom_entry *region = rom_first_region(*device); region != nullptr; region = rom_next_region(region)) { for (const rom_entry *rom = rom_first_file(region); rom != nullptr; rom = rom_next_file(rom)) { hash_collection hashes(ROM_GETHASHDATA(rom)); if (g!=-1) { machine_config pconfig(*parent, MameUIGlobal()); device_iterator deviter(pconfig.root_device()); for (device_t *device = deviter.first(); device != nullptr; device = deviter.next()) for (const rom_entry *pregion = rom_first_region(*device); pregion != nullptr; pregion = rom_next_region(pregion)) for (const rom_entry *prom = rom_first_file(pregion); prom != nullptr; prom = rom_next_file(prom)) { hash_collection phashes(ROM_GETHASHDATA(prom)); if (hashes == phashes) break; } } snprintf(name, ARRAY_LENGTH(name), "%-16s \t", ROM_GETNAME(rom)); strcat(buffer, name); snprintf(name, ARRAY_LENGTH(name), "%09d \t", rom_file_size(rom)); strcat(buffer, name); snprintf(name, ARRAY_LENGTH(name), "%-10s", ROMREGION_GETTAG(region)); strcat(buffer, name); strcat(buffer, "\n"); } } } samples_device_iterator samplesiter(config.root_device()); for (samples_device *device = samplesiter.first(); device != nullptr; device = samplesiter.next()) { samples_iterator sampiter(*device); if (sampiter.altbasename() != nullptr) { snprintf(name, ARRAY_LENGTH(name), "\nSAMPLES (%s):\n", sampiter.altbasename()); strcat(buffer, name); } std::unordered_set<std::string> already_printed; for (const char *samplename = sampiter.first(); samplename != nullptr; samplename = sampiter.next()) { // filter out duplicates if (!already_printed.insert(samplename).second) continue; // output the sample name snprintf(name, ARRAY_LENGTH(name), "%s.wav\n", samplename); strcat(buffer, name); } } if (!is_bios) { int g = driver_list::clone(*drv); if (g!=-1) drv = &driver_list::driver(g); strcat(buffer, "\nORIGINAL:\n"); strcat(buffer, drv->description); strcat(buffer, "\n\nCLONES:\n"); for (int i = 0; i < driver_list::total(); i++) { if (!strcmp (drv->name, driver_list::driver(i).parent)) { strcat(buffer, driver_list::driver(i).description); strcat(buffer, "\n"); } } } strcat(buffer, "\n"); return (mameinfo == 0); }
static void print_game_display(FILE *out, const game_driver *game, const machine_config *config) { const device_config *screen; /* iterate over screens */ for (screen = video_screen_first(config); screen != NULL; screen = video_screen_next(screen)) { const screen_config *scrconfig = (const screen_config *)screen->inline_config; fprintf(out, "\t\t<display"); switch (scrconfig->type) { case SCREEN_TYPE_RASTER: fprintf(out, " type=\"raster\""); break; case SCREEN_TYPE_VECTOR: fprintf(out, " type=\"vector\""); break; case SCREEN_TYPE_LCD: fprintf(out, " type=\"lcd\""); break; default: fprintf(out, " type=\"unknown\""); break; } /* output the orientation as a string */ switch (game->flags & ORIENTATION_MASK) { case ORIENTATION_FLIP_X: fprintf(out, " rotate=\"0\" flipx=\"yes\""); break; case ORIENTATION_FLIP_Y: fprintf(out, " rotate=\"180\" flipx=\"yes\""); break; case ORIENTATION_FLIP_X|ORIENTATION_FLIP_Y: fprintf(out, " rotate=\"180\""); break; case ORIENTATION_SWAP_XY: fprintf(out, " rotate=\"90\" flipx=\"yes\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_X: fprintf(out, " rotate=\"90\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_Y: fprintf(out, " rotate=\"270\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_X|ORIENTATION_FLIP_Y: fprintf(out, " rotate=\"270\" flipx=\"yes\""); break; default: fprintf(out, " rotate=\"0\""); break; } /* output width and height only for games that are not vector */ if (scrconfig->type != SCREEN_TYPE_VECTOR) { int dx = scrconfig->visarea.max_x - scrconfig->visarea.min_x + 1; int dy = scrconfig->visarea.max_y - scrconfig->visarea.min_y + 1; fprintf(out, " width=\"%d\"", dx); fprintf(out, " height=\"%d\"", dy); } /* output refresh rate */ fprintf(out, " refresh=\"%f\"", ATTOSECONDS_TO_HZ(scrconfig->refresh)); /* output raw video parameters only for games that are not vector */ /* and had raw parameters specified */ if ((scrconfig->type != SCREEN_TYPE_VECTOR) && !scrconfig->oldstyle_vblank_supplied) { int pixclock = scrconfig->width * scrconfig->height * ATTOSECONDS_TO_HZ(scrconfig->refresh); fprintf(out, " pixclock=\"%d\"", pixclock); fprintf(out, " htotal=\"%d\"", scrconfig->width); fprintf(out, " hbend=\"%d\"", scrconfig->visarea.min_x); fprintf(out, " hbstart=\"%d\"", scrconfig->visarea.max_x+1); fprintf(out, " vtotal=\"%d\"", scrconfig->height); fprintf(out, " vbend=\"%d\"", scrconfig->visarea.min_y); fprintf(out, " vbstart=\"%d\"", scrconfig->visarea.max_y+1); } fprintf(out, " />\n"); } }
void info_xml_creator::output_display(device_t &device, const char *root_tag) { // iterate over screens screen_device_iterator iter(device); for (const screen_device *screendev = iter.first(); screendev != NULL; screendev = iter.next()) { if (strcmp(screendev->tag(), device.tag())) { astring newtag(screendev->tag()), oldtag(":"); newtag.substr(newtag.find(oldtag.cat(root_tag)) + oldtag.len()); fprintf(m_output, "\t\t<display"); fprintf(m_output, " tag=\"%s\"", xml_normalize_string(newtag)); switch (screendev->screen_type()) { case SCREEN_TYPE_RASTER: fprintf(m_output, " type=\"raster\""); break; case SCREEN_TYPE_VECTOR: fprintf(m_output, " type=\"vector\""); break; case SCREEN_TYPE_LCD: fprintf(m_output, " type=\"lcd\""); break; default: fprintf(m_output, " type=\"unknown\""); break; } // output the orientation as a string switch (m_drivlist.driver().flags & ORIENTATION_MASK) { case ORIENTATION_FLIP_X: fprintf(m_output, " rotate=\"0\" flipx=\"yes\""); break; case ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"180\" flipx=\"yes\""); break; case ORIENTATION_FLIP_X|ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"180\""); break; case ORIENTATION_SWAP_XY: fprintf(m_output, " rotate=\"90\" flipx=\"yes\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_X: fprintf(m_output, " rotate=\"90\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"270\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_X|ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"270\" flipx=\"yes\""); break; default: fprintf(m_output, " rotate=\"0\""); break; } // output width and height only for games that are not vector if (screendev->screen_type() != SCREEN_TYPE_VECTOR) { const rectangle &visarea = screendev->visible_area(); fprintf(m_output, " width=\"%d\"", visarea.width()); fprintf(m_output, " height=\"%d\"", visarea.height()); } // output refresh rate fprintf(m_output, " refresh=\"%f\"", ATTOSECONDS_TO_HZ(screendev->refresh_attoseconds())); // output raw video parameters only for games that are not vector // and had raw parameters specified if (screendev->screen_type() != SCREEN_TYPE_VECTOR && !screendev->oldstyle_vblank_supplied()) { int pixclock = screendev->width() * screendev->height() * ATTOSECONDS_TO_HZ(screendev->refresh_attoseconds()); fprintf(m_output, " pixclock=\"%d\"", pixclock); fprintf(m_output, " htotal=\"%d\"", screendev->width()); fprintf(m_output, " hbend=\"%d\"", screendev->visible_area().min_x); fprintf(m_output, " hbstart=\"%d\"", screendev->visible_area().max_x+1); fprintf(m_output, " vtotal=\"%d\"", screendev->height()); fprintf(m_output, " vbend=\"%d\"", screendev->visible_area().min_y); fprintf(m_output, " vbstart=\"%d\"", screendev->visible_area().max_y+1); } fprintf(m_output, " />\n"); } } }
void info_xml_creator::output_display() { // iterate over screens for (const screen_device *device = m_drivlist.config().first_screen(); device != NULL; device = device->next_screen()) { fprintf(m_output, "\t\t<display"); switch (device->screen_type()) { case SCREEN_TYPE_RASTER: fprintf(m_output, " type=\"raster\""); break; case SCREEN_TYPE_VECTOR: fprintf(m_output, " type=\"vector\""); break; case SCREEN_TYPE_LCD: fprintf(m_output, " type=\"lcd\""); break; default: fprintf(m_output, " type=\"unknown\""); break; } // output the orientation as a string switch (m_drivlist.driver().flags & ORIENTATION_MASK) { case ORIENTATION_FLIP_X: fprintf(m_output, " rotate=\"0\" flipx=\"yes\""); break; case ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"180\" flipx=\"yes\""); break; case ORIENTATION_FLIP_X|ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"180\""); break; case ORIENTATION_SWAP_XY: fprintf(m_output, " rotate=\"90\" flipx=\"yes\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_X: fprintf(m_output, " rotate=\"90\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"270\""); break; case ORIENTATION_SWAP_XY|ORIENTATION_FLIP_X|ORIENTATION_FLIP_Y: fprintf(m_output, " rotate=\"270\" flipx=\"yes\""); break; default: fprintf(m_output, " rotate=\"0\""); break; } // output width and height only for games that are not vector if (device->screen_type() != SCREEN_TYPE_VECTOR) { const rectangle &visarea = device->visible_area(); fprintf(m_output, " width=\"%d\"", visarea.max_x - visarea.min_x + 1); fprintf(m_output, " height=\"%d\"", visarea.max_y - visarea.min_y + 1); } // output refresh rate fprintf(m_output, " refresh=\"%f\"", ATTOSECONDS_TO_HZ(device->refresh_attoseconds())); // output raw video parameters only for games that are not vector // and had raw parameters specified if (device->screen_type() != SCREEN_TYPE_VECTOR && !device->oldstyle_vblank_supplied()) { int pixclock = device->width() * device->height() * ATTOSECONDS_TO_HZ(device->refresh_attoseconds()); fprintf(m_output, " pixclock=\"%d\"", pixclock); fprintf(m_output, " htotal=\"%d\"", device->width()); fprintf(m_output, " hbend=\"%d\"", device->visible_area().min_x); fprintf(m_output, " hbstart=\"%d\"", device->visible_area().max_x+1); fprintf(m_output, " vtotal=\"%d\"", device->height()); fprintf(m_output, " vbend=\"%d\"", device->visible_area().min_y); fprintf(m_output, " vbstart=\"%d\"", device->visible_area().max_y+1); } fprintf(m_output, " />\n"); } }
void menu_device_config::populate() { std::ostringstream str; device_t *dev; util::stream_format(str, "[This option is%s currently mounted in the running system]\n\n", m_mounted ? "" : " NOT"); util::stream_format(str, "Option: %s\n", m_option->name()); dev = const_cast<machine_config &>(machine().config()).device_add(&machine().config().root_device(), m_option->name(), m_option->devtype(), 0); util::stream_format(str, "Device: %s\n", dev->name()); if (!m_mounted) str << "\nIf you select this option, the following items will be enabled:\n"; else str << "\nThe selected option enables the following items:\n"; // loop over all CPUs execute_interface_iterator execiter(*dev); if (execiter.count() > 0) { str << "* CPU:\n"; std::unordered_set<std::string> exectags; for (device_execute_interface &exec : execiter) { if (!exectags.insert(exec.device().tag()).second) continue; // get cpu specific clock that takes internal multiplier/dividers into account int clock = exec.device().clock(); // count how many identical CPUs we have int count = 1; const char *name = exec.device().name(); for (device_execute_interface &scan : execiter) { if (exec.device().type() == scan.device().type() && strcmp(name, scan.device().name()) == 0 && exec.device().clock() == scan.device().clock()) if (exectags.insert(scan.device().tag()).second) count++; } // if more than one, prepend a #x in front of the CPU name if (count > 1) util::stream_format(str, " %d" UTF8_MULTIPLY, count); else str << " "; str << name; // display clock in kHz or MHz if (clock >= 1000000) util::stream_format(str, " %d.%06d" UTF8_NBSP "MHz\n", clock / 1000000, clock % 1000000); else util::stream_format(str, " %d.%03d" UTF8_NBSP "kHz\n", clock / 1000, clock % 1000); } } // display screen information screen_device_iterator scriter(*dev); if (scriter.count() > 0) { str << "* Video:\n"; for (screen_device &screen : scriter) { util::stream_format(str, " Screen '%s': ", screen.tag()); if (screen.screen_type() == SCREEN_TYPE_VECTOR) str << "Vector\n"; else { const rectangle &visarea = screen.visible_area(); util::stream_format(str, "%d " UTF8_MULTIPLY " %d (%s) %f" UTF8_NBSP "Hz\n", visarea.width(), visarea.height(), (machine().system().flags & ORIENTATION_SWAP_XY) ? "V" : "H", ATTOSECONDS_TO_HZ(screen.frame_period().attoseconds())); } } } // loop over all sound chips sound_interface_iterator snditer(*dev); if (snditer.count() > 0) { str << "* Sound:\n"; std::unordered_set<std::string> soundtags; for (device_sound_interface &sound : snditer) { if (!soundtags.insert(sound.device().tag()).second) continue; // count how many identical sound chips we have int count = 1; for (device_sound_interface &scan : snditer) { if (sound.device().type() == scan.device().type() && sound.device().clock() == scan.device().clock()) if (soundtags.insert(scan.device().tag()).second) count++; } // if more than one, prepend a #x in front of the CPU name if (count > 1) util::stream_format(str," %d" UTF8_MULTIPLY, count); else str << " "; str << sound.device().name(); // display clock in kHz or MHz int clock = sound.device().clock(); if (clock >= 1000000) util::stream_format(str," %d.%06d" UTF8_NBSP "MHz\n", clock / 1000000, clock % 1000000); else if (clock != 0) util::stream_format(str," %d.%03d" UTF8_NBSP "kHz\n", clock / 1000, clock % 1000); else str << '\n'; } } // scan for BIOS settings int bios = 0; if (dev->rom_region()) { std::string bios_str; // first loop through roms in search of default bios (shortname) for (const rom_entry &rom : dev->rom_region_vector()) if (ROMENTRY_ISDEFAULT_BIOS(&rom)) bios_str.assign(ROM_GETNAME(&rom)); // then loop again to count bios options and to get the default bios complete name for (const rom_entry &rom : dev->rom_region_vector()) { if (ROMENTRY_ISSYSTEM_BIOS(&rom)) { bios++; if (bios_str.compare(ROM_GETNAME(&rom))==0) bios_str.assign(ROM_GETHASHDATA(&rom)); } } if (bios) util::stream_format(str, "* BIOS settings:\n %d options [default: %s]\n", bios, bios_str.c_str()); } int input = 0, input_mj = 0, input_hana = 0, input_gamble = 0, input_analog = 0, input_adjust = 0; int input_keypad = 0, input_keyboard = 0, dips = 0, confs = 0; std::string errors; std::ostringstream dips_opt, confs_opt; ioport_list portlist; for (device_t &iptdev : device_iterator(*dev)) portlist.append(iptdev, errors); // check if the device adds inputs to the system for (auto &port : portlist) for (ioport_field &field : port.second->fields()) { if (field.type() >= IPT_MAHJONG_FIRST && field.type() < IPT_MAHJONG_LAST) input_mj++; else if (field.type() >= IPT_HANAFUDA_FIRST && field.type() < IPT_HANAFUDA_LAST) input_hana++; else if (field.type() >= IPT_GAMBLING_FIRST && field.type() < IPT_GAMBLING_LAST) input_gamble++; else if (field.type() >= IPT_ANALOG_FIRST && field.type() < IPT_ANALOG_LAST) input_analog++; else if (field.type() == IPT_ADJUSTER) input_adjust++; else if (field.type() == IPT_KEYPAD) input_keypad++; else if (field.type() == IPT_KEYBOARD) input_keyboard++; else if (field.type() >= IPT_START1 && field.type() < IPT_UI_FIRST) input++; else if (field.type() == IPT_DIPSWITCH) { dips++; dips_opt << " " << field.name(); for (ioport_setting &setting : field.settings()) { if (setting.value() == field.defvalue()) { util::stream_format(dips_opt, " [default: %s]\n", setting.name()); break; } } } else if (field.type() == IPT_CONFIG) { confs++; confs_opt << " " << field.name(); for (ioport_setting &setting : field.settings()) { if (setting.value() == field.defvalue()) { util::stream_format(confs_opt, " [default: %s]\n", setting.name()); break; } } } } if (dips) str << "* Dispwitch settings:\n" << dips_opt.str(); if (confs) str << "* Configuration settings:\n" << confs_opt.str(); if (input + input_mj + input_hana + input_gamble + input_analog + input_adjust + input_keypad + input_keyboard) str << "* Input device(s):\n"; if (input) util::stream_format(str, " User inputs [%d inputs]\n", input); if (input_mj) util::stream_format(str, " Mahjong inputs [%d inputs]\n", input_mj); if (input_hana) util::stream_format(str, " Hanafuda inputs [%d inputs]\n", input_hana); if (input_gamble) util::stream_format(str, " Gambling inputs [%d inputs]\n", input_gamble); if (input_analog) util::stream_format(str, " Analog inputs [%d inputs]\n", input_analog); if (input_adjust) util::stream_format(str, " Adjuster inputs [%d inputs]\n", input_adjust); if (input_keypad) util::stream_format(str, " Keypad inputs [%d inputs]\n", input_keypad); if (input_keyboard) util::stream_format(str, " Keyboard inputs [%d inputs]\n", input_keyboard); image_interface_iterator imgiter(*dev); if (imgiter.count() > 0) { str << "* Media Options:\n"; for (const device_image_interface &imagedev : imgiter) util::stream_format(str, " %s [tag: %s]\n", imagedev.image_type_name(), imagedev.device().tag()); } slot_interface_iterator slotiter(*dev); if (slotiter.count() > 0) { str << "* Slot Options:\n"; for (const device_slot_interface &slot : slotiter) util::stream_format(str, " %s [default: %s]\n", slot.device().tag(), slot.default_option() ? slot.default_option() : "----"); } if ((execiter.count() + scriter.count() + snditer.count() + imgiter.count() + slotiter.count() + bios + dips + confs + input + input_mj + input_hana + input_gamble + input_analog + input_adjust + input_keypad + input_keyboard) == 0) str << "[None]\n"; const_cast<machine_config &>(machine().config()).device_remove(&machine().config().root_device(), m_option->name()); item_append(str.str(), "", FLAG_MULTILINE, nullptr); }
int gtia_device::is_ntsc() { return ATTOSECONDS_TO_HZ(machine().first_screen()->frame_period().attoseconds()) > 55; }
void nesapu_device::device_start() { int rate = clock() / 4; /* Initialize global variables */ m_samps_per_sync = rate / ATTOSECONDS_TO_HZ(machine().first_screen()->frame_period().attoseconds); m_buffer_size = m_samps_per_sync; m_real_rate = m_samps_per_sync * ATTOSECONDS_TO_HZ(machine().first_screen()->frame_period().attoseconds); m_apu_incsize = (float) (clock() / (float) m_real_rate); /* Use initializer calls */ create_noise(m_noise_lut, 13, NOISE_LONG); create_vbltimes(m_vbl_times,vbl_length,m_samps_per_sync); create_syncs(m_samps_per_sync); /* Adjust buffer size if 16 bits */ m_buffer_size+=m_samps_per_sync; /* Initialize individual chips */ (m_APU.dpcm).memory = &machine().device(m_cpu_tag)->memory().space(AS_PROGRAM); m_stream = machine().sound().stream_alloc(*this, 0, 1, rate); /* register for save */ for (int i = 0; i < 2; i++) { save_item(NAME(m_APU.squ[i].regs), i); save_item(NAME(m_APU.squ[i].vbl_length), i); save_item(NAME(m_APU.squ[i].freq), i); save_item(NAME(m_APU.squ[i].phaseacc), i); save_item(NAME(m_APU.squ[i].output_vol), i); save_item(NAME(m_APU.squ[i].env_phase), i); save_item(NAME(m_APU.squ[i].sweep_phase), i); save_item(NAME(m_APU.squ[i].adder), i); save_item(NAME(m_APU.squ[i].env_vol), i); save_item(NAME(m_APU.squ[i].enabled), i); } save_item(NAME(m_APU.tri.regs)); save_item(NAME(m_APU.tri.linear_length)); save_item(NAME(m_APU.tri.vbl_length)); save_item(NAME(m_APU.tri.write_latency)); save_item(NAME(m_APU.tri.phaseacc)); save_item(NAME(m_APU.tri.output_vol)); save_item(NAME(m_APU.tri.adder)); save_item(NAME(m_APU.tri.counter_started)); save_item(NAME(m_APU.tri.enabled)); save_item(NAME(m_APU.noi.regs)); save_item(NAME(m_APU.noi.cur_pos)); save_item(NAME(m_APU.noi.vbl_length)); save_item(NAME(m_APU.noi.phaseacc)); save_item(NAME(m_APU.noi.output_vol)); save_item(NAME(m_APU.noi.env_phase)); save_item(NAME(m_APU.noi.env_vol)); save_item(NAME(m_APU.noi.enabled)); save_item(NAME(m_APU.dpcm.regs)); save_item(NAME(m_APU.dpcm.address)); save_item(NAME(m_APU.dpcm.length)); save_item(NAME(m_APU.dpcm.bits_left)); save_item(NAME(m_APU.dpcm.phaseacc)); save_item(NAME(m_APU.dpcm.output_vol)); save_item(NAME(m_APU.dpcm.cur_byte)); save_item(NAME(m_APU.dpcm.enabled)); save_item(NAME(m_APU.dpcm.irq_occurred)); save_item(NAME(m_APU.dpcm.vol)); save_item(NAME(m_APU.regs)); #ifdef USE_QUEUE save_item(NAME(m_APU.queue)); save_item(NAME(m_APU.head)); save_item(NAME(m_APU.tail)); #else save_item(NAME(m_APU.buf_pos)); save_item(NAME(m_APU.step_mode)); #endif }
static int is_ntsc(running_machine &machine) { return ATTOSECONDS_TO_HZ(machine.primary_screen->frame_period().attoseconds) > 55; }