diff options
Diffstat (limited to 'src')
47 files changed, 314 insertions, 310 deletions
diff --git a/src/devices/imagedev/cassette.cpp b/src/devices/imagedev/cassette.cpp index 0a7671cffd5..14ea57cf4d9 100644 --- a/src/devices/imagedev/cassette.cpp +++ b/src/devices/imagedev/cassette.cpp @@ -263,7 +263,7 @@ image_init_result cassette_image_device::call_load() image_init_result cassette_image_device::internal_load(bool is_create) { - casserr_t err; + cassette_image::error err; int cassette_flags; bool is_writable; device_image_interface *image = nullptr; @@ -273,7 +273,7 @@ image_init_result cassette_image_device::internal_load(bool 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) + if (err != cassette_image::error::SUCCESS) goto error; } else @@ -285,9 +285,9 @@ image_init_result cassette_image_device::internal_load(bool is_create) cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY; err = cassette_open_choices((void *)image, &image_ioprocs, filetype(), m_formats, cassette_flags, &m_cassette); } - while(err && is_writable); + while(err != cassette_image::error::SUCCESS && is_writable); - if (err) + if (err != cassette_image::error::SUCCESS) goto error; } @@ -309,16 +309,16 @@ error: image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED; switch(err) { - case CASSETTE_ERROR_INTERNAL: + case cassette_image::error::INTERNAL: imgerr = IMAGE_ERROR_INTERNAL; break; - case CASSETTE_ERROR_UNSUPPORTED: + case cassette_image::error::UNSUPPORTED: imgerr = IMAGE_ERROR_UNSUPPORTED; break; - case CASSETTE_ERROR_OUTOFMEMORY: + case cassette_image::error::OUT_OF_MEMORY: imgerr = IMAGE_ERROR_OUTOFMEMORY; break; - case CASSETTE_ERROR_INVALIDIMAGE: + case cassette_image::error::INVALID_IMAGE: imgerr = IMAGE_ERROR_INVALIDIMAGE; break; default: diff --git a/src/lib/formats/a26_cas.cpp b/src/lib/formats/a26_cas.cpp index d13b5270b45..2e76eea73a0 100644 --- a/src/lib/formats/a26_cas.cpp +++ b/src/lib/formats/a26_cas.cpp @@ -142,17 +142,17 @@ static const struct CassetteLegacyWaveFiller a26_legacy_fill_wave = { 0 }; -static casserr_t a26_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error a26_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { UINT64 size; size = cassette_image_size( cassette ); if ( size == A26_CAS_SIZE ) { return cassette_legacy_identify( cassette, opts, &a26_legacy_fill_wave ); } - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; } -static casserr_t a26_cassette_load( cassette_image *cassette ) { +static cassette_image::error a26_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &a26_legacy_fill_wave ); } diff --git a/src/lib/formats/ace_tap.cpp b/src/lib/formats/ace_tap.cpp index e247b0803d6..6d0e4ad2c6e 100644 --- a/src/lib/formats/ace_tap.cpp +++ b/src/lib/formats/ace_tap.cpp @@ -167,13 +167,13 @@ static const struct CassetteLegacyWaveFiller ace_legacy_fill_wave = }; -static casserr_t ace_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error ace_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &ace_legacy_fill_wave); } -static casserr_t ace_tap_load(cassette_image *cassette) +static cassette_image::error ace_tap_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &ace_legacy_fill_wave); } diff --git a/src/lib/formats/adam_cas.cpp b/src/lib/formats/adam_cas.cpp index 644be2cd0cc..30deb27a1a9 100644 --- a/src/lib/formats/adam_cas.cpp +++ b/src/lib/formats/adam_cas.cpp @@ -50,19 +50,19 @@ Data is phase encoded, with 70us bit cells with a transition at 31us for a 1 and ****************************************************************/ -static casserr_t coladam_ddp_identify ( cassette_image *cass, struct CassetteOptions *opts ) +static cassette_image::error coladam_ddp_identify ( cassette_image *cass, struct CassetteOptions *opts ) { opts -> bits_per_sample = 16; opts -> channels = 2; opts -> sample_frequency = 44100; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } // Store byte of data -casserr_t coladam_put_byte(cassette_image *cass, int channel, double *time_index, int byte, int *prev_sign) +cassette_image::error coladam_put_byte(cassette_image *cass, int channel, double *time_index, int byte, int *prev_sign) { - casserr_t err = CASSETTE_ERROR_SUCCESS; + cassette_image::error err = cassette_image::error::SUCCESS; for (int i = 0; i < 8; i++) { if(byte & 0x80) @@ -83,11 +83,11 @@ casserr_t coladam_put_byte(cassette_image *cass, int channel, double *time_index return err; } -casserr_t coladam_put_block(cassette_image *cass, int channel, double *time_index, int *prev_sign, int block_index, UINT8 *buffer, int layout_type) +cassette_image::error coladam_put_block(cassette_image *cass, int channel, double *time_index, int *prev_sign, int block_index, UINT8 *buffer, int layout_type) { int i, checksum_16=0; UINT8 header[] = { 0x16, 0x48, 0x45, 0x00, static_cast<UINT8>(block_index), 0xff, static_cast<UINT8>(0xff - block_index), 0x00, 0x80, 0xf4 }; - casserr_t err; + cassette_image::error err; if (layout_type == TYPE_GW) { header[1] = 0x47; @@ -126,12 +126,12 @@ casserr_t coladam_put_block(cassette_image *cass, int channel, double *time_inde } -static casserr_t coladam_ddp_load( cassette_image *cass ) +static cassette_image::error coladam_ddp_load( cassette_image *cass ) { double time = 0.; int i, block, prev_sign=-1; UINT8 buffer[0x400]; - casserr_t err = CASSETTE_ERROR_SUCCESS; + cassette_image::error err = cassette_image::error::SUCCESS; // It would appear that data packs that originally had the type GW data layout and headers work fine when converted to type // HE. Thus we set all tapes to type HE. diff --git a/src/lib/formats/apf_apt.cpp b/src/lib/formats/apf_apt.cpp index f1a333f2c77..d2064122d82 100644 --- a/src/lib/formats/apf_apt.cpp +++ b/src/lib/formats/apf_apt.cpp @@ -195,12 +195,12 @@ static const struct CassetteLegacyWaveFiller apf_cpf_fill_intf = 0 /* trailer_samples */ }; -static casserr_t apf_cpf_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error apf_cpf_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &apf_cpf_fill_intf); } -static casserr_t apf_cpf_load(cassette_image *cassette) +static cassette_image::error apf_cpf_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &apf_cpf_fill_intf); } @@ -226,12 +226,12 @@ static const struct CassetteLegacyWaveFiller apf_apt_fill_intf = 0 /* trailer_samples */ }; -static casserr_t apf_apt_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error apf_apt_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &apf_apt_fill_intf); } -static casserr_t apf_apt_load(cassette_image *cassette) +static cassette_image::error apf_apt_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &apf_apt_fill_intf); } diff --git a/src/lib/formats/atom_tap.cpp b/src/lib/formats/atom_tap.cpp index 917500eace1..f3ab980a8fa 100644 --- a/src/lib/formats/atom_tap.cpp +++ b/src/lib/formats/atom_tap.cpp @@ -80,7 +80,7 @@ static UINT8 cassette_image_read_uint8(cassette_image *cassette, UINT64 offset) atom_tap_identify - identify cassette -------------------------------------------------*/ -static casserr_t atom_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error atom_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_modulation_identify( cassette, &atom_tap_modulation, opts); } @@ -92,15 +92,15 @@ static casserr_t atom_tap_identify(cassette_image *cassette, struct CassetteOpti #define MODULATE(_value) \ for (int i = 0; i < (_value ? 8 : 4); i++) { \ err = cassette_put_modulated_data_bit(cassette, 0, time_index, _value, &atom_tap_modulation, &time_displacement);\ - if (err) return err;\ + if (err != cassette_image::error::SUCCESS) return err;\ time_index += time_displacement;\ } #define BIT(x,n) (((x)>>(n))&1) -static casserr_t atom_tap_load(cassette_image *cassette) +static cassette_image::error atom_tap_load(cassette_image *cassette) { - casserr_t err; + cassette_image::error err; UINT64 image_size = cassette_image_size(cassette); UINT64 image_pos = 0; double time_index = 0.0; @@ -126,7 +126,7 @@ static casserr_t atom_tap_load(cassette_image *cassette) image_pos++; } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } /*------------------------------------------------- diff --git a/src/lib/formats/camplynx_cas.cpp b/src/lib/formats/camplynx_cas.cpp index 15ed26c8201..330df5601a1 100644 --- a/src/lib/formats/camplynx_cas.cpp +++ b/src/lib/formats/camplynx_cas.cpp @@ -175,22 +175,22 @@ static const struct CassetteLegacyWaveFiller lynx128k_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t lynx48k_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error lynx48k_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &lynx48k_legacy_fill_wave); } -static casserr_t lynx128k_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error lynx128k_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &lynx128k_legacy_fill_wave); } -static casserr_t lynx48k_cassette_load(cassette_image *cassette) +static cassette_image::error lynx48k_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &lynx48k_legacy_fill_wave); } -static casserr_t lynx128k_cassette_load(cassette_image *cassette) +static cassette_image::error lynx128k_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &lynx128k_legacy_fill_wave); } diff --git a/src/lib/formats/cassimg.cpp b/src/lib/formats/cassimg.cpp index cfa8e246a01..36297aa6c88 100644 --- a/src/lib/formats/cassimg.cpp +++ b/src/lib/formats/cassimg.cpp @@ -96,9 +96,9 @@ static cassette_image *cassette_init(const struct CassetteFormat *format, void * -static void cassette_finishinit(casserr_t err, cassette_image *cassette, cassette_image **outcassette) +static void cassette_finishinit(cassette_image::error err, cassette_image *cassette, cassette_image **outcassette) { - if (cassette && (err || !outcassette)) + if (cassette && ((err != cassette_image::error::SUCCESS) || !outcassette)) { cassette_close(cassette); cassette = nullptr; @@ -120,10 +120,10 @@ static bool good_format(const struct CassetteFormat *format, const std::string & -casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const std::string &extension, +cassette_image::error cassette_open_choices(void *file, const struct io_procs *procs, const std::string &extension, const struct CassetteFormat *const *formats, int flags, cassette_image **outcassette) { - casserr_t err; + cassette_image::error err; cassette_image *cassette; const struct CassetteFormat *format; struct CassetteOptions opts = {0, }; @@ -137,7 +137,7 @@ casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const cassette = cassette_init(nullptr, file, procs, flags); if (!cassette) { - err = CASSETTE_ERROR_OUTOFMEMORY; + err = cassette_image::error::OUT_OF_MEMORY; goto done; } @@ -150,9 +150,9 @@ casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const format = formats[i]; memset(&opts, 0, sizeof(opts)); err = format->identify(cassette, &opts); - if (err == CASSETTE_ERROR_INVALIDIMAGE) + if (err == cassette_image::error::INVALID_IMAGE) format = nullptr; - else if (err) + else if (err != cassette_image::error::SUCCESS) goto done; } } @@ -160,7 +160,7 @@ casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const /* have we found a proper format */ if (!format) { - err = CASSETTE_ERROR_INVALIDIMAGE; + err = cassette_image::error::INVALID_IMAGE; goto done; } cassette->format = format; @@ -171,12 +171,12 @@ casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const /* load the image */ err = format->load(cassette); - if (err) + if (err != cassette_image::error::SUCCESS) goto done; /* success */ cassette->flags &= ~CASSETTE_FLAG_DIRTY; - err = CASSETTE_ERROR_SUCCESS; + err = cassette_image::error::SUCCESS; done: cassette_finishinit(err, cassette, outcassette); @@ -185,7 +185,7 @@ done: -casserr_t cassette_open(void *file, const struct io_procs *procs, +cassette_image::error cassette_open(void *file, const struct io_procs *procs, const struct CassetteFormat *format, int flags, cassette_image **outcassette) { const struct CassetteFormat *formats[2]; @@ -196,20 +196,20 @@ casserr_t cassette_open(void *file, const struct io_procs *procs, -casserr_t cassette_create(void *file, const struct io_procs *procs, const struct CassetteFormat *format, +cassette_image::error cassette_create(void *file, const struct io_procs *procs, const struct CassetteFormat *format, const struct CassetteOptions *opts, int flags, cassette_image **outcassette) { - casserr_t err; + cassette_image::error err; cassette_image *cassette; static const struct CassetteOptions default_options = { 1, 16, 44100 }; /* cannot create to a read only image */ if (flags & CASSETTE_FLAG_READONLY) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; /* is this a good format? */ if (!good_format(format, nullptr, flags)) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; /* normalize arguments */ if (!opts) @@ -219,7 +219,7 @@ casserr_t cassette_create(void *file, const struct io_procs *procs, const struct cassette = cassette_init(format, file, procs, flags); if (!cassette) { - err = CASSETTE_ERROR_OUTOFMEMORY; + err = cassette_image::error::OUT_OF_MEMORY; goto done; } @@ -227,7 +227,7 @@ casserr_t cassette_create(void *file, const struct io_procs *procs, const struct cassette->channels = opts->channels; cassette->sample_frequency = opts->sample_frequency; - err = CASSETTE_ERROR_SUCCESS; + err = cassette_image::error::SUCCESS; done: cassette_finishinit(err, cassette, outcassette); @@ -236,7 +236,7 @@ done: -static casserr_t cassette_perform_save(cassette_image *cassette) +static cassette_image::error cassette_perform_save(cassette_image *cassette) { struct CassetteInfo info; cassette_get_info(cassette, &info); @@ -245,19 +245,19 @@ static casserr_t cassette_perform_save(cassette_image *cassette) -casserr_t cassette_save(cassette_image *cassette) +cassette_image::error cassette_save(cassette_image *cassette) { - casserr_t err; + cassette_image::error err; if (!cassette->format || !cassette->format->save) - return CASSETTE_ERROR_UNSUPPORTED; + return cassette_image::error::UNSUPPORTED; err = cassette_perform_save(cassette); - if (err) + if (err != cassette_image::error::SUCCESS) return err; cassette->flags &= ~CASSETTE_FLAG_DIRTY; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } @@ -350,7 +350,7 @@ static size_t my_round(double d) -static casserr_t compute_manipulation_ranges(cassette_image *cassette, int channel, +static cassette_image::error compute_manipulation_ranges(cassette_image *cassette, int channel, double time_index, double sample_period, struct manipulation_ranges *ranges) { if (channel < 0) @@ -370,12 +370,12 @@ static casserr_t compute_manipulation_ranges(cassette_image *cassette, int chann if (ranges->sample_last > ranges->sample_first) ranges->sample_last--; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -static casserr_t lookup_sample(cassette_image *cassette, int channel, size_t sample, INT32 **ptr) +static cassette_image::error lookup_sample(cassette_image *cassette, int channel, size_t sample, INT32 **ptr) { *ptr = nullptr; size_t sample_blocknum = (sample / SAMPLES_PER_BLOCK) * cassette->channels + channel; @@ -401,7 +401,7 @@ static casserr_t lookup_sample(cassette_image *cassette, int channel, size_t sam } *ptr = &block[sample_index]; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } @@ -410,11 +410,11 @@ static casserr_t lookup_sample(cassette_image *cassette, int channel, size_t sam waveform accesses *********************************************************************/ -casserr_t cassette_get_samples(cassette_image *cassette, int channel, +cassette_image::error cassette_get_samples(cassette_image *cassette, int channel, double time_index, double sample_period, size_t sample_count, size_t sample_bytes, void *samples, int waveform_flags) { - casserr_t err; + cassette_image::error err; struct manipulation_ranges ranges; size_t sample_index; size_t cassette_sample_index; @@ -428,7 +428,7 @@ casserr_t cassette_get_samples(cassette_image *cassette, int channel, assert(cassette); err = compute_manipulation_ranges(cassette, channel, time_index, sample_period, &ranges); - if (err) + if (err != cassette_image::error::SUCCESS) return err; for (sample_index = 0; sample_index < sample_count; sample_index++) @@ -441,7 +441,7 @@ casserr_t cassette_get_samples(cassette_image *cassette, int channel, d = map_double(ranges.sample_last + 1 - ranges.sample_first, 0, sample_count, sample_index) + ranges.sample_first; cassette_sample_index = (size_t) d; err = lookup_sample(cassette, channel, cassette_sample_index, (INT32 **) &source_ptr); - if (err) + if (err != cassette_image::error::SUCCESS) return err; sum += *source_ptr; @@ -472,16 +472,16 @@ casserr_t cassette_get_samples(cassette_image *cassette, int channel, break; } } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -casserr_t cassette_put_samples(cassette_image *cassette, int channel, +cassette_image::error cassette_put_samples(cassette_image *cassette, int channel, double time_index, double sample_period, size_t sample_count, size_t sample_bytes, const void *samples, int waveform_flags) { - casserr_t err; + cassette_image::error err; struct manipulation_ranges ranges; size_t sample_index; INT32 *dest_ptr; @@ -492,13 +492,13 @@ casserr_t cassette_put_samples(cassette_image *cassette, int channel, double d; if (!cassette) - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; if (sample_period == 0) - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; err = compute_manipulation_ranges(cassette, channel, time_index, sample_period, &ranges); - if (err) + if (err != cassette_image::error::SUCCESS) return err; if (cassette->sample_count < ranges.sample_last+1) @@ -540,24 +540,24 @@ casserr_t cassette_put_samples(cassette_image *cassette, int channel, dest_value = dword; break; default: - return CASSETTE_ERROR_INTERNAL; + return cassette_image::error::INTERNAL; } for (channel = ranges.channel_first; channel <= ranges.channel_last; channel++) { /* find the sample that we are putting */ err = lookup_sample(cassette, channel, sample_index, &dest_ptr); - if (err) + if (err != cassette_image::error::SUCCESS) return err; *dest_ptr = dest_value; } } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -casserr_t cassette_get_sample(cassette_image *cassette, int channel, +cassette_image::error cassette_get_sample(cassette_image *cassette, int channel, double time_index, double sample_period, INT32 *sample) { return cassette_get_samples(cassette, channel, time_index, @@ -566,7 +566,7 @@ casserr_t cassette_get_sample(cassette_image *cassette, int channel, -casserr_t cassette_put_sample(cassette_image *cassette, int channel, +cassette_image::error cassette_put_sample(cassette_image *cassette, int channel, double time_index, double sample_period, INT32 sample) { return cassette_put_samples(cassette, channel, time_index, @@ -579,10 +579,10 @@ casserr_t cassette_put_sample(cassette_image *cassette, int channel, waveform accesses to/from the raw image *********************************************************************/ -casserr_t cassette_read_samples(cassette_image *cassette, int channels, double time_index, +cassette_image::error cassette_read_samples(cassette_image *cassette, int channels, double time_index, double sample_period, size_t sample_count, UINT64 offset, int waveform_flags) { - casserr_t err; + cassette_image::error err; size_t chunk_sample_count; size_t bytes_per_sample; size_t sample_bytes; @@ -607,22 +607,22 @@ casserr_t cassette_read_samples(cassette_image *cassette, int channels, double t { err = cassette_put_samples(cassette, channel, chunk_time_index, chunk_sample_period, chunk_sample_count, sample_bytes, &buffer[channel * bytes_per_sample], waveform_flags); - if (err) + if (err != cassette_image::error::SUCCESS) return err; } offset += chunk_sample_count * sample_bytes; samples_loaded += chunk_sample_count; } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -casserr_t cassette_write_samples(cassette_image *cassette, int channels, double time_index, +cassette_image::error cassette_write_samples(cassette_image *cassette, int channels, double time_index, double sample_period, size_t sample_count, UINT64 offset, int waveform_flags) { - casserr_t err; + cassette_image::error err; size_t chunk_sample_count; size_t bytes_per_sample; size_t sample_bytes; @@ -645,7 +645,7 @@ casserr_t cassette_write_samples(cassette_image *cassette, int channels, double { err = cassette_get_samples(cassette, channel, chunk_time_index, chunk_sample_period, chunk_sample_count, sample_bytes, &buffer[channel * bytes_per_sample], waveform_flags); - if (err) + if (err != cassette_image::error::SUCCESS) return err; } @@ -654,7 +654,7 @@ casserr_t cassette_write_samples(cassette_image *cassette, int channels, double offset += chunk_sample_count * sample_bytes; samples_saved += chunk_sample_count; } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } @@ -682,7 +682,7 @@ static const INT8 *choose_wave(const struct CassetteModulation *modulation, size -casserr_t cassette_modulation_identify(cassette_image *cassette, const struct CassetteModulation *modulation, +cassette_image::error cassette_modulation_identify(cassette_image *cassette, const struct CassetteModulation *modulation, struct CassetteOptions *opts) { size_t wave_bytes_length; @@ -690,16 +690,16 @@ casserr_t cassette_modulation_identify(cassette_image *cassette, const struct Ca opts->bits_per_sample = 8; opts->channels = 1; opts->sample_frequency = (UINT32) (std::max(modulation->zero_frequency_high, modulation->one_frequency_high) * wave_bytes_length * 2); - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -casserr_t cassette_put_modulated_data(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_put_modulated_data(cassette_image *cassette, int channel, double time_index, const void *data, size_t data_length, const struct CassetteModulation *modulation, double *time_displacement) { - casserr_t err; + cassette_image::error err; const UINT8 *data_bytes = (const UINT8 *)data; const INT8 *wave_bytes; size_t wave_bytes_length; @@ -719,13 +719,13 @@ casserr_t cassette_put_modulated_data(cassette_image *cassette, int channel, dou pulse_frequency = (b & (1 << i)) ? modulation->one_frequency_cannonical : modulation->zero_frequency_cannonical; pulse_period = 1 / pulse_frequency; err = cassette_put_samples(cassette, 0, time_index, pulse_period, wave_bytes_length, 1, wave_bytes, CASSETTE_WAVEFORM_8BIT); - if (err) + if (err != cassette_image::error::SUCCESS) goto done; time_index += pulse_period; total_displacement += pulse_period; } } - err = CASSETTE_ERROR_SUCCESS; + err = cassette_image::error::SUCCESS; done: if (time_displacement) @@ -735,18 +735,18 @@ done: -casserr_t cassette_put_modulated_filler(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_put_modulated_filler(cassette_image *cassette, int channel, double time_index, UINT8 filler, size_t filler_length, const struct CassetteModulation *modulation, double *time_displacement) { - casserr_t err; + cassette_image::error err; double delta; double total_displacement = 0.0; while(filler_length--) { err = cassette_put_modulated_data(cassette, channel, time_index, &filler, 1, modulation, &delta); - if (err) + if (err != cassette_image::error::SUCCESS) return err; total_displacement += delta; time_index += delta; @@ -754,16 +754,16 @@ casserr_t cassette_put_modulated_filler(cassette_image *cassette, int channel, d if (time_displacement) *time_displacement = total_displacement; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -casserr_t cassette_read_modulated_data(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_read_modulated_data(cassette_image *cassette, int channel, double time_index, UINT64 offset, UINT64 length, const struct CassetteModulation *modulation, double *time_displacement) { - casserr_t err; + cassette_image::error err; UINT8 buffer_stack[1024]; UINT8 *buffer; UINT8 *alloc_buffer = nullptr; @@ -783,7 +783,7 @@ casserr_t cassette_read_modulated_data(cassette_image *cassette, int channel, do alloc_buffer = (UINT8*)malloc(buffer_length); if (!alloc_buffer) { - err = CASSETTE_ERROR_OUTOFMEMORY; + err = cassette_image::error::OUT_OF_MEMORY; goto done; } buffer = alloc_buffer; @@ -795,7 +795,7 @@ casserr_t cassette_read_modulated_data(cassette_image *cassette, int channel, do cassette_image_read(cassette, buffer, offset, this_length); err = cassette_put_modulated_data(cassette, channel, time_index, buffer, this_length, modulation, &delta); - if (err) + if (err != cassette_image::error::SUCCESS) goto done; total_displacement += delta; time_index += delta; @@ -804,7 +804,7 @@ casserr_t cassette_read_modulated_data(cassette_image *cassette, int channel, do if (time_displacement) *time_displacement = total_displacement; - err = CASSETTE_ERROR_SUCCESS; + err = cassette_image::error::SUCCESS; done: if (alloc_buffer) @@ -814,11 +814,11 @@ done: -casserr_t cassette_put_modulated_data_bit(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_put_modulated_data_bit(cassette_image *cassette, int channel, double time_index, UINT8 data, const struct CassetteModulation *modulation, double *time_displacement) { - casserr_t err; + cassette_image::error err; const INT8 *wave_bytes; size_t wave_bytes_length; double total_displacement = 0.0; @@ -830,12 +830,12 @@ casserr_t cassette_put_modulated_data_bit(cassette_image *cassette, int channel, pulse_frequency = (data) ? modulation->one_frequency_cannonical : modulation->zero_frequency_cannonical; pulse_period = 1 / pulse_frequency; err = cassette_put_samples(cassette, 0, time_index, pulse_period, wave_bytes_length, 1, wave_bytes, CASSETTE_WAVEFORM_8BIT); - if (err) + if (err != cassette_image::error::SUCCESS) goto done; time_index += pulse_period; total_displacement += pulse_period; - err = CASSETTE_ERROR_SUCCESS; + err = cassette_image::error::SUCCESS; done: if (time_displacement) @@ -849,21 +849,21 @@ done: waveform accesses to/from the raw image *********************************************************************/ -casserr_t cassette_legacy_identify(cassette_image *cassette, struct CassetteOptions *opts, +cassette_image::error cassette_legacy_identify(cassette_image *cassette, struct CassetteOptions *opts, const struct CassetteLegacyWaveFiller *legacy_args) { opts->channels = 1; opts->bits_per_sample = 16; opts->sample_frequency = legacy_args->sample_frequency; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -casserr_t cassette_legacy_construct(cassette_image *cassette, +cassette_image::error cassette_legacy_construct(cassette_image *cassette, const struct CassetteLegacyWaveFiller *legacy_args) { - casserr_t err; + cassette_image::error err; int length; int sample_count; dynamic_buffer bytes; @@ -898,7 +898,7 @@ casserr_t cassette_legacy_construct(cassette_image *cassette, { if (size > 0x7FFFFFFF) { - err = CASSETTE_ERROR_OUTOFMEMORY; + err = cassette_image::error::OUT_OF_MEMORY; goto done; } @@ -925,7 +925,7 @@ casserr_t cassette_legacy_construct(cassette_image *cassette, length = args.fill_wave(&samples[pos], sample_count - pos, CODE_HEADER); if (length < 0) { - err = CASSETTE_ERROR_INVALIDIMAGE; + err = cassette_image::error::INVALID_IMAGE; goto done; } pos += length; @@ -940,7 +940,7 @@ casserr_t cassette_legacy_construct(cassette_image *cassette, length = args.fill_wave(&samples[pos], sample_count - pos, &chunk[0]); if (length < 0) { - err = CASSETTE_ERROR_INVALIDIMAGE; + err = cassette_image::error::INVALID_IMAGE; goto done; } pos += length; @@ -954,7 +954,7 @@ casserr_t cassette_legacy_construct(cassette_image *cassette, length = args.fill_wave(&samples[pos], sample_count - pos, CODE_TRAILER); if (length < 0) { - err = CASSETTE_ERROR_INVALIDIMAGE; + err = cassette_image::error::INVALID_IMAGE; goto done; } pos += length; @@ -963,11 +963,11 @@ casserr_t cassette_legacy_construct(cassette_image *cassette, /* specify the wave */ err = cassette_put_samples(cassette, 0, 0.0, ((double) pos) / args.sample_frequency, pos, 2, &samples[0], CASSETTE_WAVEFORM_16BIT); - if (err) + if (err != cassette_image::error::SUCCESS) goto done; /* success! */ - err = CASSETTE_ERROR_SUCCESS; + err = cassette_image::error::SUCCESS; #if DUMP_CASSETTES cassette_dump(cassette, "C:\\TEMP\\CASDUMP.WAV"); diff --git a/src/lib/formats/cassimg.h b/src/lib/formats/cassimg.h index 5b585df5804..6dcf5b4b118 100644 --- a/src/lib/formats/cassimg.h +++ b/src/lib/formats/cassimg.h @@ -19,6 +19,11 @@ #define LOG_FORMATS if (0) printf #endif +// hack to get around rogues that define this +#ifdef UNSUPPORTED +#undef UNSUPPORTED +#endif + /*************************************************************************** Constants @@ -61,16 +66,6 @@ ***************************************************************************/ -typedef enum -{ - CASSETTE_ERROR_SUCCESS, /* no error */ - CASSETTE_ERROR_INTERNAL, /* fatal internal error */ - CASSETTE_ERROR_UNSUPPORTED, /* this operation is unsupported */ - CASSETTE_ERROR_OUTOFMEMORY, /* ran out of memory */ - CASSETTE_ERROR_INVALIDIMAGE /* invalid image */ -} -casserr_t; - typedef std::vector<INT32> sample_block; struct CassetteOptions @@ -90,6 +85,15 @@ struct CassetteInfo struct cassette_image { + enum class error + { + SUCCESS, // no error + INTERNAL, // fatal internal error + UNSUPPORTED, // this operation is unsupported + OUT_OF_MEMORY, // ran out of memory + INVALID_IMAGE // invalid image + }; + const struct CassetteFormat *format; struct io_generic io; @@ -104,9 +108,9 @@ struct cassette_image struct CassetteFormat { const char *extensions; - casserr_t (*identify)(cassette_image *cassette, struct CassetteOptions *opts); - casserr_t (*load)(cassette_image *cassette); - casserr_t (*save)(cassette_image *cassette, const struct CassetteInfo *info); + cassette_image::error (*identify)(cassette_image *cassette, struct CassetteOptions *opts); + cassette_image::error (*load)(cassette_image *cassette); + cassette_image::error (*save)(cassette_image *cassette, const struct CassetteInfo *info); }; /* used for the core modulation code */ @@ -158,13 +162,13 @@ CASSETTE_FORMATLIST_EXTERN(cassette_default_formats); ***************************************************************************/ -casserr_t cassette_open(void *file, const struct io_procs *procs, +cassette_image::error cassette_open(void *file, const struct io_procs *procs, const struct CassetteFormat *format, int flags, cassette_image **outcassette); -casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const std::string &extension, +cassette_image::error cassette_open_choices(void *file, const struct io_procs *procs, const std::string &extension, const struct CassetteFormat *const *formats, int flags, cassette_image **outcassette); -casserr_t cassette_create(void *file, const struct io_procs *procs, const struct CassetteFormat *format, +cassette_image::error cassette_create(void *file, const struct io_procs *procs, const struct CassetteFormat *format, const struct CassetteOptions *opts, int flags, cassette_image **outcassette); -casserr_t cassette_save(cassette_image *cassette); +cassette_image::error cassette_save(cassette_image *cassette); void cassette_close(cassette_image *cassette); void cassette_change(cassette_image *cassette, void *file, const struct io_procs *procs, const struct CassetteFormat *format, int flags); void cassette_get_info(cassette_image *cassette, struct CassetteInfo *info); @@ -175,36 +179,36 @@ void cassette_image_write(cassette_image *cassette, const void *buffer, UINT64 o UINT64 cassette_image_size(cassette_image *cassette); /* waveform accesses */ -casserr_t cassette_get_samples(cassette_image *cassette, int channel, +cassette_image::error cassette_get_samples(cassette_image *cassette, int channel, double time_index, double sample_period, size_t sample_count, size_t sample_bytes, void *samples, int waveform_flags); -casserr_t cassette_put_samples(cassette_image *cassette, int channel, +cassette_image::error cassette_put_samples(cassette_image *cassette, int channel, double time_index, double sample_period, size_t sample_count, size_t sample_bytes, const void *samples, int waveform_flags); -casserr_t cassette_get_sample(cassette_image *cassette, int channel, +cassette_image::error cassette_get_sample(cassette_image *cassette, int channel, double time_index, double sample_period, INT32 *sample); -casserr_t cassette_put_sample(cassette_image *cassette, int channel, +cassette_image::error cassette_put_sample(cassette_image *cassette, int channel, double time_index, double sample_period, INT32 sample); /* waveform accesses to/from the raw image */ -casserr_t cassette_read_samples(cassette_image *cassette, int channels, double time_index, +cassette_image::error cassette_read_samples(cassette_image *cassette, int channels, double time_index, double sample_period, size_t sample_count, UINT64 offset, int waveform_flags); -casserr_t cassette_write_samples(cassette_image *cassette, int channels, double time_index, +cassette_image::error cassette_write_samples(cassette_image *cassette, int channels, double time_index, double sample_period, size_t sample_count, UINT64 offset, int waveform_flags); /* modulation support */ -casserr_t cassette_modulation_identify(cassette_image *cassette, const struct CassetteModulation *modulation, +cassette_image::error cassette_modulation_identify(cassette_image *cassette, const struct CassetteModulation *modulation, struct CassetteOptions *opts); -casserr_t cassette_put_modulated_data(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_put_modulated_data(cassette_image *cassette, int channel, double time_index, const void *data, size_t data_length, const struct CassetteModulation *modulation, double *time_displacement); -casserr_t cassette_put_modulated_filler(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_put_modulated_filler(cassette_image *cassette, int channel, double time_index, UINT8 filler, size_t filler_length, const struct CassetteModulation *modulation, double *time_displacement); -casserr_t cassette_read_modulated_data(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_read_modulated_data(cassette_image *cassette, int channel, double time_index, UINT64 offset, UINT64 length, const struct CassetteModulation *modulation, double *time_displacement); -casserr_t cassette_put_modulated_data_bit(cassette_image *cassette, int channel, double time_index, +cassette_image::error cassette_put_modulated_data_bit(cassette_image *cassette, int channel, double time_index, UINT8 data, const struct CassetteModulation *modulation, double *time_displacement); @@ -214,9 +218,9 @@ void cassette_dump(cassette_image *image, const char *filename); /* legacy code support */ #define CODE_HEADER ((UINT8*)-1) #define CODE_TRAILER ((UINT8*)-2) -casserr_t cassette_legacy_identify(cassette_image *cassette, struct CassetteOptions *opts, +cassette_image::error cassette_legacy_identify(cassette_image *cassette, struct CassetteOptions *opts, const struct CassetteLegacyWaveFiller *legacy_args); -casserr_t cassette_legacy_construct(cassette_image *cassette, +cassette_image::error cassette_legacy_construct(cassette_image *cassette, const struct CassetteLegacyWaveFiller *legacy_args); #endif /* CASSIMG_H */ diff --git a/src/lib/formats/cbm_tap.cpp b/src/lib/formats/cbm_tap.cpp index 1293d3c531d..a7b28a8f8af 100644 --- a/src/lib/formats/cbm_tap.cpp +++ b/src/lib/formats/cbm_tap.cpp @@ -348,13 +348,13 @@ static const struct CassetteLegacyWaveFiller cbm_legacy_fill_wave = { }; -static casserr_t cbm_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) +static cassette_image::error cbm_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &cbm_legacy_fill_wave ); } -static casserr_t cbm_cassette_load( cassette_image *cassette ) +static cassette_image::error cbm_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &cbm_legacy_fill_wave ); } diff --git a/src/lib/formats/cgen_cas.cpp b/src/lib/formats/cgen_cas.cpp index 9bb77842618..17ad904c630 100644 --- a/src/lib/formats/cgen_cas.cpp +++ b/src/lib/formats/cgen_cas.cpp @@ -136,13 +136,13 @@ static const struct CassetteLegacyWaveFiller cgenie_cas_legacy_fill_wave = }; -static casserr_t cgenie_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error cgenie_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &cgenie_cas_legacy_fill_wave); } -static casserr_t cgenie_cas_load(cassette_image *cassette) +static cassette_image::error cgenie_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &cgenie_cas_legacy_fill_wave); } diff --git a/src/lib/formats/coco_cas.cpp b/src/lib/formats/coco_cas.cpp index d9599aa8c5a..cf711718a34 100644 --- a/src/lib/formats/coco_cas.cpp +++ b/src/lib/formats/coco_cas.cpp @@ -54,7 +54,7 @@ const struct CassetteModulation coco_cas_modulation = -static casserr_t coco_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error coco_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_modulation_identify(cassette, &coco_cas_modulation, opts); } @@ -150,9 +150,9 @@ static int get_cas_block(cassette_image *cassette, UINT64 *offset, UINT8 *block, -static casserr_t cas_load(cassette_image *cassette, UINT8 silence) +static cassette_image::error cas_load(cassette_image *cassette, UINT8 silence) { - casserr_t err; + cassette_image::error err; UINT64 offset; UINT64 image_size; UINT8 block[258]; /* 255 bytes per block + 3 (type, length, checksum) */ @@ -195,7 +195,7 @@ static casserr_t cas_load(cassette_image *cassette, UINT8 silence) #endif err = cassette_put_sample(cassette, 0, time_index, COCO_WAVESAMPLES_HEADER, 0); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += COCO_WAVESAMPLES_HEADER; @@ -213,13 +213,13 @@ static casserr_t cas_load(cassette_image *cassette, UINT8 silence) { /* silence */ err = cassette_put_sample(cassette, 0, time_index, silence, 0); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += silence; /* sync data */ err = cassette_put_modulated_filler(cassette, 0, time_index, 0x55, 128, &coco_cas_modulation, &time_displacement); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; } @@ -227,26 +227,26 @@ static casserr_t cas_load(cassette_image *cassette, UINT8 silence) { /* are passed through */ /* sync data */ err = cassette_put_modulated_filler(cassette, 0, time_index, 0x55, synccount, &coco_cas_modulation, &time_displacement); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; } /* now fill in the magic bytes */ err = cassette_put_modulated_data(cassette, 0, time_index, magic_bytes, sizeof(magic_bytes), &coco_cas_modulation, &time_displacement); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; /* now fill in the block */ err = cassette_put_modulated_data(cassette, 0, time_index, block, block_length, &coco_cas_modulation, &time_displacement); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; /* and the last magic byte */ err = cassette_put_modulated_filler(cassette, 0, time_index, 0x55, 1, &coco_cas_modulation, &time_displacement); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; @@ -255,19 +255,19 @@ static casserr_t cas_load(cassette_image *cassette, UINT8 silence) /* all futher data is undecipherable, so output it verbatim */ err = cassette_read_modulated_data(cassette, 0, time_index, offset, image_size - offset, &coco_cas_modulation, &time_displacement); - if (err) + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -static casserr_t coco_cas_load(cassette_image *cassette) +static cassette_image::error coco_cas_load(cassette_image *cassette) { return cas_load(cassette, COCO_WAVESAMPLES_HEADER); } -static casserr_t alice32_cas_load(cassette_image *cassette) +static cassette_image::error alice32_cas_load(cassette_image *cassette) { return cas_load(cassette, ALICE32_WAVESAMPLES_HEADER); } diff --git a/src/lib/formats/csw_cas.cpp b/src/lib/formats/csw_cas.cpp index f2523ef839d..db7cf4d4248 100644 --- a/src/lib/formats/csw_cas.cpp +++ b/src/lib/formats/csw_cas.cpp @@ -286,12 +286,12 @@ static const struct CassetteLegacyWaveFiller csw_legacy_fill_wave = { 0 /* trailer_samples */ }; -static casserr_t csw_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) +static cassette_image::error csw_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &csw_legacy_fill_wave ); } -static casserr_t csw_cassette_load( cassette_image *cassette ) +static cassette_image::error csw_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &csw_legacy_fill_wave ); } diff --git a/src/lib/formats/fc100_cas.cpp b/src/lib/formats/fc100_cas.cpp index 01986e789bf..48f2373dc19 100644 --- a/src/lib/formats/fc100_cas.cpp +++ b/src/lib/formats/fc100_cas.cpp @@ -133,12 +133,12 @@ static const struct CassetteLegacyWaveFiller fc100_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t fc100_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error fc100_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &fc100_legacy_fill_wave); } -static casserr_t fc100_cassette_load(cassette_image *cassette) +static cassette_image::error fc100_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &fc100_legacy_fill_wave); } diff --git a/src/lib/formats/fm7_cas.cpp b/src/lib/formats/fm7_cas.cpp index 52892fdea2e..5d4aad61092 100644 --- a/src/lib/formats/fm7_cas.cpp +++ b/src/lib/formats/fm7_cas.cpp @@ -87,14 +87,14 @@ static const struct CassetteLegacyWaveFiller fm7_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t fm7_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error fm7_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &fm7_legacy_fill_wave); } -static casserr_t fm7_cas_load(cassette_image *cassette) +static cassette_image::error fm7_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &fm7_legacy_fill_wave); } diff --git a/src/lib/formats/fmsx_cas.cpp b/src/lib/formats/fmsx_cas.cpp index c135880dc79..ca2ab078fd4 100644 --- a/src/lib/formats/fmsx_cas.cpp +++ b/src/lib/formats/fmsx_cas.cpp @@ -117,14 +117,14 @@ static const struct CassetteLegacyWaveFiller fmsx_legacy_fill_wave = -static casserr_t fmsx_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error fmsx_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &fmsx_legacy_fill_wave); } -static casserr_t fmsx_cas_load(cassette_image *cassette) +static cassette_image::error fmsx_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &fmsx_legacy_fill_wave); } diff --git a/src/lib/formats/gtp_cas.cpp b/src/lib/formats/gtp_cas.cpp index 4cdb546ea6b..577d878b67a 100644 --- a/src/lib/formats/gtp_cas.cpp +++ b/src/lib/formats/gtp_cas.cpp @@ -176,13 +176,13 @@ static const struct CassetteLegacyWaveFiller gtp_legacy_fill_wave = { -static casserr_t gtp_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error gtp_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, >p_legacy_fill_wave ); } -static casserr_t gtp_cassette_load( cassette_image *cassette ) { +static cassette_image::error gtp_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, >p_legacy_fill_wave ); } diff --git a/src/lib/formats/hect_tap.cpp b/src/lib/formats/hect_tap.cpp index ba79afe1180..d24c5625c78 100644 --- a/src/lib/formats/hect_tap.cpp +++ b/src/lib/formats/hect_tap.cpp @@ -263,24 +263,24 @@ static const struct CassetteLegacyWaveFiller hector_forth_legacy_fill_wave = }; -static casserr_t hector_k7_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error hector_k7_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &hector_legacy_fill_wave); } -static casserr_t hector_k7_load(cassette_image *cassette) +static cassette_image::error hector_k7_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &hector_legacy_fill_wave); } -static casserr_t hector_k7forth_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error hector_k7forth_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &hector_forth_legacy_fill_wave); } -static casserr_t hector_k7forth_load(cassette_image *cassette) +static cassette_image::error hector_k7forth_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &hector_forth_legacy_fill_wave); } diff --git a/src/lib/formats/kc_cas.cpp b/src/lib/formats/kc_cas.cpp index 3e3d36e3f8b..e357261ec5e 100644 --- a/src/lib/formats/kc_cas.cpp +++ b/src/lib/formats/kc_cas.cpp @@ -206,7 +206,7 @@ static int kc_handle_tap(INT16 *buffer, const UINT8 *casdata) } else { - return CASSETTE_ERROR_INVALIDIMAGE; + return (int)cassette_image::error::INVALID_IMAGE; } } @@ -260,13 +260,13 @@ static const struct CassetteLegacyWaveFiller kc_kcc_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t kc_kcc_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error kc_kcc_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &kc_kcc_legacy_fill_wave); } -static casserr_t kc_kcc_load(cassette_image *cassette) +static cassette_image::error kc_kcc_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &kc_kcc_legacy_fill_wave); } @@ -312,13 +312,13 @@ static const struct CassetteLegacyWaveFiller kc_tap_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t kc_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error kc_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &kc_tap_legacy_fill_wave); } -static casserr_t kc_tap_load(cassette_image *cassette) +static cassette_image::error kc_tap_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &kc_tap_legacy_fill_wave); } @@ -364,13 +364,13 @@ static const struct CassetteLegacyWaveFiller kc_sss_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t kc_sss_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error kc_sss_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &kc_sss_legacy_fill_wave); } -static casserr_t kc_sss_load(cassette_image *cassette) +static cassette_image::error kc_sss_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &kc_sss_legacy_fill_wave); } diff --git a/src/lib/formats/kim1_cas.cpp b/src/lib/formats/kim1_cas.cpp index ed9a1a36a0e..6cef030874a 100644 --- a/src/lib/formats/kim1_cas.cpp +++ b/src/lib/formats/kim1_cas.cpp @@ -171,13 +171,13 @@ static const struct CassetteLegacyWaveFiller kim1_kim_legacy_fill_wave = }; -static casserr_t kim1_kim_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error kim1_kim_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &kim1_kim_legacy_fill_wave); } -static casserr_t kim1_kim_load(cassette_image *cassette) +static cassette_image::error kim1_kim_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &kim1_kim_legacy_fill_wave); } diff --git a/src/lib/formats/lviv_lvt.cpp b/src/lib/formats/lviv_lvt.cpp index 03172f6ac36..e53a68be471 100644 --- a/src/lib/formats/lviv_lvt.cpp +++ b/src/lib/formats/lviv_lvt.cpp @@ -124,14 +124,14 @@ static const struct CassetteLegacyWaveFiller lviv_legacy_fill_wave = -static casserr_t lviv_lvt_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error lviv_lvt_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &lviv_legacy_fill_wave); } -static casserr_t lviv_lvt_load(cassette_image *cassette) +static cassette_image::error lviv_lvt_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &lviv_legacy_fill_wave); } diff --git a/src/lib/formats/mbee_cas.cpp b/src/lib/formats/mbee_cas.cpp index 58a8f81232a..738bd4e4b31 100644 --- a/src/lib/formats/mbee_cas.cpp +++ b/src/lib/formats/mbee_cas.cpp @@ -238,12 +238,12 @@ static const struct CassetteLegacyWaveFiller mbee_tap_config = 0 /* trailer_samples */ }; -static casserr_t mbee_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error mbee_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &mbee_tap_config); } -static casserr_t mbee_tap_load(cassette_image *cassette) +static cassette_image::error mbee_tap_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &mbee_tap_config); } diff --git a/src/lib/formats/mz_cas.cpp b/src/lib/formats/mz_cas.cpp index 3a6b934b882..1fb9d6c1577 100644 --- a/src/lib/formats/mz_cas.cpp +++ b/src/lib/formats/mz_cas.cpp @@ -314,14 +314,14 @@ static const struct CassetteLegacyWaveFiller mz700_legacy_fill_wave = -static casserr_t mz700_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error mz700_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &mz700_legacy_fill_wave); } -static casserr_t mz700_cas_load(cassette_image *cassette) +static cassette_image::error mz700_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &mz700_legacy_fill_wave); } diff --git a/src/lib/formats/orao_cas.cpp b/src/lib/formats/orao_cas.cpp index 784f9563cc0..a97d8aa691f 100644 --- a/src/lib/formats/orao_cas.cpp +++ b/src/lib/formats/orao_cas.cpp @@ -97,13 +97,13 @@ static const struct CassetteLegacyWaveFiller orao_legacy_fill_wave = { -static casserr_t orao_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error orao_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &orao_legacy_fill_wave ); } -static casserr_t orao_cassette_load( cassette_image *cassette ) { +static cassette_image::error orao_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &orao_legacy_fill_wave ); } diff --git a/src/lib/formats/oric_tap.cpp b/src/lib/formats/oric_tap.cpp index ed2a7841076..5c24d40f47e 100644 --- a/src/lib/formats/oric_tap.cpp +++ b/src/lib/formats/oric_tap.cpp @@ -494,14 +494,14 @@ static const struct CassetteLegacyWaveFiller oric_legacy_fill_wave = -static casserr_t oric_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error oric_tap_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &oric_legacy_fill_wave); } -static casserr_t oric_tap_load(cassette_image *cassette) +static cassette_image::error oric_tap_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &oric_legacy_fill_wave); } diff --git a/src/lib/formats/p6001_cas.cpp b/src/lib/formats/p6001_cas.cpp index e91e4b40748..bcaf97d94ba 100644 --- a/src/lib/formats/p6001_cas.cpp +++ b/src/lib/formats/p6001_cas.cpp @@ -72,14 +72,14 @@ static const struct CassetteLegacyWaveFiller pc6001_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t pc6001_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error pc6001_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &pc6001_legacy_fill_wave); } -static casserr_t pc6001_cas_load(cassette_image *cassette) +static cassette_image::error pc6001_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &pc6001_legacy_fill_wave); } diff --git a/src/lib/formats/phc25_cas.cpp b/src/lib/formats/phc25_cas.cpp index 73dfdb17ff3..16a38120441 100644 --- a/src/lib/formats/phc25_cas.cpp +++ b/src/lib/formats/phc25_cas.cpp @@ -158,12 +158,12 @@ static const struct CassetteLegacyWaveFiller phc25_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t phc25_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error phc25_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &phc25_legacy_fill_wave); } -static casserr_t phc25_cassette_load(cassette_image *cassette) +static cassette_image::error phc25_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &phc25_legacy_fill_wave); } diff --git a/src/lib/formats/pmd_cas.cpp b/src/lib/formats/pmd_cas.cpp index 4643eaf9251..516f8cf867b 100644 --- a/src/lib/formats/pmd_cas.cpp +++ b/src/lib/formats/pmd_cas.cpp @@ -195,12 +195,12 @@ static const struct CassetteLegacyWaveFiller pmd85_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t pmd85_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error pmd85_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &pmd85_legacy_fill_wave); } -static casserr_t pmd85_cassette_load(cassette_image *cassette) +static cassette_image::error pmd85_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &pmd85_legacy_fill_wave); } diff --git a/src/lib/formats/primoptp.cpp b/src/lib/formats/primoptp.cpp index 23aab613c29..b3c1875ffb1 100644 --- a/src/lib/formats/primoptp.cpp +++ b/src/lib/formats/primoptp.cpp @@ -226,12 +226,12 @@ static const struct CassetteLegacyWaveFiller primo_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t primo_ptp_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error primo_ptp_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &primo_legacy_fill_wave); } -static casserr_t primo_ptp_load(cassette_image *cassette) +static cassette_image::error primo_ptp_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &primo_legacy_fill_wave); } diff --git a/src/lib/formats/rk_cas.cpp b/src/lib/formats/rk_cas.cpp index 968b8afdc23..8c422506451 100644 --- a/src/lib/formats/rk_cas.cpp +++ b/src/lib/formats/rk_cas.cpp @@ -151,11 +151,11 @@ static const struct CassetteLegacyWaveFiller rk20_legacy_fill_wave = { 0 /* trailer_samples */ }; -static casserr_t rk20_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error rk20_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &rk20_legacy_fill_wave ); } -static casserr_t rk20_cassette_load( cassette_image *cassette ) { +static cassette_image::error rk20_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &rk20_legacy_fill_wave ); } @@ -169,11 +169,11 @@ static const struct CassetteLegacyWaveFiller rk22_legacy_fill_wave = { 0 /* trailer_samples */ }; -static casserr_t rk22_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error rk22_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &rk22_legacy_fill_wave ); } -static casserr_t rk22_cassette_load( cassette_image *cassette ) { +static cassette_image::error rk22_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &rk22_legacy_fill_wave ); } @@ -187,11 +187,11 @@ static const struct CassetteLegacyWaveFiller gam_legacy_fill_wave = { 0 /* trailer_samples */ }; -static casserr_t gam_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error gam_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &gam_legacy_fill_wave ); } -static casserr_t gam_cassette_load( cassette_image *cassette ) { +static cassette_image::error gam_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &gam_legacy_fill_wave ); } @@ -205,11 +205,11 @@ static const struct CassetteLegacyWaveFiller rk60_legacy_fill_wave = { 0 /* trailer_samples */ }; -static casserr_t rk60_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error rk60_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &rk60_legacy_fill_wave ); } -static casserr_t rk60_cassette_load( cassette_image *cassette ) { +static cassette_image::error rk60_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &rk60_legacy_fill_wave ); } diff --git a/src/lib/formats/sc3000_bit.cpp b/src/lib/formats/sc3000_bit.cpp index f15488bda68..8143c52e14d 100644 --- a/src/lib/formats/sc3000_bit.cpp +++ b/src/lib/formats/sc3000_bit.cpp @@ -37,7 +37,7 @@ static const struct CassetteModulation sc3000_bit_modulation = sc3000_bit_identify - identify cassette -------------------------------------------------*/ -static casserr_t sc3000_bit_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error sc3000_bit_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_modulation_identify( cassette, &sc3000_bit_modulation, opts); } @@ -49,13 +49,13 @@ static casserr_t sc3000_bit_identify(cassette_image *cassette, struct CassetteOp #define MODULATE(_value) \ for (int i = 0; i < (_value ? 2 : 1); i++) { \ err = cassette_put_modulated_data_bit(cassette, 0, time_index, _value, &sc3000_bit_modulation, &time_displacement);\ - if (err) return err;\ + if (err != cassette_image::error::SUCCESS) return err;\ time_index += time_displacement;\ } -static casserr_t sc3000_bit_load(cassette_image *cassette) +static cassette_image::error sc3000_bit_load(cassette_image *cassette) { - casserr_t err; + cassette_image::error err; UINT64 image_size = cassette_image_size(cassette); UINT64 image_pos = 0; double time_index = 0.0; @@ -78,7 +78,7 @@ static casserr_t sc3000_bit_load(cassette_image *cassette) case ' ': err = cassette_put_sample( cassette, 0, time_index, 1/1200.0, 0); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += 1/1200.0; break; } @@ -86,7 +86,7 @@ static casserr_t sc3000_bit_load(cassette_image *cassette) image_pos++; } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } /*------------------------------------------------- diff --git a/src/lib/formats/sol_cas.cpp b/src/lib/formats/sol_cas.cpp index ef808842ec6..d42c8d45101 100644 --- a/src/lib/formats/sol_cas.cpp +++ b/src/lib/formats/sol_cas.cpp @@ -367,12 +367,12 @@ static const struct CassetteLegacyWaveFiller sol20_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t sol20_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error sol20_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &sol20_legacy_fill_wave); } -static casserr_t sol20_cassette_load(cassette_image *cassette) +static cassette_image::error sol20_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &sol20_legacy_fill_wave); } diff --git a/src/lib/formats/sorc_cas.cpp b/src/lib/formats/sorc_cas.cpp index 2c714135a12..da31aaa6e49 100644 --- a/src/lib/formats/sorc_cas.cpp +++ b/src/lib/formats/sorc_cas.cpp @@ -135,12 +135,12 @@ static const struct CassetteLegacyWaveFiller sorcerer_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t sorcerer_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error sorcerer_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &sorcerer_legacy_fill_wave); } -static casserr_t sorcerer_cassette_load(cassette_image *cassette) +static cassette_image::error sorcerer_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &sorcerer_legacy_fill_wave); } diff --git a/src/lib/formats/sord_cas.cpp b/src/lib/formats/sord_cas.cpp index 39de0fbca84..f535216e18e 100644 --- a/src/lib/formats/sord_cas.cpp +++ b/src/lib/formats/sord_cas.cpp @@ -32,14 +32,14 @@ static UINT8 cassette_image_read_uint8( cassette_image *cassette, UINT64 offset) return data; } -static casserr_t sordm5_tap_identify( cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error sordm5_tap_identify( cassette_image *cassette, struct CassetteOptions *opts) { return cassette_modulation_identify( cassette, &sordm5_cas_modulation, opts); } -static casserr_t sordm5_tap_load( cassette_image *cassette) +static cassette_image::error sordm5_tap_load( cassette_image *cassette) { - casserr_t err; + cassette_image::error err; UINT64 image_size; double time_index = 0.0; double time_displacement; @@ -52,20 +52,20 @@ static casserr_t sordm5_tap_load( cassette_image *cassette) image_size = cassette_image_size(cassette); image_pos = 0; // read/check header - if (image_size < 16) return CASSETTE_ERROR_INVALIDIMAGE; + if (image_size < 16) return cassette_image::error::INVALID_IMAGE; cassette_image_read( cassette, &header, image_pos, 16); image_pos += 16; - if (memcmp( header, SORDM5_CAS_HEADER, sizeof(SORDM5_CAS_HEADER)) != 0) return CASSETTE_ERROR_INVALIDIMAGE; + if (memcmp( header, SORDM5_CAS_HEADER, sizeof(SORDM5_CAS_HEADER)) != 0) return cassette_image::error::INVALID_IMAGE; // add silence (header) err = cassette_put_sample( cassette, 0, time_index, SORDM5_WAVESAMPLES_HEADER, 0); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += SORDM5_WAVESAMPLES_HEADER; // process blocks while (image_pos < image_size) { // read block type block_type = cassette_image_read_uint8( cassette, image_pos + 0); - if ((block_type != 'H') && (block_type != 'D')) return CASSETTE_ERROR_INVALIDIMAGE; + if ((block_type != 'H') && (block_type != 'D')) return cassette_image::error::INVALID_IMAGE; // read block size block_size = cassette_image_read_uint8( cassette, image_pos + 1); if (block_size == 0) block_size = 0x100; @@ -74,13 +74,13 @@ static casserr_t sordm5_tap_load( cassette_image *cassette) if (block_type == 'H') { err = cassette_put_sample( cassette, 0, time_index, SORDM5_WAVESAMPLES_BLOCK, 0); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += SORDM5_WAVESAMPLES_BLOCK; } // add sync if (block_type == 'H') filler_length = 2.4 * (3150 / 8); else filler_length = 0.15 * (3150 / 8); err = cassette_put_modulated_filler(cassette, 0, time_index, 0xFF, filler_length, &sordm5_cas_modulation, &time_displacement); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; // process block for (i=0;i<block_size;i++) @@ -91,7 +91,7 @@ static casserr_t sordm5_tap_load( cassette_image *cassette) #if 0 if (i == block_size) { - if (byte != (crc & 0xFF)) return CASSETTE_ERROR_INVALIDIMAGE; + if (byte != (crc & 0xFF)) return cassette_image::error::INVALID_IMAGE; } if (i > 2) crc += byte; #endif @@ -109,23 +109,23 @@ static casserr_t sordm5_tap_load( cassette_image *cassette) } // add bit err = cassette_put_modulated_data_bit( cassette, 0, time_index, bit, &sordm5_cas_modulation, &time_displacement); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; } } // mark end of block err = cassette_put_modulated_data_bit( cassette, 0, time_index, 1, &sordm5_cas_modulation, &time_displacement); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += time_displacement; // next block image_pos += block_size; } // add silence (trailer) err = cassette_put_sample( cassette, 0, time_index, SORDM5_WAVESAMPLES_TRAILER, 0); - if (err) return err; + if (err != cassette_image::error::SUCCESS) return err; time_index += SORDM5_WAVESAMPLES_TRAILER; // - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } static const struct CassetteFormat sordm5_cas_format = diff --git a/src/lib/formats/spc1000_cas.cpp b/src/lib/formats/spc1000_cas.cpp index 3c86305e8a8..6d3a2af52fb 100644 --- a/src/lib/formats/spc1000_cas.cpp +++ b/src/lib/formats/spc1000_cas.cpp @@ -136,12 +136,12 @@ static const struct CassetteLegacyWaveFiller spc1000_tap_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t spc1000_tap_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error spc1000_tap_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &spc1000_tap_legacy_fill_wave); } -static casserr_t spc1000_tap_cassette_load(cassette_image *cassette) +static cassette_image::error spc1000_tap_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &spc1000_tap_legacy_fill_wave); } @@ -167,12 +167,12 @@ static const struct CassetteLegacyWaveFiller spc1000_cas_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t spc1000_cas_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error spc1000_cas_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &spc1000_cas_legacy_fill_wave); } -static casserr_t spc1000_cas_cassette_load(cassette_image *cassette) +static cassette_image::error spc1000_cas_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &spc1000_cas_legacy_fill_wave); } diff --git a/src/lib/formats/svi_cas.cpp b/src/lib/formats/svi_cas.cpp index a95c3b97fb5..4030fedc051 100644 --- a/src/lib/formats/svi_cas.cpp +++ b/src/lib/formats/svi_cas.cpp @@ -184,14 +184,14 @@ static const struct CassetteLegacyWaveFiller svi_legacy_fill_wave = -static casserr_t svi_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error svi_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &svi_legacy_fill_wave); } -static casserr_t svi_cas_load(cassette_image *cassette) +static cassette_image::error svi_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &svi_legacy_fill_wave); } diff --git a/src/lib/formats/thom_cas.cpp b/src/lib/formats/thom_cas.cpp index 799e96c38ca..c6ab5a2d004 100644 --- a/src/lib/formats/thom_cas.cpp +++ b/src/lib/formats/thom_cas.cpp @@ -95,15 +95,15 @@ static const struct CassetteModulation to7_k7_modulation = -static casserr_t to7_k7_identify ( cassette_image *cass, struct CassetteOptions *opts ) +static cassette_image::error to7_k7_identify ( cassette_image *cass, struct CassetteOptions *opts ) { - casserr_t e = cassette_modulation_identify( cass, &to7_k7_modulation, opts ); + cassette_image::error e = cassette_modulation_identify( cass, &to7_k7_modulation, opts ); return e; } -static casserr_t to7_k7_load( cassette_image *cass ) +static cassette_image::error to7_k7_load( cassette_image *cass ) { #if ! K7_SPEED_HACK static const INT8 square_wave[] = { -128, 127 }; @@ -132,10 +132,10 @@ static casserr_t to7_k7_load( cassette_image *cass ) #define K7_PUT( PERIOD ) \ do \ { \ - casserr_t err; \ + cassette_image::error err; \ err = cassette_put_samples( cass, 0, time, (PERIOD), 2, 1, \ square_wave, CASSETTE_WAVEFORM_8BIT ); \ - if ( err ) \ + if ( err != cassette_image::error::SUCCESS ) \ return err; \ time += (PERIOD); \ } while (0) @@ -360,7 +360,7 @@ static casserr_t to7_k7_load( cassette_image *cass ) sz = to7_k7_bitsize * TO7_BIT_LENGTH; PRINT (( "to7_k7_load: cassette length: %imn %is (%i samples)\n", sz / 60, sz % 60, to7_k7_bitsize )); - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } @@ -374,18 +374,18 @@ static const struct CassetteFormat to7_k7 = -static casserr_t to7_wav_identify ( cassette_image *cass, +static cassette_image::error to7_wav_identify ( cassette_image *cass, struct CassetteOptions *opts ) { - casserr_t e = wavfile_format.identify( cass, opts ); + cassette_image::error e = wavfile_format.identify( cass, opts ); return e; } -static casserr_t to7_wav_load ( cassette_image *cass ) +static cassette_image::error to7_wav_load ( cassette_image *cass ) { - casserr_t e = wavfile_format.load( cass ); + cassette_image::error e = wavfile_format.load( cass ); struct CassetteInfo info; double len; @@ -395,7 +395,7 @@ static casserr_t to7_wav_load ( cassette_image *cass ) to7_k7_bits = nullptr; } - if ( e != CASSETTE_ERROR_SUCCESS ) + if ( e != cassette_image::error::SUCCESS ) return e; cassette_get_info( cass, &info ); @@ -407,12 +407,12 @@ static casserr_t to7_wav_load ( cassette_image *cass ) info.sample_frequency, info.bits_per_sample, (int) (len / TO7_BIT_LENGTH) )); - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -static casserr_t to7_wav_save ( cassette_image *cass, const struct CassetteInfo *info ) +static cassette_image::error to7_wav_save ( cassette_image *cass, const struct CassetteInfo *info ) { int len = info->sample_count / info->sample_frequency; PRINT (( "to7_wav_save: saving cassette, length %imn %is, %i Hz, %i bps\n", len / 60, len % 60, info->sample_frequency, info->bits_per_sample )); @@ -431,13 +431,13 @@ static const struct CassetteFormat to7_wav = -static casserr_t mo5_k5_identify ( cassette_image *cass, +static cassette_image::error mo5_k5_identify ( cassette_image *cass, struct CassetteOptions *opts ) { opts -> bits_per_sample = 8; opts -> channels = 1; opts -> sample_frequency = 22100;//11050; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } @@ -462,7 +462,7 @@ static casserr_t mo5_k5_identify ( cassette_image *cass, kinds of blocks, when the motor is supposed to go off and back on. */ -static casserr_t mo5_k5_load( cassette_image *cass ) +static cassette_image::error mo5_k5_load( cassette_image *cass ) { size_t size = cassette_image_size( cass ), pos = 0; int i, sz, sz2, hbit = 0; @@ -724,7 +724,7 @@ static casserr_t mo5_k5_load( cassette_image *cass ) sz = hbitsize * MO5_HBIT_LENGTH; PRINT (( "mo5_k5_load: cassette length: %imn %is (%i half-bits)\n", sz / 60, sz % 60, hbitsize )); - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } @@ -737,21 +737,21 @@ static const struct CassetteFormat mo5_k5 = -static casserr_t mo5_wav_identify ( cassette_image *cass, +static cassette_image::error mo5_wav_identify ( cassette_image *cass, struct CassetteOptions *opts ) { - casserr_t e = wavfile_format.identify( cass, opts ); + cassette_image::error e = wavfile_format.identify( cass, opts ); return e; } -static casserr_t mo5_wav_load ( cassette_image *cass ) +static cassette_image::error mo5_wav_load ( cassette_image *cass ) { - casserr_t e = wavfile_format.load( cass ); + cassette_image::error e = wavfile_format.load( cass ); struct CassetteInfo info; int len; - if ( e == CASSETTE_ERROR_SUCCESS ) + if ( e == cassette_image::error::SUCCESS ) { cassette_get_info( cass, &info ); len = info.sample_count / info.sample_frequency; @@ -762,7 +762,7 @@ static casserr_t mo5_wav_load ( cassette_image *cass ) -static casserr_t mo5_wav_save ( cassette_image *cass, const struct CassetteInfo *info ) +static cassette_image::error mo5_wav_save ( cassette_image *cass, const struct CassetteInfo *info ) { int len = info->sample_count / info->sample_frequency; PRINT (( "mo5_wav_save: saving cassette, length %imn %is, %i Hz, %i bps\n", len / 60, len % 60, info->sample_frequency, info->bits_per_sample )); diff --git a/src/lib/formats/trs_cas.cpp b/src/lib/formats/trs_cas.cpp index ec8bea116a7..9f00989bc02 100644 --- a/src/lib/formats/trs_cas.cpp +++ b/src/lib/formats/trs_cas.cpp @@ -111,13 +111,13 @@ static const struct CassetteLegacyWaveFiller trs80l2_cas_legacy_fill_wave = }; -static casserr_t trs80l2_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error trs80l2_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &trs80l2_cas_legacy_fill_wave); } -static casserr_t trs80l2_cas_load(cassette_image *cassette) +static cassette_image::error trs80l2_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &trs80l2_cas_legacy_fill_wave); } diff --git a/src/lib/formats/tvc_cas.cpp b/src/lib/formats/tvc_cas.cpp index 7dad5dac819..c7c60829945 100644 --- a/src/lib/formats/tvc_cas.cpp +++ b/src/lib/formats/tvc_cas.cpp @@ -28,7 +28,7 @@ static void tvc64_emit_level(cassette_image *cass, double &time, int freq, int l time += period; } -static casserr_t tvc64_output_byte(cassette_image *cass, double &time, UINT8 byte) +static cassette_image::error tvc64_output_byte(cassette_image *cass, double &time, UINT8 byte) { for (int i=0; i<8; i++) { @@ -44,7 +44,7 @@ static casserr_t tvc64_output_byte(cassette_image *cass, double &time, UINT8 byt } } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } static int tvc64_output_predata(cassette_image *cass, double &time, int number) @@ -55,7 +55,7 @@ static int tvc64_output_predata(cassette_image *cass, double &time, int number) tvc64_emit_level(cass, time, TVC64_PRE_FREQ*2, -1); } - return CASSETTE_ERROR_SUCCESS; + return (int)cassette_image::error::SUCCESS; } static UINT16 tvc64_calc_crc(const UINT8 *bytes, int size) @@ -82,7 +82,7 @@ static UINT16 tvc64_calc_crc(const UINT8 *bytes, int size) return crc; } -static casserr_t tvc64_cassette_load(cassette_image *cassette) +static cassette_image::error tvc64_cassette_load(cassette_image *cassette) { UINT8 tmp_buff[512]; int buff_idx = 0; @@ -197,10 +197,10 @@ static casserr_t tvc64_cassette_load(cassette_image *cassette) // 1 sec silence tvc64_emit_level(cassette, time, 1, 0); - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -static casserr_t tvc64_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error tvc64_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { UINT8 byte; cassette_image_read(cassette, &byte, 0, 1); @@ -210,10 +210,10 @@ static casserr_t tvc64_cassette_identify(cassette_image *cassette, struct Casset opts->bits_per_sample = 16; opts->channels = 1; opts->sample_frequency = 44100; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; } static const struct CassetteFormat tvc64_cassette_image_format = diff --git a/src/lib/formats/tzx_cas.cpp b/src/lib/formats/tzx_cas.cpp index fa157b282f9..bf8142f9b95 100644 --- a/src/lib/formats/tzx_cas.cpp +++ b/src/lib/formats/tzx_cas.cpp @@ -901,32 +901,32 @@ static const struct CassetteLegacyWaveFiller cdt_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t tzx_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) +static cassette_image::error tzx_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify(cassette, opts, &tzx_legacy_fill_wave); } -static casserr_t tap_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) +static cassette_image::error tap_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify(cassette, opts, &tap_legacy_fill_wave); } -static casserr_t cdt_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) +static cassette_image::error cdt_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify(cassette, opts, &cdt_legacy_fill_wave); } -static casserr_t tzx_cassette_load( cassette_image *cassette ) +static cassette_image::error tzx_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct(cassette, &tzx_legacy_fill_wave); } -static casserr_t tap_cassette_load( cassette_image *cassette ) +static cassette_image::error tap_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct(cassette, &tap_legacy_fill_wave); } -static casserr_t cdt_cassette_load( cassette_image *cassette ) +static cassette_image::error cdt_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct(cassette, &cdt_legacy_fill_wave); } diff --git a/src/lib/formats/uef_cas.cpp b/src/lib/formats/uef_cas.cpp index 6db1716348b..fd200339efa 100644 --- a/src/lib/formats/uef_cas.cpp +++ b/src/lib/formats/uef_cas.cpp @@ -315,11 +315,11 @@ static const struct CassetteLegacyWaveFiller uef_legacy_fill_wave = { 0 /* trailer_samples */ }; -static casserr_t uef_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { +static cassette_image::error uef_cassette_identify( cassette_image *cassette, struct CassetteOptions *opts ) { return cassette_legacy_identify( cassette, opts, &uef_legacy_fill_wave ); } -static casserr_t uef_cassette_load( cassette_image *cassette ) { +static cassette_image::error uef_cassette_load( cassette_image *cassette ) { return cassette_legacy_construct( cassette, &uef_legacy_fill_wave ); } diff --git a/src/lib/formats/vg5k_cas.cpp b/src/lib/formats/vg5k_cas.cpp index 2933f77f8c0..2c298f79304 100644 --- a/src/lib/formats/vg5k_cas.cpp +++ b/src/lib/formats/vg5k_cas.cpp @@ -211,13 +211,13 @@ static const struct CassetteLegacyWaveFiller vg5k_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t vg5k_k7_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error vg5k_k7_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &vg5k_legacy_fill_wave); } -static casserr_t vg5k_k7_load(cassette_image *cassette) +static cassette_image::error vg5k_k7_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &vg5k_legacy_fill_wave); } diff --git a/src/lib/formats/vt_cas.cpp b/src/lib/formats/vt_cas.cpp index 91e5f69ba64..d3284d4d301 100644 --- a/src/lib/formats/vt_cas.cpp +++ b/src/lib/formats/vt_cas.cpp @@ -108,12 +108,12 @@ static const struct CassetteLegacyWaveFiller vtech1_legacy_fill_wave = 600*V1_BITSAMPLES /* trailer_samples */ }; -static casserr_t vtech1_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error vtech1_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &vtech1_legacy_fill_wave); } -static casserr_t vtech1_cas_load(cassette_image *cassette) +static cassette_image::error vtech1_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &vtech1_legacy_fill_wave); } @@ -203,12 +203,12 @@ static const struct CassetteLegacyWaveFiller vtech2_legacy_fill_wave = 600*VT2_BITSAMPLES /* trailer_samples */ }; -static casserr_t vtech2_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error vtech2_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &vtech2_legacy_fill_wave); } -static casserr_t vtech2_cas_load(cassette_image *cassette) +static cassette_image::error vtech2_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &vtech2_legacy_fill_wave); } diff --git a/src/lib/formats/wavfile.cpp b/src/lib/formats/wavfile.cpp index f827102a57b..70fb992c97a 100644 --- a/src/lib/formats/wavfile.cpp +++ b/src/lib/formats/wavfile.cpp @@ -57,7 +57,7 @@ static void put_leuint16(void *ptr, UINT16 value) -static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOptions *opts, +static cassette_image::error wavfile_process(cassette_image *cassette, struct CassetteOptions *opts, int read_waveform) { UINT8 file_header[12]; @@ -81,9 +81,9 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption /* check magic numbers */ if (memcmp(&file_header[0], magic1, 4)) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; if (memcmp(&file_header[8], magic2, 4)) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; /* read and sanity check size */ stated_size = get_leuint32(&file_header[4]) + 8; @@ -101,7 +101,7 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption { /* format tag */ if (format_specified || (tag_size < sizeof(format_tag))) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; format_specified = TRUE; cassette_image_read(cassette, format_tag, offset, sizeof(format_tag)); @@ -114,9 +114,9 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption opts->bits_per_sample = get_leuint16(&format_tag[14]); if (format_type != WAV_FORMAT_PCM) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; if (opts->sample_frequency * opts->bits_per_sample * opts->channels / 8 != bytes_per_second) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; switch(opts->bits_per_sample) { @@ -130,14 +130,14 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption waveform_flags = CASSETTE_WAVEFORM_32BITLE; break; default: - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; } } else if (!memcmp(tag_header, data_tag_id, 4)) { /* data tag */ if (!format_specified) - return CASSETTE_ERROR_INVALIDIMAGE; + return cassette_image::error::INVALID_IMAGE; if (read_waveform) { @@ -153,19 +153,19 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption offset += tag_size; } - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } -static casserr_t wavfile_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error wavfile_identify(cassette_image *cassette, struct CassetteOptions *opts) { return wavfile_process(cassette, opts, FALSE); } -static casserr_t wavfile_load(cassette_image *cassette) +static cassette_image::error wavfile_load(cassette_image *cassette) { struct CassetteOptions opts; memset(&opts, 0, sizeof(opts)); @@ -174,9 +174,9 @@ static casserr_t wavfile_load(cassette_image *cassette) -static casserr_t wavfile_save(cassette_image *cassette, const struct CassetteInfo *info) +static cassette_image::error wavfile_save(cassette_image *cassette, const struct CassetteInfo *info) { - casserr_t err; + cassette_image::error err; UINT8 consolidated_header[12 + 8 + 16 + 8]; UINT8 *header = &consolidated_header[0]; UINT8 *format_tag_header = &consolidated_header[12]; @@ -222,10 +222,10 @@ static casserr_t wavfile_save(cassette_image *cassette, const struct CassetteInf err = cassette_write_samples(cassette, info->channels, 0.0, info->sample_count / (double) info->sample_frequency, info->sample_count, sizeof(consolidated_header), waveform_flags); - if (err) + if (err != cassette_image::error::SUCCESS) return err; - return CASSETTE_ERROR_SUCCESS; + return cassette_image::error::SUCCESS; } diff --git a/src/lib/formats/x07_cas.cpp b/src/lib/formats/x07_cas.cpp index b55ed79913a..93c34705105 100644 --- a/src/lib/formats/x07_cas.cpp +++ b/src/lib/formats/x07_cas.cpp @@ -151,12 +151,12 @@ static const struct CassetteLegacyWaveFiller x07_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t x07_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error x07_cassette_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &x07_legacy_fill_wave); } -static casserr_t x07_cassette_load(cassette_image *cassette) +static cassette_image::error x07_cassette_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &x07_legacy_fill_wave); } diff --git a/src/lib/formats/x1_tap.cpp b/src/lib/formats/x1_tap.cpp index f66ca7d4431..33ecefd683f 100644 --- a/src/lib/formats/x1_tap.cpp +++ b/src/lib/formats/x1_tap.cpp @@ -114,14 +114,14 @@ static const struct CassetteLegacyWaveFiller x1_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t x1_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error x1_cas_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &x1_legacy_fill_wave); } -static casserr_t x1_cas_load(cassette_image *cassette) +static cassette_image::error x1_cas_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &x1_legacy_fill_wave); } diff --git a/src/lib/formats/zx81_p.cpp b/src/lib/formats/zx81_p.cpp index 5e6af375468..7a5f82fd8f1 100644 --- a/src/lib/formats/zx81_p.cpp +++ b/src/lib/formats/zx81_p.cpp @@ -206,12 +206,12 @@ static const struct CassetteLegacyWaveFiller zx81_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t zx81_p_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error zx81_p_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &zx81_legacy_fill_wave); } -static casserr_t zx81_p_load(cassette_image *cassette) +static cassette_image::error zx81_p_load(cassette_image *cassette) { /* The filename of the file is used to create the wave stream for the emulated machine. Why is this information not part of the image file itself? @@ -274,12 +274,12 @@ static const struct CassetteLegacyWaveFiller zx80_legacy_fill_wave = 0 /* trailer_samples */ }; -static casserr_t zx80_o_identify(cassette_image *cassette, struct CassetteOptions *opts) +static cassette_image::error zx80_o_identify(cassette_image *cassette, struct CassetteOptions *opts) { return cassette_legacy_identify(cassette, opts, &zx80_legacy_fill_wave); } -static casserr_t zx80_o_load(cassette_image *cassette) +static cassette_image::error zx80_o_load(cassette_image *cassette) { return cassette_legacy_construct(cassette, &zx80_legacy_fill_wave); } |