static int device_load_cassette(mess_image *image)
{
casserr_t err;
int cassette_flags;
struct mess_cassetteimg *tag;
const struct IODevice *dev;
const struct CassetteFormat **formats;
const struct CassetteOptions *create_opts;
const char *extension;
int is_writable;
tag = get_cassimg(image);
/* figure out the cassette format */
dev = device_find(Machine->devices, IO_CASSETTE);
formats = device_get_info_ptr(&dev->devclass, DEVINFO_PTR_CASSETTE_FORMATS);
if (image_has_been_created(image))
{
/* creating an image */
create_opts = (const struct CassetteOptions *) device_get_info_ptr(&dev->devclass, DEVINFO_PTR_CASSETTE_OPTIONS);
err = cassette_create(image, &mess_ioprocs, &wavfile_format, create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &tag->cassette);
if (err)
goto error;
}
else
{
/* opening an image */
do
{
is_writable = image_is_writable(image);
cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;
extension = image_filetype(image);
err = cassette_open_choices(image, &mess_ioprocs, extension, formats, cassette_flags, &tag->cassette);
/* this is kind of a hack */
if (err && is_writable)
image_make_readonly(image);
}
while(err && is_writable);
if (err)
goto error;
}
/* set to default state, but only change the UI state */
cassette_change_state(image, get_default_state(dev), CASSETTE_MASK_UISTATE);
/* reset the position */
tag->position = 0.0;
tag->position_time = timer_get_time();
return INIT_PASS;
error:
return INIT_FAIL;
}
static int internal_floppy_device_load(mess_image *image, mame_file *file, int create_format, option_resolution *create_args)
{
floperr_t err;
struct mess_flopimg *flopimg;
const struct IODevice *dev;
const struct FloppyFormat *floppy_options;
int floppy_flags, i;
const char *extension;
/* look up instance data */
flopimg = get_flopimg(image);
/* figure out the floppy options */
dev = image_device(image);
floppy_options = device_get_info_ptr(&dev->devclass, DEVINFO_PTR_FLOPPY_OPTIONS);
if (image_has_been_created(image))
{
/* creating an image */
assert(create_format >= 0);
err = floppy_create(file, &mess_ioprocs, &floppy_options[create_format], create_args, &flopimg->floppy);
if (err)
goto error;
}
else
{
/* opening an image */
floppy_flags = image_is_writable(image) ? FLOPPY_FLAGS_READWRITE : FLOPPY_FLAGS_READONLY;
extension = image_filetype(image);
err = floppy_open_choices(file, &mess_ioprocs, extension, floppy_options, floppy_flags, &flopimg->floppy);
if (err)
goto error;
}
/* if we can get head and track counts, then set the geometry accordingly */
if (floppy_callbacks(flopimg->floppy)->get_heads_per_disk
&& floppy_callbacks(flopimg->floppy)->get_tracks_per_disk)
{
floppy_drive_set_geometry_absolute(image,
floppy_get_tracks_per_disk(flopimg->floppy),
floppy_get_heads_per_disk(flopimg->floppy));
}
return INIT_PASS;
error:
for (i = 0; i < sizeof(errmap) / sizeof(errmap[0]); i++)
{
if (err == errmap[i].ferr)
image_seterror(image, errmap[i].ierr, errmap[i].message);
}
return INIT_FAIL;
}
static int image_load_internal(mess_image *image, const char *path,
int is_create, int create_format, option_resolution *create_args)
{
image_error_t err;
const char *software_path;
char *software_path_list = NULL;
const void *buffer;
const game_driver *gamedrv;
UINT32 open_plan[4];
int i;
/* sanity checks */
assert_always(image, "image_load(): image is NULL");
assert_always(path, "image_load(): path is NULL");
/* we are now loading */
image->is_loading = 1;
/* first unload the image */
image_unload(image);
/* record the filename */
image->err = set_image_filename(image, path, NULL);
if (image->err)
goto done;
/* tell the OSD layer that this is changing */
osd_image_load_status_changed(image, 0);
/* do we need to reset the CPU? */
if ((timer_get_time() > 0) && image->dev->reset_on_load)
mame_schedule_soft_reset(Machine);
/* determine open plan */
determine_open_plan(image, is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !image->file && open_plan[i]; i++)
{
software_path = software_path_list;
do
{
gamedrv = Machine->gamedrv;
while(!is_loaded(image) && gamedrv)
{
/* open the file */
image->err = load_image_by_path(image, software_path, gamedrv, open_plan[i], path);
if (image->err && (image->err != IMAGE_ERROR_FILENOTFOUND))
goto done;
/* move on to the next driver */
gamedrv = mess_next_compatible_driver(gamedrv);
}
/* move on to the next entry in the software path; if we can */
if (software_path)
software_path += strlen(software_path) + 1;
}
while(!is_loaded(image) && software_path && *software_path);
}
/* did we fail to find the file? */
if (!is_loaded(image))
{
image->err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* if applicable, call device verify */
if (image->dev->imgverify && !image_has_been_created(image))
{
/* access the memory */
buffer = image_ptr(image);
if (!buffer)
{
image->err = IMAGE_ERROR_OUTOFMEMORY;
goto done;
}
/* verify the file */
err = image->dev->imgverify(buffer, (size_t) image->length);
if (err)
{
image->err = IMAGE_ERROR_INVALIDIMAGE;
goto done;
}
}
/* call device load or create */
if (image_has_been_created(image) && image->dev->create)
{
err = image->dev->create(image, create_format, create_args);
if (err)
{
if (!image->err)
image->err = IMAGE_ERROR_UNSPECIFIED;
goto done;
}
}
else if (image->dev->load)
{
/* using device load */
err = image->dev->load(image);
if (err)
{
if (!image->err)
image->err = IMAGE_ERROR_UNSPECIFIED;
goto done;
}
}
/* success! */
done:
if (software_path_list)
free(software_path_list);
if (image->err)
image_clear(image);
image->is_loading = 1;
return image->err ? INIT_FAIL : INIT_PASS;
}
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;
}