Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-04 17:38:08 +03:00
Code Issues Actions 36 Packages Projects Releases Wiki Activity

Provide the variants to the floppy formats

Browse Source
This commit is contained in:
Olivier Galibert 2021-01-09 21:41:19 +01:00
parent 31390d3f3e
commit 23af0ace46
123 changed files with 355 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/devices/imagedev/floppy.cpp
View File

@ -307,7 +307,7 @@ void floppy_image_device::commit_image()
if (err != osd_file::error::NONE)
popmessage("Error, unable to truncate image: %d", int(err));
output_format->save(&io, image.get());
output_format->save(&io, variants, image.get());
}
//-------------------------------------------------
@ -413,7 +413,7 @@ floppy_image_format_t *floppy_image_device::identify(std::string filename)
floppy_image_format_t *best_format = nullptr;
for (floppy_image_format_t *format = fif_list; format; format = format->next)
{
int score = format->identify(&io, form_factor);
int score = format->identify(&io, form_factor, variants);
if(score > best) {
best = score;
best_format = format;
@ -460,7 +460,7 @@ image_init_result floppy_image_device::call_load()
int best = 0;
floppy_image_format_t *best_format = nullptr;
for (floppy_image_format_t *format = fif_list; format; format = format->next) {
int score = format->identify(&io, form_factor);
int score = format->identify(&io, form_factor, variants);
if(score > best) {
best = score;
best_format = format;
@ -473,7 +473,7 @@ image_init_result floppy_image_device::call_load()
}
image = std::make_unique<floppy_image>(tracks, sides, form_factor);
if (!best_format->load(&io, form_factor, image.get())) {
if (!best_format->load(&io, form_factor, variants, image.get())) {
seterror(IMAGE_ERROR_UNSUPPORTED, "Incompatible image format or corrupted data");
image.reset();
return image_init_result::FAIL;

18
src/lib/formats/acorn_dsk.cpp
View File

@ -93,7 +93,7 @@ int acorn_ssd_format::find_size(io_generic *io, uint32_t form_factor)
return -1;
}
int acorn_ssd_format::identify(io_generic *io, uint32_t form_factor)
int acorn_ssd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -216,7 +216,7 @@ int acorn_dsd_format::find_size(io_generic *io, uint32_t form_factor)
return -1;
}
int acorn_dsd_format::identify(io_generic *io, uint32_t form_factor)
int acorn_dsd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -311,7 +311,7 @@ int opus_ddos_format::find_size(io_generic *io, uint32_t form_factor)
return -1;
}
int opus_ddos_format::identify(io_generic *io, uint32_t form_factor)
int opus_ddos_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -399,7 +399,7 @@ int acorn_adfs_old_format::find_size(io_generic *io, uint32_t form_factor)
return -1;
}
int acorn_adfs_old_format::identify(io_generic *io, uint32_t form_factor)
int acorn_adfs_old_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -496,7 +496,7 @@ int acorn_adfs_new_format::find_size(io_generic *io, uint32_t form_factor)
return -1;
}
int acorn_adfs_new_format::identify(io_generic *io, uint32_t form_factor)
int acorn_adfs_new_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -567,7 +567,7 @@ int acorn_dos_format::find_size(io_generic *io, uint32_t form_factor)
return -1;
}
int acorn_dos_format::identify(io_generic *io, uint32_t form_factor)
int acorn_dos_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -618,7 +618,7 @@ bool opus_ddcpm_format::supports_save() const
return false;
}
int opus_ddcpm_format::identify(io_generic *io, uint32_t form_factor)
int opus_ddcpm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[8];
@ -630,7 +630,7 @@ int opus_ddcpm_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
// Double density discs formatted with DDCPM :
//
@ -677,7 +677,7 @@ bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, floppy_image
return true;
}
bool opus_ddcpm_format::save(io_generic *io, floppy_image *image)
bool opus_ddcpm_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}

18
src/lib/formats/acorn_dsk.h
View File

@ -21,7 +21,7 @@ public:
acorn_ssd_format();
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -37,7 +37,7 @@ public:
acorn_dsd_format();
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -53,7 +53,7 @@ public:
opus_ddos_format();
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -69,7 +69,7 @@ public:
acorn_adfs_old_format();
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -85,7 +85,7 @@ public:
acorn_adfs_new_format();
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -101,7 +101,7 @@ public:
acorn_dos_format();
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -116,9 +116,9 @@ class opus_ddcpm_format : public floppy_image_format_t
public:
opus_ddcpm_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

2
src/lib/formats/afs_dsk.cpp
View File

@ -30,7 +30,7 @@ const char *afs_format::extensions() const
return "adl,img";
}
int afs_format::identify(io_generic *io, uint32_t form_factor)
int afs_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);

2
src/lib/formats/afs_dsk.h
View File

@ -20,7 +20,7 @@ class afs_format : public wd177x_format
public:
afs_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -40,7 +40,7 @@ const char *aim_format::extensions() const
}
int aim_format::identify(io_generic *io, uint32_t form_factor)
int aim_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
if (io_generic_size(io) == 2068480)
{
@ -51,7 +51,7 @@ int aim_format::identify(io_generic *io, uint32_t form_factor)
}
bool aim_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool aim_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
image->set_variant(floppy_image::DSQD);

4
src/lib/formats/aim_dsk.h
View File

@ -20,8 +20,8 @@ class aim_format : public floppy_image_format_t
public:
aim_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -36,7 +36,7 @@ bool adf_format::supports_save() const
return true;
}
int adf_format::identify(io_generic *io, uint32_t form_factor)
int adf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
if ((size == 901120) || (size == 912384) || (size == 1802240))
@ -46,7 +46,7 @@ int adf_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool adf_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool adf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
desc_s sectors[22];
uint8_t sectdata[512*22];
@ -127,7 +127,7 @@ uint32_t adf_format::checksum(const uint8_t *trackbuf, int track_size, int pos,
return check & 0x55555555;
}
bool adf_format::save(io_generic *io, floppy_image *image)
bool adf_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t sectdata[512*22];
uint8_t trackbuf[300000/8];

6
src/lib/formats/ami_dsk.h
View File

@ -19,9 +19,9 @@ class adf_format : public floppy_image_format_t
public:
adf_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

20
src/lib/formats/ap2_dsk.cpp
View File

@ -559,7 +559,7 @@ bool a2_16sect_format::supports_save() const
return true;
}
int a2_16sect_format::identify(io_generic *io, uint32_t form_factor)
int a2_16sect_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
//uint32_t expected_size = 35 * 16 * 256;
@ -604,7 +604,7 @@ const floppy_image_format_t::desc_e a2_16sect_format::mac_gcr[] = {
{ END },
};
bool a2_16sect_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool a2_16sect_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
@ -768,7 +768,7 @@ void a2_16sect_format::update_chk(const uint8_t *data, int size, uint32_t &chk)
//#define VERBOSE_SAVE
bool a2_16sect_format::save(io_generic *io, floppy_image *image)
bool a2_16sect_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int g_tracks, g_heads;
int visualgrid[16][APPLE2_TRACK_COUNT]; // visualizer grid, cleared/initialized below
@ -1046,7 +1046,7 @@ bool a2_rwts18_format::supports_save() const
return true;
}
int a2_rwts18_format::identify(io_generic *io, uint32_t form_factor)
int a2_rwts18_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
uint32_t expected_size = APPLE2_TRACK_COUNT * 16 * 256;
@ -1084,7 +1084,7 @@ const floppy_image_format_t::desc_e a2_rwts18_format::mac_gcr[] = {
};
bool a2_rwts18_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool a2_rwts18_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
/* TODO: rewrite me properly
uint8_t sector_data[(256)*16];
@ -1133,7 +1133,7 @@ void a2_rwts18_format::update_chk(const uint8_t *data, int size, uint32_t &chk)
{
}
bool a2_rwts18_format::save(io_generic *io, floppy_image *image)
bool a2_rwts18_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int g_tracks, g_heads;
int visualgrid[18][APPLE2_TRACK_COUNT]; // visualizer grid, cleared/initialized below
@ -1562,7 +1562,7 @@ bool a2_edd_format::supports_save() const
return false;
}
int a2_edd_format::identify(io_generic *io, uint32_t form_factor)
int a2_edd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
return ((io_generic_size(io) == 2244608) || (io_generic_size(io) == 2310144)) ? 50 : 0;
}
@ -1572,7 +1572,7 @@ uint8_t a2_edd_format::pick(const uint8_t *data, int pos)
return ((data[pos>>3] << 8) | data[(pos>>3)+1]) >> (8-(pos & 7));
}
bool a2_edd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool a2_edd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t *img;
uint8_t nibble[16384], stream[16384];
@ -1686,7 +1686,7 @@ bool a2_woz_format::supports_save() const
const uint8_t a2_woz_format::signature[8] = { 0x57, 0x4f, 0x5a, 0x31, 0xff, 0x0a, 0x0d, 0x0a };
const uint8_t a2_woz_format::signature2[8] = { 0x57, 0x4f, 0x5a, 0x32, 0xff, 0x0a, 0x0d, 0x0a };
int a2_woz_format::identify(io_generic *io, uint32_t form_factor)
int a2_woz_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[8];
io_generic_read(io, header, 0, 8);
@ -1695,7 +1695,7 @@ int a2_woz_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool a2_woz_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool a2_woz_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
std::vector<uint8_t> img(io_generic_size(io));
io_generic_read(io, &img[0], 0, img.size());

20
src/lib/formats/ap2_dsk.h
View File

@ -41,9 +41,9 @@ class a2_16sect_format : public floppy_image_format_t
public:
a2_16sect_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -68,9 +68,9 @@ class a2_rwts18_format : public floppy_image_format_t
public:
a2_rwts18_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@ -92,8 +92,8 @@ class a2_edd_format : public floppy_image_format_t
public:
a2_edd_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
virtual const char *name() const override;
@ -111,8 +111,8 @@ class a2_woz_format : public floppy_image_format_t
public:
a2_woz_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
virtual const char *name() const override;

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

@ -1232,7 +1232,7 @@ bool dc42_format::supports_save() const
return true;
}
int dc42_format::identify(io_generic *io, uint32_t form_factor)
int dc42_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[0x54];
uint64_t size = io_generic_size(io);
@ -1276,7 +1276,7 @@ const floppy_image_format_t::desc_e dc42_format::mac_gcr[] = {
};
bool dc42_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dc42_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t h[0x54];
io_generic_read(io, h, 0, 0x54);
@ -1350,7 +1350,7 @@ void dc42_format::update_chk(const uint8_t *data, int size, uint32_t &chk)
}
}
bool dc42_format::save(io_generic *io, floppy_image *image)
bool dc42_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int g_tracks, g_heads;
image->get_actual_geometry(g_tracks, g_heads);

6
src/lib/formats/ap_dsk35.h
View File

@ -29,9 +29,9 @@ class dc42_format : public floppy_image_format_t
public:
dc42_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -85,7 +85,7 @@ const char *apd_format::extensions() const
return "apd";
}
int apd_format::identify(io_generic *io, uint32_t form_factor)
int apd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> img(size);
@ -123,7 +123,7 @@ int apd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool apd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool apd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> img(size);

4
src/lib/formats/apd_dsk.h
View File

@ -23,8 +23,8 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
};

2
src/lib/formats/apollo_dsk.cpp
View File

@ -46,7 +46,7 @@ const apollo_format::format apollo_format::formats[] = {
const floppy_format_type FLOPPY_APOLLO_FORMAT = &floppy_image_format_creator<apollo_format>;
int apollo_format::identify(io_generic *io, uint32_t form_factor)
int apollo_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
uint32_t expected_size = 77*2*8*1024;

2
src/lib/formats/apollo_dsk.h
View File

@ -19,7 +19,7 @@ class apollo_format : public upd765_format
public:
apollo_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual const char *name() const override;
virtual const char *description() const override;
virtual const char *extensions() const override;

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

@ -32,7 +32,7 @@ const char *apridisk_format::extensions() const
return "dsk";
}
int apridisk_format::identify(io_generic *io, uint32_t form_factor)
int apridisk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[APR_HEADER_SIZE];
io_generic_read(io, header, 0, APR_HEADER_SIZE);
@ -45,7 +45,7 @@ int apridisk_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool apridisk_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool apridisk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
desc_pc_sector sectors[80][2][18];
std::unique_ptr<uint8_t []> sector_data(new uint8_t [MAX_SECTORS * SECTOR_SIZE]);
@ -140,7 +140,7 @@ bool apridisk_format::load(io_generic *io, uint32_t form_factor, floppy_image *i
return true;
}
bool apridisk_format::save(io_generic *io, floppy_image *image)
bool apridisk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}

6
src/lib/formats/apridisk.h
View File

@ -23,9 +23,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
private:

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

@ -46,7 +46,7 @@ const ccvf_format::format ccvf_format::file_formats[] = {
{}
};
int ccvf_format::identify(io_generic *io, uint32_t form_factor)
int ccvf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char h[36];
@ -87,7 +87,7 @@ floppy_image_format_t::desc_e* ccvf_format::get_desc_8n1(const format &f, int &c
return desc;
}
bool ccvf_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool ccvf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
const format &f = formats[0];

4
src/lib/formats/ccvf_dsk.h
View File

@ -39,8 +39,8 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
protected:

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

@ -89,7 +89,7 @@ void cc525dsdd_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &
track_count = head_count = sector_count = 0;
}
int cc525dsdd_format::identify(io_generic *io, uint32_t form_factor)
int cc525dsdd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -99,7 +99,7 @@ int cc525dsdd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool cc525dsdd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool cc525dsdd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -125,7 +125,7 @@ bool cc525dsdd_format::load(io_generic *io, uint32_t form_factor, floppy_image *
return true;
}
bool cc525dsdd_format::save(io_generic *io, floppy_image *image)
bool cc525dsdd_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int track_count, head_count, sector_count;
get_geometry_mfm_pc(image, 2000, track_count, head_count, sector_count);

6
src/lib/formats/concept_dsk.h
View File

@ -17,9 +17,9 @@ class cc525dsdd_format : public floppy_image_format_t
public:
cc525dsdd_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -64,7 +64,7 @@ bool mgt_format::supports_save() const
return true;
}
int mgt_format::identify(io_generic *io, uint32_t form_factor)
int mgt_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
@ -74,7 +74,7 @@ int mgt_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool mgt_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool mgt_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
int sector_count = size == 737280 ? 9 : 10;
@ -99,7 +99,7 @@ bool mgt_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool mgt_format::save(io_generic *io, floppy_image *image)
bool mgt_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int track_count, head_count, sector_count;
get_geometry_mfm_pc(image, 2000, track_count, head_count, sector_count);

6
src/lib/formats/coupedsk.h
View File

@ -19,9 +19,9 @@ class mgt_format : public floppy_image_format_t
public:
mgt_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -261,7 +261,7 @@ const char *cqm_format::extensions() const
return "cqm,cqi,dsk";
}
int cqm_format::identify(io_generic *io, uint32_t form_factor)
int cqm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[3];
io_generic_read(io, h, 0, 3);
@ -272,7 +272,7 @@ int cqm_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool cqm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool cqm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
const int max_size = 4*1024*1024; // 4MB ought to be large enough for any floppy
std::vector<uint8_t> imagebuf(max_size);
@ -369,7 +369,7 @@ bool cqm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool cqm_format::save(io_generic *io, floppy_image *image)
bool cqm_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}

6
src/lib/formats/cqm_dsk.h
View File

@ -19,9 +19,9 @@ class cqm_format : public floppy_image_format_t
public:
cqm_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -92,7 +92,7 @@ int d64_format::find_size(io_generic *io, uint32_t form_factor) const
return -1;
}
int d64_format::identify(io_generic *io, uint32_t form_factor)
int d64_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -206,7 +206,7 @@ void d64_format::fix_end_gap(floppy_image_format_t::desc_e* desc, int remaining_
desc[22].p1 >>= remaining_size & 0x01;
}
bool d64_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool d64_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)
@ -266,7 +266,7 @@ bool d64_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool d64_format::save(io_generic *io, floppy_image *image)
bool d64_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
const format &f = formats[0];

6
src/lib/formats/d64_dsk.h
View File

@ -37,9 +37,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override { return true; }
protected:

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

@ -414,7 +414,7 @@ const char *d88_format::extensions() const
return "d77,d88,1dd";
}
int d88_format::identify(io_generic *io, uint32_t form_factor)
int d88_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
uint8_t h[32];
@ -427,7 +427,7 @@ int d88_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool d88_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool d88_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t h[32];
@ -536,7 +536,7 @@ bool d88_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
}
bool d88_format::save(io_generic *io, floppy_image *image)
bool d88_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}

6
src/lib/formats/d88_dsk.h
View File

@ -20,9 +20,9 @@ class d88_format : public floppy_image_format_t
public:
d88_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -43,7 +43,7 @@ const char *dcp_format::extensions() const
return "dcp,dcu";
}
int dcp_format::identify(io_generic *io, uint32_t form_factor)
int dcp_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
uint8_t h[0xa2];
@ -112,7 +112,7 @@ int dcp_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool dcp_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dcp_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t h[0xa2];
int heads, tracks, spt, bps;

4
src/lib/formats/dcp_dsk.h
View File

@ -20,8 +20,8 @@ class dcp_format : public floppy_image_format_t
public:
dcp_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -56,14 +56,14 @@ bool dfi_format::supports_save() const
return false;
}
int dfi_format::identify(io_generic *io, uint32_t form_factor)
int dfi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char sign[4];
io_generic_read(io, sign, 0, 4);
return memcmp(sign, "DFE2", 4) ? 0 : 100;
}
bool dfi_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
char sign[4];
io_generic_read(io, sign, 0, 4);

6
src/lib/formats/dfi_dsk.h
View File

@ -12,9 +12,9 @@ class dfi_format : public floppy_image_format_t
public:
dfi_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
// virtual bool save(io_generic *io, floppy_image *image);
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
// virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image);
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -132,7 +132,7 @@ const char *dim_format::extensions() const
return "dim";
}
int dim_format::identify(io_generic *io, uint32_t form_factor)
int dim_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[16];
@ -144,7 +144,7 @@ int dim_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool dim_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dim_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int offset = 0x100;
uint8_t h;
@ -223,7 +223,7 @@ bool dim_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
}
bool dim_format::save(io_generic *io, floppy_image *image)
bool dim_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}

6
src/lib/formats/dim_dsk.h
View File

@ -25,9 +25,9 @@ class dim_format : public floppy_image_format_t
public:
dim_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -37,7 +37,7 @@ const char *dip_format::extensions() const
return "dip";
}
int dip_format::identify(io_generic *io, uint32_t form_factor)
int dip_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
@ -47,7 +47,7 @@ int dip_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool dip_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dip_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int heads, tracks, spt, bps;

4
src/lib/formats/dip_dsk.h
View File

@ -20,8 +20,8 @@ class dip_format : public floppy_image_format_t
public:
dip_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -41,7 +41,7 @@ const char *dmk_format::extensions() const
}
int dmk_format::identify(io_generic *io, uint32_t form_factor)
int dmk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
const int header_size = 16;
uint8_t header[header_size];
@ -81,7 +81,7 @@ int dmk_format::identify(io_generic *io, uint32_t form_factor)
}
bool dmk_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dmk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
const int header_size = 16;
uint8_t header[header_size];
@ -213,7 +213,7 @@ bool dmk_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
}
bool dmk_format::save(io_generic *io, floppy_image *image)
bool dmk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}

6
src/lib/formats/dmk_dsk.h
View File

@ -21,9 +21,9 @@ class dmk_format : public floppy_image_format_t
public:
dmk_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -113,7 +113,7 @@ void ds9_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_c
track_count = head_count = sector_count = 0;
}
int ds9_format::identify(io_generic *io, uint32_t form_factor)
int ds9_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -123,7 +123,7 @@ int ds9_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool ds9_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool ds9_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);

4
src/lib/formats/ds9_dsk.h
View File

@ -19,8 +19,8 @@ class ds9_format : public floppy_image_format_t
public:
ds9_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -299,7 +299,7 @@ bool dsk_format::supports_save() const
return false;
}
int dsk_format::identify(io_generic *io, uint32_t form_factor)
int dsk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[16];
@ -344,7 +344,7 @@ struct sector_header
#pragma pack()
bool dsk_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t header[0x100];
bool extendformat = false;

4
src/lib/formats/dsk_dsk.h
View File

@ -19,8 +19,8 @@ class dsk_format : public floppy_image_format_t
public:
dsk_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -108,7 +108,7 @@ void dvk_mx_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &hea
}
}
int dvk_mx_format::identify(io_generic *io, uint32_t form_factor)
int dvk_mx_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t track_count, head_count, sector_count;
@ -129,7 +129,7 @@ int dvk_mx_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool dvk_mx_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool dvk_mx_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;

4
src/lib/formats/dvk_mx_dsk.h
View File

@ -19,8 +19,8 @@ class dvk_mx_format : public floppy_image_format_t
public:
dvk_mx_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -87,7 +87,7 @@ void esqimg_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &hea
track_count = head_count = sector_count = 0;
}
int esqimg_format::identify(io_generic *io, uint32_t form_factor)
int esqimg_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -97,7 +97,7 @@ int esqimg_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool esqimg_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool esqimg_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -123,7 +123,7 @@ bool esqimg_format::load(io_generic *io, uint32_t form_factor, floppy_image *ima
return true;
}
bool esqimg_format::save(io_generic *io, floppy_image *image)
bool esqimg_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int track_count, head_count, sector_count;
get_geometry_mfm_pc(image, 2000, track_count, head_count, sector_count);

6
src/lib/formats/esq16_dsk.h
View File

@ -21,9 +21,9 @@ class esqimg_format : public floppy_image_format_t
public:
esqimg_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -88,7 +88,7 @@ void esq8img_format::find_size(io_generic *io, int &track_count, int &head_count
track_count = head_count = sector_count = 0;
}
int esq8img_format::identify(io_generic *io, uint32_t form_factor)
int esq8img_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -98,7 +98,7 @@ int esq8img_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool esq8img_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool esq8img_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int track_count, head_count, sector_count;
find_size(io, track_count, head_count, sector_count);
@ -136,7 +136,7 @@ bool esq8img_format::load(io_generic *io, uint32_t form_factor, floppy_image *im
return true;
}
bool esq8img_format::save(io_generic *io, floppy_image *image)
bool esq8img_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int track_count, head_count, sector_count;
get_geometry_mfm_pc(image, 2000, track_count, head_count, sector_count);

6
src/lib/formats/esq8_dsk.h
View File

@ -23,9 +23,9 @@ class esq8img_format : public floppy_image_format_t
public:
esq8img_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -54,7 +54,7 @@ const char *fdd_format::extensions() const
return "fdd";
}
int fdd_format::identify(io_generic *io, uint32_t form_factor)
int fdd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[7];
io_generic_read(io, h, 0, 7);
@ -65,7 +65,7 @@ int fdd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool fdd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool fdd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t hsec[0x0c];

4
src/lib/formats/fdd_dsk.h
View File

@ -20,8 +20,8 @@ class fdd_format : public floppy_image_format_t
public:
fdd_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

2
src/lib/formats/flex_dsk.cpp
View File

@ -71,7 +71,7 @@ const char *flex_format::extensions() const
return "dsk";
}
int flex_format::identify(io_generic *io, uint32_t form_factor)
int flex_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);

2
src/lib/formats/flex_dsk.h
View File

@ -21,7 +21,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track) override;

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

@ -969,6 +969,14 @@ const char *floppy_image::get_variant_name(uint32_t form_factor, uint32_t varian
return "Unknown";
}
bool floppy_image_format_t::has_variant(const std::vector<uint32_t> &variants, uint32_t variant)
{
for(uint32_t v : variants)
if(variant == v)
return true;
return false;
}
floppy_image_format_t::floppy_image_format_t()
{
next = nullptr;
@ -986,7 +994,7 @@ void floppy_image_format_t::append(floppy_image_format_t *_next)
next = _next;
}
bool floppy_image_format_t::save(io_generic *, floppy_image *)
bool floppy_image_format_t::save(io_generic *, const std::vector<uint32_t> &, floppy_image *)
{
return false;
}

17
src/lib/formats/flopimg.h
View File

@ -233,9 +233,10 @@ public:
@param io buffer containing the image data.
@param form_factor Physical form factor of disk, from the enum
in floppy_image
@param variants the variants from floppy_image the drive can handle
@return 1 if image valid, 0 otherwise.
*/
virtual int identify(io_generic *io, uint32_t form_factor) = 0;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) = 0;
/*! @brief Load an image.
The load function opens an image file and converts it to the
@ -243,19 +244,21 @@ public:
@param io source buffer containing the image data.
@param form_factor Physical form factor of disk, from the enum
in floppy_image
@param variants the variants from floppy_image the drive can handle
@param image output buffer for data in MESS internal format.
@return true on success, false otherwise.
*/
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) = 0;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) = 0;
/*! @brief Save an image.
The save function writes back an image from the MESS internal
floppy representation to the appropriate format on disk.
@param io output buffer for the data in the on-disk format.
@param variants the variants from floppy_image the drive can handle
@param image source buffer containing data in MESS internal format.
@return true on success, false otherwise.
*/
virtual bool save(io_generic *io, floppy_image *image);
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image);
//! @returns string containing name of format.
virtual const char *name() const = 0;
@ -366,6 +369,14 @@ protected:
SECTOR_INTERLEAVE_SKEW //!< Defines interleave and skew for sector counting
};
/*! @brief Test if a variant is present in the variant vector
@param variants the variant vector
@param variant the variant to test
@result true if variant is in variants
*/
static bool has_variant(const std::vector<uint32_t> &variants, uint32_t variant);
//! Sector data description
struct desc_s
{

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

@ -83,7 +83,7 @@ bool fsd_format::supports_save() const
return false;
}
int fsd_format::identify(io_generic *io, uint32_t form_factor)
int fsd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[3];
@ -95,7 +95,7 @@ int fsd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool fsd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool fsd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
const char* result[255];
result[0x00] = "OK";

4
src/lib/formats/fsd_dsk.h
View File

@ -33,8 +33,8 @@ public:
virtual const char *extensions() const override;
virtual bool supports_save() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
};
extern const floppy_format_type FLOPPY_FSD_FORMAT;

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

@ -27,7 +27,7 @@ const uint32_t g64_format::c1541_cell_size[] =
3250 // 16MHz/13/4
};
int g64_format::identify(io_generic *io, uint32_t form_factor)
int g64_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char h[8];
@ -38,7 +38,7 @@ int g64_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool g64_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool g64_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> img(size);
@ -109,7 +109,7 @@ int g64_format::generate_bitstream(int track, int head, int speed_zone, uint8_t
return ((actual_cell_size >= cell_size-10) && (actual_cell_size <= cell_size+10)) ? speed_zone : -1;
}
bool g64_format::save(io_generic *io, floppy_image *image)
bool g64_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks, heads;
image->get_actual_geometry(tracks, heads);

6
src/lib/formats/g64_dsk.h
View File

@ -20,9 +20,9 @@ class g64_format : public floppy_image_format_t
public:
g64_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -78,7 +78,7 @@ hpi_format::hpi_format()
(void)HPI_RED_IMAGE_SIZE;
}
int hpi_format::identify(io_generic *io, uint32_t form_factor)
int hpi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
@ -142,7 +142,7 @@ bool hpi_format::geometry_from_size(uint64_t image_size , unsigned& heads , unsi
}
}
bool hpi_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool hpi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
unsigned heads;
unsigned cylinders;
@ -191,7 +191,7 @@ bool hpi_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool hpi_format::save(io_generic *io, floppy_image *image)
bool hpi_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks;
int heads;

6
src/lib/formats/hpi_dsk.h
View File

@ -28,9 +28,9 @@ class hpi_format : public floppy_image_format_t
public:
hpi_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
virtual const char *extensions() const override;

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

@ -144,7 +144,7 @@ bool hfe_format::supports_save() const
return true;
}
int hfe_format::identify(io_generic *io, uint32_t form_factor)
int hfe_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[8];
@ -155,7 +155,7 @@ int hfe_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool hfe_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool hfe_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t header[HEADER_LENGTH];
uint8_t track_table[TRACK_TABLE_LENGTH];
@ -412,7 +412,7 @@ void hfe_format::generate_track_from_hfe_bitstream(int cyl, int head, int sample
image->set_write_splice_position(cyl, head, 0, 0);
}
bool hfe_format::save(io_generic *io, floppy_image *image)
bool hfe_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
std::vector<uint8_t> cylbuf;

6
src/lib/formats/hxchfe_dsk.h
View File

@ -47,9 +47,9 @@ public:
hfe_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -57,7 +57,7 @@ bool mfm_format::supports_save() const
return true;
}
int mfm_format::identify(io_generic *io, uint32_t form_factor)
int mfm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[7];
@ -68,7 +68,7 @@ int mfm_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool mfm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool mfm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
MFMIMG header;
MFMTRACKIMG trackdesc;
@ -109,7 +109,7 @@ bool mfm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool mfm_format::save(io_generic *io, floppy_image *image)
bool mfm_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
// TODO: HD support
MFMIMG header;

6
src/lib/formats/hxcmfm_dsk.h
View File

@ -19,9 +19,9 @@ class mfm_format : public floppy_image_format_t
public:
mfm_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -52,7 +52,7 @@ const char *ibmxdf_format::extensions() const
return "xdf,img";
}
int ibmxdf_format::identify(io_generic *io, uint32_t form_factor)
int ibmxdf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@ -173,7 +173,7 @@ const ibmxdf_format::format ibmxdf_format::formats_head1_track0[] = {
{}
};
bool ibmxdf_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool ibmxdf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)

4
src/lib/formats/ibmxdf_dsk.h
View File

@ -23,8 +23,8 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override { return false; }
virtual int find_size(io_generic *io, uint32_t form_factor) override;

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

@ -409,7 +409,7 @@ void imd_format::fixnum(char *start, char *end) const
};
}
int imd_format::identify(io_generic *io, uint32_t form_factor)
int imd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char h[4];
@ -420,7 +420,7 @@ int imd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool imd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool imd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> img(size);
@ -561,7 +561,7 @@ bool can_compress(const uint8_t* buffer, uint8_t ptrn, uint64_t size)
return true;
}
bool imd_format::save(io_generic* io, floppy_image* image)
bool imd_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t pos = 0;
io_generic_write(io, &m_comment[0], pos, m_comment.size());

6
src/lib/formats/imd_dsk.h
View File

@ -17,9 +17,9 @@ class imd_format : public floppy_image_format_t
public:
imd_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic* io, floppy_image* image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image* image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -40,7 +40,7 @@ img_format::img_format()
{
}
int img_format::identify(io_generic *io, uint32_t form_factor)
int img_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
@ -52,7 +52,7 @@ int img_format::identify(io_generic *io, uint32_t form_factor)
}
}
bool img_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool img_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
if (size != IMG_IMAGE_SIZE) {
@ -96,7 +96,7 @@ bool img_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool img_format::save(io_generic *io, floppy_image *image)
bool img_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
for (int cyl = 0; cyl < TRACKS; cyl++) {
uint8_t bitstream[ 21000 ];

6
src/lib/formats/img_dsk.h
View File

@ -27,9 +27,9 @@ public:
img_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
virtual const char *extensions() const override;

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

@ -45,7 +45,7 @@ bool ipf_format::supports_save() const
return false;
}
int ipf_format::identify(io_generic *io, uint32_t form_factor)
int ipf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
static const uint8_t refh[12] = { 0x43, 0x41, 0x50, 0x53, 0x00, 0x00, 0x00, 0x0c, 0x1c, 0xd5, 0x73, 0xba };
uint8_t h[12];
@ -57,7 +57,7 @@ int ipf_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool ipf_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool ipf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> data(size);

4
src/lib/formats/ipf_dsk.h
View File

@ -14,8 +14,8 @@ class ipf_format : public floppy_image_format_t
public:
ipf_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -183,7 +183,7 @@ const char *jfd_format::extensions() const
return "jfd";
}
int jfd_format::identify(io_generic *io, uint32_t form_factor)
int jfd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> img(size);
@ -221,7 +221,7 @@ int jfd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool jfd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool jfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
std::vector<uint8_t> img(size);

4
src/lib/formats/jfd_dsk.h
View File

@ -23,8 +23,8 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
};

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

@ -168,13 +168,13 @@ bool jvc_format::parse_header(io_generic *io, int &header_size, int &tracks, int
return tracks * heads * sectors * sector_size == (size - header_size);
}
int jvc_format::identify(io_generic *io, uint32_t form_factor)
int jvc_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int header_size, tracks, heads, sectors, sector_size, sector_base_id;
return parse_header(io, header_size, tracks, heads, sectors, sector_size, sector_base_id) ? 50 : 0;
}
bool jvc_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool jvc_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int header_size, track_count, head_count, sector_count, sector_size, sector_base_id;
@ -223,7 +223,7 @@ bool jvc_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool jvc_format::save(io_generic *io, floppy_image *image)
bool jvc_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t bitstream[500000/8];
uint8_t sector_data[50000];

6
src/lib/formats/jvc_dsk.h
View File

@ -35,9 +35,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
private:

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

@ -40,14 +40,14 @@ bool m20_format::supports_save() const
return true;
}
int m20_format::identify(io_generic *io, uint32_t form_factor)
int m20_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
if(io_generic_size(io) == 286720)
return 50;
return 0;
}
bool m20_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool m20_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
for (int track = 0; track < 35; track++)
for (int head = 0; head < 2; head ++) {
@ -76,7 +76,7 @@ bool m20_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool m20_format::save(io_generic *io, floppy_image *image)
bool m20_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t bitstream[500000/8];
uint8_t sector_data[50000];

6
src/lib/formats/m20_dsk.h
View File

@ -18,9 +18,9 @@ class m20_format : public floppy_image_format_t {
public:
m20_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

2
src/lib/formats/mdos_dsk.cpp
View File

@ -72,7 +72,7 @@ const char *mdos_format::extensions() const
return "dsk";
}
int mdos_format::identify(io_generic *io, uint32_t form_factor)
int mdos_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);

2
src/lib/formats/mdos_dsk.h
View File

@ -19,7 +19,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track) override;

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

@ -94,7 +94,7 @@ bool mfi_format::supports_save() const
return true;
}
int mfi_format::identify(io_generic *io, uint32_t form_factor)
int mfi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
header h;
@ -108,7 +108,7 @@ int mfi_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool mfi_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool mfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
header h;
entry entries[84*2*4];
@ -160,7 +160,7 @@ bool mfi_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
return true;
}
bool mfi_format::save(io_generic *io, floppy_image *image)
bool mfi_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks, heads;
image->get_actual_geometry(tracks, heads);

6
src/lib/formats/mfi_dsk.h
View File

@ -12,9 +12,9 @@ class mfi_format : public floppy_image_format_t
public:
mfi_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -100,7 +100,7 @@ const char *nfd_format::extensions() const
return "nfd";
}
int nfd_format::identify(io_generic *io, uint32_t form_factor)
int nfd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[16];
io_generic_read(io, h, 0, 16);
@ -111,7 +111,7 @@ int nfd_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool nfd_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t size = io_generic_size(io);
uint8_t h[0x120], hsec[0x10];

4
src/lib/formats/nfd_dsk.h
View File

@ -20,8 +20,8 @@ class nfd_format : public floppy_image_format_t
public:
nfd_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

2
src/lib/formats/opd_dsk.cpp
View File

@ -30,7 +30,7 @@ const char *opd_format::extensions() const
return "opd,opu";
}
int opd_format::identify(io_generic *io, uint32_t form_factor)
int opd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);

2
src/lib/formats/opd_dsk.h
View File

@ -21,7 +21,7 @@ class opd_format : public wd177x_format
public:
opd_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int get_image_offset(const format &f, int head, int track) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -35,7 +35,7 @@ bool oric_dsk_format::supports_save() const
return true;
}
int oric_dsk_format::identify(io_generic *io, uint32_t form_factor)
int oric_dsk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[256];
io_generic_read(io, h, 0, 256);
@ -54,7 +54,7 @@ int oric_dsk_format::identify(io_generic *io, uint32_t form_factor)
return 100;
}
bool oric_dsk_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool oric_dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t h[256];
uint8_t t[6250+3];
@ -103,7 +103,7 @@ bool oric_dsk_format::load(io_generic *io, uint32_t form_factor, floppy_image *i
return true;
}
bool oric_dsk_format::save(io_generic *io, floppy_image *image)
bool oric_dsk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return true;
}

6
src/lib/formats/oric_dsk.h
View File

@ -18,9 +18,9 @@ class oric_dsk_format : public floppy_image_format_t
{
public:
oric_dsk_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual bool save(io_generic *io, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

2
src/lib/formats/os9_dsk.cpp
View File

@ -69,7 +69,7 @@ const char *os9_format::extensions() const
return "dsk,os9";
}
int os9_format::identify(io_generic *io, uint32_t form_factor)
int os9_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);

2
src/lib/formats/os9_dsk.h
View File

@ -21,7 +21,7 @@ public:
virtual const char *name() const override;
virtual const char *description() const override;
virtual const char *extensions() const override;
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual int find_size(io_generic *io, uint32_t form_factor) override;
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track) override;

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

@ -36,7 +36,7 @@ bool pasti_format::supports_save() const
return false;
}
int pasti_format::identify(io_generic *io, uint32_t form_factor)
int pasti_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[16];
io_generic_read(io, h, 0, 16);
@ -58,7 +58,7 @@ static void hexdump(const uint8_t *d, int s)
}
}
bool pasti_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool pasti_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t fh[16];
io_generic_read(io, fh, 0, 16);

4
src/lib/formats/pasti_dsk.h
View File

@ -12,8 +12,8 @@ class pasti_format : public floppy_image_format_t
public:
pasti_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -30,7 +30,7 @@ const char *pc98fdi_format::extensions() const
return "fdi";
}
int pc98fdi_format::identify(io_generic *io, uint32_t form_factor)
int pc98fdi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
uint8_t h[32];
@ -48,7 +48,7 @@ int pc98fdi_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool pc98fdi_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool pc98fdi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t h[32];

4
src/lib/formats/pc98fdi_dsk.h
View File

@ -20,8 +20,8 @@ class pc98fdi_format : public floppy_image_format_t
public:
pc98fdi_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual bool load(io_generic *io, uint32_t form_factor, floppy_image *image) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -159,7 +159,7 @@ const char *pc_format::extensions() const
return "dsk,ima,img,ufi,360";
}
int pc_format::identify(io_generic *io, uint32_t form_factor)
int pc_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint64_t size = io_generic_size(io);
@ -178,7 +178,7 @@ int pc_format::identify(io_generic *io, uint32_t form_factor)
file_footer_skip_bytes = 0x400;
}
return upd765_format::identify(io, form_factor);
return upd765_format::identify(io, form_factor, variants);
}
const pc_format::format pc_format::formats[] = {

2
src/lib/formats/pc_dsk.h
View File

@ -25,7 +25,7 @@ class pc_format : public upd765_format
public:
pc_format();
virtual int identify(io_generic *io, uint32_t form_factor) override;
virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual const char *name() const override;
virtual const char *description() const override;

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

@ -34,7 +34,7 @@ bool poly_cpm_format::supports_save() const
return true;
}
int poly_cpm_format::identify(io_generic *io, uint32_t form_factor)
int poly_cpm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t boot[16];
uint64_t size = io_generic_size(io);
@ -52,7 +52,7 @@ int poly_cpm_format::identify(io_generic *io, uint32_t form_factor)
return 0;
}
bool poly_cpm_format::load(io_generic *io, uint32_t form_factor, floppy_image *image)
bool poly_cpm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int total_tracks, spt, bps, head_num;

Some files were not shown because too many files have changed in this diff Show More