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; }
int CLIB_DECL main(int argc, char *argv[]) { int i; int found =0; const struct CassetteFormat * const *selected_formats = NULL; cassette_image *cassette; FILE *f; if (argc > 1) { if (!core_stricmp("convert", argv[1])) { // convert command if (argc!=5) { fprintf(stderr, "Wrong parameter number.\n\n"); display_usage(); return -1; } else { for (i = 0; formats[i].name; i++) { if (core_stricmp(formats[i].name,argv[2])==0) { selected_formats = formats[i].formats; found = 1; } } if (found==0) { fprintf(stderr, "Wrong format name.\n\n"); display_usage(); fprintf(stderr, "\n"); display_formats(); return -1; } f = fopen(argv[3], "rb"); if (!f) { fprintf(stderr, "File %s not found.\n",argv[3]); return -1; } if (cassette_open_choices(f, &stdio_ioprocs, get_extension(argv[3]), selected_formats, CASSETTE_FLAG_READONLY, &cassette)) { fprintf(stderr, "Invalid format of input file.\n"); fclose(f); return -1; } cassette_dump(cassette,argv[4]); cassette_close(cassette); fclose(f); goto theend; } } } /* Usage */ fprintf(stderr, "castool - Generic cassette manipulation tool for use with MESS\n\n"); display_usage(); fprintf(stderr, "\n"); display_formats(); fprintf(stderr, "\nExample usage:\n"); fprintf(stderr, " castool.exe convert tzx game.tzx game.wav\n\n"); theend : return 0; }
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; }