Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-25 09:50:04 +03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

casserr_t ==> enum class cassette_image::error

Browse Source
This commit is contained in:
Nathan Woods 2016-08-20 19:59:04 -04:00
parent 02b9749216
commit d1227cb38f
47 changed files with 314 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/devices/imagedev/cassette.cpp
View File

@ -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:

6
src/lib/formats/a26_cas.cpp
View File

@ -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 );
}

4
src/lib/formats/ace_tap.cpp
View File

@ -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);
}

16
src/lib/formats/adam_cas.cpp
View File

@ -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.

8
src/lib/formats/apf_apt.cpp
View File

@ -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);
}

10
src/lib/formats/atom_tap.cpp
View File

@ -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;
}
/*-------------------------------------------------

8
src/lib/formats/camplynx_cas.cpp
View File

@ -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);
}

158
src/lib/formats/cassimg.cpp
View File

@ -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");

64
src/lib/formats/cassimg.h
View File

@ -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 */

4
src/lib/formats/cbm_tap.cpp
View File

@ -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 );
}

4
src/lib/formats/cgen_cas.cpp
View File

@ -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);
}

28
src/lib/formats/coco_cas.cpp
View File

@ -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);
}

4
src/lib/formats/csw_cas.cpp
View File

@ -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 );
}

4
src/lib/formats/fc100_cas.cpp
View File

@ -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);
}

4
src/lib/formats/fm7_cas.cpp
View File

@ -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);
}

4
src/lib/formats/fmsx_cas.cpp
View File

@ -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);
}

4
src/lib/formats/gtp_cas.cpp
View File

@ -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, &gtp_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, &gtp_legacy_fill_wave );
}

8
src/lib/formats/hect_tap.cpp
View File

@ -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);
}

14
src/lib/formats/kc_cas.cpp
View File

@ -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);
}

4
src/lib/formats/kim1_cas.cpp
View File

@ -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);
}

4
src/lib/formats/lviv_lvt.cpp
View File

@ -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);
}

4
src/lib/formats/mbee_cas.cpp
View File

@ -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);
}

4
src/lib/formats/mz_cas.cpp
View File

@ -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);
}

4
src/lib/formats/orao_cas.cpp
View File

@ -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 );
}

4
src/lib/formats/oric_tap.cpp
View File

@ -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);
}

4
src/lib/formats/p6001_cas.cpp
View File

@ -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);
}

4
src/lib/formats/phc25_cas.cpp
View File

@ -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);
}

4
src/lib/formats/pmd_cas.cpp
View File

@ -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);
}

4
src/lib/formats/primoptp.cpp
View File

@ -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);
}

16
src/lib/formats/rk_cas.cpp
View File

@ -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 );
}

12
src/lib/formats/sc3000_bit.cpp
View File

@ -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;
}
/*-------------------------------------------------

4
src/lib/formats/sol_cas.cpp
View File

@ -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);
}

4
src/lib/formats/sorc_cas.cpp
View File

@ -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);
}

28
src/lib/formats/sord_cas.cpp
View File

@ -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 =

8
src/lib/formats/spc1000_cas.cpp
View File

@ -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);
}

4
src/lib/formats/svi_cas.cpp
View File

@ -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);
}

46
src/lib/formats/thom_cas.cpp
View File

@ -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 ));

4
src/lib/formats/trs_cas.cpp
View File

@ -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);
}

16
src/lib/formats/tvc_cas.cpp
View File

@ -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 =

12
src/lib/formats/tzx_cas.cpp
View File

@ -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);
}

4
src/lib/formats/uef_cas.cpp
View File

@ -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 );
}

4
src/lib/formats/vg5k_cas.cpp
View File

@ -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);
}

8
src/lib/formats/vt_cas.cpp
View File

@ -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);
}

30
src/lib/formats/wavfile.cpp
View File

@ -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;
}

4
src/lib/formats/x07_cas.cpp
View File

@ -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);
}

4
src/lib/formats/x1_tap.cpp
View File

@ -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);
}

8
src/lib/formats/zx81_p.cpp
View File

@ -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);
}