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 DEVICE_IMAGE_LOAD( cassette )
{
device_t *device = &image.device();
dev_cassette_t *cassette = get_safe_token( device );
casserr_t err;
int cassette_flags;
const struct CassetteFormat * const *formats;
const struct CassetteOptions *create_opts;
const char *extension;
int is_writable;
/* figure out the cassette format */
formats = cassette->config->formats;
if (image.has_been_created())
{
/* creating an image */
create_opts = cassette->config->create_opts;
err = cassette_create((void *) &image, &image_ioprocs, &wavfile_format, create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &cassette->cassette);
if (err)
goto error;
}
else
{
/* opening an image */
do
{
is_writable = image.is_writable();
cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;
extension = image.filetype();
err = cassette_open_choices((void *) &image, &image_ioprocs, extension, formats, cassette_flags, &cassette->cassette);
/* this is kind of a hack */
if (err && is_writable)
image.make_readonly();
}
while(err && is_writable);
if (err)
goto error;
}
/* set to default state, but only change the UI state */
cassette_change_state(device, cassette->config->default_state, CASSETTE_MASK_UISTATE);
/* reset the position */
cassette->position = 0.0;
cassette->position_time = device->machine().time().as_double();
return IMAGE_INIT_PASS;
error:
return IMAGE_INIT_FAIL;
}
bool cassette_image_device::call_load()
{
casserr_t err;
int cassette_flags;
const char *extension;
int is_writable;
device_image_interface *image = nullptr;
interface(image);
if ((has_been_created()) || (length() == 0))
{
/* creating an image */
err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette);
if (err)
goto error;
}
else
{
/* opening an image */
do
{
is_writable = !is_readonly();
cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;
std::string fname;
if (software_entry()==nullptr) {
extension = filetype();
} else {
fname = m_mame_file->filename();
int loc = fname.find_last_of('.');
if (loc!=-1) {
extension = fname.substr(loc + 1,fname.length()-loc).c_str();
} else {
extension = "";
}
}
err = cassette_open_choices((void *)image, &image_ioprocs, extension, m_formats, cassette_flags, &m_cassette);
/* this is kind of a hack */
if (err && is_writable)
make_readonly();
}
while(err && is_writable);
if (err)
goto error;
}
/* set to default state, but only change the UI state */
change_state(m_default_state, CASSETTE_MASK_UISTATE);
/* reset the position */
m_position = 0.0;
m_position_time = device().machine().time().as_double();
/* default channel to 0, speed multiplier to 1 */
m_channel = 0;
m_speed = 1;
m_direction = 1;
return IMAGE_INIT_PASS;
error:
image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;
switch(err)
{
case CASSETTE_ERROR_INTERNAL:
imgerr = IMAGE_ERROR_INTERNAL;
break;
case CASSETTE_ERROR_UNSUPPORTED:
imgerr = IMAGE_ERROR_UNSUPPORTED;
break;
case CASSETTE_ERROR_OUTOFMEMORY:
imgerr = IMAGE_ERROR_OUTOFMEMORY;
break;
case CASSETTE_ERROR_INVALIDIMAGE:
imgerr = IMAGE_ERROR_INVALIDIMAGE;
break;
default:
imgerr = IMAGE_ERROR_UNSPECIFIED;
break;
}
image->seterror(imgerr, "" );
return IMAGE_INIT_FAIL;
}
image_init_result cassette_image_device::internal_load(bool is_create)
{
cassette_image::error err;
device_image_interface *image = nullptr;
interface(image);
if (is_create)
{
// creating an image
err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette);
if (err != cassette_image::error::SUCCESS)
goto error;
}
else
{
// opening an image
bool retry;
do
{
// we probably don't want to retry...
retry = false;
// try opening the cassette
int cassette_flags = is_readonly()
? CASSETTE_FLAG_READONLY
: (CASSETTE_FLAG_READWRITE | CASSETTE_FLAG_SAVEONEXIT);
err = cassette_open_choices((void *)image, &image_ioprocs, filetype(), m_formats, cassette_flags, &m_cassette);
// special case - if we failed due to readwrite not being supported, make the image be read only and retry
if (err == cassette_image::error::READ_WRITE_UNSUPPORTED)
{
make_readonly();
retry = true;
}
}
while(retry);
if (err != cassette_image::error::SUCCESS)
goto error;
}
/* set to default state, but only change the UI state */
change_state(m_default_state, CASSETTE_MASK_UISTATE);
/* reset the position */
m_position = 0.0;
m_position_time = device().machine().time().as_double();
/* default channel to 0, speed multiplier to 1 */
m_channel = 0;
m_speed = 1;
m_direction = 1;
return image_init_result::PASS;
error:
image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;
switch(err)
{
case cassette_image::error::INTERNAL:
imgerr = IMAGE_ERROR_INTERNAL;
break;
case cassette_image::error::UNSUPPORTED:
imgerr = IMAGE_ERROR_UNSUPPORTED;
break;
case cassette_image::error::OUT_OF_MEMORY:
imgerr = IMAGE_ERROR_OUTOFMEMORY;
break;
case cassette_image::error::INVALID_IMAGE:
imgerr = IMAGE_ERROR_INVALIDIMAGE;
break;
default:
imgerr = IMAGE_ERROR_UNSPECIFIED;
break;
}
image->seterror(imgerr, "" );
return image_init_result::FAIL;
}
