Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-04-29 11:30:28 +03:00
Code Issues Actions 11 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) image_init_result cassette_image_device::internal_load(bool is_create)
{ {
casserr_t err; cassette_image::error err;
int cassette_flags; int cassette_flags;
bool is_writable; bool is_writable;
device_image_interface *image = nullptr; device_image_interface *image = nullptr;
@ -273,7 +273,7 @@ image_init_result cassette_image_device::internal_load(bool is_create)
{ {
// creating an image // creating an image
err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette); 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; goto error;
} }
else 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; 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); 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; goto error;
} }
@ -309,16 +309,16 @@ error:
image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED; image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;
switch(err) switch(err)
{ {
case CASSETTE_ERROR_INTERNAL: case cassette_image::error::INTERNAL:
imgerr = IMAGE_ERROR_INTERNAL; imgerr = IMAGE_ERROR_INTERNAL;
break; break;
case CASSETTE_ERROR_UNSUPPORTED: case cassette_image::error::UNSUPPORTED:
imgerr = IMAGE_ERROR_UNSUPPORTED; imgerr = IMAGE_ERROR_UNSUPPORTED;
break; break;
case CASSETTE_ERROR_OUTOFMEMORY: case cassette_image::error::OUT_OF_MEMORY:
imgerr = IMAGE_ERROR_OUTOFMEMORY; imgerr = IMAGE_ERROR_OUTOFMEMORY;
break; break;
case CASSETTE_ERROR_INVALIDIMAGE: case cassette_image::error::INVALID_IMAGE:
imgerr = IMAGE_ERROR_INVALIDIMAGE; imgerr = IMAGE_ERROR_INVALIDIMAGE;
break; break;
default: default:

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

@ -142,17 +142,17 @@ static const struct CassetteLegacyWaveFiller a26_legacy_fill_wave = {
0 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; UINT64 size;
size = cassette_image_size( cassette ); size = cassette_image_size( cassette );
if ( size == A26_CAS_SIZE ) { if ( size == A26_CAS_SIZE ) {
return cassette_legacy_identify( cassette, opts, &a26_legacy_fill_wave ); 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 ); 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); 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); 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 -> bits_per_sample = 16;
opts -> channels = 2; opts -> channels = 2;
opts -> sample_frequency = 44100; opts -> sample_frequency = 44100;
return CASSETTE_ERROR_SUCCESS; return cassette_image::error::SUCCESS;
} }
// Store byte of data // 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++) for (int i = 0; i < 8; i++)
{ {
if(byte & 0x80) if(byte & 0x80)
@ -83,11 +83,11 @@ casserr_t coladam_put_byte(cassette_image *cass, int channel, double *time_index
return err; 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; 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 }; 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) if (layout_type == TYPE_GW)
{ {
header[1] = 0x47; 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.; double time = 0.;
int i, block, prev_sign=-1; int i, block, prev_sign=-1;
UINT8 buffer[0x400]; 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 // 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. // 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 */ 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); 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); return cassette_legacy_construct(cassette, &apf_cpf_fill_intf);
} }
@ -226,12 +226,12 @@ static const struct CassetteLegacyWaveFiller apf_apt_fill_intf =
0 /* trailer_samples */ 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); 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); 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 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); 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) \ #define MODULATE(_value) \
for (int i = 0; i < (_value ? 8 : 4); i++) { \ 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);\ 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;\ time_index += time_displacement;\
} }
#define BIT(x,n) (((x)>>(n))&1) #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_size = cassette_image_size(cassette);
UINT64 image_pos = 0; UINT64 image_pos = 0;
double time_index = 0.0; double time_index = 0.0;
@ -126,7 +126,7 @@ static casserr_t atom_tap_load(cassette_image *cassette)
image_pos++; 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 */ 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); 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); 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); 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); 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_close(cassette);
cassette = nullptr; 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) const struct CassetteFormat *const *formats, int flags, cassette_image **outcassette)
{ {
casserr_t err; cassette_image::error err;
cassette_image *cassette; cassette_image *cassette;
const struct CassetteFormat *format; const struct CassetteFormat *format;
struct CassetteOptions opts = {0, }; 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); cassette = cassette_init(nullptr, file, procs, flags);
if (!cassette) if (!cassette)
{ {
err = CASSETTE_ERROR_OUTOFMEMORY; err = cassette_image::error::OUT_OF_MEMORY;
goto done; goto done;
} }
@ -150,9 +150,9 @@ casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const
format = formats[i]; format = formats[i];
memset(&opts, 0, sizeof(opts)); memset(&opts, 0, sizeof(opts));
err = format->identify(cassette, &opts); err = format->identify(cassette, &opts);
if (err == CASSETTE_ERROR_INVALIDIMAGE) if (err == cassette_image::error::INVALID_IMAGE)
format = nullptr; format = nullptr;
else if (err) else if (err != cassette_image::error::SUCCESS)
goto done; 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 */ /* have we found a proper format */
if (!format) if (!format)
{ {
err = CASSETTE_ERROR_INVALIDIMAGE; err = cassette_image::error::INVALID_IMAGE;
goto done; goto done;
} }
cassette->format = format; cassette->format = format;
@ -171,12 +171,12 @@ casserr_t cassette_open_choices(void *file, const struct io_procs *procs, const
/* load the image */ /* load the image */
err = format->load(cassette); err = format->load(cassette);
if (err) if (err != cassette_image::error::SUCCESS)
goto done; goto done;
/* success */ /* success */
cassette->flags &= ~CASSETTE_FLAG_DIRTY; cassette->flags &= ~CASSETTE_FLAG_DIRTY;
err = CASSETTE_ERROR_SUCCESS; err = cassette_image::error::SUCCESS;
done: done:
cassette_finishinit(err, cassette, outcassette); 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 *format, int flags, cassette_image **outcassette)
{ {
const struct CassetteFormat *formats[2]; 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) const struct CassetteOptions *opts, int flags, cassette_image **outcassette)
{ {
casserr_t err; cassette_image::error err;
cassette_image *cassette; cassette_image *cassette;
static const struct CassetteOptions default_options = { 1, 16, 44100 }; static const struct CassetteOptions default_options = { 1, 16, 44100 };
/* cannot create to a read only image */ /* cannot create to a read only image */
if (flags & CASSETTE_FLAG_READONLY) if (flags & CASSETTE_FLAG_READONLY)
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
/* is this a good format? */ /* is this a good format? */
if (!good_format(format, nullptr, flags)) if (!good_format(format, nullptr, flags))
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
/* normalize arguments */ /* normalize arguments */
if (!opts) 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); cassette = cassette_init(format, file, procs, flags);
if (!cassette) if (!cassette)
{ {
err = CASSETTE_ERROR_OUTOFMEMORY; err = cassette_image::error::OUT_OF_MEMORY;
goto done; goto done;
} }
@ -227,7 +227,7 @@ casserr_t cassette_create(void *file, const struct io_procs *procs, const struct
cassette->channels = opts->channels; cassette->channels = opts->channels;
cassette->sample_frequency = opts->sample_frequency; cassette->sample_frequency = opts->sample_frequency;
err = CASSETTE_ERROR_SUCCESS; err = cassette_image::error::SUCCESS;
done: done:
cassette_finishinit(err, cassette, outcassette); 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; struct CassetteInfo info;
cassette_get_info(cassette, &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) if (!cassette->format || !cassette->format->save)
return CASSETTE_ERROR_UNSUPPORTED; return cassette_image::error::UNSUPPORTED;
err = cassette_perform_save(cassette); err = cassette_perform_save(cassette);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
cassette->flags &= ~CASSETTE_FLAG_DIRTY; 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) double time_index, double sample_period, struct manipulation_ranges *ranges)
{ {
if (channel < 0) 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) if (ranges->sample_last > ranges->sample_first)
ranges->sample_last--; 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; *ptr = nullptr;
size_t sample_blocknum = (sample / SAMPLES_PER_BLOCK) * cassette->channels + channel; 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]; *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 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, double time_index, double sample_period, size_t sample_count, size_t sample_bytes,
void *samples, int waveform_flags) void *samples, int waveform_flags)
{ {
casserr_t err; cassette_image::error err;
struct manipulation_ranges ranges; struct manipulation_ranges ranges;
size_t sample_index; size_t sample_index;
size_t cassette_sample_index; size_t cassette_sample_index;
@ -428,7 +428,7 @@ casserr_t cassette_get_samples(cassette_image *cassette, int channel,
assert(cassette); assert(cassette);
err = compute_manipulation_ranges(cassette, channel, time_index, sample_period, &ranges); err = compute_manipulation_ranges(cassette, channel, time_index, sample_period, &ranges);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
for (sample_index = 0; sample_index < sample_count; sample_index++) 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; d = map_double(ranges.sample_last + 1 - ranges.sample_first, 0, sample_count, sample_index) + ranges.sample_first;
cassette_sample_index = (size_t) d; cassette_sample_index = (size_t) d;
err = lookup_sample(cassette, channel, cassette_sample_index, (INT32 **) &source_ptr); err = lookup_sample(cassette, channel, cassette_sample_index, (INT32 **) &source_ptr);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
sum += *source_ptr; sum += *source_ptr;
@ -472,16 +472,16 @@ casserr_t cassette_get_samples(cassette_image *cassette, int channel,
break; 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, double time_index, double sample_period, size_t sample_count, size_t sample_bytes,
const void *samples, int waveform_flags) const void *samples, int waveform_flags)
{ {
casserr_t err; cassette_image::error err;
struct manipulation_ranges ranges; struct manipulation_ranges ranges;
size_t sample_index; size_t sample_index;
INT32 *dest_ptr; INT32 *dest_ptr;
@ -492,13 +492,13 @@ casserr_t cassette_put_samples(cassette_image *cassette, int channel,
double d; double d;
if (!cassette) if (!cassette)
return CASSETTE_ERROR_SUCCESS; return cassette_image::error::SUCCESS;
if (sample_period == 0) if (sample_period == 0)
return CASSETTE_ERROR_SUCCESS; return cassette_image::error::SUCCESS;
err = compute_manipulation_ranges(cassette, channel, time_index, sample_period, &ranges); err = compute_manipulation_ranges(cassette, channel, time_index, sample_period, &ranges);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
if (cassette->sample_count < ranges.sample_last+1) 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; dest_value = dword;
break; break;
default: default:
return CASSETTE_ERROR_INTERNAL; return cassette_image::error::INTERNAL;
} }
for (channel = ranges.channel_first; channel <= ranges.channel_last; channel++) for (channel = ranges.channel_first; channel <= ranges.channel_last; channel++)
{ {
/* find the sample that we are putting */ /* find the sample that we are putting */
err = lookup_sample(cassette, channel, sample_index, &dest_ptr); err = lookup_sample(cassette, channel, sample_index, &dest_ptr);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
*dest_ptr = dest_value; *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) double time_index, double sample_period, INT32 *sample)
{ {
return cassette_get_samples(cassette, channel, time_index, 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) double time_index, double sample_period, INT32 sample)
{ {
return cassette_put_samples(cassette, channel, time_index, 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 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) 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 chunk_sample_count;
size_t bytes_per_sample; size_t bytes_per_sample;
size_t sample_bytes; 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, err = cassette_put_samples(cassette, channel, chunk_time_index, chunk_sample_period,
chunk_sample_count, sample_bytes, &buffer[channel * bytes_per_sample], waveform_flags); chunk_sample_count, sample_bytes, &buffer[channel * bytes_per_sample], waveform_flags);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
} }
offset += chunk_sample_count * sample_bytes; offset += chunk_sample_count * sample_bytes;
samples_loaded += chunk_sample_count; 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) 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 chunk_sample_count;
size_t bytes_per_sample; size_t bytes_per_sample;
size_t sample_bytes; 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, err = cassette_get_samples(cassette, channel, chunk_time_index, chunk_sample_period,
chunk_sample_count, sample_bytes, &buffer[channel * bytes_per_sample], waveform_flags); chunk_sample_count, sample_bytes, &buffer[channel * bytes_per_sample], waveform_flags);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
} }
@ -654,7 +654,7 @@ casserr_t cassette_write_samples(cassette_image *cassette, int channels, double
offset += chunk_sample_count * sample_bytes; offset += chunk_sample_count * sample_bytes;
samples_saved += chunk_sample_count; 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) struct CassetteOptions *opts)
{ {
size_t wave_bytes_length; 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->bits_per_sample = 8;
opts->channels = 1; opts->channels = 1;
opts->sample_frequency = (UINT32) (std::max(modulation->zero_frequency_high, modulation->one_frequency_high) * wave_bytes_length * 2); 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, const void *data, size_t data_length, const struct CassetteModulation *modulation,
double *time_displacement) double *time_displacement)
{ {
casserr_t err; cassette_image::error err;
const UINT8 *data_bytes = (const UINT8 *)data; const UINT8 *data_bytes = (const UINT8 *)data;
const INT8 *wave_bytes; const INT8 *wave_bytes;
size_t wave_bytes_length; 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_frequency = (b & (1 << i)) ? modulation->one_frequency_cannonical : modulation->zero_frequency_cannonical;
pulse_period = 1 / pulse_frequency; pulse_period = 1 / pulse_frequency;
err = cassette_put_samples(cassette, 0, time_index, pulse_period, wave_bytes_length, 1, wave_bytes, CASSETTE_WAVEFORM_8BIT); 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; goto done;
time_index += pulse_period; time_index += pulse_period;
total_displacement += pulse_period; total_displacement += pulse_period;
} }
} }
err = CASSETTE_ERROR_SUCCESS; err = cassette_image::error::SUCCESS;
done: done:
if (time_displacement) 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, UINT8 filler, size_t filler_length, const struct CassetteModulation *modulation,
double *time_displacement) double *time_displacement)
{ {
casserr_t err; cassette_image::error err;
double delta; double delta;
double total_displacement = 0.0; double total_displacement = 0.0;
while(filler_length--) while(filler_length--)
{ {
err = cassette_put_modulated_data(cassette, channel, time_index, &filler, 1, modulation, &delta); err = cassette_put_modulated_data(cassette, channel, time_index, &filler, 1, modulation, &delta);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
total_displacement += delta; total_displacement += delta;
time_index += delta; time_index += delta;
@ -754,16 +754,16 @@ casserr_t cassette_put_modulated_filler(cassette_image *cassette, int channel, d
if (time_displacement) if (time_displacement)
*time_displacement = total_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, UINT64 offset, UINT64 length, const struct CassetteModulation *modulation,
double *time_displacement) double *time_displacement)
{ {
casserr_t err; cassette_image::error err;
UINT8 buffer_stack[1024]; UINT8 buffer_stack[1024];
UINT8 *buffer; UINT8 *buffer;
UINT8 *alloc_buffer = nullptr; 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); alloc_buffer = (UINT8*)malloc(buffer_length);
if (!alloc_buffer) if (!alloc_buffer)
{ {
err = CASSETTE_ERROR_OUTOFMEMORY; err = cassette_image::error::OUT_OF_MEMORY;
goto done; goto done;
} }
buffer = alloc_buffer; 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); cassette_image_read(cassette, buffer, offset, this_length);
err = cassette_put_modulated_data(cassette, channel, time_index, buffer, this_length, modulation, &delta); err = cassette_put_modulated_data(cassette, channel, time_index, buffer, this_length, modulation, &delta);
if (err) if (err != cassette_image::error::SUCCESS)
goto done; goto done;
total_displacement += delta; total_displacement += delta;
time_index += delta; time_index += delta;
@ -804,7 +804,7 @@ casserr_t cassette_read_modulated_data(cassette_image *cassette, int channel, do
if (time_displacement) if (time_displacement)
*time_displacement = total_displacement; *time_displacement = total_displacement;
err = CASSETTE_ERROR_SUCCESS; err = cassette_image::error::SUCCESS;
done: done:
if (alloc_buffer) 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, UINT8 data, const struct CassetteModulation *modulation,
double *time_displacement) double *time_displacement)
{ {
casserr_t err; cassette_image::error err;
const INT8 *wave_bytes; const INT8 *wave_bytes;
size_t wave_bytes_length; size_t wave_bytes_length;
double total_displacement = 0.0; 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_frequency = (data) ? modulation->one_frequency_cannonical : modulation->zero_frequency_cannonical;
pulse_period = 1 / pulse_frequency; pulse_period = 1 / pulse_frequency;
err = cassette_put_samples(cassette, 0, time_index, pulse_period, wave_bytes_length, 1, wave_bytes, CASSETTE_WAVEFORM_8BIT); 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; goto done;
time_index += pulse_period; time_index += pulse_period;
total_displacement += pulse_period; total_displacement += pulse_period;
err = CASSETTE_ERROR_SUCCESS; err = cassette_image::error::SUCCESS;
done: done:
if (time_displacement) if (time_displacement)
@ -849,21 +849,21 @@ done:
waveform accesses to/from the raw image 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) const struct CassetteLegacyWaveFiller *legacy_args)
{ {
opts->channels = 1; opts->channels = 1;
opts->bits_per_sample = 16; opts->bits_per_sample = 16;
opts->sample_frequency = legacy_args->sample_frequency; 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) const struct CassetteLegacyWaveFiller *legacy_args)
{ {
casserr_t err; cassette_image::error err;
int length; int length;
int sample_count; int sample_count;
dynamic_buffer bytes; dynamic_buffer bytes;
@ -898,7 +898,7 @@ casserr_t cassette_legacy_construct(cassette_image *cassette,
{ {
if (size > 0x7FFFFFFF) if (size > 0x7FFFFFFF)
{ {
err = CASSETTE_ERROR_OUTOFMEMORY; err = cassette_image::error::OUT_OF_MEMORY;
goto done; 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); length = args.fill_wave(&samples[pos], sample_count - pos, CODE_HEADER);
if (length < 0) if (length < 0)
{ {
err = CASSETTE_ERROR_INVALIDIMAGE; err = cassette_image::error::INVALID_IMAGE;
goto done; goto done;
} }
pos += length; 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]); length = args.fill_wave(&samples[pos], sample_count - pos, &chunk[0]);
if (length < 0) if (length < 0)
{ {
err = CASSETTE_ERROR_INVALIDIMAGE; err = cassette_image::error::INVALID_IMAGE;
goto done; goto done;
} }
pos += length; 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); length = args.fill_wave(&samples[pos], sample_count - pos, CODE_TRAILER);
if (length < 0) if (length < 0)
{ {
err = CASSETTE_ERROR_INVALIDIMAGE; err = cassette_image::error::INVALID_IMAGE;
goto done; goto done;
} }
pos += length; pos += length;
@ -963,11 +963,11 @@ casserr_t cassette_legacy_construct(cassette_image *cassette,
/* specify the wave */ /* specify the wave */
err = cassette_put_samples(cassette, 0, 0.0, ((double) pos) / args.sample_frequency, err = cassette_put_samples(cassette, 0, 0.0, ((double) pos) / args.sample_frequency,
pos, 2, &samples[0], CASSETTE_WAVEFORM_16BIT); pos, 2, &samples[0], CASSETTE_WAVEFORM_16BIT);
if (err) if (err != cassette_image::error::SUCCESS)
goto done; goto done;
/* success! */ /* success! */
err = CASSETTE_ERROR_SUCCESS; err = cassette_image::error::SUCCESS;
#if DUMP_CASSETTES #if DUMP_CASSETTES
cassette_dump(cassette, "C:\\TEMP\\CASDUMP.WAV"); 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 #define LOG_FORMATS if (0) printf
#endif #endif
// hack to get around rogues that define this
#ifdef UNSUPPORTED
#undef UNSUPPORTED
#endif
/*************************************************************************** /***************************************************************************
Constants 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; typedef std::vector<INT32> sample_block;
struct CassetteOptions struct CassetteOptions
@ -90,6 +85,15 @@ struct CassetteInfo
struct cassette_image 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; const struct CassetteFormat *format;
struct io_generic io; struct io_generic io;
@ -104,9 +108,9 @@ struct cassette_image
struct CassetteFormat struct CassetteFormat
{ {
const char *extensions; const char *extensions;
casserr_t (*identify)(cassette_image *cassette, struct CassetteOptions *opts); cassette_image::error (*identify)(cassette_image *cassette, struct CassetteOptions *opts);
casserr_t (*load)(cassette_image *cassette); cassette_image::error (*load)(cassette_image *cassette);
casserr_t (*save)(cassette_image *cassette, const struct CassetteInfo *info); cassette_image::error (*save)(cassette_image *cassette, const struct CassetteInfo *info);
}; };
/* used for the core modulation code */ /* 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); 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); 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); 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_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_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); 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); UINT64 cassette_image_size(cassette_image *cassette);
/* waveform accesses */ /* 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, double time_index, double sample_period, size_t sample_count, size_t sample_bytes,
void *samples, int waveform_flags); 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, double time_index, double sample_period, size_t sample_count, size_t sample_bytes,
const void *samples, int waveform_flags); 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); 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); double time_index, double sample_period, INT32 sample);
/* waveform accesses to/from the raw image */ /* 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); 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); double sample_period, size_t sample_count, UINT64 offset, int waveform_flags);
/* modulation support */ /* 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); 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, const void *data, size_t data_length, const struct CassetteModulation *modulation,
double *time_displacement); 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, UINT8 filler, size_t filler_length, const struct CassetteModulation *modulation,
double *time_displacement); 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, UINT64 offset, UINT64 length, const struct CassetteModulation *modulation,
double *time_displacement); 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, UINT8 data, const struct CassetteModulation *modulation,
double *time_displacement); double *time_displacement);
@ -214,9 +218,9 @@ void cassette_dump(cassette_image *image, const char *filename);
/* legacy code support */ /* legacy code support */
#define CODE_HEADER ((UINT8*)-1) #define CODE_HEADER ((UINT8*)-1)
#define CODE_TRAILER ((UINT8*)-2) #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); 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); const struct CassetteLegacyWaveFiller *legacy_args);
#endif /* CASSIMG_H */ #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 ); 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 ); 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); 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); 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); 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 offset;
UINT64 image_size; UINT64 image_size;
UINT8 block[258]; /* 255 bytes per block + 3 (type, length, checksum) */ 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 #endif
err = cassette_put_sample(cassette, 0, time_index, COCO_WAVESAMPLES_HEADER, 0); err = cassette_put_sample(cassette, 0, time_index, COCO_WAVESAMPLES_HEADER, 0);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
time_index += COCO_WAVESAMPLES_HEADER; time_index += COCO_WAVESAMPLES_HEADER;
@ -213,13 +213,13 @@ static casserr_t cas_load(cassette_image *cassette, UINT8 silence)
{ {
/* silence */ /* silence */
err = cassette_put_sample(cassette, 0, time_index, silence, 0); err = cassette_put_sample(cassette, 0, time_index, silence, 0);
if (err) if (err != cassette_image::error::SUCCESS)
return err; return err;
time_index += silence; time_index += silence;
/* sync data */ /* sync data */
err = cassette_put_modulated_filler(cassette, 0, time_index, 0x55, 128, &coco_cas_modulation, &time_displacement); 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; return err;
time_index += time_displacement; time_index += time_displacement;
} }
@ -227,26 +227,26 @@ static casserr_t cas_load(cassette_image *cassette, UINT8 silence)
{ /* are passed through */ { /* are passed through */
/* sync data */ /* sync data */
err = cassette_put_modulated_filler(cassette, 0, time_index, 0x55, synccount, &coco_cas_modulation, &time_displacement); 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; return err;
time_index += time_displacement; time_index += time_displacement;
} }
/* now fill in the magic bytes */ /* 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); 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; return err;
time_index += time_displacement; time_index += time_displacement;
/* now fill in the block */ /* now fill in the block */
err = cassette_put_modulated_data(cassette, 0, time_index, block, block_length, &coco_cas_modulation, &time_displacement); 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; return err;
time_index += time_displacement; time_index += time_displacement;
/* and the last magic byte */ /* and the last magic byte */
err = cassette_put_modulated_filler(cassette, 0, time_index, 0x55, 1, &coco_cas_modulation, &time_displacement); 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; return err;
time_index += time_displacement; 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 */ /* 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); 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; return err;
time_index += time_displacement; 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); 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); 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 */ 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 ); 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 ); 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 */ 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); 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); 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 */ 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); 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); 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); 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); 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 ); 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 ); 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); 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); 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); 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); 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 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 */ 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); 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); 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 */ 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); 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); 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 */ 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); 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); 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); 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); 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); 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); 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 */ 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); 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); 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); 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); 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 ); 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 ); 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); 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); 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 */ 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); 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); 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 */ 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); 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); 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 */ 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); 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); 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 */ 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); 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); 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 */ 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 ); 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 ); return cassette_legacy_construct( cassette, &rk20_legacy_fill_wave );
} }
@ -169,11 +169,11 @@ static const struct CassetteLegacyWaveFiller rk22_legacy_fill_wave = {
0 /* trailer_samples */ 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 ); 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 ); return cassette_legacy_construct( cassette, &rk22_legacy_fill_wave );
} }
@ -187,11 +187,11 @@ static const struct CassetteLegacyWaveFiller gam_legacy_fill_wave = {
0 /* trailer_samples */ 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 ); 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 ); return cassette_legacy_construct( cassette, &gam_legacy_fill_wave );
} }
@ -205,11 +205,11 @@ static const struct CassetteLegacyWaveFiller rk60_legacy_fill_wave = {
0 /* trailer_samples */ 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 ); 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 ); 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 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); 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) \ #define MODULATE(_value) \
for (int i = 0; i < (_value ? 2 : 1); i++) { \ 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);\ 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;\ 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_size = cassette_image_size(cassette);
UINT64 image_pos = 0; UINT64 image_pos = 0;
double time_index = 0.0; double time_index = 0.0;
@ -78,7 +78,7 @@ static casserr_t sc3000_bit_load(cassette_image *cassette)
case ' ': case ' ':
err = cassette_put_sample( cassette, 0, time_index, 1/1200.0, 0); 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; time_index += 1/1200.0;
break; break;
} }
@ -86,7 +86,7 @@ static casserr_t sc3000_bit_load(cassette_image *cassette)
image_pos++; 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 */ 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); 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); 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 */ 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); 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); 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; 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); 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; UINT64 image_size;
double time_index = 0.0; double time_index = 0.0;
double time_displacement; double time_displacement;
@ -52,20 +52,20 @@ static casserr_t sordm5_tap_load( cassette_image *cassette)
image_size = cassette_image_size(cassette); image_size = cassette_image_size(cassette);
image_pos = 0; image_pos = 0;
// read/check header // 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); cassette_image_read( cassette, &header, image_pos, 16);
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) // add silence (header)
err = cassette_put_sample( cassette, 0, time_index, SORDM5_WAVESAMPLES_HEADER, 0); 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; time_index += SORDM5_WAVESAMPLES_HEADER;
// process blocks // process blocks
while (image_pos < image_size) while (image_pos < image_size)
{ {
// read block type // read block type
block_type = cassette_image_read_uint8( cassette, image_pos + 0); 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 // read block size
block_size = cassette_image_read_uint8( cassette, image_pos + 1); block_size = cassette_image_read_uint8( cassette, image_pos + 1);
if (block_size == 0) block_size = 0x100; if (block_size == 0) block_size = 0x100;
@ -74,13 +74,13 @@ static casserr_t sordm5_tap_load( cassette_image *cassette)
if (block_type == 'H') if (block_type == 'H')
{ {
err = cassette_put_sample( cassette, 0, time_index, SORDM5_WAVESAMPLES_BLOCK, 0); 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; time_index += SORDM5_WAVESAMPLES_BLOCK;
} }
// add sync // add sync
if (block_type == 'H') filler_length = 2.4 * (3150 / 8); else filler_length = 0.15 * (3150 / 8); 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); 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; time_index += time_displacement;
// process block // process block
for (i=0;i<block_size;i++) for (i=0;i<block_size;i++)
@ -91,7 +91,7 @@ static casserr_t sordm5_tap_load( cassette_image *cassette)
#if 0 #if 0
if (i == block_size) 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; if (i > 2) crc += byte;
#endif #endif
@ -109,23 +109,23 @@ static casserr_t sordm5_tap_load( cassette_image *cassette)
} }
// add bit // add bit
err = cassette_put_modulated_data_bit( cassette, 0, time_index, bit, &sordm5_cas_modulation, &time_displacement); 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; time_index += time_displacement;
} }
} }
// mark end of block // mark end of block
err = cassette_put_modulated_data_bit( cassette, 0, time_index, 1, &sordm5_cas_modulation, &time_displacement); 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; time_index += time_displacement;
// next block // next block
image_pos += block_size; image_pos += block_size;
} }
// add silence (trailer) // add silence (trailer)
err = cassette_put_sample( cassette, 0, time_index, SORDM5_WAVESAMPLES_TRAILER, 0); 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; time_index += SORDM5_WAVESAMPLES_TRAILER;
// //
return CASSETTE_ERROR_SUCCESS; return cassette_image::error::SUCCESS;
} }
static const struct CassetteFormat sordm5_cas_format = 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 */ 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); 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); 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 */ 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); 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); 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); 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); 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; 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 #if ! K7_SPEED_HACK
static const INT8 square_wave[] = { -128, 127 }; static const INT8 square_wave[] = { -128, 127 };
@ -132,10 +132,10 @@ static casserr_t to7_k7_load( cassette_image *cass )
#define K7_PUT( PERIOD ) \ #define K7_PUT( PERIOD ) \
do \ do \
{ \ { \
casserr_t err; \ cassette_image::error err; \
err = cassette_put_samples( cass, 0, time, (PERIOD), 2, 1, \ err = cassette_put_samples( cass, 0, time, (PERIOD), 2, 1, \
square_wave, CASSETTE_WAVEFORM_8BIT ); \ square_wave, CASSETTE_WAVEFORM_8BIT ); \
if ( err ) \ if ( err != cassette_image::error::SUCCESS ) \
return err; \ return err; \
time += (PERIOD); \ time += (PERIOD); \
} while (0) } while (0)
@ -360,7 +360,7 @@ static casserr_t to7_k7_load( cassette_image *cass )
sz = to7_k7_bitsize * TO7_BIT_LENGTH; 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 )); 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 ) struct CassetteOptions *opts )
{ {
casserr_t e = wavfile_format.identify( cass, opts ); cassette_image::error e = wavfile_format.identify( cass, opts );
return e; 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; struct CassetteInfo info;
double len; double len;
@ -395,7 +395,7 @@ static casserr_t to7_wav_load ( cassette_image *cass )
to7_k7_bits = nullptr; to7_k7_bits = nullptr;
} }
if ( e != CASSETTE_ERROR_SUCCESS ) if ( e != cassette_image::error::SUCCESS )
return e; return e;
cassette_get_info( cass, &info ); 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, info.sample_frequency, info.bits_per_sample,
(int) (len / TO7_BIT_LENGTH) )); (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; 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 )); 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 ) struct CassetteOptions *opts )
{ {
opts -> bits_per_sample = 8; opts -> bits_per_sample = 8;
opts -> channels = 1; opts -> channels = 1;
opts -> sample_frequency = 22100;//11050; 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. 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; size_t size = cassette_image_size( cass ), pos = 0;
int i, sz, sz2, hbit = 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; sz = hbitsize * MO5_HBIT_LENGTH;
PRINT (( "mo5_k5_load: cassette length: %imn %is (%i half-bits)\n", sz / 60, sz % 60, hbitsize )); 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 ) struct CassetteOptions *opts )
{ {
casserr_t e = wavfile_format.identify( cass, opts ); cassette_image::error e = wavfile_format.identify( cass, opts );
return e; 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; struct CassetteInfo info;
int len; int len;
if ( e == CASSETTE_ERROR_SUCCESS ) if ( e == cassette_image::error::SUCCESS )
{ {
cassette_get_info( cass, &info ); cassette_get_info( cass, &info );
len = info.sample_count / info.sample_frequency; 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; 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 )); 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); 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); 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; 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++) 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) 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); 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) 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; 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]; UINT8 tmp_buff[512];
int buff_idx = 0; int buff_idx = 0;
@ -197,10 +197,10 @@ static casserr_t tvc64_cassette_load(cassette_image *cassette)
// 1 sec silence // 1 sec silence
tvc64_emit_level(cassette, time, 1, 0); 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; UINT8 byte;
cassette_image_read(cassette, &byte, 0, 1); 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->bits_per_sample = 16;
opts->channels = 1; opts->channels = 1;
opts->sample_frequency = 44100; 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 = 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 */ 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); 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); 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); 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); 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); 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); 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 */ 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 ); 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 ); 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 */ 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); 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); 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 */ 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); 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); 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 */ 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); 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); 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) int read_waveform)
{ {
UINT8 file_header[12]; UINT8 file_header[12];
@ -81,9 +81,9 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption
/* check magic numbers */ /* check magic numbers */
if (memcmp(&file_header[0], magic1, 4)) if (memcmp(&file_header[0], magic1, 4))
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
if (memcmp(&file_header[8], magic2, 4)) if (memcmp(&file_header[8], magic2, 4))
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
/* read and sanity check size */ /* read and sanity check size */
stated_size = get_leuint32(&file_header[4]) + 8; stated_size = get_leuint32(&file_header[4]) + 8;
@ -101,7 +101,7 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption
{ {
/* format tag */ /* format tag */
if (format_specified || (tag_size < sizeof(format_tag))) if (format_specified || (tag_size < sizeof(format_tag)))
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
format_specified = TRUE; format_specified = TRUE;
cassette_image_read(cassette, format_tag, offset, sizeof(format_tag)); 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]); opts->bits_per_sample = get_leuint16(&format_tag[14]);
if (format_type != WAV_FORMAT_PCM) 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) 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) switch(opts->bits_per_sample)
{ {
@ -130,14 +130,14 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption
waveform_flags = CASSETTE_WAVEFORM_32BITLE; waveform_flags = CASSETTE_WAVEFORM_32BITLE;
break; break;
default: default:
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
} }
} }
else if (!memcmp(tag_header, data_tag_id, 4)) else if (!memcmp(tag_header, data_tag_id, 4))
{ {
/* data tag */ /* data tag */
if (!format_specified) if (!format_specified)
return CASSETTE_ERROR_INVALIDIMAGE; return cassette_image::error::INVALID_IMAGE;
if (read_waveform) if (read_waveform)
{ {
@ -153,19 +153,19 @@ static casserr_t wavfile_process(cassette_image *cassette, struct CassetteOption
offset += tag_size; 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); 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; struct CassetteOptions opts;
memset(&opts, 0, sizeof(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 consolidated_header[12 + 8 + 16 + 8];
UINT8 *header = &consolidated_header[0]; UINT8 *header = &consolidated_header[0];
UINT8 *format_tag_header = &consolidated_header[12]; 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 err = cassette_write_samples(cassette, info->channels, 0.0, info->sample_count
/ (double) info->sample_frequency, info->sample_count, sizeof(consolidated_header), / (double) info->sample_frequency, info->sample_count, sizeof(consolidated_header),
waveform_flags); waveform_flags);
if (err) if (err != cassette_image::error::SUCCESS)
return err; 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 */ 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); 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); 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 */ 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); 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); 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 */ 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); 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 /* 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? part of the image file itself?
@ -274,12 +274,12 @@ static const struct CassetteLegacyWaveFiller zx80_legacy_fill_wave =
0 /* trailer_samples */ 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); 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); return cassette_legacy_construct(cassette, &zx80_legacy_fill_wave);
} }