void bitbanger_output(mess_image *img, int value) { int id = image_index_in_device(img); struct bitbanger_info *bi = bitbangers[id]; double current_time; double pulse_width; /* normalize input */ value = value ? 1 : 0; /* only meaningful if we change */ if (bi->value != value) { current_time = timer_get_time(); pulse_width = current_time - bi->last_pulse_time; assert(pulse_width >= 0); if (!bi->over_threshhold && ((bi->recorded_pulses > 0) || (bi->value == bi->config->initial_value))) bitbanger_addpulse(id, bi, pulse_width); /* update state */ bi->value = value; bi->last_pulse_time = current_time; bi->over_threshhold = 0; /* update timeout timer */ timer_reset(bi->timeout_timer, bi->config->pulse_threshhold); } }
static basicdsk *get_basicdsk(mess_image *img) { int drive = image_index_in_device(img); assert(drive >= 0); assert(drive < (sizeof(basicdsk_drives) / sizeof(basicdsk_drives[0]))); return &basicdsk_drives[drive]; }
static void determine_open_plan(mess_image *image, int is_create, UINT32 *open_plan) { unsigned int readable, writeable, creatable; int i = 0; if (image->dev->getdispositions) { image->dev->getdispositions(image->dev, image_index_in_device(image), &readable, &writeable, &creatable); } else { readable = image->dev->readable; writeable = image->dev->writeable; creatable = image->dev->creatable; } /* emit flags */ if (!is_create && readable && writeable) open_plan[i++] = OPEN_FLAG_READ | OPEN_FLAG_WRITE; if (!is_create && !readable && writeable) open_plan[i++] = OPEN_FLAG_WRITE; if (!is_create && readable) open_plan[i++] = OPEN_FLAG_READ; if (writeable && creatable) open_plan[i++] = OPEN_FLAG_READ | OPEN_FLAG_WRITE | OPEN_FLAG_CREATE; open_plan[i] = 0; }
static int bitbanger_init(mess_image *img) { int id = image_index_in_device(img); struct bitbanger_info *bi; const struct bitbanger_config *config; config = (const struct bitbanger_config *) device_find(Machine->devices, IO_BITBANGER)->user1; bi = (struct bitbanger_info *) auto_malloc(sizeof(struct bitbanger_info)); if (!bi) return INIT_FAIL; bi->pulses = (double *) auto_malloc(config->maximum_pulses * sizeof(double)); if (!bi->pulses) return INIT_FAIL; bi->factored_pulses = (int *) auto_malloc(config->maximum_pulses * sizeof(int)); if (!bi->factored_pulses) return INIT_FAIL; bi->config = config; bi->last_pulse_time = 0.0; bi->recorded_pulses = 0; bi->value = config->initial_value; bi->timeout_timer = timer_alloc(bitbanger_overthreshhold); bi->over_threshhold = 1; bitbangers[id] = bi; return INIT_PASS; }
static int internal_load_mess_cd(mess_image *image, const char *metadata) { chd_error err = 0; struct mess_cd *cd; chd_file *chd; int id = image_index_in_device(image); cd = get_drive(image); /* open the CHD file */ err = chdcd_open_ref(image, CHD_OPEN_READ, NULL, &chd); /* CDs are never writable */ if (err) goto error; /* open the CD-ROM file */ cd->cdrom_handle = cdrom_open(chd); if (!cd->cdrom_handle) goto error; drive_handles[id] = cd->cdrom_handle; return INIT_PASS; error: if (chd) chd_close(chd); if (err) image_seterror(image, IMAGE_ERROR_UNSPECIFIED, chd_get_error_string(err)); return INIT_FAIL; }
static int process_cartridge(mess_image *image, mame_file *file) { const rom_entry *romrgn, *roment; int position, result; romrgn = rom_first_region(Machine->gamedrv); while(romrgn) { roment = romrgn + 1; while(!ROMENTRY_ISREGIONEND(roment)) { if (is_cart_roment(roment)) { parse_rom_name(roment, &position, NULL); if (position == image_index_in_device(image)) { result = load_cartridge(romrgn, roment, file); if (!result) return result; } } roment++; } romrgn = rom_next_region(romrgn); } return INIT_PASS; }
static DEVICE_INIT(cbm_drive) { int id = image_index_in_device(image); if (id == 0) cbm_drive_open(); /* boy these C64 drivers are butt ugly */ return INIT_PASS; }
void device_unload_mess_hd(mess_image *image) { struct mess_hd *hd = get_drive(image); assert(hd->hard_disk_handle); hard_disk_close(hd->hard_disk_handle); hd->hard_disk_handle = NULL; drive_handles[image_index_in_device(image)] = NULL; }
static int internal_load_mess_hd(mess_image *image, const char *metadata) { int err = 0; struct mess_hd *hd; chd_file *chd; int is_writeable; int id = image_index_in_device(image); hd = get_drive(image); /* open the CHD file */ do { is_writeable = image_is_writable(image); chd = chd_open_ref(image, is_writeable, NULL); if (!chd) { err = chd_get_last_error(); /* special case; if we get CHDERR_FILE_NOT_WRITEABLE, make the * image read only and repeat */ if (err == CHDERR_FILE_NOT_WRITEABLE) image_make_readonly(image); } } while(!chd && is_writeable && (err == CHDERR_FILE_NOT_WRITEABLE)); if (!chd) goto error; /* if we created the image and hence, have metadata to set, set the metadata */ if (metadata) { err = chd_set_metadata(chd, HARD_DISK_STANDARD_METADATA, 0, metadata, strlen(metadata) + 1); if (err != CHDERR_NONE) goto error; } /* open the hard disk file */ hd->hard_disk_handle = hard_disk_open(chd); if (!hd->hard_disk_handle) goto error; drive_handles[id] = hd->hard_disk_handle; return INIT_PASS; error: if (chd) chd_close(chd); err = chd_get_last_error(); if (err) image_seterror(image, IMAGE_ERROR_UNSPECIFIED, chd_get_error_string(err)); return INIT_FAIL; }
static DEVICE_INIT(cbm_rom) { int id = image_index_in_device(image); if (id == 0) { cbm_c64_game = -1; cbm_c64_exrom = -1; } return INIT_PASS; }
const char *image_typename_id(mess_image *image) { const struct IODevice *dev; int id; static char buf[64]; dev = image_device(image); id = image_index_in_device(image); return dev->name(dev, id, buf, sizeof(buf) / sizeof(buf[0])); }
/* open an d64 image */ static DEVICE_LOAD(cbm_drive) { int size; int id = image_index_in_device(image); cbm_drive[id].drive = 0; cbm_drive[id].image = NULL; size = mame_fsize(file); cbm_drive[id].image = (UINT8*) image_malloc(image, size); if (!cbm_drive[id].image) return INIT_FAIL; if (size != mame_fread (file, cbm_drive[id].image, size)) return INIT_FAIL; cbm_drive[id].drive = D64_IMAGE; return 0; }
/* display a small tape icon, with the current position in the tape image */ static void device_display_cassette(mess_image *image) { char buf[65]; float x, y; int n; double position, length; cassette_state uistate; /* abort if we should not be showing the image */ if (!image_exists(image)) return; if (!cassette_is_motor_on(image)) return; /* figure out where we are in the cassette */ position = cassette_get_position(image); length = cassette_get_length(image); uistate = cassette_get_state(image) & CASSETTE_MASK_UISTATE; /* choose a location on the screen */ x = 0.0f; y = image_index_in_device(image) * ui_get_line_height(); /* choose which frame of the animation we are at */ n = ((int) position / ANIMATION_FPS) % ANIMATION_FRAMES; /* character pairs 2-3, 4-5, 6-7, 8-9 form little tape cassette images */ snprintf(buf, sizeof(buf) / sizeof(buf[0]), "%c%c %c %02d:%02d (%04d) [%02d:%02d (%04d)]", n * 2 + 2, /* cassette icon left */ n * 2 + 3, /* cassette icon right */ (uistate == CASSETTE_PLAY) ? 16 : 14, /* play or record icon */ ((int) position / 60), ((int) position % 60), (int) position, ((int) length / 60), ((int) length % 60), (int) length); /* draw the cassette */ ui_draw_text_box(buf, JUSTIFY_LEFT, x, y, UI_FILLCOLOR); }
static int image_load_internal(mess_image *img, const char *name, int is_create, int create_format, option_resolution *create_args) { const struct IODevice *dev; const char *s; char *newname; int err = INIT_PASS; mame_file *file = NULL; UINT8 *buffer = NULL; UINT64 size; unsigned int readable, writeable, creatable; /* unload if we are loaded */ if (img->status & IMAGE_STATUS_ISLOADED) image_unload(img); /* clear out the error */ image_clear_error(img); /* if we are attempting to "load" NULL, then exit at this point */ if (!name) return INIT_PASS; dev = image_device(img); assert(dev); img->status |= IMAGE_STATUS_ISLOADING; if (name && *name) { newname = image_strdup(img, name); if (!newname) { err = IMAGE_ERROR_OUTOFMEMORY; goto error; } } else newname = NULL; img->name = newname; img->dir = NULL; osd_image_load_status_changed(img, 0); /* do we need to reset the CPU? */ if ((timer_get_time() > 0) && dev->reset_on_load) machine_reset(); /* prepare to open the file */ img->created = 0; img->writeable = 0; file = NULL; if (dev->getdispositions) { dev->getdispositions(dev, image_index_in_device(img), &readable, &writeable, &creatable); } else { readable = dev->readable; writeable = dev->writeable; creatable = dev->creatable; } /* is this a ZIP file? */ s = strrchr(img->name, '.'); if (s && !mame_stricmp(s, ".ZIP")) { /* ZIP files are writeable */ writeable = 0; creatable = 0; } if (readable && !writeable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ); } else if (!readable && writeable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_WRITE); img->writeable = file ? 1 : 0; } else if (readable && writeable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW); img->writeable = file ? 1 : 0; if (!file) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ); if (!file && creatable) { file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW_CREATE); img->writeable = file ? 1 : 0; img->created = file ? 1 : 0; } } } /* did this attempt succeed? */ if (!file) { img->err = IMAGE_ERROR_FILENOTFOUND; goto error; } /* if applicable, call device verify */ if (dev->imgverify && !image_has_been_created(img)) { size = mame_fsize(file); buffer = malloc(size); if (!buffer) { img->err = IMAGE_ERROR_OUTOFMEMORY; goto error; } if (mame_fread(file, buffer, (UINT32) size) != size) { img->err = IMAGE_ERROR_INVALIDIMAGE; goto error; } err = dev->imgverify(buffer, size); if (err) { img->err = IMAGE_ERROR_INVALIDIMAGE; goto error; } mame_fseek(file, 0, SEEK_SET); free(buffer); buffer = NULL; } /* call device load or create */ if (image_has_been_created(img) && dev->create) { err = dev->create(img, file, create_format, create_args); if (err) { if (!img->err) img->err = IMAGE_ERROR_UNSPECIFIED; goto error; } } else if (dev->load) { /* using device load */ err = dev->load(img, file); if (err) { if (!img->err) img->err = IMAGE_ERROR_UNSPECIFIED; goto error; } } img->status &= ~IMAGE_STATUS_ISLOADING; img->status |= IMAGE_STATUS_ISLOADED; return INIT_PASS; error: if (file) mame_fclose(file); if (buffer) free(buffer); if (img) { img->fp = NULL; img->name = NULL; img->status &= ~IMAGE_STATUS_ISLOADING|IMAGE_STATUS_ISLOADED; } osd_image_load_status_changed(img, 0); return INIT_FAIL; }
static d88image *get_d88image(mess_image *img) { return &d88image_drives[image_index_in_device(img)]; }
static DEVICE_EXIT(cbm_drive) { int id = image_index_in_device(image); if (id == 0) cbm_drive_close(); /* boy these C64 drivers are butt ugly */ }
static DEVICE_UNLOAD(cbm_rom) { int id = image_index_in_device(image); cbm_rom[id].size = 0; cbm_rom[id].chip = 0; }
static struct mfm_disk_info *get_disk(mess_image *image) { int disk = image_index_in_device(image); return &mfm_disks[disk]; }
int image_slotexists(mess_image *img) { return image_index_in_device(img) < image_device(img)->count; }