summaryrefslogtreecommitdiffstatshomepage
path: root/src/lib/formats
diff options
context:
space:
mode:
author Vas Crabb <cuavas@users.noreply.github.com>2021-08-22 09:06:15 +1000
committer GitHub <noreply@github.com>2021-08-22 09:06:15 +1000
commite8bbea1fc6e94e14768509d322f6c624403ffb36 (patch)
tree74dd1606a900d83de8aecff17a6737af4113308d /src/lib/formats
parente319bde5fc3696d7f48f62b15b6366c4377fe5d1 (diff)
formats, osd, util: Started refactoring file I/O stuff. (#8456)
Added more modern generic I/O interfaces with implementation backed by stdio, osd_file and core_file, replacing io_generic. Also replaced core_file's build-in zlib compression with a filter. unzip.cpp, un7z.cpp: Added option to supply abstract I/O interface rather than filename. Converted osd_file, core_file, archive_file, chd_file and device_image_interface to use std::error_condition rather than their own error enums. Allow mounting TI-99 RPK from inside archives.
Diffstat (limited to 'src/lib/formats')
-rw-r--r--src/lib/formats/acorn_dsk.cpp216
-rw-r--r--src/lib/formats/acorn_dsk.h30
-rw-r--r--src/lib/formats/afs_dsk.cpp3
-rw-r--r--src/lib/formats/afs_dsk.h2
-rw-r--r--src/lib/formats/aim_dsk.cpp19
-rw-r--r--src/lib/formats/aim_dsk.h11
-rw-r--r--src/lib/formats/ami_dsk.cpp80
-rw-r--r--src/lib/formats/ami_dsk.h6
-rw-r--r--src/lib/formats/ap2_dsk.cpp141
-rw-r--r--src/lib/formats/ap2_dsk.h26
-rw-r--r--src/lib/formats/ap_dsk35.cpp83
-rw-r--r--src/lib/formats/ap_dsk35.h18
-rw-r--r--src/lib/formats/apd_dsk.cpp26
-rw-r--r--src/lib/formats/apd_dsk.h4
-rw-r--r--src/lib/formats/apollo_dsk.cpp14
-rw-r--r--src/lib/formats/apollo_dsk.h2
-rw-r--r--src/lib/formats/apridisk.cpp24
-rw-r--r--src/lib/formats/apridisk.h6
-rw-r--r--src/lib/formats/cassimg.cpp79
-rw-r--r--src/lib/formats/cassimg.h22
-rw-r--r--src/lib/formats/ccvf_dsk.cpp19
-rw-r--r--src/lib/formats/ccvf_dsk.h4
-rw-r--r--src/lib/formats/concept_dsk.cpp49
-rw-r--r--src/lib/formats/concept_dsk.h8
-rw-r--r--src/lib/formats/coupedsk.cpp28
-rw-r--r--src/lib/formats/coupedsk.h6
-rw-r--r--src/lib/formats/cqm_dsk.cpp36
-rw-r--r--src/lib/formats/cqm_dsk.h6
-rw-r--r--src/lib/formats/d64_dsk.cpp33
-rw-r--r--src/lib/formats/d64_dsk.h10
-rw-r--r--src/lib/formats/d80_dsk.cpp5
-rw-r--r--src/lib/formats/d88_dsk.cpp35
-rw-r--r--src/lib/formats/d88_dsk.h6
-rw-r--r--src/lib/formats/dcp_dsk.cpp28
-rw-r--r--src/lib/formats/dcp_dsk.h4
-rw-r--r--src/lib/formats/dfi_dsk.cpp25
-rw-r--r--src/lib/formats/dfi_dsk.h6
-rw-r--r--src/lib/formats/dim_dsk.cpp22
-rw-r--r--src/lib/formats/dim_dsk.h6
-rw-r--r--src/lib/formats/dip_dsk.cpp16
-rw-r--r--src/lib/formats/dip_dsk.h4
-rw-r--r--src/lib/formats/dmk_dsk.cpp27
-rw-r--r--src/lib/formats/dmk_dsk.h6
-rw-r--r--src/lib/formats/ds9_dsk.cpp24
-rw-r--r--src/lib/formats/ds9_dsk.h13
-rw-r--r--src/lib/formats/dsk_dsk.cpp35
-rw-r--r--src/lib/formats/dsk_dsk.h4
-rw-r--r--src/lib/formats/dvk_mx_dsk.cpp25
-rw-r--r--src/lib/formats/dvk_mx_dsk.h13
-rw-r--r--src/lib/formats/esq16_dsk.cpp40
-rw-r--r--src/lib/formats/esq16_dsk.h8
-rw-r--r--src/lib/formats/esq8_dsk.cpp38
-rw-r--r--src/lib/formats/esq8_dsk.h8
-rw-r--r--src/lib/formats/fdd_dsk.cpp18
-rw-r--r--src/lib/formats/fdd_dsk.h4
-rw-r--r--src/lib/formats/flex_dsk.cpp22
-rw-r--r--src/lib/formats/flex_dsk.h4
-rw-r--r--src/lib/formats/flopimg.cpp77
-rw-r--r--src/lib/formats/flopimg.h24
-rw-r--r--src/lib/formats/fsd_dsk.cpp16
-rw-r--r--src/lib/formats/fsd_dsk.h4
-rw-r--r--src/lib/formats/g64_dsk.cpp45
-rw-r--r--src/lib/formats/g64_dsk.h6
-rw-r--r--src/lib/formats/hpi_dsk.cpp23
-rw-r--r--src/lib/formats/hpi_dsk.h6
-rw-r--r--src/lib/formats/hti_tape.cpp52
-rw-r--r--src/lib/formats/hti_tape.h12
-rw-r--r--src/lib/formats/hxchfe_dsk.cpp26
-rw-r--r--src/lib/formats/hxchfe_dsk.h6
-rw-r--r--src/lib/formats/hxcmfm_dsk.cpp28
-rw-r--r--src/lib/formats/hxcmfm_dsk.h6
-rw-r--r--src/lib/formats/ibmxdf_dsk.cpp17
-rw-r--r--src/lib/formats/ibmxdf_dsk.h6
-rw-r--r--src/lib/formats/imd_dsk.cpp76
-rw-r--r--src/lib/formats/imd_dsk.h6
-rw-r--r--src/lib/formats/img_dsk.cpp22
-rw-r--r--src/lib/formats/img_dsk.h6
-rw-r--r--src/lib/formats/ioprocs.cpp214
-rw-r--r--src/lib/formats/ioprocs.h70
-rw-r--r--src/lib/formats/ipf_dsk.cpp21
-rw-r--r--src/lib/formats/ipf_dsk.h4
-rw-r--r--src/lib/formats/jfd_dsk.cpp25
-rw-r--r--src/lib/formats/jfd_dsk.h4
-rw-r--r--src/lib/formats/jvc_dsk.cpp26
-rw-r--r--src/lib/formats/jvc_dsk.h8
-rw-r--r--src/lib/formats/m20_dsk.cpp42
-rw-r--r--src/lib/formats/m20_dsk.h6
-rw-r--r--src/lib/formats/mdos_dsk.cpp22
-rw-r--r--src/lib/formats/mdos_dsk.h4
-rw-r--r--src/lib/formats/mfi_dsk.cpp29
-rw-r--r--src/lib/formats/mfi_dsk.h6
-rw-r--r--src/lib/formats/mfm_hd.cpp17
-rw-r--r--src/lib/formats/mfm_hd.h8
-rw-r--r--src/lib/formats/nfd_dsk.cpp31
-rw-r--r--src/lib/formats/nfd_dsk.h4
-rw-r--r--src/lib/formats/opd_dsk.cpp5
-rw-r--r--src/lib/formats/opd_dsk.h2
-rw-r--r--src/lib/formats/oric_dsk.cpp53
-rw-r--r--src/lib/formats/oric_dsk.h12
-rw-r--r--src/lib/formats/os9_dsk.cpp15
-rw-r--r--src/lib/formats/os9_dsk.h4
-rw-r--r--src/lib/formats/pasti_dsk.cpp16
-rw-r--r--src/lib/formats/pasti_dsk.h4
-rw-r--r--src/lib/formats/pc98fdi_dsk.cpp54
-rw-r--r--src/lib/formats/pc98fdi_dsk.h4
-rw-r--r--src/lib/formats/pc_dsk.cpp13
-rw-r--r--src/lib/formats/pc_dsk.h2
-rw-r--r--src/lib/formats/poly_dsk.cpp31
-rw-r--r--src/lib/formats/poly_dsk.h4
-rw-r--r--src/lib/formats/rx50_dsk.cpp27
-rw-r--r--src/lib/formats/rx50_dsk.h8
-rw-r--r--src/lib/formats/sdd_dsk.cpp5
-rw-r--r--src/lib/formats/sdf_dsk.cpp23
-rw-r--r--src/lib/formats/sdf_dsk.h6
-rw-r--r--src/lib/formats/st_dsk.cpp66
-rw-r--r--src/lib/formats/st_dsk.h16
-rw-r--r--src/lib/formats/svi_dsk.cpp37
-rw-r--r--src/lib/formats/svi_dsk.h6
-rw-r--r--src/lib/formats/td0_dsk.cpp73
-rw-r--r--src/lib/formats/td0_dsk.h6
-rw-r--r--src/lib/formats/ti99_dsk.cpp75
-rw-r--r--src/lib/formats/ti99_dsk.h26
-rw-r--r--src/lib/formats/trd_dsk.cpp17
-rw-r--r--src/lib/formats/trd_dsk.h2
-rw-r--r--src/lib/formats/trs80_dsk.cpp58
-rw-r--r--src/lib/formats/trs80_dsk.h6
-rw-r--r--src/lib/formats/uniflex_dsk.cpp21
-rw-r--r--src/lib/formats/uniflex_dsk.h4
-rw-r--r--src/lib/formats/upd765_dsk.cpp21
-rw-r--r--src/lib/formats/upd765_dsk.h8
-rw-r--r--src/lib/formats/vdk_dsk.cpp42
-rw-r--r--src/lib/formats/vdk_dsk.h6
-rw-r--r--src/lib/formats/victor9k_dsk.cpp32
-rw-r--r--src/lib/formats/victor9k_dsk.h8
-rw-r--r--src/lib/formats/vt_dsk.cpp47
-rw-r--r--src/lib/formats/vt_dsk.h12
-rw-r--r--src/lib/formats/wd177x_dsk.cpp27
-rw-r--r--src/lib/formats/wd177x_dsk.h8
138 files changed, 1810 insertions, 1564 deletions
diff --git a/src/lib/formats/acorn_dsk.cpp b/src/lib/formats/acorn_dsk.cpp
index c4668478b05..40ab6eb1029 100644
--- a/src/lib/formats/acorn_dsk.cpp
+++ b/src/lib/formats/acorn_dsk.cpp
@@ -10,6 +10,9 @@
#include "acorn_dsk.h"
+#include "ioprocs.h"
+
+
acorn_ssd_format::acorn_ssd_format() : wd177x_format(formats)
{
}
@@ -29,29 +32,36 @@ const char *acorn_ssd_format::extensions() const
return "ssd,bbc,img";
}
-int acorn_ssd_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_ssd_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t cat[8];
uint32_t sectors0, sectors2;
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("ssd: error getting image size\n");
+ return -1;
+ }
- for(int i=0; formats[i].form_factor; i++) {
+ for (int i=0; formats[i].form_factor; i++)
+ {
+ size_t actual;
const format &f = formats[i];
- if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
+ if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
continue;
// test for Torch CPN - test pattern at sector &0018
- io_generic_read(io, cat, 0x32800, 8);
+ io.read_at(0x32800, cat, 8, actual);
if (memcmp(cat, "\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
return i;
// test for HADFS - test pattern at sector 70
- io_generic_read(io, cat, 0x04610, 8);
+ io.read_at(0x04610, cat, 8, actual);
if (memcmp(cat, "\x00\x28\x43\x29\x4a\x47\x48\x00", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
return i;
// test for Kenda SD - offset &0962 = 0 SD/1 DD, offset &0963 = disk size blocks / 4 (block size = 1K, ie. 0x400 bytes), reserved tracks = 3, ie. 0x1e00 bytes, soft stagger = 2 sectors, ie. 0x200 bytes
- io_generic_read(io, cat, 0x0960, 8);
+ io.read_at(0x0960, cat, 8, actual);
if (cat[2] == 0 && ((uint64_t)cat[3] * 4 * 0x400 + 0x2000) == size && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
{
// valid blocks for single sided
@@ -63,20 +73,22 @@ int acorn_ssd_format::find_size(io_generic *io, uint32_t form_factor, const std:
}
// read sector count from side 0 catalogue
- io_generic_read(io, cat, 0x100, 8);
+ io.read_at(0x100, cat, 8, actual);
sectors0 = ((cat[6] & 3) << 8) + cat[7];
LOG_FORMATS("ssd: sector count 0: %d %s\n", sectors0, sectors0 % 10 != 0 ? "invalid" : "");
- if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count)) {
+ if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count))
+ {
if (f.head_count == 2)
{
// read sector count from side 2 catalogue
- io_generic_read(io, cat, (uint64_t)compute_track_size(f) * f.track_count + 0x100, 8); // sequential
+ io.read_at((uint64_t)compute_track_size(f) * f.track_count + 0x100, cat, 8, actual); // sequential
sectors2 = ((cat[6] & 3) << 8) + cat[7];
// exception case for Acorn CP/M System Disc 1
- io_generic_read(io, cat, 0x367ec, 8);
- if (memcmp(cat, "/M ", 4) == 0) sectors2 = ((cat[6] & 3) << 8) + cat[7];
+ io.read_at(0x367ec, cat, 8, actual);
+ if (memcmp(cat, "/M ", 4) == 0)
+ sectors2 = ((cat[6] & 3) << 8) + cat[7];
LOG_FORMATS("ssd: sector count 2: %d %s\n", sectors2, sectors2 % 10 != 0 ? "invalid" : "");
}
@@ -93,12 +105,13 @@ int acorn_ssd_format::find_size(io_generic *io, uint32_t form_factor, const std:
return -1;
}
-int acorn_ssd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_ssd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
- if(type != -1)
+ if (type != -1)
return 90;
+
return 0;
}
@@ -171,40 +184,49 @@ const char *acorn_dsd_format::extensions() const
return "dsd";
}
-int acorn_dsd_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_dsd_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t cat[8];
uint32_t sectors0, sectors2;
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("dsd: error getting image size\n");
+ return -1;
+ }
- for (int i = 0; formats[i].form_factor; i++) {
+ for (int i = 0; formats[i].form_factor; i++)
+ {
+ size_t actual;
const format &f = formats[i];
if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
continue;
// test for Torch CPN - test pattern at sector &0018
- io_generic_read(io, cat, 0x1200, 8);
+ io.read_at(0x1200, cat, 8, actual);
if (memcmp(cat, "\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
return i;
// test for HADFS - test pattern at sector 70
- io_generic_read(io, cat, 0x08c10, 8);
+ io.read_at(0x08c10, cat, 8, actual);
if (memcmp(cat, "\x00\x28\x43\x29\x4a\x47\x48\x00", 4) == 0 && size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
return i;
// read sector count from side 0 catalogue
- io_generic_read(io, cat, 0x100, 8);
+ io.read_at(0x100, cat, 8, actual);
sectors0 = ((cat[6] & 3) << 8) + cat[7];
LOG_FORMATS("dsd: sector count 0: %d %s\n", sectors0, sectors0 % 10 != 0 ? "invalid" : "");
- if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count)) {
+ if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count))
+ {
// read sector count from side 2 catalogue
- io_generic_read(io, cat, 0xb00, 8); // interleaved
+ io.read_at(0xb00, cat, 8, actual); // interleaved
sectors2 = ((cat[6] & 3) << 8) + cat[7];
// exception case for Acorn CP/M System Disc 1
- io_generic_read(io, cat, 0x97ec, 8);
- if (memcmp(cat, "/M ", 4) == 0) sectors2 = ((cat[6] & 3) << 8) + cat[7];
+ io.read_at(0x97ec, cat, 8, actual);
+ if (memcmp(cat, "/M ", 4) == 0)
+ sectors2 = ((cat[6] & 3) << 8) + cat[7];
LOG_FORMATS("dsd: sector count 2: %d %s\n", sectors2, sectors2 % 10 != 0 ? "invalid" : "");
@@ -216,12 +238,13 @@ int acorn_dsd_format::find_size(io_generic *io, uint32_t form_factor, const std:
return -1;
}
-int acorn_dsd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_dsd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
if (type != -1)
return 90;
+
return 0;
}
@@ -274,27 +297,36 @@ const char *opus_ddos_format::extensions() const
return "dds";
}
-int opus_ddos_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int opus_ddos_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ size_t actual;
uint8_t cat[8];
uint32_t sectors0, sectors2;
// read sector count from side 0 catalogue
- io_generic_read(io, cat, 0x1000, 8);
+ io.read_at(0x1000, cat, 8, actual);
sectors0 = (cat[1] << 8) + cat[2];
LOG_FORMATS("ddos: sector count 0: %d %s\n", sectors0, sectors0 % 18 != 0 ? "invalid" : "");
- uint64_t size = io_generic_size(io);
- for (int i = 0; formats[i].form_factor; i++) {
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("ddos: error getting image size\n");
+ return -1;
+ }
+
+ for (int i = 0; formats[i].form_factor; i++)
+ {
const format &f = formats[i];
if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
continue;
- if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count)) {
+ if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (sectors0 <= f.track_count * f.sector_count))
+ {
if (f.head_count == 2)
{
// read sector count from side 2 catalogue
- io_generic_read(io, cat, (uint64_t)compute_track_size(f) * f.track_count + 0x1000, 8); // sequential
+ io.read_at((uint64_t)compute_track_size(f) * f.track_count + 0x1000, cat, 8, actual); // sequential
sectors2 = (cat[1] << 8) + cat[2];
LOG_FORMATS("ddos: sector count 2: %d %s\n", sectors2, sectors2 % 18 != 0 ? "invalid" : "");
}
@@ -311,12 +343,13 @@ int opus_ddos_format::find_size(io_generic *io, uint32_t form_factor, const std:
return -1;
}
-int opus_ddos_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int opus_ddos_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
if (type != -1)
return 90;
+
return 0;
}
@@ -369,25 +402,33 @@ const char *acorn_adfs_old_format::extensions() const
return "adf,ads,adm,adl";
}
-int acorn_adfs_old_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_adfs_old_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ size_t actual;
uint8_t map[3];
uint32_t sectors;
uint8_t oldmap[4];
// read sector count from free space map
- io_generic_read(io, map, 0xfc, 3);
+ io.read_at(0xfc, map, 3, actual);
sectors = map[0] + (map[1] << 8) + (map[2] << 16);
LOG_FORMATS("adfs_o: sector count %d %s\n", sectors, sectors % 16 != 0 ? "invalid" : "");
// read map identifier
- io_generic_read(io, oldmap, 0x201, 4);
+ io.read_at(0x201, oldmap, 4, actual);
LOG_FORMATS("adfs_o: map identifier %s %s\n", oldmap, memcmp(oldmap, "Hugo", 4) != 0 ? "invalid" : "");
- uint64_t size = io_generic_size(io);
- for(int i=0; formats[i].form_factor; i++) {
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("adfs_o: error getting image size\n");
+ return -1;
+ }
+
+ for (int i=0; formats[i].form_factor; i++)
+ {
const format &f = formats[i];
- if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
+ if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
continue;
// valid images will have map identifier 'Hugo' and sector counts adfs-s = 0x280; adfs-m = 0x500; adfs-l = 0xa00; adfs-dos = 0xaa0; though many adfs-s images are incorrect
@@ -399,12 +440,13 @@ int acorn_adfs_old_format::find_size(io_generic *io, uint32_t form_factor, const
return -1;
}
-int acorn_adfs_old_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_adfs_old_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
if(type != -1)
return 100;
+
return 0;
}
@@ -465,43 +507,50 @@ const char *acorn_adfs_new_format::extensions() const
return "adf";
}
-int acorn_adfs_new_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_adfs_new_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ size_t actual;
uint8_t dform[4];
uint8_t eform[4];
// read map identifiers for D and E formats
- io_generic_read(io, dform, 0x401, 4);
+ io.read_at(0x401, dform, 4, actual);
LOG_FORMATS("adfs_n: map identifier (D format) %s %s\n", dform, (memcmp(dform, "Hugo", 4) != 0 && memcmp(dform, "Nick", 4) != 0) ? "invalid" : "");
- io_generic_read(io, eform, 0x801, 4);
+ io.read_at(0x801, eform, 4, actual);
LOG_FORMATS("adfs_n: map identifier (E format) %s %s\n", eform, memcmp(eform, "Nick", 4) != 0 ? "invalid" : "");
- uint64_t size = io_generic_size(io);
- for (int i = 0; formats[i].form_factor; i++) {
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("adfs_n: error getting image size\n");
+ return -1;
+ }
+
+ for (int i = 0; formats[i].form_factor; i++)
+ {
const format &f = formats[i];
if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
continue;
// no further checks for 1600K images
- if ((size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && size == 0x190000) {
+ if ((size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && size == 0x190000)
return i;
- }
// valid 800K images will have map identifier Nick, Arthur D format still use Hugo
- if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (memcmp(dform, "Hugo", 4) == 0 || memcmp(dform, "Nick", 4) == 0 || memcmp(eform, "Nick", 4) == 0)) {
+ if ((size <= (uint64_t)compute_track_size(f) * f.track_count * f.head_count) && (memcmp(dform, "Hugo", 4) == 0 || memcmp(dform, "Nick", 4) == 0 || memcmp(eform, "Nick", 4) == 0))
return i;
- }
}
LOG_FORMATS("adfs_n: no match\n");
return -1;
}
-int acorn_adfs_new_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_adfs_new_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
if (type != -1)
return 100;
+
return 0;
}
@@ -546,33 +595,43 @@ const char *acorn_dos_format::extensions() const
return "img";
}
-int acorn_dos_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_dos_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint8_t type;
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("dos: error getting image size\n");
+ return -1;
+ }
- uint64_t size = io_generic_size(io);
- for(int i=0; formats[i].form_factor; i++) {
+ for (int i=0; formats[i].form_factor; i++)
+ {
const format &f = formats[i];
- if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
+ if (form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
continue;
- if (size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count) {
+ if (size == (uint64_t)compute_track_size(f) * f.track_count * f.head_count)
+ {
// read media type ID from FAT - Acorn DOS = 0xfd
- io_generic_read(io, &type, 0, 1);
+ size_t actual;
+ uint8_t type;
+ io.read_at(0, &type, 1, actual);
LOG_FORMATS("dos: 800k media type id %02X %s\n", type, type != 0xfd ? "invalid" : "");
- if (type == 0xfd) return i;
+ if (type == 0xfd)
+ return i;
}
}
LOG_FORMATS("dos: no match\n");
return -1;
}
-int acorn_dos_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int acorn_dos_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
- if(type != -1)
+ if (type != -1)
return 90;
+
return 0;
}
@@ -618,19 +677,28 @@ bool opus_ddcpm_format::supports_save() const
return false;
}
-int opus_ddcpm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int opus_ddcpm_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ size_t actual;
uint8_t h[8];
- io_generic_read(io, h, 0, 8);
+ io.read_at(0, h, 8, actual);
+
+ uint64_t size;
+ if (io.length(size))
+ {
+ LOG_FORMATS("ddcpm: error getting image size\n");
+ return -1;
+ }
- if (io_generic_size(io) == 819200 && memcmp(h, "Slogger ", 8) == 0)
+ if (size == 819200 && memcmp(h, "Slogger ", 8) == 0)
return 100;
+
LOG_FORMATS("ddcpm: no match\n");
return 0;
}
-bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool opus_ddcpm_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
// Double density discs formatted with DDCPM :
//
@@ -644,19 +712,21 @@ bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, const std::ve
// Sector skew of 1
// Sector interleave of 2
//
- int spt, bps;
-
- for (int head = 0; head < 2; head++) {
- for (int track = 0; track < 80; track++) {
- bool mfm = track > 2 || head;
- bps = mfm ? 512 : 256;
- spt = 10;
+ for (int head = 0; head < 2; head++)
+ {
+ for (int track = 0; track < 80; track++)
+ {
+ bool const mfm = track > 2 || head;
+ int const bps = mfm ? 512 : 256;
+ int const spt = 10;
desc_pc_sector sects[10];
uint8_t sectdata[10*512];
- io_generic_read(io, sectdata, head * 80 * spt * 512 + track * spt * 512, spt * 512);
+ size_t actual;
+ io.read_at(head * 80 * spt * 512 + track * spt * 512, sectdata, spt * 512, actual);
- for (int i = 0; i < spt; i++) {
+ for (int i = 0; i < spt; i++)
+ {
sects[i].track = track;
sects[i].head = head;
sects[i].sector = i;
@@ -677,7 +747,7 @@ bool opus_ddcpm_format::load(io_generic *io, uint32_t form_factor, const std::ve
return true;
}
-bool opus_ddcpm_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool opus_ddcpm_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/acorn_dsk.h b/src/lib/formats/acorn_dsk.h
index 1428212cfaa..de07e8b9fed 100644
--- a/src/lib/formats/acorn_dsk.h
+++ b/src/lib/formats/acorn_dsk.h
@@ -20,8 +20,8 @@ class acorn_ssd_format : public wd177x_format
public:
acorn_ssd_format();
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
@@ -36,8 +36,8 @@ class acorn_dsd_format : public wd177x_format
public:
acorn_dsd_format();
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
@@ -52,8 +52,8 @@ class opus_ddos_format : public wd177x_format
public:
opus_ddos_format();
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
@@ -68,8 +68,8 @@ class acorn_adfs_old_format : public wd177x_format
public:
acorn_adfs_old_format();
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
@@ -84,8 +84,8 @@ class acorn_adfs_new_format : public wd177x_format
public:
acorn_adfs_new_format();
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
@@ -100,8 +100,8 @@ class acorn_dos_format : public wd177x_format
public:
acorn_dos_format();
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/afs_dsk.cpp b/src/lib/formats/afs_dsk.cpp
index d6b275240de..000daf62df7 100644
--- a/src/lib/formats/afs_dsk.cpp
+++ b/src/lib/formats/afs_dsk.cpp
@@ -30,12 +30,13 @@ const char *afs_format::extensions() const
return "adl,img";
}
-int afs_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int afs_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
if (type != -1)
return 50;
+
return 0;
}
diff --git a/src/lib/formats/afs_dsk.h b/src/lib/formats/afs_dsk.h
index 1a15e54d90d..f56b2dcb1f4 100644
--- a/src/lib/formats/afs_dsk.h
+++ b/src/lib/formats/afs_dsk.h
@@ -20,7 +20,7 @@ class afs_format : public wd177x_format
public:
afs_format();
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
diff --git a/src/lib/formats/aim_dsk.cpp b/src/lib/formats/aim_dsk.cpp
index 489ec1752e4..6ad49b22969 100644
--- a/src/lib/formats/aim_dsk.cpp
+++ b/src/lib/formats/aim_dsk.cpp
@@ -12,10 +12,10 @@
*********************************************************************/
-#include <cassert>
-
#include "aim_dsk.h"
+#include "ioprocs.h"
+
aim_format::aim_format()
{
@@ -40,18 +40,20 @@ const char *aim_format::extensions() const
}
-int aim_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int aim_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- if (io_generic_size(io) == 2068480)
- {
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
+ if (size == 2068480)
return 100;
- }
return 0;
}
-bool aim_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool aim_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
image->set_variant(floppy_image::DSQD);
@@ -70,7 +72,8 @@ bool aim_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
bool header = false;
// Read track
- io_generic_read(io, &track_data[0], ( heads * track + head ) * track_size, track_size);
+ size_t actual;
+ io.read_at((heads * track + head) * track_size, &track_data[0], track_size, actual);
// Find first sector header or index mark
for (int offset = 0; offset < track_size; offset += 2)
diff --git a/src/lib/formats/aim_dsk.h b/src/lib/formats/aim_dsk.h
index c4737efc7e6..560943be30c 100644
--- a/src/lib/formats/aim_dsk.h
+++ b/src/lib/formats/aim_dsk.h
@@ -7,9 +7,10 @@
AIM disk images
*********************************************************************/
+#ifndef MAME_FORMATS_AIM_DSK_H
+#define MAME_FORMATS_AIM_DSK_H
-#ifndef AIM_DSK_H
-#define AIM_DSK_H
+#pragma once
#include "flopimg.h"
@@ -20,8 +21,8 @@ class aim_format : public floppy_image_format_t
public:
aim_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
@@ -31,4 +32,4 @@ public:
extern const floppy_format_type FLOPPY_AIM_FORMAT;
-#endif /* AIM_DSK_H */
+#endif // MAME_FORMATS_AIM_DSK_H
diff --git a/src/lib/formats/ami_dsk.cpp b/src/lib/formats/ami_dsk.cpp
index 5973bc69dab..eb96b01377d 100644
--- a/src/lib/formats/ami_dsk.cpp
+++ b/src/lib/formats/ami_dsk.cpp
@@ -8,10 +8,11 @@
*********************************************************************/
-#include <cassert>
-
#include "formats/ami_dsk.h"
+#include "ioprocs.h"
+
+
adf_format::adf_format() : floppy_image_format_t()
{
}
@@ -36,59 +37,61 @@ bool adf_format::supports_save() const
return true;
}
-int adf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int adf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
if ((size == 901120) || (size == 912384) || (size == 1802240))
- {
return 50;
- }
+
return 0;
}
-bool adf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool adf_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
desc_s sectors[22];
uint8_t sectdata[512*22];
bool is_hd = false;
int tracks = 80;
- for(int i=0; i<22; i++) {
+ for (int i=0; i<22; i++) {
sectors[i].data = sectdata + 512*i;
sectors[i].size = 512;
sectors[i].sector_id = i;
}
- uint64_t size = io_generic_size(io);
- if(size == 901120)
- {
+ uint64_t size;
+ if (io.length(size))
+ return false;
+
+ if (size == 901120) {
is_hd = false;
tracks = 80;
- }
- else if (size == 912384)
- {
+ } else if (size == 912384) {
is_hd = false;
tracks = 81;
- }
- else
- {
+ } else {
is_hd = true;
tracks = 80;
}
if (!is_hd) {
image->set_variant(floppy_image::DSDD);
- for(int track=0; track < tracks; track++) {
- for(int side=0; side < 2; side++) {
- io_generic_read(io, sectdata, (track*2 + side)*512*11, 512*11);
+ for (int track=0; track < tracks; track++) {
+ for (int side=0; side < 2; side++) {
+ size_t actual;
+ io.read_at((track*2 + side)*512*11, sectdata, 512*11, actual);
generate_track(amiga_11, track, side, sectors, 11, 100000, image);
}
}
} else {
image->set_variant(floppy_image::DSHD);
- for(int track=0; track < tracks; track++) {
- for(int side=0; side < 2; side++) {
- io_generic_read(io, sectdata, (track*2 + side)*512*22, 512*22);
+ for (int track=0; track < tracks; track++) {
+ for (int side=0; side < 2; side++) {
+ size_t actual;
+ io.read_at((track*2 + side)*512*22, sectdata, 512*22, actual);
generate_track(amiga_22, track, side, sectors, 22, 200000, image);
}
}
@@ -100,11 +103,11 @@ bool adf_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
uint32_t adf_format::g32(const std::vector<bool> &trackbuf, uint32_t pos)
{
uint32_t res = 0;
- for(int i=0; i != 32; i++) {
- if(trackbuf[pos])
+ for (int i=0; i != 32; i++) {
+ if (trackbuf[pos])
res |= 0x80000000 >> i;
- pos ++;
- if(pos == trackbuf.size())
+ pos++;
+ if (pos == trackbuf.size())
pos = 0;
}
return res;
@@ -113,34 +116,34 @@ uint32_t adf_format::g32(const std::vector<bool> &trackbuf, uint32_t pos)
uint32_t adf_format::checksum(const std::vector<bool> &trackbuf, uint32_t pos, int long_count)
{
uint32_t check = 0;
- for(int i=0; i<long_count; i++)
+ for (int i=0; i<long_count; i++)
check ^= g32(trackbuf, pos+32*i);
return check & 0x55555555;
}
-bool adf_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool adf_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t sectdata[512*22];
- bool hd = image->get_variant() == floppy_image::DSHD;
+ bool const hd = image->get_variant() == floppy_image::DSHD;
- int data_track_size = hd ? 512*22 : 512*11;
+ int const data_track_size = hd ? 512*22 : 512*11;
- for(int track=0; track < 80; track++) {
- for(int side=0; side < 2; side++) {
+ for (int track=0; track < 80; track++) {
+ for (int side=0; side < 2; side++) {
auto trackbuf = generate_bitstream_from_track(track, side, hd ? 1000 : 2000, image);
- for(uint32_t i=0; i<trackbuf.size(); i++)
- if(g32(trackbuf, i) == 0x44894489 &&
+ for (uint32_t i=0; i<trackbuf.size(); i++)
+ if (g32(trackbuf, i) == 0x44894489 &&
(g32(trackbuf, i+384) & 0x55555555) == checksum(trackbuf, i+32, 10) &&
(g32(trackbuf, i+448) & 0x55555555) == checksum(trackbuf, i+480, 256)) {
uint32_t head = ((g32(trackbuf, i+32) & 0x55555555) << 1) | (g32(trackbuf, i+64) & 0x55555555);
int sect = (head >> 8) & 0xff;
- if(sect > (hd ? 22 : 11))
+ if (sect > (hd ? 22 : 11))
continue;
uint8_t *dest = sectdata + 512*sect;
- for(int j=0; j<128; j++) {
+ for (int j=0; j<128; j++) {
uint32_t val = ((g32(trackbuf, i+480+32*j) & 0x55555555) << 1) | (g32(trackbuf, i+4576+32*j) & 0x55555555);
*dest++ = val >> 24;
*dest++ = val >> 16;
@@ -148,7 +151,8 @@ bool adf_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
*dest++ = val;
}
- io_generic_write(io, sectdata, (track*2 + side)*data_track_size, data_track_size);
+ size_t actual;
+ io.write_at((track*2 + side) * data_track_size, sectdata, data_track_size, actual);
}
}
}
diff --git a/src/lib/formats/ami_dsk.h b/src/lib/formats/ami_dsk.h
index d25fd45a210..595beb1bcd3 100644
--- a/src/lib/formats/ami_dsk.h
+++ b/src/lib/formats/ami_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/ap2_dsk.cpp b/src/lib/formats/ap2_dsk.cpp
index 50b071d6432..8adc13d69d3 100644
--- a/src/lib/formats/ap2_dsk.cpp
+++ b/src/lib/formats/ap2_dsk.cpp
@@ -8,13 +8,15 @@
*********************************************************************/
-#include <cstdlib>
-#include <cstring>
-#include <cassert>
-
#include "ap2_dsk.h"
#include "basicdsk.h"
+#include "ioprocs.h"
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+
#define APPLE2_IMAGE_DO 0
#define APPLE2_IMAGE_PO 1
@@ -559,9 +561,12 @@ bool a2_16sect_format::supports_save() const
return true;
}
-int a2_16sect_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int a2_16sect_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
//uint32_t expected_size = 35 * 16 * 256;
uint32_t expected_size = APPLE2_TRACK_COUNT * 16 * 256;
@@ -574,9 +579,11 @@ int a2_16sect_format::identify(io_generic *io, uint32_t form_factor, const std::
return 0;
}
-bool a2_16sect_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_16sect_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD);
@@ -595,7 +602,8 @@ bool a2_16sect_format::load(io_generic *io, uint32_t form_factor, const std::vec
static const unsigned char cpm22_block1[8] = { 0xa2, 0x55, 0xa9, 0x00, 0x9d, 0x00, 0x0d, 0xca };
static const unsigned char subnod_block1[8] = { 0x63, 0xaa, 0xf0, 0x76, 0x8d, 0x63, 0xaa, 0x8e };
- io_generic_read(io, sector_data, fpos, 256*16);
+ size_t actual;
+ io.read_at(fpos, sector_data, 256*16, actual);
if (track == 0 && fpos == 0)
{
@@ -740,7 +748,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, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_16sect_format::save(util::random_read_write &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
@@ -938,8 +946,9 @@ bool a2_16sect_format::save(io_generic *io, const std::vector<uint32_t> &variant
}
for(int i=0; i<nsect; i++) {
//if(nsect>0) printf("t%d,", track);
- uint8_t *data = sectdata + (256)*i;
- io_generic_write(io, data, pos_data, 256);
+ uint8_t const *const data = sectdata + (256)*i;
+ size_t actual;
+ io.write_at(pos_data, data, 256, actual);
pos_data += 256;
}
//printf("\n");
@@ -952,11 +961,11 @@ bool a2_16sect_format::save(io_generic *io, const std::vector<uint32_t> &variant
for (int i = 0; i < 16; i++) {
if (visualgrid[i][j] == NOTFOUND) printf("-NF- ");
else {
- if (visualgrid[i][j] & ADDRFOUND) printf("a"); else printf(" ");
- if (visualgrid[i][j] & ADDRGOOD) printf("A"); else printf(" ");
- if (visualgrid[i][j] & DATAFOUND) printf("d"); else printf(" ");
- if (visualgrid[i][j] & DATAGOOD) { printf("D"); total_good++; } else printf(" ");
- if (visualgrid[i][j] & DATAPOST) printf("."); else printf(" ");
+ if (visualgrid[i][j] & ADDRFOUND) printf("a"); else printf(" ");
+ if (visualgrid[i][j] & ADDRGOOD) printf("A"); else printf(" ");
+ if (visualgrid[i][j] & DATAFOUND) printf("d"); else printf(" ");
+ if (visualgrid[i][j] & DATAGOOD) { printf("D"); total_good++; } else printf(" ");
+ if (visualgrid[i][j] & DATAPOST) printf("."); else printf(" ");
}
}
printf("\n");
@@ -1019,14 +1028,16 @@ bool a2_rwts18_format::supports_save() const
return true;
}
-int a2_rwts18_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int a2_rwts18_format::identify(util::random_read &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;
+ uint64_t size;
+ if(io.length(size))
+ return 0;
+ uint32_t const expected_size = APPLE2_TRACK_COUNT * 16 * 256;
return size == expected_size;
}
-bool a2_rwts18_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_rwts18_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
/* TODO: rewrite me properly
uint8_t sector_data[(256)*16];
@@ -1046,7 +1057,8 @@ bool a2_rwts18_format::load(io_generic *io, uint32_t form_factor, const std::vec
sectors[si].size = 256;
sectors[si].sector_id = si;
sectors[si].sector_info = format;
- io_generic_read(io, data, pos_data, 256);
+ size_t actual;
+ io.read_at(pos_data, data, 256, actual);
pos_data += 256;
}
generate_track(mac_gcr, track, head, sectors, 16, 3104*16, image);
@@ -1075,7 +1087,7 @@ void a2_rwts18_format::update_chk(const uint8_t *data, int size, uint32_t &chk)
{
}
-bool a2_rwts18_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_rwts18_format::save(util::random_read_write &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
@@ -1266,8 +1278,9 @@ bool a2_rwts18_format::save(io_generic *io, const std::vector<uint32_t> &variant
}
for(int i=0; i<nsect; i++) {
//if(nsect>0) printf("t%d,", track);
- uint8_t *data = sectdata + (256)*i;
- io_generic_write(io, data, pos_data, 256);
+ uint8_t const *const data = sectdata + (256)*i;
+ size_t actual;
+ io.write_at(pos_data, data, 256, actual);
pos_data += 256;
}
@@ -1447,8 +1460,9 @@ bool a2_rwts18_format::save(io_generic *io, const std::vector<uint32_t> &variant
}
for(int i=0; i<nsect; i++) {
//if(nsect>0) printf("t%d,", track);
- uint8_t *data = sectdata + (256)*i;
- io_generic_write(io, data, pos_data, 256);
+ uint8_t const *const data = sectdata + (256)*i;
+ size_t actual;
+ io.write_at(pos_data, data, 256, actual);
pos_data += 256;
}
//printf("\n");
@@ -1500,9 +1514,12 @@ bool a2_edd_format::supports_save() const
return false;
}
-int a2_edd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int a2_edd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- return ((io_generic_size(io) == 2244608) || (io_generic_size(io) == 2310144)) ? 50 : 0;
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+ return ((size == 2244608) || (size == 2310144)) ? 50 : 0;
}
uint8_t a2_edd_format::pick(const uint8_t *data, int pos)
@@ -1510,23 +1527,20 @@ 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, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_edd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint8_t *img;
uint8_t nibble[16384], stream[16384];
int npos[16384];
- img = (uint8_t *) malloc(2244608);
-
+ std::unique_ptr<uint8_t []> img(new (std::nothrow) uint8_t[2244608]);
if (!img)
- {
return false;
- }
- io_generic_read(io, img, 0, 2244608);
+ size_t actual;
+ io.read_at(0, img.get(), 2244608, actual);
for(int i=0; i<137; i++) {
- const uint8_t *trk = img + 16384*i;
+ uint8_t const *const trk = &img[16384*i];
int pos = 0;
int wpos = 0;
while(pos < 16383*8) {
@@ -1590,7 +1604,7 @@ bool a2_edd_format::load(io_generic *io, uint32_t form_factor, const std::vector
generate_track_from_bitstream(i >> 2, 0, stream, len, image, i & 3);
image->set_write_splice_position(i >> 2, 0, uint32_t(uint64_t(200'000'000)*splice/len), i & 3);
}
- free(img);
+ img.reset();
image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD);
@@ -1627,26 +1641,31 @@ 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, const std::vector<uint32_t> &variants)
+int a2_woz_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[8];
- io_generic_read(io, header, 0, 8);
+ size_t actual;
+ io.read_at(0, header, 8, actual);
if (!memcmp(header, signature, 8)) return 100;
if (!memcmp(header, signature2, 8)) return 100;
return 0;
}
-bool a2_woz_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_woz_format::load(util::random_read &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());
+ uint64_t image_size;
+ if(io.length(image_size))
+ return false;
+ std::vector<uint8_t> img(image_size);
+ size_t actual;
+ io.read_at(0, &img[0], img.size(), actual);
// Check signature
- if ((memcmp(&img[0], signature, 8)) && (memcmp(&img[0], signature2, 8)))
+ if((memcmp(&img[0], signature, 8)) && (memcmp(&img[0], signature2, 8)))
return false;
uint32_t woz_vers = 1;
- if (!memcmp(&img[0], signature2, 8)) woz_vers = 2;
+ if(!memcmp(&img[0], signature2, 8)) woz_vers = 2;
// Check integrity
uint32_t crc = crc32r(&img[12], img.size() - 12);
@@ -1663,7 +1682,7 @@ bool a2_woz_format::load(io_generic *io, uint32_t form_factor, const std::vector
uint32_t info_vers = r8(img, off_info + 0);
- if ((info_vers != 1) && (info_vers != 2))
+ if((info_vers != 1) && (info_vers != 2))
return false;
bool is_35 = r8(img, off_info + 1) == 2;
@@ -1721,7 +1740,7 @@ bool a2_woz_format::load(io_generic *io, uint32_t form_factor, const std::vector
return true;
}
-bool a2_woz_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_woz_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
std::vector<std::vector<bool>> tracks(160);
bool twosided = false;
@@ -1823,7 +1842,8 @@ bool a2_woz_format::save(io_generic *io, const std::vector<uint32_t> &variants,
w32(data, 8, crc32r(&data[12], data.size() - 12));
- io_generic_write(io, data.data(), 0, data.size());
+ size_t actual;
+ io.write_at(0, data.data(), data.size(), actual);
return true;
}
@@ -1911,12 +1931,15 @@ bool a2_nib_format::supports_save() const
return false;
}
-int a2_nib_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int a2_nib_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- const auto size = io_generic_size(io);
- if (size == expected_size_35t || size == expected_size_40t) {
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
+ if (size == expected_size_35t || size == expected_size_40t)
return 50;
- }
+
return 0;
}
@@ -2031,18 +2054,20 @@ std::vector<uint32_t> a2_nib_format::generate_levels_from_nibbles(const std::vec
return levels;
}
-bool a2_nib_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool a2_nib_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- auto size = io_generic_size(io);
- if (size != expected_size_35t && size != expected_size_40t) {
+ uint64_t size;
+ if (io.length(size))
return false;
- }
+ if (size != expected_size_35t && size != expected_size_40t)
+ return false;
+
const auto nr_tracks = size == expected_size_35t? 35 : 40;
std::vector<uint8_t> nibbles(nibbles_per_track);
for (unsigned track = 0; track < nr_tracks; ++track) {
- io_generic_read(io, &nibbles[0],
- track * nibbles_per_track, nibbles_per_track);
+ size_t actual;
+ io.read_at(track * nibbles_per_track, &nibbles[0], nibbles_per_track, actual);
auto levels = generate_levels_from_nibbles(nibbles);
generate_track_from_levels(track, 0,
levels,
diff --git a/src/lib/formats/ap2_dsk.h b/src/lib/formats/ap2_dsk.h
index 7420d72d818..bab61cf96b8 100644
--- a/src/lib/formats/ap2_dsk.h
+++ b/src/lib/formats/ap2_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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,9 +111,9 @@ class a2_woz_format : public floppy_image_format_t
public:
a2_woz_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
virtual const char *name() const override;
@@ -141,8 +141,8 @@ class a2_nib_format : public floppy_image_format_t
public:
a2_nib_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/ap_dsk35.cpp b/src/lib/formats/ap_dsk35.cpp
index 9819406183c..6a3fa5d742b 100644
--- a/src/lib/formats/ap_dsk35.cpp
+++ b/src/lib/formats/ap_dsk35.cpp
@@ -100,6 +100,8 @@
#include "ap_dsk35.h"
+#include "ioprocs.h"
+
#include <cassert>
#include <cstdio>
@@ -1233,14 +1235,15 @@ bool dc42_format::supports_save() const
return true;
}
-int dc42_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dc42_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint8_t h[0x54];
- uint64_t size = io_generic_size(io);
- if(size < 0x54)
+ uint64_t size;
+ if(io.length(size) || (size < 0x54))
return 0;
- io_generic_read(io, h, 0, 0x54);
+ uint8_t h[0x54];
+ size_t actual;
+ io.read_at(0, h, 0x54, actual);
uint32_t dsize = (h[0x40] << 24) | (h[0x41] << 16) | (h[0x42] << 8) | h[0x43];
uint32_t tsize = (h[0x44] << 24) | (h[0x45] << 16) | (h[0x46] << 8) | h[0x47];
@@ -1252,13 +1255,14 @@ int dc42_format::identify(io_generic *io, uint32_t form_factor, const std::vecto
return 0;
}
- return size == 0x54+tsize+dsize && h[0] < 64 && h[0x52] == 1 && h[0x53] == 0 ? 100 : 0;
+ return (size == 0x54+tsize+dsize && h[0] < 64 && h[0x52] == 1 && h[0x53] == 0) ? 100 : 0;
}
-bool dc42_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dc42_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
uint8_t h[0x54];
- io_generic_read(io, h, 0, 0x54);
+ io.read_at(0, h, 0x54, actual);
int dsize = (h[0x40] << 24) | (h[0x41] << 16) | (h[0x42] << 8) | h[0x43];
int tsize = (h[0x44] << 24) | (h[0x45] << 16) | (h[0x46] << 8) | h[0x47];
@@ -1270,8 +1274,7 @@ bool dc42_format::load(io_generic *io, uint32_t form_factor, const std::vector<u
return false;
}
- switch (dsize)
- {
+ switch(dsize) {
case 409600: // Mac 400K
image->set_form_variant(floppy_image::FF_35, floppy_image::SSDD);
break;
@@ -1315,13 +1318,14 @@ bool dc42_format::load(io_generic *io, uint32_t form_factor, const std::vector<u
sectors[si].sector = i;
sectors[si].info = format;
if(tsize) {
- io_generic_read(io, data, pos_tag, 12);
+ io.read_at(pos_tag, data, 12, actual);
sectors[si].tag = data;
pos_tag += 12;
- } else
+ } else {
sectors[si].tag = nullptr;
+ }
sectors[si].data = data+12;
- io_generic_read(io, data+12, pos_data, 512);
+ io.read_at(pos_data, data+12, 512, actual);
pos_data += 512;
si = (si + 2) % ns;
if(si == 0)
@@ -1341,7 +1345,7 @@ void dc42_format::update_chk(const uint8_t *data, int size, uint32_t &chk)
}
}
-bool dc42_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dc42_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int g_tracks, g_heads;
image->get_actual_geometry(g_tracks, g_heads);
@@ -1381,8 +1385,9 @@ bool dc42_format::save(io_generic *io, const std::vector<uint32_t> &variants, fl
for(unsigned int i=0; i < sectors.size(); i++) {
auto &sdata = sectors[i];
sdata.resize(512+12);
- io_generic_write(io, &sdata[0], pos_tag, 12);
- io_generic_write(io, &sdata[12], pos_data, 512);
+ size_t actual;
+ io.write_at(pos_tag, &sdata[0], 12, actual);
+ io.write_at(pos_data, &sdata[12], 512, actual);
pos_tag += 12;
pos_data += 512;
if(track || head || i)
@@ -1401,7 +1406,8 @@ bool dc42_format::save(io_generic *io, const std::vector<uint32_t> &variants, fl
h[0x4e] = tchk >> 8;
h[0x4f] = tchk;
- io_generic_write(io, h, 0, 0x54);
+ size_t actual;
+ io.write_at(0, h, 0x54, actual);
return true;
}
@@ -1432,26 +1438,32 @@ bool apple_gcr_format::supports_save() const
return true;
}
-int apple_gcr_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int apple_gcr_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
+
if(size == 409600 || (size == 819200 && (variants.empty() || has_variant(variants, floppy_image::DSDD))))
return 50;
return 0;
}
-bool apple_gcr_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apple_gcr_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
desc_gcr_sector sectors[12];
uint8_t sdata[512*12];
int pos_data = 0;
uint8_t header[64];
- io_generic_read(io, header, 0, 64);
+ io.read_at(0, header, 64, actual);
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
int head_count = size == 409600 ? 1 : size == 819200 ? 2 : 0;
image->set_form_variant(floppy_image::FF_35, head_count == 2 ? floppy_image::DSDD : floppy_image::SSDD);
@@ -1461,7 +1473,7 @@ bool apple_gcr_format::load(io_generic *io, uint32_t form_factor, const std::vec
for(int track=0; track < 80; track++) {
for(int head=0; head < head_count; head++) {
int ns = 12 - (track/16);
- io_generic_read(io, sdata, pos_data, 512*ns);
+ io.read_at(pos_data, sdata, 512*ns, actual);
pos_data += 512*ns;
int si = 0;
@@ -1482,7 +1494,7 @@ bool apple_gcr_format::load(io_generic *io, uint32_t form_factor, const std::vec
return true;
}
-bool apple_gcr_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apple_gcr_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int g_tracks, g_heads;
image->get_actual_geometry(g_tracks, g_heads);
@@ -1498,7 +1510,8 @@ bool apple_gcr_format::save(io_generic *io, const std::vector<uint32_t> &variant
for(unsigned int i=0; i < sectors.size(); i++) {
auto &sdata = sectors[i];
sdata.resize(512+12);
- io_generic_write(io, &sdata[12], pos_data, 512);
+ size_t actual;
+ io.write_at(pos_data, &sdata[12], 512, actual);
pos_data += 512;
}
}
@@ -1534,10 +1547,11 @@ bool apple_2mg_format::supports_save() const
return true;
}
-int apple_2mg_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int apple_2mg_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t signature[4];
- io_generic_read(io, signature, 0, 4);
+ size_t actual;
+ io.read_at(0, signature, 4, actual);
if (!strncmp(reinterpret_cast<char *>(signature), "2IMG", 4))
{
return 100;
@@ -1552,11 +1566,12 @@ int apple_2mg_format::identify(io_generic *io, uint32_t form_factor, const std::
return 0;
}
-bool apple_2mg_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apple_2mg_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
desc_gcr_sector sectors[12];
uint8_t sdata[512*12], header[64];
- io_generic_read(io, header, 0, 64);
+ io.read_at(0, header, 64, actual);
uint32_t blocks = header[0x14] | (header[0x15] << 8) | (header[0x16] << 16) | (header[0x17] << 24);
uint32_t pos_data = header[0x18] | (header[0x19] << 8) | (header[0x1a] << 16) | (header[0x1b] << 24);
@@ -1568,7 +1583,7 @@ bool apple_2mg_format::load(io_generic *io, uint32_t form_factor, const std::vec
for(int track=0; track < 80; track++) {
for(int head=0; head < 2; head++) {
int ns = 12 - (track/16);
- io_generic_read(io, sdata, pos_data, 512*ns);
+ io.read_at(pos_data, sdata, 512*ns, actual);
pos_data += 512*ns;
int si = 0;
@@ -1589,8 +1604,10 @@ bool apple_2mg_format::load(io_generic *io, uint32_t form_factor, const std::vec
return true;
}
-bool apple_2mg_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apple_2mg_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
+
uint8_t header[0x40];
int pos_data = 0x40;
@@ -1611,7 +1628,7 @@ bool apple_2mg_format::save(io_generic *io, const std::vector<uint32_t> &variant
header[0x18] = 0x40;
// bytes of disk data
header[0x1c] = 0x00; header[0x1d] = 0x80; header[0x1e] = 0x0c; // 0xC8000 (819200)
- io_generic_write(io, header, 0, 0x40);
+ io.write_at(0, header, 0x40, actual);
for(int track=0; track < 80; track++) {
for(int head=0; head < 2; head++) {
@@ -1619,7 +1636,7 @@ bool apple_2mg_format::save(io_generic *io, const std::vector<uint32_t> &variant
for(unsigned int i=0; i < sectors.size(); i++) {
auto &sdata = sectors[i];
sdata.resize(512+12);
- io_generic_write(io, &sdata[12], pos_data, 512);
+ io.write_at(pos_data, &sdata[12], 512, actual);
pos_data += 512;
}
}
diff --git a/src/lib/formats/ap_dsk35.h b/src/lib/formats/ap_dsk35.h
index def1cb86856..f4a8ec7bff8 100644
--- a/src/lib/formats/ap_dsk35.h
+++ b/src/lib/formats/ap_dsk35.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -49,9 +49,9 @@ class apple_gcr_format : public floppy_image_format_t
public:
apple_gcr_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -66,9 +66,9 @@ class apple_2mg_format : public floppy_image_format_t
public:
apple_2mg_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/apd_dsk.cpp b/src/lib/formats/apd_dsk.cpp
index 45d385a0800..f882d90fe23 100644
--- a/src/lib/formats/apd_dsk.cpp
+++ b/src/lib/formats/apd_dsk.cpp
@@ -60,9 +60,13 @@
*********************************************************************/
-#include <zlib.h>
#include "formats/apd_dsk.h"
+#include "ioprocs.h"
+
+#include <zlib.h>
+
+
static const uint8_t APD_HEADER[8] = { 'A', 'P', 'D', 'X', '0', '0', '0', '1' };
static const uint8_t GZ_HEADER[2] = { 0x1f, 0x8b };
@@ -85,11 +89,15 @@ const char *apd_format::extensions() const
return "apd";
}
-int apd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int apd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
int err;
std::vector<uint8_t> gz_ptr(8);
@@ -123,11 +131,15 @@ int apd_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool apd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
+
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
int err;
std::vector<uint8_t> gz_ptr;
diff --git a/src/lib/formats/apd_dsk.h b/src/lib/formats/apd_dsk.h
index bc551973c4a..8c3ac6f0d42 100644
--- a/src/lib/formats/apd_dsk.h
+++ b/src/lib/formats/apd_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
};
diff --git a/src/lib/formats/apollo_dsk.cpp b/src/lib/formats/apollo_dsk.cpp
index 75c31cfe7f8..a1159ac68c8 100644
--- a/src/lib/formats/apollo_dsk.cpp
+++ b/src/lib/formats/apollo_dsk.cpp
@@ -8,10 +8,11 @@
*********************************************************************/
-#include <cassert>
-
#include "formats/apollo_dsk.h"
+#include "ioprocs.h"
+
+
apollo_format::apollo_format() : upd765_format(formats)
{
}
@@ -46,10 +47,13 @@ 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, const std::vector<uint32_t> &variants)
+int apollo_format::identify(util::random_read &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;
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
+ constexpr uint32_t expected_size = 77*2*8*1024;
return ((size == expected_size) || (size == 0)) ? 1 : 0;
}
diff --git a/src/lib/formats/apollo_dsk.h b/src/lib/formats/apollo_dsk.h
index 6376c77b067..1c2c6d81030 100644
--- a/src/lib/formats/apollo_dsk.h
+++ b/src/lib/formats/apollo_dsk.h
@@ -19,7 +19,7 @@ class apollo_format : public upd765_format
public:
apollo_format();
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
diff --git a/src/lib/formats/apridisk.cpp b/src/lib/formats/apridisk.cpp
index 388d358f6f8..1560c199149 100644
--- a/src/lib/formats/apridisk.cpp
+++ b/src/lib/formats/apridisk.cpp
@@ -12,6 +12,8 @@
#include "imageutl.h"
+#include "ioprocs.h"
+
apridisk_format::apridisk_format()
{
@@ -32,10 +34,11 @@ const char *apridisk_format::extensions() const
return "dsk";
}
-int apridisk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int apridisk_format::identify(util::random_read &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);
+ size_t actual;
+ io.read_at(0, header, APR_HEADER_SIZE, actual);
const char magic[] = "ACT Apricot disk image\x1a\x04";
@@ -45,21 +48,26 @@ int apridisk_format::identify(io_generic *io, uint32_t form_factor, const std::v
return 0;
}
-bool apridisk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apridisk_format::load(util::random_read &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]);
uint8_t *data_ptr = sector_data.get();
int track_count = 0, head_count = 0, sector_count = 0;
- uint64_t file_size = io_generic_size(io);
+ uint64_t file_size;
+ if (io.length(file_size))
+ return false;
+
uint64_t file_offset = APR_HEADER_SIZE;
while (file_offset < file_size)
{
+ size_t actual;
+
// read sector header
uint8_t sector_header[16];
- io_generic_read(io, sector_header, file_offset, 16);
+ io.read_at(file_offset, sector_header, 16, actual);
uint32_t type = pick_integer_le(&sector_header, 0, 4);
uint16_t compression = pick_integer_le(&sector_header, 4, 2);
@@ -94,7 +102,7 @@ bool apridisk_format::load(io_generic *io, uint32_t form_factor, const std::vect
case APR_COMPRESSED:
{
uint8_t comp[3];
- io_generic_read(io, comp, file_offset, 3);
+ io.read_at(file_offset, comp, 3, actual);
uint16_t length = pick_integer_le(comp, 0, 2);
if (length != SECTOR_SIZE)
@@ -108,7 +116,7 @@ bool apridisk_format::load(io_generic *io, uint32_t form_factor, const std::vect
break;
case APR_UNCOMPRESSED:
- io_generic_read(io, data_ptr, file_offset, SECTOR_SIZE);
+ io.read_at(file_offset, data_ptr, SECTOR_SIZE, actual);
break;
default:
@@ -140,7 +148,7 @@ bool apridisk_format::load(io_generic *io, uint32_t form_factor, const std::vect
return true;
}
-bool apridisk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool apridisk_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/apridisk.h b/src/lib/formats/apridisk.h
index 3e751f8d6ec..5cc8a1403fb 100644
--- a/src/lib/formats/apridisk.h
+++ b/src/lib/formats/apridisk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
private:
diff --git a/src/lib/formats/cassimg.cpp b/src/lib/formats/cassimg.cpp
index cf5812c67c1..2fab4a1ec8b 100644
--- a/src/lib/formats/cassimg.cpp
+++ b/src/lib/formats/cassimg.cpp
@@ -199,12 +199,15 @@ cassette_image::error cassette_image::lookup_sample(int channel, size_t sample,
-cassette_image::cassette_image(const Format *format, void *file, const io_procs *procs, int flags)
+cassette_image::cassette_image(const Format *format, util::random_read_write::ptr &&io, int flags) :
+ m_format(format),
+ m_io(std::move(io)),
+ m_channels(0),
+ m_flags(flags),
+ m_sample_frequency(0),
+ m_blocks(),
+ m_sample_count(0)
{
- m_format = format;
- m_io.file = file;
- m_io.procs = procs;
- m_flags = flags;
}
@@ -217,17 +220,24 @@ cassette_image::~cassette_image()
-cassette_image::error cassette_image::open(void *file, const io_procs *procs,
- const Format *format, int flags, ptr &outcassette)
+cassette_image::error cassette_image::open(
+ util::random_read_write::ptr &&io,
+ const Format *format,
+ int flags,
+ ptr &outcassette)
{
const Format *const formats[2] = { format, nullptr };
- return open_choices(file, procs, {}, formats, flags, outcassette);
+ return open_choices(std::move(io), { }, formats, flags, outcassette);
}
-cassette_image::error cassette_image::open_choices(void *file, const io_procs *procs, const std::string &extension,
- const Format *const *formats, int flags, ptr &outcassette)
+cassette_image::error cassette_image::open_choices(
+ util::random_read_write::ptr &&io,
+ const std::string &extension,
+ const Format *const *formats,
+ int flags,
+ ptr &outcassette)
{
// if not specified, use the dummy arguments
if (!formats)
@@ -235,7 +245,7 @@ cassette_image::error cassette_image::open_choices(void *file, const io_procs *p
// create the cassette object
ptr cassette;
- try { cassette.reset(new cassette_image(nullptr, file, procs, flags)); }
+ try { cassette.reset(new cassette_image(nullptr, std::move(io), flags)); }
catch (std::bad_alloc const &) { return error::OUT_OF_MEMORY; }
// identify the image
@@ -275,8 +285,12 @@ cassette_image::error cassette_image::open_choices(void *file, const io_procs *p
-cassette_image::error cassette_image::create(void *file, const io_procs *procs, const Format *format,
- const Options *opts, int flags, ptr &outcassette)
+cassette_image::error cassette_image::create(
+ util::random_read_write::ptr &&io,
+ const Format *format,
+ const Options *opts,
+ int flags,
+ ptr &outcassette)
{
static const Options default_options = { 1, 16, 44100 };
@@ -294,7 +308,7 @@ cassette_image::error cassette_image::create(void *file, const io_procs *procs,
// create the cassette object
ptr cassette;
- try { cassette.reset(new cassette_image(format, file, procs, flags)); }
+ try { cassette.reset(new cassette_image(format, std::move(io), flags)); }
catch (std::bad_alloc const &) { return error::OUT_OF_MEMORY; }
// read the options
@@ -334,13 +348,13 @@ cassette_image::Info cassette_image::get_info() const
-void cassette_image::change(void *file, const io_procs *procs, const Format *format, int flags)
+void cassette_image::change(util::random_read_write::ptr &&io, const Format *format, int flags)
{
- if ((flags & FLAG_READONLY) == 0)
+ if (!(flags & FLAG_READONLY))
flags |= CASSETTE_FLAG_DIRTY;
- m_io.file = file;
- m_io.procs = procs;
+
m_format = format;
+ m_io = std::move(io);
m_flags = flags;
}
@@ -352,7 +366,8 @@ void cassette_image::change(void *file, const io_procs *procs, const Format *for
void cassette_image::image_read(void *buffer, uint64_t offset, size_t length)
{
- io_generic_read(&m_io, buffer, offset, length);
+ size_t actual;
+ m_io->read_at(offset, buffer, length, actual);
}
@@ -360,7 +375,7 @@ void cassette_image::image_read(void *buffer, uint64_t offset, size_t length)
uint8_t cassette_image::image_read_byte(uint64_t offset)
{
uint8_t data;
- io_generic_read(&m_io, &data, offset, 1);
+ image_read(&data, offset, 1);
return data;
}
@@ -368,14 +383,17 @@ uint8_t cassette_image::image_read_byte(uint64_t offset)
void cassette_image::image_write(const void *buffer, uint64_t offset, size_t length)
{
- io_generic_write(&m_io, buffer, offset, length);
+ size_t actual;
+ m_io->write_at(offset, buffer, length, actual);
}
uint64_t cassette_image::image_size()
{
- return io_generic_size(&m_io);
+ uint64_t size = 0;
+ m_io->length(size);
+ return size;
}
@@ -900,20 +918,19 @@ done:
void cassette_image::dump(const char *filename)
{
- FILE *f = fopen(filename, "wb");
- if (!f)
+ util::random_read_write::ptr saved_io = util::stdio_read_write(fopen(filename, "wb"), 0);
+ if (!saved_io)
return;
- io_generic saved_io = m_io;
- const Format *saved_format = m_format;
+ Format const *const saved_format = m_format;
- m_io.file = f;
- m_io.procs = &stdio_ioprocs_noclose;
+ using std::swap;
+
+ swap(m_io, saved_io);
m_format = &wavfile_format;
+
perform_save();
- m_io = saved_io;
+ swap(m_io, saved_io);
m_format = saved_format;
-
- fclose(f);
}
diff --git a/src/lib/formats/cassimg.h b/src/lib/formats/cassimg.h
index 3a59870571a..765b860b659 100644
--- a/src/lib/formats/cassimg.h
+++ b/src/lib/formats/cassimg.h
@@ -185,14 +185,14 @@ public:
void dump(const char *filename);
error save();
- void change(void *file, const io_procs *procs, const Format *format, int flags);
+ void change(util::random_read_write::ptr &&io, const Format *format, int flags);
Info get_info() const;
- static error open(void *file, const io_procs *procs,
+ static error open(util::random_read_write::ptr &&io,
const Format *format, int flags, ptr &outcassette);
- static error open_choices(void *file, const io_procs *procs, const std::string &extension,
+ static error open_choices(util::random_read_write::ptr &&io, const std::string &extension,
const Format *const *formats, int flags, ptr &outcassette);
- static error create(void *file, const io_procs *procs, const cassette_image::Format *format,
+ static error create(util::random_read_write::ptr &&io, const cassette_image::Format *format,
const cassette_image::Options *opts, int flags, ptr &outcassette);
// builtin formats
@@ -201,7 +201,7 @@ public:
private:
struct manipulation_ranges;
- cassette_image(const Format *format, void *file, const io_procs *procs, int flags);
+ cassette_image(const Format *format, util::random_read_write::ptr &&io, int flags);
cassette_image(const cassette_image &) = delete;
cassette_image(cassette_image &&) = delete;
cassette_image &operator=(const cassette_image &) = delete;
@@ -212,15 +212,15 @@ private:
error compute_manipulation_ranges(int channel, double time_index, double sample_period, manipulation_ranges &ranges) const;
error lookup_sample(int channel, size_t sample, int32_t *&ptr);
- const Format *m_format = nullptr;
- io_generic m_io;
+ const Format *m_format;
+ util::random_read_write::ptr m_io;
- int m_channels = 0;
- int m_flags = 0;
- uint32_t m_sample_frequency = 0;
+ int m_channels;
+ int m_flags;
+ uint32_t m_sample_frequency;
std::vector<std::unique_ptr<int32_t []> > m_blocks;
- size_t m_sample_count = 0;
+ size_t m_sample_count;
};
/* macros for specifying format lists */
diff --git a/src/lib/formats/ccvf_dsk.cpp b/src/lib/formats/ccvf_dsk.cpp
index bba52d3922a..6ed0c14038a 100644
--- a/src/lib/formats/ccvf_dsk.cpp
+++ b/src/lib/formats/ccvf_dsk.cpp
@@ -11,6 +11,7 @@
#include "formats/ccvf_dsk.h"
#include "coretmpl.h" // BIT
+#include "ioprocs.h"
ccvf_format::ccvf_format()
@@ -46,12 +47,12 @@ const ccvf_format::format ccvf_format::file_formats[] = {
{}
};
-int ccvf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ccvf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char h[36];
-
- io_generic_read(io, h, 0, 36);
- if(!memcmp(h, "Compucolor Virtual Floppy Disk Image", 36))
+ size_t actual;
+ io.read_at(0, h, 36, actual);
+ if (!memcmp(h, "Compucolor Virtual Floppy Disk Image", 36))
return 100;
return 0;
@@ -87,13 +88,17 @@ 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, const std::vector<uint32_t> &variants, floppy_image *image)
+bool ccvf_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
const format &f = formats[0];
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
+
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
std::string ccvf = std::string((const char *)&img[0], size);
std::vector<uint8_t> bytes(78720);
diff --git a/src/lib/formats/ccvf_dsk.h b/src/lib/formats/ccvf_dsk.h
index 5895a882550..92f04e03ddd 100644
--- a/src/lib/formats/ccvf_dsk.h
+++ b/src/lib/formats/ccvf_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
protected:
diff --git a/src/lib/formats/concept_dsk.cpp b/src/lib/formats/concept_dsk.cpp
index 67c8562e1c3..7f5edce3363 100644
--- a/src/lib/formats/concept_dsk.cpp
+++ b/src/lib/formats/concept_dsk.cpp
@@ -10,11 +10,11 @@
*********************************************************************/
-#include <cassert>
-
-#include "flopimg.h"
#include "formats/concept_dsk.h"
+#include "ioprocs.h"
+
+
/* 9 sectors / track, 512 bytes per sector */
const floppy_image_format_t::desc_e cc525dsdd_format::cc_9_desc[] = {
{ MFM, 0x4e, 80 },
@@ -72,50 +72,50 @@ bool cc525dsdd_format::supports_save() const
return true;
}
-void cc525dsdd_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
+void cc525dsdd_format::find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
{
- uint64_t size = io_generic_size(io);
-
track_count = 77;
head_count = 2;
sector_count = 9;
- uint32_t expected_size = 512 * track_count*head_count*sector_count;
- if (size == expected_size)
- {
+ uint32_t const expected_size = 512 * track_count*head_count*sector_count;
+
+ uint64_t size;
+ if (!io.length(size) && (size == expected_size))
return;
- }
track_count = head_count = sector_count = 0;
}
-int cc525dsdd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int cc525dsdd_format::identify(util::random_read &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);
- if(track_count)
+ if (track_count)
return 50;
+
return 0;
}
-bool cc525dsdd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool cc525dsdd_format::load(util::random_read &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);
uint8_t sectdata[10*512];
desc_s sectors[10];
- for(int i=0; i<sector_count; i++) {
+ for (int i=0; i<sector_count; i++) {
sectors[i+1].data = sectdata + 512*i;
sectors[i+1].size = 512;
sectors[i+1].sector_id = i+1;
}
int track_size = sector_count*512;
- for(int track=0; track < track_count; track++) {
- for(int head=0; head < head_count; head++) {
- io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
+ for (int track=0; track < track_count; track++) {
+ for (int head=0; head < head_count; head++) {
+ size_t actual;
+ io.read_at((track*head_count + head) * track_size, sectdata, track_size, actual);
generate_track(cc_9_desc, track, head, sectors, sector_count, 100000, image);
}
}
@@ -125,28 +125,29 @@ bool cc525dsdd_format::load(io_generic *io, uint32_t form_factor, const std::vec
return true;
}
-bool cc525dsdd_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool cc525dsdd_format::save(util::random_read_write &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);
- if(track_count != 77)
+ if (track_count != 77)
track_count = 77;
// Happens for a fully unformatted floppy
- if(!head_count)
+ if (!head_count)
head_count = 2;
- if(sector_count != 9)
+ if (sector_count != 9)
sector_count = 9;
uint8_t sectdata[9*512];
int track_size = sector_count*512;
- for(int track=0; track < track_count; track++) {
- for(int head=0; head < head_count; head++) {
+ for (int track=0; track < track_count; track++) {
+ for (int head=0; head < head_count; head++) {
get_track_data_mfm_pc(track, head, image, 2000, 512, sector_count, sectdata);
- io_generic_write(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.write_at((track*head_count + head)*track_size, sectdata, track_size, actual);
}
}
diff --git a/src/lib/formats/concept_dsk.h b/src/lib/formats/concept_dsk.h
index 58d4e1c52b3..36e3f790a84 100644
--- a/src/lib/formats/concept_dsk.h
+++ b/src/lib/formats/concept_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -29,7 +29,7 @@ public:
static const desc_e cc_9_desc[];
private:
- void find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
+ void find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
};
extern const floppy_format_type FLOPPY_CONCEPT_525DSDD_FORMAT;
diff --git a/src/lib/formats/coupedsk.cpp b/src/lib/formats/coupedsk.cpp
index 16842583855..9400cd41bb6 100644
--- a/src/lib/formats/coupedsk.cpp
+++ b/src/lib/formats/coupedsk.cpp
@@ -8,10 +8,10 @@
**************************************************************************/
-#include <cassert>
+#include "coupedsk.h"
+
+#include "ioprocs.h"
-#include "formats/coupedsk.h"
-#include "flopimg.h"
const floppy_image_format_t::desc_e mgt_format::desc_10[] = {
{ MFM, 0x4e, 60 },
@@ -64,9 +64,11 @@ bool mgt_format::supports_save() const
return true;
}
-int mgt_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int mgt_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
if(/*size == 737280 || */ size == 819200)
return 50;
@@ -74,10 +76,12 @@ int mgt_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool mgt_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool mgt_format::load(util::random_read &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;
+ uint64_t size;
+ if(io.length(size))
+ return false;
+ int const sector_count = (size == 737280) ? 9 : 10;
uint8_t sectdata[10*512];
desc_s sectors[10];
@@ -90,7 +94,8 @@ bool mgt_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
int track_size = sector_count*512;
for(int head=0; head < 2; head++) {
for(int track=0; track < 80; track++) {
- io_generic_read(io, sectdata, (track*2+head)*track_size, track_size);
+ size_t actual;
+ io.read_at((track*2+head)*track_size, sectdata, track_size, actual);
generate_track(desc_10, track, head, sectors, sector_count+1, 100000, image);
}
}
@@ -99,7 +104,7 @@ bool mgt_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool mgt_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool mgt_format::save(util::random_read_write &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);
@@ -115,7 +120,8 @@ bool mgt_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
for(int head=0; head < 2; head++) {
for(int track=0; track < 80; track++) {
get_track_data_mfm_pc(track, head, image, 2000, 512, sector_count, sectdata);
- io_generic_write(io, sectdata, (track*2+head)*track_size, track_size);
+ size_t actual;
+ io.write_at((track*2+head)*track_size, sectdata, track_size, actual);
}
}
diff --git a/src/lib/formats/coupedsk.h b/src/lib/formats/coupedsk.h
index 3700d3e9974..e9ef4b118ca 100644
--- a/src/lib/formats/coupedsk.h
+++ b/src/lib/formats/coupedsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/cqm_dsk.cpp b/src/lib/formats/cqm_dsk.cpp
index 5f79a4d3694..6639e50f801 100644
--- a/src/lib/formats/cqm_dsk.cpp
+++ b/src/lib/formats/cqm_dsk.cpp
@@ -8,9 +8,12 @@
*********************************************************************/
+#include "cqm_dsk.h"
+
+#include "ioprocs.h"
+
#include <cstring>
-#include <cassert>
-#include "flopimg.h"
+
#define CQM_HEADER_SIZE 133
@@ -231,17 +234,6 @@ FLOPPY_CONSTRUCT( cqm_dsk_construct )
-
-/*********************************************************************
-
- formats/cqm_dsk.c
-
- CopyQM disk images
-
-*********************************************************************/
-
-#include "cqm_dsk.h"
-
cqm_format::cqm_format()
{
}
@@ -261,10 +253,11 @@ const char *cqm_format::extensions() const
return "cqm,cqi,dsk";
}
-int cqm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int cqm_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[3];
- io_generic_read(io, h, 0, 3);
+ size_t actual;
+ io.read_at(0, h, 3, actual);
if (h[0] == 'C' && h[1] == 'Q' && h[2] == 0x14)
return 100;
@@ -272,12 +265,13 @@ int cqm_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool cqm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool cqm_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
const int max_size = 4*1024*1024; // 4MB ought to be large enough for any floppy
std::vector<uint8_t> imagebuf(max_size);
uint8_t header[CQM_HEADER_SIZE];
- io_generic_read(io, header, 0, CQM_HEADER_SIZE);
+ io.read_at(0, header, CQM_HEADER_SIZE, actual);
int sector_size = (header[0x04] << 8) | header[0x03];
int sector_per_track = (header[0x11] << 8) | header[0x10];
@@ -318,9 +312,11 @@ bool cqm_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
int rpm = form_factor == floppy_image::FF_8 || (form_factor == floppy_image::FF_525 && rate >= 300000) ? 360 : 300;
int base_cell_count = rate*60/rpm;
- int cqm_size = io_generic_size(io);
+ uint64_t cqm_size;
+ if (io.length(cqm_size))
+ return false;
std::vector<uint8_t> cqmbuf(cqm_size);
- io_generic_read(io, &cqmbuf[0], 0, cqm_size);
+ io.read_at(0, &cqmbuf[0], cqm_size, actual);
// decode the RLE data
for (int s = 0, pos = CQM_HEADER_SIZE + comment_size; pos < cqm_size; )
@@ -369,7 +365,7 @@ bool cqm_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool cqm_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool cqm_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/cqm_dsk.h b/src/lib/formats/cqm_dsk.h
index 183c0b83e68..fc8376a2b85 100644
--- a/src/lib/formats/cqm_dsk.h
+++ b/src/lib/formats/cqm_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/d64_dsk.cpp b/src/lib/formats/d64_dsk.cpp
index 4819ecc68d2..149130f0b3c 100644
--- a/src/lib/formats/d64_dsk.cpp
+++ b/src/lib/formats/d64_dsk.cpp
@@ -12,6 +12,8 @@
#include "formats/d64_dsk.h"
+#include "ioprocs.h"
+
d64_format::d64_format()
{
@@ -79,9 +81,12 @@ const int d64_format::speed_zone[] =
0, 0 // 41-42
};
-int d64_format::find_size(io_generic *io, uint32_t form_factor) const
+int d64_format::find_size(util::random_read &io, uint32_t form_factor) const
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
+
for(int i=0; formats[i].sector_count; i++) {
const format &f = formats[i];
if(size == (uint32_t) f.sector_count*f.sector_base_size*f.head_count)
@@ -89,12 +94,13 @@ int d64_format::find_size(io_generic *io, uint32_t form_factor) const
if(size == (uint32_t) (f.sector_count*f.sector_base_size*f.head_count) + f.sector_count)
return i;
}
+
return -1;
}
-int d64_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int d64_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int type = find_size(io, form_factor);
+ const int type = find_size(io, form_factor);
if (type != -1)
return 50;
@@ -114,10 +120,11 @@ int d64_format::get_disk_id_offset(const format &f)
return 0x165a2;
}
-void d64_format::get_disk_id(const format &f, io_generic *io, uint8_t &id1, uint8_t &id2)
+void d64_format::get_disk_id(const format &f, util::random_read &io, uint8_t &id1, uint8_t &id2)
{
uint8_t id[2];
- io_generic_read(io, id, get_disk_id_offset(f), 2);
+ size_t actual;
+ io.read_at(get_disk_id_offset(f), id, 2, actual);
id1 = id[0];
id2 = id[1];
}
@@ -206,7 +213,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, const std::vector<uint32_t> &variants, floppy_image *image)
+bool d64_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int type = find_size(io, form_factor);
if(type == -1)
@@ -214,7 +221,9 @@ bool d64_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
const format &f = formats[type];
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
std::vector<uint8_t> img;
if(size == (uint32_t)f.sector_count*f.sector_base_size) {
@@ -225,7 +234,8 @@ bool d64_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
img.resize(size);
}
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
int track_offset = 0, error_offset = f.sector_count*f.sector_base_size;
@@ -266,7 +276,7 @@ bool d64_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool d64_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool d64_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
const format &f = formats[0];
@@ -280,7 +290,8 @@ bool d64_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
build_sector_description(f, sectdata, 0, 0, sectors, sector_count);
extract_sectors(image, f, sectors, track, head, sector_count);
- io_generic_write(io, sectdata, offset, track_size);
+ size_t actual;
+ io.write_at(offset, sectdata, track_size, actual);
}
}
diff --git a/src/lib/formats/d64_dsk.h b/src/lib/formats/d64_dsk.h
index 665f6489a81..13f1bd4e91c 100644
--- a/src/lib/formats/d64_dsk.h
+++ b/src/lib/formats/d64_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override { return true; }
protected:
@@ -61,12 +61,12 @@ protected:
const format *formats;
- int find_size(io_generic *io, uint32_t form_factor) const;
+ int find_size(util::random_read &io, uint32_t form_factor) const;
virtual int get_physical_track(const format &f, int head, int track);
virtual uint32_t get_cell_size(const format &f, int track);
virtual int get_sectors_per_track(const format &f, int track);
virtual int get_disk_id_offset(const format &f);
- void get_disk_id(const format &f, io_generic *io, uint8_t &id1, uint8_t &id2);
+ void get_disk_id(const format &f, util::random_read &io, uint8_t &id1, uint8_t &id2);
virtual int get_image_offset(const format &f, int head, int track);
int compute_track_size(const format &f, int track);
virtual int get_gap2(const format &f, int head, int track) { return f.gap_2; }
diff --git a/src/lib/formats/d80_dsk.cpp b/src/lib/formats/d80_dsk.cpp
index d350411b159..338f00292a9 100644
--- a/src/lib/formats/d80_dsk.cpp
+++ b/src/lib/formats/d80_dsk.cpp
@@ -8,10 +8,11 @@
*********************************************************************/
-#include <cassert>
-
#include "formats/d80_dsk.h"
+#include "ioprocs.h"
+
+
d80_format::d80_format() : d64_format(file_formats), formats(nullptr)
{
}
diff --git a/src/lib/formats/d88_dsk.cpp b/src/lib/formats/d88_dsk.cpp
index 7c4eaa079dc..6e29f10df6a 100644
--- a/src/lib/formats/d88_dsk.cpp
+++ b/src/lib/formats/d88_dsk.cpp
@@ -29,11 +29,12 @@
*
*/
- #include <cassert>
-
#include "flopimg.h"
#include "imageutl.h"
+#include "ioprocs.h"
+
+
#define D88_HEADER_LEN 0x2b0
struct d88_tag
@@ -414,12 +415,15 @@ const char *d88_format::extensions() const
return "d77,d88,1dd";
}
-int d88_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int d88_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
- uint8_t h[32];
+ uint64_t size;
+ if(io.length(size))
+ return 0;
- io_generic_read(io, h, 0, 32);
+ uint8_t h[32];
+ size_t actual;
+ io.read_at(0, h, 32, actual);
if((little_endianize_int32(*(uint32_t *)(h+0x1c)) == size) &&
(h[0x1b] == 0x00 || h[0x1b] == 0x10 || h[0x1b] == 0x20 || h[0x1b] == 0x30 || h[0x1b] == 0x40))
return 100;
@@ -427,11 +431,12 @@ int d88_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool d88_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool d88_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint8_t h[32];
+ size_t actual;
- io_generic_read(io, h, 0, 32);
+ uint8_t h[32];
+ io.read_at(0, h, 32, actual);
int cell_count = 0;
int track_count = 0;
@@ -477,9 +482,11 @@ bool d88_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return false;
uint32_t track_pos[164];
- io_generic_read(io, track_pos, 32, 164*4);
+ io.read_at(32, track_pos, 164*4, actual);
- uint64_t file_size = io_generic_size(io);
+ uint64_t file_size;
+ if(io.length(file_size))
+ return false;
for(int track=0; track < track_count; track++)
for(int head=0; head < head_count; head++) {
@@ -496,7 +503,7 @@ bool d88_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
uint8_t hs[16];
- io_generic_read(io, hs, pos, 16);
+ io.read_at(pos, hs, 16, actual);
pos += 16;
uint16_t size = little_endianize_int16(*(uint16_t *)(hs+14));
@@ -521,7 +528,7 @@ bool d88_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
if(size) {
sects[i].data = sect_data + sdatapos;
- io_generic_read(io, sects[i].data, pos, size);
+ io.read_at(pos, sects[i].data, size, actual);
pos += size;
sdatapos += size;
@@ -536,7 +543,7 @@ bool d88_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
}
-bool d88_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool d88_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/d88_dsk.h b/src/lib/formats/d88_dsk.h
index c7c85fc1949..aeed5ed16e8 100644
--- a/src/lib/formats/d88_dsk.h
+++ b/src/lib/formats/d88_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/dcp_dsk.cpp b/src/lib/formats/dcp_dsk.cpp
index b3beb40404f..7d419628bdc 100644
--- a/src/lib/formats/dcp_dsk.cpp
+++ b/src/lib/formats/dcp_dsk.cpp
@@ -20,10 +20,11 @@
*********************************************************************/
-#include <cassert>
-
#include "dcp_dsk.h"
+#include "ioprocs.h"
+
+
dcp_format::dcp_format()
{
}
@@ -43,14 +44,18 @@ const char *dcp_format::extensions() const
return "dcp,dcu";
}
-int dcp_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dcp_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
uint8_t h[0xa2];
int heads, tracks, spt, bps, count_tracks = 0;
bool is_hdb = false;
- io_generic_read(io, h, 0, 0xa2);
+ size_t actual;
+ io.read_at(0, h, 0xa2, actual);
// First byte is the disk format (see below in load() for details)
switch (h[0])
@@ -112,13 +117,14 @@ int dcp_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool dcp_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dcp_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
uint8_t h[0xa2];
int heads, tracks, spt, bps;
bool is_hdb = false;
- io_generic_read(io, h, 0, 0xa2);
+ io.read_at(0, h, 0xa2, actual);
// First byte is the disk format:
switch (h[0])
@@ -215,7 +221,7 @@ bool dcp_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for (int track = 0; track < tracks; track++)
for (int head = 0; head < heads; head++)
{
- io_generic_read(io, sect_data, 0xa2 + bps * spt * (track * heads + head), bps * spt);
+ io.read_at(0xa2 + bps * spt * (track * heads + head), sect_data, bps * spt, actual);
for (int i = 0; i < spt; i++)
{
@@ -235,7 +241,7 @@ bool dcp_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
else // FIXME: the code below is untested, because no image was found... there might be some silly mistake in the disk geometry!
{
// Read Head 0 Track 0 is FM with 26 sectors of 128bytes instead of 256
- io_generic_read(io, sect_data, 0xa2, 128 * spt);
+ io.read_at(0xa2, sect_data, 128 * spt, actual);
for (int i = 0; i < spt; i++)
{
@@ -252,7 +258,7 @@ bool dcp_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
build_pc_track_fm(0, 0, image, cell_count, spt, sects, calc_default_pc_gap3_size(form_factor, 128));
// Read Head 1 Track 0 is MFM with 26 sectors of 256bytes
- io_generic_read(io, sect_data, 0xa2 + 128 * spt, bps * spt);
+ io.read_at(0xa2 + 128 * spt, sect_data, bps * spt, actual);
for (int i = 0; i < spt; i++)
{
@@ -273,7 +279,7 @@ bool dcp_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for (int track = 1; track < tracks; track++)
for (int head = 0; head < heads; head++)
{
- io_generic_read(io, sect_data, data_offs + bps * spt * ((track - 1) * heads + head), bps * spt);
+ io.read_at(data_offs + bps * spt * ((track - 1) * heads + head), sect_data, bps * spt, actual);
for (int i = 0; i < spt; i++)
{
diff --git a/src/lib/formats/dcp_dsk.h b/src/lib/formats/dcp_dsk.h
index c06396d527e..716814ffd48 100644
--- a/src/lib/formats/dcp_dsk.h
+++ b/src/lib/formats/dcp_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/dfi_dsk.cpp b/src/lib/formats/dfi_dsk.cpp
index 409797e9583..607be56f741 100644
--- a/src/lib/formats/dfi_dsk.cpp
+++ b/src/lib/formats/dfi_dsk.cpp
@@ -13,7 +13,8 @@
#include "dfi_dsk.h"
-#include <zlib.h>
+#include "ioprocs.h"
+
#define NUMBER_OF_MULTIREADS 3
// thresholds for brickwall windowing
@@ -56,24 +57,28 @@ bool dfi_format::supports_save() const
return false;
}
-int dfi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dfi_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char sign[4];
- io_generic_read(io, sign, 0, 4);
+ size_t actual;
+ io.read_at(0, sign, 4, actual);
return memcmp(sign, "DFE2", 4) ? 0 : 100;
}
-bool dfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dfi_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
char sign[4];
- io_generic_read(io, sign, 0, 4);
- if (memcmp(sign, "DFER", 4) == 0)
- {
+ io.read_at(0, sign, 4, actual);
+ if(memcmp(sign, "DFER", 4) == 0) {
osd_printf_error("dfi_dsk: Old type Discferret image detected; the mess Discferret decoder will not handle this properly, bailing out!\n");
return false;
}
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
+
uint64_t pos = 4;
std::vector<uint8_t> data;
int onerev_time = 0; // time for one revolution, used to guess clock and rpm for DFE2 files
@@ -81,7 +86,7 @@ bool dfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
int rpm=360; // drive rpm
while(pos < size) {
uint8_t h[10];
- io_generic_read(io, h, pos, 10);
+ io.read_at(pos, h, 10, actual);
uint16_t track = (h[0] << 8) | h[1];
uint16_t head = (h[2] << 8) | h[3];
// Ignore sector
@@ -97,7 +102,7 @@ bool dfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
data.resize(tsize);
pos += 10; // skip the header, we already read it
- io_generic_read(io, &data[0], pos, tsize);
+ io.read_at(pos, &data[0], tsize, actual);
pos += tsize; // for next time we read, increment to the beginning of next header
int index_time = 0; // what point the last index happened
diff --git a/src/lib/formats/dfi_dsk.h b/src/lib/formats/dfi_dsk.h
index d727f1d3c06..71b69c43d70 100644
--- a/src/lib/formats/dfi_dsk.h
+++ b/src/lib/formats/dfi_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ // virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image);
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/dim_dsk.cpp b/src/lib/formats/dim_dsk.cpp
index 964f19ce028..04f6e3b8995 100644
--- a/src/lib/formats/dim_dsk.cpp
+++ b/src/lib/formats/dim_dsk.cpp
@@ -8,12 +8,14 @@
*********************************************************************/
-#include <cstring>
-#include <cassert>
-
#include "dim_dsk.h"
#include "basicdsk.h"
+#include "ioprocs.h"
+
+#include <cstring>
+
+
FLOPPY_IDENTIFY(dim_dsk_identify)
{
uint8_t dim_header[16];
@@ -132,11 +134,12 @@ const char *dim_format::extensions() const
return "dim";
}
-int dim_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dim_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[16];
- io_generic_read(io, h, 0xab, 16);
+ size_t actual;
+ io.read_at(0xab, h, 16, actual);
if(strncmp((const char *)h, "DIFC HEADER", 11) == 0)
return 100;
@@ -144,14 +147,15 @@ int dim_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool dim_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dim_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
int offset = 0x100;
uint8_t h;
uint8_t track_total = 77;
int cell_count = form_factor == floppy_image::FF_35 ? 200000 : 166666;
- io_generic_read(io, &h, 0, 1);
+ io.read_at(0, &h, 1, actual);
int spt, gap3, bps, size;
switch(h) {
@@ -211,7 +215,7 @@ bool dim_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
sects[i].deleted = false;
sects[i].bad_crc = false;
sects[i].data = &sect_data[sdatapos];
- io_generic_read(io, sects[i].data, offset, bps);
+ io.read_at(offset, sects[i].data, bps, actual);
offset += bps;
sdatapos += bps;
}
@@ -223,7 +227,7 @@ bool dim_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
}
-bool dim_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dim_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/dim_dsk.h b/src/lib/formats/dim_dsk.h
index e0227e2e221..5c84f329cb6 100644
--- a/src/lib/formats/dim_dsk.h
+++ b/src/lib/formats/dim_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/dip_dsk.cpp b/src/lib/formats/dip_dsk.cpp
index a33d6fe35d6..17a7f856efe 100644
--- a/src/lib/formats/dip_dsk.cpp
+++ b/src/lib/formats/dip_dsk.cpp
@@ -14,10 +14,11 @@
*********************************************************************/
-#include <cassert>
-
#include "dip_dsk.h"
+#include "ioprocs.h"
+
+
dip_format::dip_format()
{
}
@@ -37,9 +38,11 @@ const char *dip_format::extensions() const
return "dip";
}
-int dip_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dip_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
if (size == 0x134000 + 0x100)
return 100;
@@ -47,7 +50,7 @@ int dip_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool dip_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dip_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int heads, tracks, spt, bps;
@@ -69,7 +72,8 @@ bool dip_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for (int track = 0; track < tracks; track++)
for (int head = 0; head < heads; head++)
{
- io_generic_read(io, sect_data, 0x100 + bps * spt * (track * heads + head), bps * spt);
+ size_t actual;
+ io.read_at(0x100 + bps * spt * (track * heads + head), sect_data, bps * spt, actual);
for (int i = 0; i < spt; i++)
{
diff --git a/src/lib/formats/dip_dsk.h b/src/lib/formats/dip_dsk.h
index 255e4e6c8a1..e310ef3f655 100644
--- a/src/lib/formats/dip_dsk.h
+++ b/src/lib/formats/dip_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/dmk_dsk.cpp b/src/lib/formats/dmk_dsk.cpp
index 39c23223ec5..6a9e1dc0f0b 100644
--- a/src/lib/formats/dmk_dsk.cpp
+++ b/src/lib/formats/dmk_dsk.cpp
@@ -13,10 +13,10 @@ TODO:
*********************************************************************/
-#include <cassert>
-
#include "dmk_dsk.h"
+#include "ioprocs.h"
+
dmk_format::dmk_format()
{
@@ -41,14 +41,16 @@ const char *dmk_format::extensions() const
}
-int dmk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dmk_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
const int header_size = 16;
uint8_t header[header_size];
-
- uint64_t size = io_generic_size(io);
-
- io_generic_read(io, header, 0, header_size);
+ size_t actual;
+ io.read_at(0, header, header_size, actual);
int tracks = header[1];
int track_size = ( header[3] << 8 ) | header[2];
@@ -81,12 +83,13 @@ int dmk_format::identify(io_generic *io, uint32_t form_factor, const std::vector
}
-bool dmk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dmk_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
+
const int header_size = 16;
uint8_t header[header_size];
-
- io_generic_read(io, header, 0, header_size);
+ io.read_at(0, header, header_size, actual);
const int tracks = header[1];
const int track_size = ( header[3] << 8 ) | header[2];
@@ -128,7 +131,7 @@ bool dmk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
int dam_location[64];
// Read track
- io_generic_read(io, &track_data[0], header_size + ( heads * track + head ) * track_size, track_size);
+ io.read_at(header_size + (heads * track + head) * track_size, &track_data[0], track_size, actual);
for (int i = 0; i < 64; i++)
{
@@ -213,7 +216,7 @@ bool dmk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
}
-bool dmk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dmk_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/dmk_dsk.h b/src/lib/formats/dmk_dsk.h
index a2e7898dece..5485869b5b6 100644
--- a/src/lib/formats/dmk_dsk.h
+++ b/src/lib/formats/dmk_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/ds9_dsk.cpp b/src/lib/formats/ds9_dsk.cpp
index fdf4f5e2299..c97a2cced51 100644
--- a/src/lib/formats/ds9_dsk.cpp
+++ b/src/lib/formats/ds9_dsk.cpp
@@ -14,10 +14,10 @@
************************************************************************/
-#include <cassert>
-
#include "formats/ds9_dsk.h"
+#include "ioprocs.h"
+
static FLOPPY_IDENTIFY(ds9_dsk_identify)
{
@@ -97,33 +97,32 @@ const char *ds9_format::extensions() const
return "ds9";
}
-void ds9_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
+void ds9_format::find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
{
- uint32_t expected_size = 0;
- uint64_t size = io_generic_size(io);
-
head_count = 2;
track_count = 80;
sector_count = 21;
- expected_size = 256 * track_count * head_count * sector_count;
+ uint32_t const expected_size = 256 * track_count * head_count * sector_count;
- if (size >= expected_size) // standard format has 860160 bytes
+ uint64_t size;
+ if (!io.length(size) && (size >= expected_size)) // standard format has 860160 bytes
return;
track_count = head_count = sector_count = 0;
}
-int ds9_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ds9_format::identify(util::random_read &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);
- if (track_count) return 50;
+ if (track_count)
+ return 50;
return 0;
}
-bool ds9_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool ds9_format::load(util::random_read &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);
@@ -143,7 +142,8 @@ bool ds9_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
{
for (int head = 0; head < head_count; head++)
{
- io_generic_read(io, sectdata, (track * head_count + head) * track_size, track_size);
+ size_t actual;
+ io.read_at((track * head_count + head) * track_size, sectdata, track_size, actual);
generate_track(ds9_desc, track, head, sectors, sector_count, 104000, image);
}
}
diff --git a/src/lib/formats/ds9_dsk.h b/src/lib/formats/ds9_dsk.h
index 317134eab87..abdf152b2b3 100644
--- a/src/lib/formats/ds9_dsk.h
+++ b/src/lib/formats/ds9_dsk.h
@@ -5,9 +5,10 @@
formats/ds9_dsk.h
*********************************************************************/
+#ifndef MAME_FORMATS_DS9_DSK_H
+#define MAME_FORMATS_DS9_DSK_H
-#ifndef DS9_DSK_H_
-#define DS9_DSK_H_
+#pragma once
#include "flopimg.h"
#include "formats/basicdsk.h"
@@ -19,8 +20,8 @@ class ds9_format : public floppy_image_format_t
public:
ds9_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
@@ -30,9 +31,9 @@ public:
static const desc_e ds9_desc[];
private:
- void find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
+ void find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
};
extern const floppy_format_type FLOPPY_DS9_FORMAT;
-#endif /* DS9_DSK_H_ */
+#endif // MAME_FORMATS_DS9_DSK_H
diff --git a/src/lib/formats/dsk_dsk.cpp b/src/lib/formats/dsk_dsk.cpp
index dba11347887..fcf967edcb1 100644
--- a/src/lib/formats/dsk_dsk.cpp
+++ b/src/lib/formats/dsk_dsk.cpp
@@ -8,11 +8,12 @@
*********************************************************************/
-#include <cstring>
-#include <cassert>
-
+#include "dsk_dsk.h"
#include "imageutl.h"
-#include "flopimg.h"
+
+#include "ioprocs.h"
+
+#include <cstring>
#define MV_CPC "MV - CPC"
#define EXTENDED "EXTENDED"
@@ -270,7 +271,8 @@ FLOPPY_CONSTRUCT( dsk_dsk_construct )
return FLOPPY_ERROR_SUCCESS;
}
-#include "dsk_dsk.h"
+
+
#define DSK_FORMAT_HEADER "MV - CPC"
#define EXT_FORMAT_HEADER "EXTENDED CPC DSK"
@@ -299,11 +301,12 @@ bool dsk_format::supports_save() const
return false;
}
-int dsk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int dsk_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[16];
- io_generic_read(io, &header, 0, sizeof(header));
+ size_t actual;
+ io.read_at(0, &header, sizeof(header), actual);
if ( memcmp( header, DSK_FORMAT_HEADER, 8 ) ==0) {
return 100;
}
@@ -344,14 +347,18 @@ struct sector_header
#pragma pack()
-bool dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dsk_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
+
uint8_t header[0x100];
bool extendformat = false;
- uint64_t image_size = io_generic_size(io);
+ uint64_t image_size;
+ if (io.length(image_size))
+ return false;
- io_generic_read(io, &header, 0, sizeof(header));
+ io.read_at(0, &header, sizeof(header), actual);
if ( memcmp( header, EXT_FORMAT_HEADER, 16 ) ==0) {
extendformat = true;
}
@@ -418,7 +425,7 @@ bool dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
if(track_offsets[(track<<1)+side] >= image_size)
continue;
track_header tr;
- io_generic_read(io, &tr,track_offsets[(track<<1)+side],sizeof(tr));
+ io.read_at(track_offsets[(track<<1)+side], &tr, sizeof(tr), actual);
// skip if there are no sectors in this track
if (tr.number_of_sector == 0)
@@ -428,7 +435,7 @@ bool dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
int first_sector_code = -1;
for(int j=0;j<tr.number_of_sector;j++) {
sector_header sector;
- io_generic_read(io, &sector,track_offsets[(track<<1)+side]+sizeof(tr)+(sizeof(sector)*j),sizeof(sector));
+ io.read_at(track_offsets[(track<<1)+side]+sizeof(tr)+(sizeof(sector)*j), &sector, sizeof(sector), actual);
if (j == 0)
first_sector_code = sector.sector_size_code;
@@ -447,7 +454,7 @@ bool dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for(int j=0;j<tr.number_of_sector;j++) {
sector_header sector;
- io_generic_read(io, &sector,track_offsets[(track<<1)+side]+sizeof(tr)+(sizeof(sector)*j),sizeof(sector));
+ io.read_at(track_offsets[(track<<1)+side]+sizeof(tr)+(sizeof(sector)*j), &sector, sizeof(sector), actual);
sects[j].track = sector.track;
sects[j].head = sector.side;
@@ -470,7 +477,7 @@ bool dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
if(!(sector.fdc_status_reg1 & 0x04)) {
sects[j].data = sect_data + sdatapos;
- io_generic_read(io, sects[j].data, pos, sects[j].actual_size);
+ io.read_at(pos, sects[j].data, sects[j].actual_size, actual);
sdatapos += sects[j].actual_size;
} else
diff --git a/src/lib/formats/dsk_dsk.h b/src/lib/formats/dsk_dsk.h
index a08e3955888..7d6b3bc43dc 100644
--- a/src/lib/formats/dsk_dsk.h
+++ b/src/lib/formats/dsk_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/dvk_mx_dsk.cpp b/src/lib/formats/dvk_mx_dsk.cpp
index 07d7a38cf95..08156d29e9c 100644
--- a/src/lib/formats/dvk_mx_dsk.cpp
+++ b/src/lib/formats/dvk_mx_dsk.cpp
@@ -18,11 +18,11 @@
************************************************************************/
-#include <cassert>
-
-#include "flopimg.h"
#include "formats/dvk_mx_dsk.h"
+#include "ioprocs.h"
+
+
const floppy_image_format_t::desc_e dvk_mx_format::dvk_mx_new_desc[] = {
/* 01 */ { FM, 0x00, 8*2 }, // eight 0x0000 words
/* 03 */ { FM, 0x00, 1 },
@@ -81,9 +81,14 @@ bool dvk_mx_format::supports_save() const
return false;
}
-void dvk_mx_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
+void dvk_mx_format::find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ {
+ track_count = head_count = sector_count = 0;
+ return;
+ }
switch (size)
{
@@ -108,7 +113,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, const std::vector<uint32_t> &variants)
+int dvk_mx_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t track_count, head_count, sector_count;
@@ -117,7 +122,8 @@ int dvk_mx_format::identify(io_generic *io, uint32_t form_factor, const std::vec
if (track_count)
{
uint8_t sectdata[512];
- io_generic_read(io, sectdata, 512, 512);
+ size_t actual;
+ io.read_at(512, sectdata, 512, actual);
// check value in RT-11 home block. see src/tools/imgtool/modules/rt11.cpp
if (pick_integer_le(sectdata, 0724, 2) == 6)
return 100;
@@ -129,7 +135,7 @@ int dvk_mx_format::identify(io_generic *io, uint32_t form_factor, const std::vec
return 0;
}
-bool dvk_mx_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool dvk_mx_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t track_count, head_count, sector_count;
@@ -150,7 +156,8 @@ bool dvk_mx_format::load(io_generic *io, uint32_t form_factor, const std::vector
{
for (int head = 0; head < head_count; head++)
{
- io_generic_read(io, sectdata, (track * head_count + head) * track_size, track_size);
+ size_t actual;
+ io.read_at((track * head_count + head) * track_size, sectdata, track_size, actual);
generate_track(dvk_mx_new_desc, track, head, sectors, sector_count, 45824, image);
}
}
diff --git a/src/lib/formats/dvk_mx_dsk.h b/src/lib/formats/dvk_mx_dsk.h
index 38fd895d154..e20066fc3ec 100644
--- a/src/lib/formats/dvk_mx_dsk.h
+++ b/src/lib/formats/dvk_mx_dsk.h
@@ -5,9 +5,8 @@
formats/dvk_mx_dsk.h
*********************************************************************/
-
-#ifndef DVK_MX_DSK_H_
-#define DVK_MX_DSK_H_
+#ifndef MAME_FORMATS_DVK_MX_DSK_H
+#define MAME_FORMATS_DVK_MX_DSK_H
#pragma once
@@ -19,8 +18,8 @@ class dvk_mx_format : public floppy_image_format_t
public:
dvk_mx_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
@@ -31,9 +30,9 @@ public:
static const desc_e dvk_mx_new_desc[];
private:
- void find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
+ void find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
};
extern const floppy_format_type FLOPPY_DVK_MX_FORMAT;
-#endif /* DVK_MX_DSK_H_ */
+#endif // MAME_FORMATS_DVK_MX_DSK_H
diff --git a/src/lib/formats/esq16_dsk.cpp b/src/lib/formats/esq16_dsk.cpp
index 10802d26495..b33e529fef2 100644
--- a/src/lib/formats/esq16_dsk.cpp
+++ b/src/lib/formats/esq16_dsk.cpp
@@ -10,10 +10,10 @@
*********************************************************************/
-#include <cassert>
+#include "esq16_dsk.h"
+
+#include "ioprocs.h"
-#include "flopimg.h"
-#include "formats/esq16_dsk.h"
const floppy_image_format_t::desc_e esqimg_format::esq_10_desc[] = {
{ MFM, 0x4e, 80 },
@@ -71,23 +71,23 @@ bool esqimg_format::supports_save() const
return true;
}
-void esqimg_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
+void esqimg_format::find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
{
- uint64_t size = io_generic_size(io);
- track_count = 80;
- head_count = 2;
- sector_count = 10;
-
- uint32_t expected_size = 512 * track_count*head_count*sector_count;
- if (size == expected_size)
- {
- return;
- }
+ uint64_t size;
+ if(!io.length(size)) {
+ track_count = 80;
+ head_count = 2;
+ sector_count = 10;
+ uint32_t expected_size = 512 * track_count*head_count*sector_count;
+ if(size == expected_size) {
+ return;
+ }
+ }
track_count = head_count = sector_count = 0;
}
-int esqimg_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int esqimg_format::identify(util::random_read &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, const std::vec
return 0;
}
-bool esqimg_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool esqimg_format::load(util::random_read &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);
@@ -113,7 +113,8 @@ bool esqimg_format::load(io_generic *io, uint32_t form_factor, const std::vector
int track_size = sector_count*512;
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
- io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.read_at((track*head_count + head)*track_size, sectdata, track_size, actual);
generate_track(esq_10_desc, track, head, sectors, sector_count, 110528, image);
}
}
@@ -123,7 +124,7 @@ bool esqimg_format::load(io_generic *io, uint32_t form_factor, const std::vector
return true;
}
-bool esqimg_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool esqimg_format::save(util::random_read_write &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);
@@ -144,7 +145,8 @@ bool esqimg_format::save(io_generic *io, const std::vector<uint32_t> &variants,
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
get_track_data_mfm_pc(track, head, image, 2000, 512, sector_count, sectdata);
- io_generic_write(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.write_at((track*head_count + head)*track_size, sectdata, track_size, actual);
}
}
diff --git a/src/lib/formats/esq16_dsk.h b/src/lib/formats/esq16_dsk.h
index 8cc49150d2c..2347d64f59c 100644
--- a/src/lib/formats/esq16_dsk.h
+++ b/src/lib/formats/esq16_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -33,7 +33,7 @@ public:
static const desc_e esq_10_desc[];
private:
- void find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
+ void find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
};
extern const floppy_format_type FLOPPY_ESQIMG_FORMAT;
diff --git a/src/lib/formats/esq8_dsk.cpp b/src/lib/formats/esq8_dsk.cpp
index f9dcb3d0727..952dd16edbd 100644
--- a/src/lib/formats/esq8_dsk.cpp
+++ b/src/lib/formats/esq8_dsk.cpp
@@ -12,10 +12,10 @@
*********************************************************************/
-#include <cassert>
+#include "esq8_dsk.h"
+
+#include "ioprocs.h"
-#include "flopimg.h"
-#include "formats/esq8_dsk.h"
const floppy_image_format_t::desc_e esq8img_format::esq_6_desc[] = {
{ MFM, 0x4e, 80 },
@@ -73,22 +73,24 @@ bool esq8img_format::supports_save() const
return true;
}
-void esq8img_format::find_size(io_generic *io, int &track_count, int &head_count, int &sector_count)
+void esq8img_format::find_size(util::random_read &io, int &track_count, int &head_count, int &sector_count)
{
- uint64_t size = io_generic_size(io);
- track_count = 80;
- head_count = 1;
- sector_count = 6;
-
- if(size == 5632 * 80)
+ uint64_t size;
+ if(!io.length(size))
{
- return;
- }
+ track_count = 80;
+ head_count = 1;
+ sector_count = 6;
+ if(size == 5632 * 80)
+ {
+ return;
+ }
+ }
track_count = head_count = sector_count = 0;
}
-int esq8img_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int esq8img_format::identify(util::random_read &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);
@@ -99,7 +101,7 @@ int esq8img_format::identify(io_generic *io, uint32_t form_factor, const std::ve
return 0;
}
-bool esq8img_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool esq8img_format::load(util::random_read &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);
@@ -128,7 +130,8 @@ bool esq8img_format::load(io_generic *io, uint32_t form_factor, const std::vecto
{
for(int head=0; head < head_count; head++)
{
- io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.read_at((track*head_count + head)*track_size, sectdata, track_size, actual);
generate_track(esq_6_desc, track, head, sectors, sector_count, 109376, image);
}
}
@@ -138,7 +141,7 @@ bool esq8img_format::load(io_generic *io, uint32_t form_factor, const std::vecto
return true;
}
-bool esq8img_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool esq8img_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t file_offset = 0;
int track_count, head_count, sector_count;
@@ -175,7 +178,8 @@ bool esq8img_format::save(io_generic *io, const std::vector<uint32_t> &variants,
return false;
}
- io_generic_write(io, sectors[sector].data(), file_offset, sector_expected_size);
+ size_t actual;
+ io.write_at(file_offset, sectors[sector].data(), sector_expected_size, actual);
file_offset += sector_expected_size;
}
}
diff --git a/src/lib/formats/esq8_dsk.h b/src/lib/formats/esq8_dsk.h
index c4fe5a74f1b..aa09fd278a7 100644
--- a/src/lib/formats/esq8_dsk.h
+++ b/src/lib/formats/esq8_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -35,7 +35,7 @@ public:
static const desc_e esq_6_desc[];
private:
- void find_size(io_generic *io, int &track_count, int &head_count, int &sector_count);
+ void find_size(util::random_read &io, int &track_count, int &head_count, int &sector_count);
};
extern const floppy_format_type FLOPPY_ESQ8IMG_FORMAT;
diff --git a/src/lib/formats/fdd_dsk.cpp b/src/lib/formats/fdd_dsk.cpp
index df5fd3caa8c..8c8249c9452 100644
--- a/src/lib/formats/fdd_dsk.cpp
+++ b/src/lib/formats/fdd_dsk.cpp
@@ -31,10 +31,11 @@
*********************************************************************/
-#include <cassert>
-
#include "fdd_dsk.h"
+#include "ioprocs.h"
+
+
fdd_format::fdd_format()
{
}
@@ -54,10 +55,11 @@ const char *fdd_format::extensions() const
return "fdd";
}
-int fdd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int fdd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[7];
- io_generic_read(io, h, 0, 7);
+ size_t actual;
+ io.read_at(0, h, 7, actual);
if (strncmp((const char *)h, "VFD1.0", 6) == 0)
return 100;
@@ -65,7 +67,7 @@ int fdd_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool fdd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool fdd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t hsec[0x0c];
@@ -86,7 +88,8 @@ bool fdd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for (int sect = 0; sect < 26; sect++)
{
// read sector map for this sector
- io_generic_read(io, hsec, pos, 0x0c);
+ size_t actual;
+ io.read_at(pos, hsec, 0x0c, actual);
pos += 0x0c;
if (hsec[0] == 0xff) // unformatted/unused sector
@@ -118,10 +121,11 @@ bool fdd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
cur_sec_map = track * 26 + i;
sector_size = 128 << sec_sizes[cur_sec_map];
+ size_t actual;
if (sec_offs[cur_sec_map] == 0xffffffff)
memset(sect_data + cur_pos, fill_vals[cur_sec_map], sector_size);
else
- io_generic_read(io, sect_data + cur_pos, sec_offs[cur_sec_map], sector_size);
+ io.read_at(sec_offs[cur_sec_map], sect_data + cur_pos, sector_size, actual);
sects[i].track = tracks[cur_sec_map];
sects[i].head = heads[cur_sec_map];
diff --git a/src/lib/formats/fdd_dsk.h b/src/lib/formats/fdd_dsk.h
index ec013c58571..c1a3ae8a29b 100644
--- a/src/lib/formats/fdd_dsk.h
+++ b/src/lib/formats/fdd_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/flex_dsk.cpp b/src/lib/formats/flex_dsk.cpp
index 692cc4bdc9d..4989a25e707 100644
--- a/src/lib/formats/flex_dsk.cpp
+++ b/src/lib/formats/flex_dsk.cpp
@@ -50,7 +50,11 @@
*/
#include "flex_dsk.h"
-#include "formats/imageutl.h"
+
+#include "imageutl.h"
+
+#include "ioprocs.h"
+
flex_format::flex_format() : wd177x_format(formats)
{
@@ -71,7 +75,7 @@ const char *flex_format::extensions() const
return "dsk";
}
-int flex_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int flex_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
@@ -80,17 +84,21 @@ int flex_format::identify(io_generic *io, uint32_t form_factor, const std::vecto
return 0;
}
-int flex_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int flex_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return -1;
+
uint8_t boot0[256], boot1[256];
+ size_t actual;
// Look at the boot sector.
// Density, sides, link??
- io_generic_read(io, &boot0, 256 * 0, sizeof(boot0));
- io_generic_read(io, &boot1, 256 * 1, sizeof(boot1));
+ io.read_at(256 * 0, &boot0, sizeof(boot0), actual);
+ io.read_at(256 * 1, &boot1, sizeof(boot1), actual);
// Look at the system information sector.
- io_generic_read(io, &info, 256 * 2, sizeof(struct sysinfo_sector));
+ io.read_at(256 * 2, &info, sizeof(struct sysinfo_sector), actual);
LOG_FORMATS("FLEX floppy dsk: size %d bytes, %d total sectors, %d remaining bytes, expected form factor %x\n", (uint32_t)size, (uint32_t)size / 256, (uint32_t)size % 256, form_factor);
diff --git a/src/lib/formats/flex_dsk.h b/src/lib/formats/flex_dsk.h
index 094c6854b24..0048e4e088f 100644
--- a/src/lib/formats/flex_dsk.h
+++ b/src/lib/formats/flex_dsk.h
@@ -21,8 +21,8 @@ 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, const std::vector<uint32_t> &variants) override;
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track) override;
private:
diff --git a/src/lib/formats/flopimg.cpp b/src/lib/formats/flopimg.cpp
index 48c2fa1b610..55d00d1bb83 100644
--- a/src/lib/formats/flopimg.cpp
+++ b/src/lib/formats/flopimg.cpp
@@ -11,9 +11,10 @@
#include "flopimg.h"
#include "imageutl.h"
-#include "osdcore.h"
#include "ioprocs.h"
+#include "osdcore.h"
+
#include <cassert>
#include <cctype>
#include <climits>
@@ -30,7 +31,7 @@ using util::BIT;
struct floppy_image_legacy
{
- struct io_generic io = { 0 };
+ util::random_read_write::ptr io = nullptr;
const struct FloppyFormat *floppy_option = nullptr;
struct FloppyCallbacks format = { 0 };
@@ -69,22 +70,20 @@ OPTION_GUIDE_START(floppy_option_guide)
OPTION_GUIDE_END
-static void floppy_close_internal(floppy_image_legacy *floppy, bool close_file);
+static void floppy_close_internal(floppy_image_legacy *floppy);
/*********************************************************************
opening, closing and creating of floppy images
*********************************************************************/
/* basic floppy_image_legacy initialization common to floppy_open() and floppy_create() */
-static floppy_image_legacy *floppy_init(void *fp, const struct io_procs *procs, int flags)
+static floppy_image_legacy *floppy_init(util::random_read_write::ptr &&io, int flags)
{
floppy_image_legacy *floppy;
floppy = new floppy_image_legacy;
- floppy->io.file = fp;
- floppy->io.procs = procs;
- floppy->io.filler = 0xFF;
+ floppy->io = std::move(io);
floppy->flags = (uint8_t) flags;
return floppy;
}
@@ -93,7 +92,7 @@ static floppy_image_legacy *floppy_init(void *fp, const struct io_procs *procs,
/* main code for identifying and maybe opening a disk image; not exposed
* directly because this function is big and hideous */
-static floperr_t floppy_open_internal(void *fp, const struct io_procs *procs, const std::string &extension,
+static floperr_t floppy_open_internal(util::random_read_write::ptr &&io, const std::string &extension,
const struct FloppyFormat *floppy_options, int max_options, int flags, floppy_image_legacy **outfloppy,
int *outoption)
{
@@ -104,7 +103,7 @@ static floperr_t floppy_open_internal(void *fp, const struct io_procs *procs, co
int vote;
size_t i;
- floppy = floppy_init(fp, procs, flags);
+ floppy = floppy_init(std::move(io), flags);
if (!floppy)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
@@ -163,7 +162,7 @@ done:
/* if we have a floppy disk and we either errored or are not keeping it, close it */
if (floppy && (!outfloppy || err))
{
- floppy_close_internal(floppy, false);
+ floppy_close_internal(floppy);
floppy = nullptr;
}
@@ -176,31 +175,31 @@ done:
-floperr_t floppy_identify(void *fp, const struct io_procs *procs, const char *extension,
+floperr_t floppy_identify(util::random_read_write::ptr &&io, const char *extension,
const struct FloppyFormat *formats, int *identified_format)
{
- return floppy_open_internal(fp, procs, extension, formats, INT_MAX, FLOPPY_FLAGS_READONLY, nullptr, identified_format);
+ return floppy_open_internal(std::move(io), extension, formats, INT_MAX, FLOPPY_FLAGS_READONLY, nullptr, identified_format);
}
-floperr_t floppy_open(void *fp, const struct io_procs *procs, const std::string &extension,
+floperr_t floppy_open(util::random_read_write::ptr &&io, const std::string &extension,
const struct FloppyFormat *format, int flags, floppy_image_legacy **outfloppy)
{
- return floppy_open_internal(fp, procs, extension, format, 1, flags, outfloppy, nullptr);
+ return floppy_open_internal(std::move(io), extension, format, 1, flags, outfloppy, nullptr);
}
-floperr_t floppy_open_choices(void *fp, const struct io_procs *procs, const std::string &extension,
+floperr_t floppy_open_choices(util::random_read_write::ptr &&io, const std::string &extension,
const struct FloppyFormat *formats, int flags, floppy_image_legacy **outfloppy)
{
- return floppy_open_internal(fp, procs, extension, formats, INT_MAX, flags, outfloppy, nullptr);
+ return floppy_open_internal(std::move(io), extension, formats, INT_MAX, flags, outfloppy, nullptr);
}
-floperr_t floppy_create(void *fp, const struct io_procs *procs, const struct FloppyFormat *format, util::option_resolution *parameters, floppy_image_legacy **outfloppy)
+floperr_t floppy_create(util::random_read_write::ptr &&io, const struct FloppyFormat *format, util::option_resolution *parameters, floppy_image_legacy **outfloppy)
{
floppy_image_legacy *floppy = nullptr;
floperr_t err;
@@ -210,7 +209,7 @@ floperr_t floppy_create(void *fp, const struct io_procs *procs, const struct Flo
assert(format);
/* create the new image */
- floppy = floppy_init(fp, procs, 0);
+ floppy = floppy_init(std::move(io), 0);
if (!floppy)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
@@ -266,28 +265,26 @@ floperr_t floppy_create(void *fp, const struct io_procs *procs, const struct Flo
done:
if (err && floppy)
{
- floppy_close_internal(floppy, false);
+ floppy_close_internal(floppy);
floppy = nullptr;
}
if (outfloppy)
*outfloppy = floppy;
else if (floppy)
- floppy_close_internal(floppy, false);
+ floppy_close_internal(floppy);
return err;
}
-static void floppy_close_internal(floppy_image_legacy *floppy, bool close_file)
+static void floppy_close_internal(floppy_image_legacy *floppy)
{
if (floppy) {
floppy_track_unload(floppy);
if(floppy->floppy_option && floppy->floppy_option->destruct)
floppy->floppy_option->destruct(floppy, floppy->floppy_option);
- if (close_file)
- io_generic_close(&floppy->io);
delete floppy;
}
@@ -297,7 +294,7 @@ static void floppy_close_internal(floppy_image_legacy *floppy, bool close_file)
void floppy_close(floppy_image_legacy *floppy)
{
- floppy_close_internal(floppy, true);
+ floppy_close_internal(floppy);
}
@@ -332,14 +329,16 @@ void *floppy_create_tag(floppy_image_legacy *floppy, size_t tagsize)
uint8_t floppy_get_filler(floppy_image_legacy *floppy)
{
- return floppy->io.filler;
+ // FIXME: remove this function, it's here for legacy reasons
+ // the caller actually sets the filler byte - in practice it's always 0xff but there's no actual guarantee
+ return 0xff;
}
-void floppy_set_filler(floppy_image_legacy *floppy, uint8_t filler)
+util::random_read_write &floppy_get_io(floppy_image_legacy *floppy)
{
- floppy->io.filler = filler;
+ return *floppy->io;
}
@@ -350,28 +349,42 @@ void floppy_set_filler(floppy_image_legacy *floppy, uint8_t filler)
void floppy_image_read(floppy_image_legacy *floppy, void *buffer, uint64_t offset, size_t length)
{
- io_generic_read(&floppy->io, buffer, offset, length);
+ size_t actual;
+ floppy->io->read_at(offset, buffer, length, actual);
}
void floppy_image_write(floppy_image_legacy *floppy, const void *buffer, uint64_t offset, size_t length)
{
- io_generic_write(&floppy->io, buffer, offset, length);
+ size_t actual;
+ floppy->io->write_at(offset, buffer, length, actual);
}
void floppy_image_write_filler(floppy_image_legacy *floppy, uint8_t filler, uint64_t offset, size_t length)
{
- io_generic_write_filler(&floppy->io, filler, offset, length);
+ uint8_t buffer[512];
+ memset(buffer, filler, std::min(sizeof(buffer), length));
+
+ while (length)
+ {
+ size_t const block = std::min(sizeof(buffer), length);
+ size_t actual;
+ floppy->io->write_at(offset, buffer, block, actual);
+ offset += block;
+ length -= block;
+ }
}
uint64_t floppy_image_size(floppy_image_legacy *floppy)
{
- return io_generic_size(&floppy->io);
+ uint64_t result;
+ floppy->io->length(result);
+ return result;
}
@@ -976,7 +989,7 @@ bool floppy_image_format_t::has_variant(const std::vector<uint32_t> &variants, u
return false;
}
-bool floppy_image_format_t::save(io_generic *, const std::vector<uint32_t> &, floppy_image *)
+bool floppy_image_format_t::save(util::random_read_write &io, const std::vector<uint32_t> &, floppy_image *)
{
return false;
}
diff --git a/src/lib/formats/flopimg.h b/src/lib/formats/flopimg.h
index 101d9bd86bd..6279def82f8 100644
--- a/src/lib/formats/flopimg.h
+++ b/src/lib/formats/flopimg.h
@@ -12,11 +12,13 @@
#pragma once
-#include "osdcore.h"
-#include "ioprocs.h"
-#include "opresolv.h"
#include "coretmpl.h"
+#include "opresolv.h"
+#include "utilfwd.h"
+
+#include "osdcore.h"
+#include <memory>
#include <vector>
#ifndef LOG_FORMATS
@@ -166,20 +168,20 @@ LEGACY_FLOPPY_OPTIONS_EXTERN(default);
OPTION_GUIDE_EXTERN(floppy_option_guide);
/* opening, closing and creating of floppy images */
-floperr_t floppy_open(void *fp, const struct io_procs *procs, const std::string &extension, const struct FloppyFormat *format, int flags, floppy_image_legacy **outfloppy);
-floperr_t floppy_open_choices(void *fp, const struct io_procs *procs, const std::string &extension, const struct FloppyFormat *formats, int flags, floppy_image_legacy **outfloppy);
-floperr_t floppy_create(void *fp, const struct io_procs *procs, const struct FloppyFormat *format, util::option_resolution *parameters, floppy_image_legacy **outfloppy);
+floperr_t floppy_open(std::unique_ptr<util::random_read_write> &&io, const std::string &extension, const struct FloppyFormat *format, int flags, floppy_image_legacy **outfloppy);
+floperr_t floppy_open_choices(std::unique_ptr<util::random_read_write> &&io, const std::string &extension, const struct FloppyFormat *formats, int flags, floppy_image_legacy **outfloppy);
+floperr_t floppy_create(std::unique_ptr<util::random_read_write> &&io, const struct FloppyFormat *format, util::option_resolution *parameters, floppy_image_legacy **outfloppy);
void floppy_close(floppy_image_legacy *floppy);
/* useful for identifying a floppy image */
-floperr_t floppy_identify(void *fp, const struct io_procs *procs, const char *extension, const struct FloppyFormat *formats, int *identified_format);
+floperr_t floppy_identify(std::unique_ptr<util::random_read_write> &&io, const char *extension, const struct FloppyFormat *formats, int *identified_format);
/* functions useful within format constructors */
void *floppy_tag(floppy_image_legacy *floppy);
void *floppy_create_tag(floppy_image_legacy *floppy, size_t tagsize);
struct FloppyCallbacks *floppy_callbacks(floppy_image_legacy *floppy);
uint8_t floppy_get_filler(floppy_image_legacy *floppy);
-void floppy_set_filler(floppy_image_legacy *floppy, uint8_t filler);
+util::random_read_write &floppy_get_io(floppy_image_legacy *floppy);
/* calls for accessing disk image data */
floperr_t floppy_read_sector(floppy_image_legacy *floppy, int head, int track, int sector, int offset, void *buffer, size_t buffer_len);
@@ -235,7 +237,7 @@ public:
@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, const std::vector<uint32_t> &variants) = 0;
+ virtual int identify(util::random_read &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
@@ -247,7 +249,7 @@ public:
@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, const std::vector<uint32_t> &variants, floppy_image *image) = 0;
+ virtual bool load(util::random_read &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
@@ -257,7 +259,7 @@ public:
@param image source buffer containing data in MESS internal format.
@return true on success, false otherwise.
*/
- virtual bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image);
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image);
//! @returns string containing name of format.
virtual const char *name() const = 0;
diff --git a/src/lib/formats/fsd_dsk.cpp b/src/lib/formats/fsd_dsk.cpp
index c5ebd243875..ffb23035420 100644
--- a/src/lib/formats/fsd_dsk.cpp
+++ b/src/lib/formats/fsd_dsk.cpp
@@ -10,6 +10,8 @@
#include "fsd_dsk.h"
+#include "ioprocs.h"
+
/*********************************************************************
@@ -83,11 +85,12 @@ bool fsd_format::supports_save() const
return false;
}
-int fsd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int fsd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[3];
- io_generic_read(io, h, 0, 3);
+ size_t actual;
+ io.read_at(0, h, 3, actual);
if (memcmp(h, "FSD", 3) == 0) {
return 100;
}
@@ -95,16 +98,19 @@ int fsd_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool fsd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool fsd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
const char* result[255];
result[0x00] = "OK";
result[0x0e] = "Data CRC Error";
result[0x20] = "Deleted Data";
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
uint64_t pos;
std::string title;
diff --git a/src/lib/formats/fsd_dsk.h b/src/lib/formats/fsd_dsk.h
index ee2c4aa466c..779ee28ec02 100644
--- a/src/lib/formats/fsd_dsk.h
+++ b/src/lib/formats/fsd_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
};
extern const floppy_format_type FLOPPY_FSD_FORMAT;
diff --git a/src/lib/formats/g64_dsk.cpp b/src/lib/formats/g64_dsk.cpp
index 02098db88e0..8e6b9c75e44 100644
--- a/src/lib/formats/g64_dsk.cpp
+++ b/src/lib/formats/g64_dsk.cpp
@@ -12,6 +12,8 @@
#include "formats/g64_dsk.h"
+#include "ioprocs.h"
+
#define G64_FORMAT_HEADER "GCR-1541"
@@ -27,22 +29,27 @@ const uint32_t g64_format::c1541_cell_size[] =
3250 // 16MHz/13/4
};
-int g64_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int g64_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char h[8];
- io_generic_read(io, h, 0, 8);
+ size_t actual;
+ io.read_at(0, h, 8, actual);
if (!memcmp(h, G64_FORMAT_HEADER, 8))
return 100;
return 0;
}
-bool g64_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool g64_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
+
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
if (img[POS_VERSION])
{
@@ -109,15 +116,19 @@ int g64_format::generate_bitstream(int track, int head, int speed_zone, std::vec
return ((actual_cell_size >= cell_size-10) && (actual_cell_size <= cell_size+10)) ? speed_zone : -1;
}
-bool g64_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool g64_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ uint8_t const zerofill[] = { 0x00, 0x00, 0x00, 0x00 };
+ std::vector<uint8_t> const prefill(TRACK_LENGTH, 0xff);
+ size_t actual;
+
int tracks, heads;
image->get_actual_geometry(tracks, heads);
tracks = TRACK_COUNT * heads;
// write header
uint8_t header[] = { 'G', 'C', 'R', '-', '1', '5', '4', '1', 0x00, static_cast<uint8_t>(tracks), TRACK_LENGTH & 0xff, TRACK_LENGTH >> 8 };
- io_generic_write(io, header, POS_SIGNATURE, sizeof(header));
+ io.write_at(POS_SIGNATURE, header, sizeof(header), actual);
// write tracks
for (int head = 0; head < heads; head++) {
@@ -126,12 +137,12 @@ bool g64_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
std::vector<bool> trackbuf;
for (int track = 0; track < TRACK_COUNT; track++) {
- uint32_t tpos = POS_TRACK_OFFSET + (track * 4);
- uint32_t spos = tpos + (tracks * 4);
- uint32_t dpos = POS_TRACK_OFFSET + (tracks * 4 * 2) + (tracks_written * TRACK_LENGTH);
+ uint32_t const tpos = POS_TRACK_OFFSET + (track * 4);
+ uint32_t const spos = tpos + (tracks * 4);
+ uint32_t const dpos = POS_TRACK_OFFSET + (tracks * 4 * 2) + (tracks_written * TRACK_LENGTH);
- io_generic_write_filler(io, 0x00, tpos, 4);
- io_generic_write_filler(io, 0x00, spos, 4);
+ io.write_at(tpos, zerofill, 4, actual);
+ io.write_at(spos, zerofill, 4, actual);
if (image->get_buffer(track, head).size() <= 1)
continue;
@@ -163,11 +174,11 @@ bool g64_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
place_integer_le(speed_offset, 0, 4, speed_zone);
place_integer_le(track_length, 0, 2, packed.size());
- io_generic_write(io, track_offset, tpos, 4);
- io_generic_write(io, speed_offset, spos, 4);
- io_generic_write_filler(io, 0xff, dpos, TRACK_LENGTH);
- io_generic_write(io, track_length, dpos, 2);
- io_generic_write(io, packed.data(), dpos + 2, packed.size());
+ io.write_at(tpos, track_offset, 4, actual);
+ io.write_at(spos, speed_offset, 4, actual);
+ io.write_at(dpos, prefill.data(), TRACK_LENGTH, actual);
+ io.write_at(dpos, track_length, 2, actual);
+ io.write_at(dpos + 2, packed.data(), packed.size(), actual);
tracks_written++;
}
diff --git a/src/lib/formats/g64_dsk.h b/src/lib/formats/g64_dsk.h
index 6691146c70e..fcd48d96796 100644
--- a/src/lib/formats/g64_dsk.h
+++ b/src/lib/formats/g64_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/hpi_dsk.cpp b/src/lib/formats/hpi_dsk.cpp
index d9fc788fd45..bdccc66803d 100644
--- a/src/lib/formats/hpi_dsk.cpp
+++ b/src/lib/formats/hpi_dsk.cpp
@@ -48,6 +48,7 @@
#include "hpi_dsk.h"
#include "coretmpl.h" // BIT
+#include "ioprocs.h"
// Debugging
@@ -78,9 +79,12 @@ hpi_format::hpi_format()
(void)HPI_RED_IMAGE_SIZE;
}
-int hpi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int hpi_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size)) {
+ return 0;
+ }
// we try to stay back and give only 50 points, since another image
// format may also have images of the same size (there is no header and no
@@ -142,12 +146,15 @@ bool hpi_format::geometry_from_size(uint64_t image_size , unsigned& heads , unsi
}
}
-bool hpi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool hpi_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
unsigned heads;
unsigned cylinders;
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size)) {
+ return false;
+ }
if (!geometry_from_size(size, heads, cylinders)) {
return false;
}
@@ -161,7 +168,8 @@ bool hpi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
// Suck in the whole image
std::vector<uint8_t> image_data(size);
- io_generic_read(io, (void *)image_data.data(), 0, size);
+ size_t actual;
+ io.read_at(0, image_data.data(), size, actual);
// Get interleave factor from image
unsigned il = (unsigned)image_data[ IL_OFFSET ] * 256 + image_data[ IL_OFFSET + 1 ];
@@ -191,7 +199,7 @@ bool hpi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool hpi_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool hpi_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks;
int heads;
@@ -206,7 +214,8 @@ bool hpi_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
while (get_next_sector(bitstream , pos , track_no , head_no , sector_no , sector_data)) {
if (track_no == cyl && head_no == head && sector_no < HPI_SECTORS) {
unsigned offset_in_image = chs_to_lba(cyl, head, sector_no, heads) * HPI_SECTOR_SIZE;
- io_generic_write(io, sector_data, offset_in_image, HPI_SECTOR_SIZE);
+ size_t actual;
+ io.write_at(offset_in_image, sector_data, HPI_SECTOR_SIZE, actual);
}
}
}
diff --git a/src/lib/formats/hpi_dsk.h b/src/lib/formats/hpi_dsk.h
index 38c70e91c33..ca8aa1ffe11 100644
--- a/src/lib/formats/hpi_dsk.h
+++ b/src/lib/formats/hpi_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &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;
diff --git a/src/lib/formats/hti_tape.cpp b/src/lib/formats/hti_tape.cpp
index 7f77e3f99df..8fbaeef91cc 100644
--- a/src/lib/formats/hti_tape.cpp
+++ b/src/lib/formats/hti_tape.cpp
@@ -10,6 +10,8 @@
#include "imageutl.h"
+#include "ioprocs.h"
+
static constexpr uint32_t OLD_FILE_MAGIC = 0x5441434f; // Magic value at start of old-format image file: "TACO"
static constexpr uint32_t FILE_MAGIC_DELTA = 0x48544930; // Magic value at start of delta-modulation image file: "HTI0"
@@ -47,22 +49,25 @@ hti_format_t::hti_format_t()
clear_tape();
}
-bool hti_format_t::load_tape(io_generic *io)
+bool hti_format_t::load_tape(util::random_read &io)
{
+ if (io.seek(0, SEEK_SET)) {
+ return false;
+ }
+
+ size_t actual;
uint8_t tmp[ 4 ];
- io_generic_read(io, tmp, 0, 4);
+ io.read(tmp, 4, actual);
auto magic = pick_integer_be(tmp , 0 , 4);
if (((m_img_format == HTI_DELTA_MOD_16_BITS || m_img_format == HTI_DELTA_MOD_17_BITS) && magic != FILE_MAGIC_DELTA && magic != OLD_FILE_MAGIC) ||
(m_img_format == HTI_MANCHESTER_MOD && magic != FILE_MAGIC_MANCHESTER)) {
return false;
}
- uint64_t offset = 4;
-
for (unsigned i = 0; i < no_of_tracks(); i++) {
tape_track_t& track = m_tracks[ i ];
- if (!load_track(io , offset , track , magic == OLD_FILE_MAGIC)) {
+ if (!load_track(io, track, magic == OLD_FILE_MAGIC)) {
clear_tape();
return false;
}
@@ -71,14 +76,15 @@ bool hti_format_t::load_tape(io_generic *io)
return true;
}
-void hti_format_t::save_tape(io_generic *io)
+void hti_format_t::save_tape(util::random_read_write &io)
{
+ io.seek(0, SEEK_SET);
+
+ size_t actual;
uint8_t tmp[ 4 ];
place_integer_be(tmp, 0, 4, m_img_format == HTI_MANCHESTER_MOD ? FILE_MAGIC_MANCHESTER : FILE_MAGIC_DELTA);
- io_generic_write(io, tmp, 0, 4);
-
- uint64_t offset = 4;
+ io.write(tmp, 4, actual);
for (unsigned i = 0; i < no_of_tracks(); i++) {
const tape_track_t& track = m_tracks[ i ];
@@ -87,18 +93,17 @@ void hti_format_t::save_tape(io_generic *io)
tape_track_t::const_iterator it_start;
for (tape_track_t::const_iterator it = track.cbegin(); it != track.cend(); ++it) {
if (it->first != next_pos) {
- dump_sequence(io , offset , it_start , n_words);
+ dump_sequence(io, it_start, n_words);
it_start = it;
n_words = 0;
}
next_pos = it->first + word_length(it->second);
n_words++;
}
- dump_sequence(io , offset , it_start , n_words);
+ dump_sequence(io, it_start, n_words);
// End of track
place_integer_le(tmp, 0, 4, (uint32_t)-1);
- io_generic_write(io, tmp, offset, 4);
- offset += 4;
+ io.write(tmp, 4, actual);
}
}
@@ -374,8 +379,9 @@ bool hti_format_t::next_gap(unsigned track_no , tape_pos_t& pos , bool forward ,
return n_gaps == 0;
}
-bool hti_format_t::load_track(io_generic *io , uint64_t& offset , tape_track_t& track , bool old_format)
+bool hti_format_t::load_track(util::random_read &io , tape_track_t& track , bool old_format)
{
+ size_t actual;
uint8_t tmp[ 4 ];
uint32_t tmp32;
tape_pos_t delta_pos = 0;
@@ -385,8 +391,7 @@ bool hti_format_t::load_track(io_generic *io , uint64_t& offset , tape_track_t&
while (1) {
// Read no. of words to follow
- io_generic_read(io, tmp, offset, 4);
- offset += 4;
+ io.read(tmp, 4, actual);
tmp32 = pick_integer_le(tmp, 0, 4);
@@ -398,8 +403,7 @@ bool hti_format_t::load_track(io_generic *io , uint64_t& offset , tape_track_t&
unsigned n_words = tmp32;
// Read tape position of block
- io_generic_read(io, tmp, offset, 4);
- offset += 4;
+ io.read(tmp, 4, actual);
tmp32 = pick_integer_le(tmp, 0, 4);
@@ -411,8 +415,7 @@ bool hti_format_t::load_track(io_generic *io , uint64_t& offset , tape_track_t&
for (unsigned i = 0; i < n_words; i++) {
uint16_t tmp16;
- io_generic_read(io, tmp, offset, 2);
- offset += 2;
+ io.read(tmp, 2, actual);
tmp16 = pick_integer_le(tmp, 0, 2);
if (!old_format) {
@@ -469,19 +472,18 @@ bool hti_format_t::load_track(io_generic *io , uint64_t& offset , tape_track_t&
}
}
-void hti_format_t::dump_sequence(io_generic *io , uint64_t& offset , tape_track_t::const_iterator it_start , unsigned n_words)
+void hti_format_t::dump_sequence(util::random_read_write &io , tape_track_t::const_iterator it_start , unsigned n_words)
{
if (n_words) {
+ size_t actual;
uint8_t tmp[ 8 ];
place_integer_le(tmp, 0, 4, n_words);
place_integer_le(tmp, 4, 4, it_start->first);
- io_generic_write(io, tmp, offset, 8);
- offset += 8;
+ io.write(tmp, 8, actual);
for (unsigned i = 0; i < n_words; i++) {
place_integer_le(tmp, 0, 2, it_start->second);
- io_generic_write(io, tmp, offset, 2);
- offset += 2;
+ io.write(tmp, 2, actual);
++it_start;
}
}
diff --git a/src/lib/formats/hti_tape.h b/src/lib/formats/hti_tape.h
index 7725b87fa2a..373c971d174 100644
--- a/src/lib/formats/hti_tape.h
+++ b/src/lib/formats/hti_tape.h
@@ -13,10 +13,12 @@
#pragma once
-#include "ioprocs.h"
+#include "utilfwd.h"
+#include <cstdint>
#include <map>
+
class hti_format_t
{
public:
@@ -71,8 +73,8 @@ public:
// Return number of tracks
unsigned no_of_tracks() const { return m_img_format == HTI_MANCHESTER_MOD ? 1 : 2; }
- bool load_tape(io_generic *io);
- void save_tape(io_generic *io);
+ bool load_tape(util::random_read &io);
+ void save_tape(util::random_read_write &io);
void clear_tape();
// Return physical length of a bit on tape
@@ -127,8 +129,8 @@ private:
// Image format
image_format_t m_img_format;
- bool load_track(io_generic *io , uint64_t& offset , tape_track_t& track , bool old_format);
- static void dump_sequence(io_generic *io , uint64_t& offset , tape_track_t::const_iterator it_start , unsigned n_words);
+ bool load_track(util::random_read &io , tape_track_t& track , bool old_format);
+ static void dump_sequence(util::random_read_write &io , tape_track_t::const_iterator it_start , unsigned n_words);
tape_pos_t word_end_pos(const track_iterator_t& it) const;
void adjust_it(tape_track_t& track , track_iterator_t& it , tape_pos_t pos) const;
diff --git a/src/lib/formats/hxchfe_dsk.cpp b/src/lib/formats/hxchfe_dsk.cpp
index 68360f4e9bb..15598bbd746 100644
--- a/src/lib/formats/hxchfe_dsk.cpp
+++ b/src/lib/formats/hxchfe_dsk.cpp
@@ -101,6 +101,9 @@
#include "hxchfe_dsk.h"
+#include "ioprocs.h"
+
+
#define HFE_FORMAT_HEADER "HXCPICFE"
#define HEADER_LENGTH 512
@@ -144,19 +147,21 @@ bool hfe_format::supports_save() const
return true;
}
-int hfe_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int hfe_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[8];
- io_generic_read(io, &header, 0, sizeof(header));
+ size_t actual;
+ io.read_at(0, &header, sizeof(header), actual);
if ( memcmp( header, HFE_FORMAT_HEADER, 8 ) ==0) {
return 100;
}
return 0;
}
-bool hfe_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool hfe_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
uint8_t header[HEADER_LENGTH];
uint8_t track_table[TRACK_TABLE_LENGTH];
@@ -164,7 +169,7 @@ bool hfe_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
image->get_maximal_geometry(drivecyl, driveheads);
// read header
- io_generic_read(io, header, 0, HEADER_LENGTH);
+ io.read_at(0, header, HEADER_LENGTH, actual);
// get values
// Format revision must be 0
@@ -236,7 +241,7 @@ bool hfe_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
// read track lookup table (multiple of 512)
int table_offset = (header[18] & 0xff) | ((header[19] & 0xff)<<8);
- io_generic_read(io, track_table, table_offset<<9, TRACK_TABLE_LENGTH);
+ io.read_at(table_offset<<9, track_table, TRACK_TABLE_LENGTH, actual);
for (int i=0; i < m_cylinders; i++)
{
@@ -252,7 +257,7 @@ bool hfe_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
// The HFE format defines an interleave of the two sides per cylinder
// at every 256 bytes
cylinder_buffer.resize(m_cyl_length[cyl]);
- io_generic_read(io, &cylinder_buffer[0], m_cyl_offset[cyl]<<9, m_cyl_length[cyl]);
+ io.read_at(m_cyl_offset[cyl]<<9, &cylinder_buffer[0], m_cyl_length[cyl], actual);
generate_track_from_hfe_bitstream(cyl, 0, samplelength, &cylinder_buffer[0], m_cyl_length[cyl], image);
if (m_heads == 2)
@@ -412,8 +417,9 @@ 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, const std::vector<uint32_t> &variants, floppy_image *image)
+bool hfe_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
std::vector<uint8_t> cylbuf;
// Create a buffer that is big enough to handle HD formats. We don't
@@ -484,7 +490,7 @@ bool hfe_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
header[13] = (m_bit_rate >> 8) & 0xff;
// Now write the header
- io_generic_write(io, header, 0, HEADER_LENGTH);
+ io.write_at(0, header, HEADER_LENGTH, actual);
// Set up the track lookup table
// We need the encoding value to be sure about the track length
@@ -505,10 +511,10 @@ bool hfe_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
for (int i=m_cylinders*4; i < TRACK_TABLE_LENGTH; i++)
track_table[i] = 0xff;
- io_generic_write(io, track_table, 0x200, TRACK_TABLE_LENGTH);
+ io.write_at(0x200, track_table, TRACK_TABLE_LENGTH, actual);
}
// Write the current cylinder
- io_generic_write(io, &cylbuf[0], m_cyl_offset[cyl]<<9, (m_cyl_length[cyl] + 0x1ff) & 0xfe00);
+ io.write_at(m_cyl_offset[cyl]<<9, &cylbuf[0], (m_cyl_length[cyl] + 0x1ff) & 0xfe00, actual);
}
return true;
}
diff --git a/src/lib/formats/hxchfe_dsk.h b/src/lib/formats/hxchfe_dsk.h
index 9d2dbdeae77..4ea98ed861c 100644
--- a/src/lib/formats/hxchfe_dsk.h
+++ b/src/lib/formats/hxchfe_dsk.h
@@ -47,9 +47,9 @@ public:
hfe_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/hxcmfm_dsk.cpp b/src/lib/formats/hxcmfm_dsk.cpp
index b6845b28e4a..e7bf03acd2f 100644
--- a/src/lib/formats/hxcmfm_dsk.cpp
+++ b/src/lib/formats/hxcmfm_dsk.cpp
@@ -1,10 +1,11 @@
// license:BSD-3-Clause
// copyright-holders:Olivier Galibert
-#include <cassert>
-
#include "hxcmfm_dsk.h"
+#include "ioprocs.h"
+
+
#define MFM_FORMAT_HEADER "HXCMFM"
#pragma pack(1)
@@ -57,24 +58,26 @@ bool mfm_format::supports_save() const
return true;
}
-int mfm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int mfm_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[7];
- io_generic_read(io, &header, 0, sizeof(header));
+ size_t actual;
+ io.read_at(0, &header, sizeof(header), actual);
if ( memcmp( header, MFM_FORMAT_HEADER, 6 ) ==0) {
return 100;
}
return 0;
}
-bool mfm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool mfm_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
MFMIMG header;
MFMTRACKIMG trackdesc;
// read header
- io_generic_read(io, &header, 0, sizeof(header));
+ io.read_at(0, &header, sizeof(header), actual);
int drivecyl, driveheads;
image->get_maximal_geometry(drivecyl, driveheads);
@@ -86,12 +89,12 @@ bool mfm_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for(int side=0; side < header.number_of_side; side++) {
if (!skip_odd || track%2 == 0) {
// read location of
- io_generic_read(io, &trackdesc,(header.mfmtracklistoffset)+( counter *sizeof(trackdesc)),sizeof(trackdesc));
+ io.read_at((header.mfmtracklistoffset)+( counter *sizeof(trackdesc)), &trackdesc, sizeof(trackdesc), actual);
trackbuf.resize(trackdesc.mfmtracksize);
// actual data read
- io_generic_read(io, &trackbuf[0], trackdesc.mfmtrackoffset, trackdesc.mfmtracksize);
+ io.read_at(trackdesc.mfmtrackoffset, &trackbuf[0], trackdesc.mfmtracksize, actual);
if (skip_odd) {
generate_track_from_bitstream(track/2, side, &trackbuf[0], trackdesc.mfmtracksize*8, image);
@@ -109,9 +112,10 @@ bool mfm_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool mfm_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool mfm_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
// TODO: HD support
+ size_t actual;
MFMIMG header;
int track_count, head_count;
image->get_actual_geometry(track_count, head_count);
@@ -124,7 +128,7 @@ bool mfm_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
header.floppyiftype = 4;
header.mfmtracklistoffset = sizeof(MFMIMG);
- io_generic_write(io, &header, 0, sizeof(MFMIMG));
+ io.write_at(0, &header, sizeof(MFMIMG), actual);
int tpos = sizeof(MFMIMG);
int dpos = tpos + track_count*head_count*sizeof(MFMTRACKIMG);
@@ -143,8 +147,8 @@ bool mfm_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
trackdesc.mfmtracksize = packed.size();
trackdesc.mfmtrackoffset = dpos;
- io_generic_write(io, &trackdesc, tpos, sizeof(MFMTRACKIMG));
- io_generic_write(io, packed.data(), dpos, packed.size());
+ io.write_at(tpos, &trackdesc, sizeof(MFMTRACKIMG), actual);
+ io.write_at(dpos, packed.data(), packed.size(), actual);
tpos += sizeof(MFMTRACKIMG);
dpos += packed.size();
diff --git a/src/lib/formats/hxcmfm_dsk.h b/src/lib/formats/hxcmfm_dsk.h
index a6f884ab03e..c42190f3aae 100644
--- a/src/lib/formats/hxcmfm_dsk.h
+++ b/src/lib/formats/hxcmfm_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/ibmxdf_dsk.cpp b/src/lib/formats/ibmxdf_dsk.cpp
index b18ffad63dc..5a44290a337 100644
--- a/src/lib/formats/ibmxdf_dsk.cpp
+++ b/src/lib/formats/ibmxdf_dsk.cpp
@@ -32,6 +32,8 @@
#include "ibmxdf_dsk.h"
+#include "ioprocs.h"
+
ibmxdf_format::ibmxdf_format() : wd177x_format(formats)
{
@@ -52,7 +54,7 @@ const char *ibmxdf_format::extensions() const
return "xdf,img";
}
-int ibmxdf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ibmxdf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
@@ -61,9 +63,11 @@ int ibmxdf_format::identify(io_generic *io, uint32_t form_factor, const std::vec
return 0;
}
-int ibmxdf_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ibmxdf_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return -1;
if (size != 1884160)
return -1;
@@ -173,7 +177,7 @@ const ibmxdf_format::format ibmxdf_format::formats_head1_track0[] = {
{}
};
-bool ibmxdf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool ibmxdf_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int type = find_size(io, form_factor, variants);
if(type == -1)
@@ -207,8 +211,9 @@ bool ibmxdf_format::load(io_generic *io, uint32_t form_factor, const std::vector
desc[16].p1 = get_track_dam_mfm(tf, head, track);
build_sector_description(tf, sectdata, sectors, track, head);
- int track_size = compute_track_size(f) * 2; // read both sides at once
- io_generic_read(io, sectdata, get_image_offset(f, head, track), track_size);
+ int const track_size = compute_track_size(f) * 2; // read both sides at once
+ size_t actual;
+ io.read_at(get_image_offset(f, head, track), sectdata, track_size, actual);
generate_track(desc, track, head, sectors, tf.sector_count, total_size, image);
}
diff --git a/src/lib/formats/ibmxdf_dsk.h b/src/lib/formats/ibmxdf_dsk.h
index 6d37142ac30..dbb448f8ad3 100644
--- a/src/lib/formats/ibmxdf_dsk.h
+++ b/src/lib/formats/ibmxdf_dsk.h
@@ -23,11 +23,11 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &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 wd177x_format::format &get_track_format(const format &f, int head, int track) override;
diff --git a/src/lib/formats/imd_dsk.cpp b/src/lib/formats/imd_dsk.cpp
index b3d4eac8229..b0e9a4159d9 100644
--- a/src/lib/formats/imd_dsk.cpp
+++ b/src/lib/formats/imd_dsk.cpp
@@ -10,7 +10,8 @@
#include "imd_dsk.h"
-#include <cassert>
+#include "ioprocs.h"
+
#include <cstring>
@@ -409,25 +410,29 @@ void imd_format::fixnum(char *start, char *end) const
};
}
-int imd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int imd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
char h[4];
- io_generic_read(io, h, 0, 4);
+ size_t actual;
+ io.read_at(0, h, 4, actual);
if(!memcmp(h, "IMD ", 4))
return 100;
return 0;
}
-bool imd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool imd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
uint64_t pos, savepos;
- for(pos=0; pos < size && img[pos] != 0x1a; pos++) {};
+ for(pos=0; pos < size && img[pos] != 0x1a; pos++) { }
pos++;
m_comment.resize(pos);
@@ -627,39 +632,34 @@ bool can_compress(const uint8_t* buffer, uint8_t ptrn, uint64_t size)
return true;
}
-bool imd_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool imd_format::save(util::random_read_write &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());
- pos += m_comment.size();
+ if(io.seek(0, SEEK_SET))
+ return false;
+
+ size_t written;
+ io.write(&m_comment[0], m_comment.size(), written);
for (int i = 0; i < m_mode.size(); i++)
{
- io_generic_write(io, &m_mode[i], pos++, 1);
- io_generic_write(io, &m_track[i], pos++, 1);
- io_generic_write(io, &m_head[i], pos++, 1);
- io_generic_write(io, &m_sector_count[i], pos++, 1);
- io_generic_write(io, &m_ssize[i], pos++, 1);
+ io.write(&m_mode[i], 1, written);
+ io.write(&m_track[i], 1, written);
+ io.write(&m_head[i], 1, written);
+ io.write(&m_sector_count[i], 1, written);
+ io.write(&m_ssize[i], 1, written);
- io_generic_write(io, &m_snum[i][0], pos, m_sector_count[i]);
- pos += m_sector_count[i];
+ io.write(&m_snum[i][0], m_sector_count[i], written);
if (m_tnum[i].size())
- {
- io_generic_write(io, &m_tnum[i][0], pos, m_sector_count[i]);
- pos += m_sector_count[i];
- }
+ io.write(&m_tnum[i][0], m_sector_count[i], written);
if (m_hnum[i].size())
- {
- io_generic_write(io, &m_hnum[i][0], pos, m_sector_count[i]);
- pos += m_sector_count[i];
- }
+ io.write(&m_hnum[i][0], m_sector_count[i], written);
- uint32_t actual_size = m_ssize[i] < 7 ? 128 << m_ssize[i] : 8192;
- uint8_t head = m_head[i] & 0x3f;
+ uint32_t const actual_size = m_ssize[i] < 7 ? 128 << m_ssize[i] : 8192;
+ uint8_t const head = m_head[i] & 0x3f;
- bool fm = m_mode[i]< 3;
+ bool const fm = m_mode[i]< 3;
auto bitstream = generate_bitstream_from_track(m_track[i]*m_trackmult, head, fm ? 4000 : 2000, image);
std::vector<std::vector<uint8_t>> sectors;
@@ -674,11 +674,10 @@ bool imd_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
const auto &data = sectors[m_snum[i][j]];
- uint8_t mode;
if (data.empty())
{
- mode = 0;
- io_generic_write(io, &mode, pos++, 1);
+ uint8_t const mode = 0;
+ io.write(&mode, 1, written);
continue;
}
else if (data.size() < actual_size) {
@@ -690,16 +689,15 @@ bool imd_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
if (can_compress(sdata, sdata[0], actual_size))
{
- mode = 2;
- io_generic_write(io, &mode, pos++, 1);
- io_generic_write(io, &sdata[0], pos++, 1);
+ uint8_t const mode = 2;
+ io.write(&mode, 1, written);
+ io.write(&sdata[0], 1, written);
}
else
{
- mode = 1;
- io_generic_write(io, &mode, pos++, 1);
- io_generic_write(io, &sdata, pos, actual_size);
- pos += actual_size;
+ uint8_t const mode = 1;
+ io.write(&mode, 1, written);
+ io.write(&sdata, actual_size, written);
}
}
}
diff --git a/src/lib/formats/imd_dsk.h b/src/lib/formats/imd_dsk.h
index ba04a0c09e7..acf7da9b892 100644
--- a/src/lib/formats/imd_dsk.h
+++ b/src/lib/formats/imd_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image* image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/img_dsk.cpp b/src/lib/formats/img_dsk.cpp
index 757f695d923..73ae499c764 100644
--- a/src/lib/formats/img_dsk.cpp
+++ b/src/lib/formats/img_dsk.cpp
@@ -17,6 +17,7 @@
#include "img_dsk.h"
#include "coretmpl.h" // BIT
+#include "ioprocs.h"
// Debugging
@@ -40,9 +41,12 @@ img_format::img_format()
{
}
-int img_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int img_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size)) {
+ return 0;
+ }
if (((form_factor == floppy_image::FF_8) || (form_factor == floppy_image::FF_UNKNOWN)) &&
size == IMG_IMAGE_SIZE) {
@@ -52,17 +56,18 @@ int img_format::identify(io_generic *io, uint32_t form_factor, const std::vector
}
}
-bool img_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool img_format::load(util::random_read &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) {
+ uint64_t size;
+ if (io.length(size) || (size != IMG_IMAGE_SIZE)) {
return false;
}
image->set_variant(floppy_image::SSDD);
// Suck in the whole image
std::vector<uint8_t> image_data(size);
- io_generic_read(io, (void *)image_data.data(), 0, size);
+ size_t actual;
+ io.read_at(0, image_data.data(), size, actual);
for (unsigned cyl = 0; cyl < TRACKS; cyl++) {
std::vector<uint32_t> track_data;
@@ -96,7 +101,7 @@ bool img_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool img_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool img_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
for (int cyl = 0; cyl < TRACKS; cyl++) {
auto bitstream = generate_bitstream_from_track(cyl , 0 , CELL_SIZE , image , 0);
@@ -106,7 +111,8 @@ bool img_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
while (get_next_sector(bitstream , pos , track_no , sector_no , sector_data)) {
if (track_no == cyl && sector_no >= 1 && sector_no <= SECTORS) {
unsigned offset_in_image = (cyl * SECTORS + sector_no - 1) * SECTOR_SIZE;
- io_generic_write(io, sector_data, offset_in_image, SECTOR_SIZE);
+ size_t actual;
+ io.write_at(offset_in_image, sector_data, SECTOR_SIZE, actual);
}
}
}
diff --git a/src/lib/formats/img_dsk.h b/src/lib/formats/img_dsk.h
index af9a2d62466..bbd7a0fc03e 100644
--- a/src/lib/formats/img_dsk.h
+++ b/src/lib/formats/img_dsk.h
@@ -27,9 +27,9 @@ public:
img_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &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;
diff --git a/src/lib/formats/ioprocs.cpp b/src/lib/formats/ioprocs.cpp
deleted file mode 100644
index 78e009aa112..00000000000
--- a/src/lib/formats/ioprocs.cpp
+++ /dev/null
@@ -1,214 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Nathan Woods
-#include <cstdio>
-#include <cstring>
-#include <cassert>
-#include "ioprocs.h"
-#include "corefile.h"
-
-
-/*********************************************************************
- ioprocs implementation on stdio
-*********************************************************************/
-
-static void stdio_closeproc(void *file)
-{
- fclose((FILE*)file);
-}
-
-static int stdio_seekproc(void *file, int64_t offset, int whence)
-{
- return fseek((FILE*)file, (long) offset, whence);
-}
-
-static size_t stdio_readproc(void *file, void *buffer, size_t length)
-{
- return fread(buffer, 1, length, (FILE*)file);
-}
-
-static size_t stdio_writeproc(void *file, const void *buffer, size_t length)
-{
- return fwrite(buffer, 1, length, (FILE*)file);
-}
-
-static uint64_t stdio_filesizeproc(void *file)
-{
- long l, sz;
- l = ftell((FILE*)file);
- if (fseek((FILE*)file, 0, SEEK_END))
- return (size_t) -1;
- sz = ftell((FILE*)file);
- if (fseek((FILE*)file, l, SEEK_SET))
- return (size_t) -1;
- return (size_t) sz;
-}
-
-const struct io_procs stdio_ioprocs =
-{
- stdio_closeproc,
- stdio_seekproc,
- stdio_readproc,
- stdio_writeproc,
- stdio_filesizeproc
-};
-
-const struct io_procs stdio_ioprocs_noclose =
-{
- nullptr,
- stdio_seekproc,
- stdio_readproc,
- stdio_writeproc,
- stdio_filesizeproc
-};
-
-/*********************************************************************
- ioprocs implementation on corefile
-*********************************************************************/
-
-static void corefile_closeproc(void *file)
-{
- delete (util::core_file*)file;
-}
-
-static int corefile_seekproc(void *file, int64_t offset, int whence)
-{
- return ((util::core_file*)file)->seek(offset, whence);
-}
-
-static size_t corefile_readproc(void *file, void *buffer, size_t length)
-{
- return ((util::core_file*)file)->read(buffer, length);
-}
-
-static size_t corefile_writeproc(void *file, const void *buffer, size_t length)
-{
- return ((util::core_file*)file)->write(buffer, length);
-}
-
-static uint64_t corefile_filesizeproc(void *file)
-{
- const auto l = ((util::core_file*)file)->tell();
- if (((util::core_file*)file)->seek(0, SEEK_END))
- return (size_t) -1;
- const auto sz = ((util::core_file*)file)->tell();
- if (((util::core_file*)file)->seek(l, SEEK_SET))
- return uint64_t(-1);
- return uint64_t(sz);
-}
-
-const struct io_procs corefile_ioprocs =
-{
- corefile_closeproc,
- corefile_seekproc,
- corefile_readproc,
- corefile_writeproc,
- corefile_filesizeproc
-};
-
-const struct io_procs corefile_ioprocs_noclose =
-{
- nullptr,
- corefile_seekproc,
- corefile_readproc,
- corefile_writeproc,
- corefile_filesizeproc
-};
-
-
-
-/*********************************************************************
- calls for accessing generic IO
-*********************************************************************/
-
-static void io_generic_seek(struct io_generic *genio, uint64_t offset)
-{
- genio->procs->seekproc(genio->file, offset, SEEK_SET);
-}
-
-
-
-void io_generic_close(struct io_generic *genio)
-{
- if (genio->procs->closeproc)
- genio->procs->closeproc(genio->file);
-}
-
-
-
-void io_generic_read(struct io_generic *genio, void *buffer, uint64_t offset, size_t length)
-{
- uint64_t size;
- size_t bytes_read;
-
- size = io_generic_size(genio);
- if (size <= offset)
- {
- bytes_read = 0;
- }
- else
- {
- io_generic_seek(genio, offset);
- bytes_read = genio->procs->readproc(genio->file, buffer, length);
- }
- memset(((uint8_t *) buffer) + bytes_read, genio->filler, length - bytes_read);
-}
-
-
-
-void io_generic_write(struct io_generic *genio, const void *buffer, uint64_t offset, size_t length)
-{
- uint64_t filler_size = 0;
- char filler_buffer[1024];
- size_t bytes_to_write;
- uint64_t size;
-
- size = io_generic_size(genio);
-
- if (size < offset)
- {
- filler_size = offset - size;
- offset = size;
- }
-
- io_generic_seek(genio, offset);
-
- if (filler_size)
- {
- memset(filler_buffer, genio->filler, sizeof(filler_buffer));
- do
- {
- bytes_to_write = (filler_size > sizeof(filler_buffer)) ? sizeof(filler_buffer) : (size_t) filler_size;
- genio->procs->writeproc(genio->file, filler_buffer, bytes_to_write);
- filler_size -= bytes_to_write;
- }
- while(filler_size > 0);
- }
-
- if (length > 0)
- genio->procs->writeproc(genio->file, buffer, length);
-}
-
-
-
-void io_generic_write_filler(struct io_generic *genio, uint8_t filler, uint64_t offset, size_t length)
-{
- uint8_t buffer[512];
- size_t this_length;
-
- memset(buffer, filler, std::min(length, sizeof(buffer)));
-
- while(length > 0)
- {
- this_length = std::min(length, sizeof(buffer));
- io_generic_write(genio, buffer, offset, this_length);
- offset += this_length;
- length -= this_length;
- }
-}
-
-
-
-uint64_t io_generic_size(struct io_generic *genio)
-{
- return genio->procs->filesizeproc(genio->file);
-}
diff --git a/src/lib/formats/ioprocs.h b/src/lib/formats/ioprocs.h
deleted file mode 100644
index 1244873f14c..00000000000
--- a/src/lib/formats/ioprocs.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// license:BSD-3-Clause
-// copyright-holders:Nathan Woods
-/*********************************************************************
-
- ioprocs.h
-
- File IO abstraction layer
-
-*********************************************************************/
-#ifndef MAME_FORMATS_IOPROCS_H
-#define MAME_FORMATS_IOPROCS_H
-
-#pragma once
-
-#include <cstdint>
-#include <cstdlib>
-
-
-
-/***************************************************************************
-
- Type definitions
-
-***************************************************************************/
-
-struct io_procs
-{
- void (*closeproc)(void *file) = nullptr;
- int (*seekproc)(void *file, int64_t offset, int whence) = nullptr;
- size_t (*readproc)(void *file, void *buffer, size_t length) = nullptr;
- size_t (*writeproc)(void *file, const void *buffer, size_t length) = nullptr;
- uint64_t (*filesizeproc)(void *file) = nullptr;
-};
-
-
-
-struct io_generic
-{
- const struct io_procs *procs = nullptr;
- void *file = nullptr;
- uint8_t filler = 0;
-};
-
-
-/***************************************************************************
-
- Globals
-
-***************************************************************************/
-
-extern const io_procs stdio_ioprocs;
-extern const io_procs stdio_ioprocs_noclose;
-extern const io_procs corefile_ioprocs;
-extern const io_procs corefile_ioprocs_noclose;
-
-
-
-/***************************************************************************
-
- Prototypes
-
-***************************************************************************/
-
-void io_generic_close(struct io_generic *genio);
-void io_generic_read(struct io_generic *genio, void *buffer, uint64_t offset, size_t length);
-void io_generic_write(struct io_generic *genio, const void *buffer, uint64_t offset, size_t length);
-void io_generic_write_filler(struct io_generic *genio, uint8_t filler, uint64_t offset, size_t length);
-uint64_t io_generic_size(struct io_generic *genio);
-
-#endif // MAME_FORMATS_IOPROCS_H
diff --git a/src/lib/formats/ipf_dsk.cpp b/src/lib/formats/ipf_dsk.cpp
index 0f1725f5c14..10c9ba2c4a9 100644
--- a/src/lib/formats/ipf_dsk.cpp
+++ b/src/lib/formats/ipf_dsk.cpp
@@ -2,6 +2,8 @@
// copyright-holders:Olivier Galibert
#include "ipf_dsk.h"
+#include "ioprocs.h"
+
#include <cassert>
@@ -27,11 +29,12 @@ bool ipf_format::supports_save() const
return false;
}
-int ipf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ipf_format::identify(util::random_read &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];
- io_generic_read(io, h, 0, 12);
+ size_t actual;
+ io.read_at(0, h, 12, actual);
if(!memcmp(h, refh, 12))
return 100;
@@ -39,14 +42,16 @@ int ipf_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool ipf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool ipf_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- ipf_decode dec;
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
std::vector<uint8_t> data(size);
- io_generic_read(io, &data[0], 0, size);
- bool res = dec.parse(data, image);
- return res;
+ size_t actual;
+ io.read_at(0, &data[0], size, actual);
+ ipf_decode dec;
+ return dec.parse(data, image);
}
uint32_t ipf_format::ipf_decode::r32(const uint8_t *p)
diff --git a/src/lib/formats/ipf_dsk.h b/src/lib/formats/ipf_dsk.h
index d848a5bb3a0..28d552d5812 100644
--- a/src/lib/formats/ipf_dsk.h
+++ b/src/lib/formats/ipf_dsk.h
@@ -12,8 +12,8 @@
class ipf_format : public floppy_image_format_t
{
public:
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/jfd_dsk.cpp b/src/lib/formats/jfd_dsk.cpp
index 947d6ba4022..7a1da472356 100644
--- a/src/lib/formats/jfd_dsk.cpp
+++ b/src/lib/formats/jfd_dsk.cpp
@@ -158,9 +158,13 @@
*********************************************************************/
-#include <zlib.h>
#include "formats/jfd_dsk.h"
+#include "ioprocs.h"
+
+#include <zlib.h>
+
+
static const uint8_t JFD_HEADER[4] = { 'J', 'F', 'D', 'I' };
static const uint8_t GZ_HEADER[2] = { 0x1f, 0x8b };
@@ -183,11 +187,14 @@ const char *jfd_format::extensions() const
return "jfd";
}
-int jfd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int jfd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
int err;
std::vector<uint8_t> gz_ptr(4);
@@ -221,11 +228,15 @@ int jfd_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool jfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool jfd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
+
std::vector<uint8_t> img(size);
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
int err;
std::vector<uint8_t> gz_ptr;
diff --git a/src/lib/formats/jfd_dsk.h b/src/lib/formats/jfd_dsk.h
index 75b9910c426..7231ccf3460 100644
--- a/src/lib/formats/jfd_dsk.h
+++ b/src/lib/formats/jfd_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
};
diff --git a/src/lib/formats/jvc_dsk.cpp b/src/lib/formats/jvc_dsk.cpp
index 8332f86bace..c71f2c3be06 100644
--- a/src/lib/formats/jvc_dsk.cpp
+++ b/src/lib/formats/jvc_dsk.cpp
@@ -106,6 +106,8 @@
#include "jvc_dsk.h"
+#include "ioprocs.h"
+
jvc_format::jvc_format()
{
@@ -126,19 +128,22 @@ const char *jvc_format::extensions() const
return "jvc,dsk";
}
-bool jvc_format::parse_header(io_generic *io, int &header_size, int &tracks, int &heads, int &sectors, int &sector_size, int &base_sector_id)
+bool jvc_format::parse_header(util::random_read &io, int &header_size, int &tracks, int &heads, int &sectors, int &sector_size, int &base_sector_id)
{
// The JVC format has a header whose size is the size of the image modulo 256. Currently, we only
// handle up to five header bytes
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return false;
header_size = size % 256;
uint8_t header[5];
// if we know that this is a header of a bad size, we can fail immediately; otherwise read the header
+ size_t actual;
if (header_size >= sizeof(header))
return false;
if (header_size > 0)
- io_generic_read(io, header, 0, header_size);
+ io.read_at(0, header, header_size, actual);
// default values
heads = 1;
@@ -168,13 +173,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, const std::vector<uint32_t> &variants)
+int jvc_format::identify(util::random_read &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, const std::vector<uint32_t> &variants, floppy_image *image)
+bool jvc_format::load(util::random_read &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;
@@ -210,7 +215,8 @@ bool jvc_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
sectors[interleave[i]].bad_crc = false;
sectors[interleave[i]].data = &sector_data[sector_offset];
- io_generic_read(io, sectors[interleave[i]].data, file_offset, sector_size);
+ size_t actual;
+ io.read_at(file_offset, sectors[interleave[i]].data, sector_size, actual);
sector_offset += sector_size;
file_offset += sector_size;
@@ -223,7 +229,7 @@ bool jvc_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool jvc_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool jvc_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t file_offset = 0;
@@ -236,7 +242,8 @@ bool jvc_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
uint8_t header[2];
header[0] = 18;
header[1] = 2;
- io_generic_write(io, header, file_offset, sizeof(header));
+ size_t actual;
+ io.write_at(file_offset, header, sizeof(header), actual);
file_offset += sizeof(header);
}
@@ -256,7 +263,8 @@ bool jvc_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
return false;
}
- io_generic_write(io, sectors[1 + i].data(), file_offset, 256);
+ size_t actual;
+ io.write_at(file_offset, sectors[1 + i].data(), 256, actual);
file_offset += 256;
}
}
diff --git a/src/lib/formats/jvc_dsk.h b/src/lib/formats/jvc_dsk.h
index 7c744a0acb5..1b8b59c725f 100644
--- a/src/lib/formats/jvc_dsk.h
+++ b/src/lib/formats/jvc_dsk.h
@@ -35,13 +35,13 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
private:
- bool parse_header(io_generic *io, int &header_size, int &tracks, int &heads, int &sectors, int &sector_size, int &base_sector_id);
+ bool parse_header(util::random_read &io, int &header_size, int &tracks, int &heads, int &sectors, int &sector_size, int &base_sector_id);
};
extern const floppy_format_type FLOPPY_JVC_FORMAT;
diff --git a/src/lib/formats/m20_dsk.cpp b/src/lib/formats/m20_dsk.cpp
index 60b2ae58176..05c52c2f211 100644
--- a/src/lib/formats/m20_dsk.cpp
+++ b/src/lib/formats/m20_dsk.cpp
@@ -16,6 +16,9 @@
#include "m20_dsk.h"
+#include "ioprocs.h"
+
+
m20_format::m20_format()
{
}
@@ -40,21 +43,27 @@ bool m20_format::supports_save() const
return true;
}
-int m20_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int m20_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- if(io_generic_size(io) == 286720)
+ uint64_t size;
+ if (io.length(size))
+ return 0;
+
+ if (size == 286720)
return 50;
+
return 0;
}
-bool m20_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool m20_format::load(util::random_read &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 ++) {
bool mfm = track || head;
desc_pc_sector sects[16];
uint8_t sectdata[16*256];
- io_generic_read(io, sectdata, 16*256*(track*2+head), 16*256);
+ size_t actual;
+ io.read_at(16*256*(track*2+head), sectdata, 16*256, actual);
for (int i = 0; i < 16; i++) {
int j = i/2 + (i & 1 ? 0 : 8);
sects[i].track = track;
@@ -76,7 +85,7 @@ bool m20_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool m20_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool m20_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint64_t file_offset = 0;
@@ -87,26 +96,27 @@ bool m20_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
auto bitstream = generate_bitstream_from_track(0, 0, 4000, image);
auto sectors = extract_sectors_from_bitstream_fm_pc(bitstream);
- for (int i = 0; i < 16; i++)
- {
- io_generic_write(io, sectors[i + 1].data(), file_offset, 128);
+ for (int i = 0; i < 16; i++) {
+ size_t actual;
+ io.write_at(file_offset, sectors[i + 1].data(), 128, actual);
file_offset += 256; //128;
}
// rest are mfm tracks
- for (int track = 0; track < track_count; track++)
- {
- for (int head = 0; head < head_count; head++)
- {
+ for (int track = 0; track < track_count; track++) {
+ for (int head = 0; head < head_count; head++) {
// skip track 0, head 0
- if (track == 0) { if (head_count == 1) break; else head++; }
+ if (track == 0) {
+ if (head_count == 1) break;
+ else head++;
+ }
bitstream = generate_bitstream_from_track(track, head, 2000, image);
sectors = extract_sectors_from_bitstream_mfm_pc(bitstream);
- for (int i = 0; i < 16; i++)
- {
- io_generic_write(io, sectors[i + 1].data(), file_offset, 256);
+ for (int i = 0; i < 16; i++) {
+ size_t actual;
+ io.write_at(file_offset, sectors[i + 1].data(), 256, actual);
file_offset += 256;
}
}
diff --git a/src/lib/formats/m20_dsk.h b/src/lib/formats/m20_dsk.h
index ed8a7bc4517..d9bd7a45425 100644
--- a/src/lib/formats/m20_dsk.h
+++ b/src/lib/formats/m20_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/mdos_dsk.cpp b/src/lib/formats/mdos_dsk.cpp
index b96be2f327e..e49d825ea9a 100644
--- a/src/lib/formats/mdos_dsk.cpp
+++ b/src/lib/formats/mdos_dsk.cpp
@@ -50,7 +50,9 @@
*/
#include "mdos_dsk.h"
-#include "formats/imageutl.h"
+#include "imageutl.h"
+
+#include "ioprocs.h"
mdos_format::mdos_format() : wd177x_format(formats)
@@ -72,12 +74,13 @@ const char *mdos_format::extensions() const
return "dsk";
}
-int mdos_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int mdos_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int type = find_size(io, form_factor, variants);
+ int type = find_size(io, form_factor, variants);
if (type != -1)
return 75;
+
return 0;
}
@@ -109,12 +112,15 @@ int mdos_format::parse_date_field(uint8_t *str)
return (high - 0x30) * 10 + (low - 0x30);
}
-int mdos_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int mdos_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ size_t actual;
+ uint64_t size;
+ if (io.length(size))
+ return -1;
// Look at the disk id sector.
- io_generic_read(io, &info, 0, sizeof(struct disk_id_sector));
+ io.read_at(0, &info, sizeof(struct disk_id_sector), actual);
LOG_FORMATS("MDOS floppy dsk: size %d bytes, %d total sectors, %d remaining bytes, expected form factor %x\n", (uint32_t)size, (uint32_t)size / 128, (uint32_t)size % 128, form_factor);
@@ -176,8 +182,8 @@ int mdos_format::find_size(io_generic *io, uint32_t form_factor, const std::vect
// the extent of the disk are free or available.
uint8_t cluster_allocation[128], cluster_available[128];
- io_generic_read(io, &cluster_allocation, 1 * 128, sizeof(cluster_allocation));
- io_generic_read(io, &cluster_available, 2 * 128, sizeof(cluster_available));
+ io.read_at(1 * 128, &cluster_allocation, sizeof(cluster_allocation), actual);
+ io.read_at(2 * 128, &cluster_available, sizeof(cluster_available), actual);
for (int cluster = 0; cluster < sizeof(cluster_allocation) * 8; cluster++) {
if (cluster * 4 * 128 + 4 * 128 > size) {
diff --git a/src/lib/formats/mdos_dsk.h b/src/lib/formats/mdos_dsk.h
index 65e7bca9f14..56dd29c9954 100644
--- a/src/lib/formats/mdos_dsk.h
+++ b/src/lib/formats/mdos_dsk.h
@@ -19,8 +19,8 @@ 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, const std::vector<uint32_t> &variants) override;
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track) override;
private:
diff --git a/src/lib/formats/mfi_dsk.cpp b/src/lib/formats/mfi_dsk.cpp
index 7670bf6bfb9..8272253c36a 100644
--- a/src/lib/formats/mfi_dsk.cpp
+++ b/src/lib/formats/mfi_dsk.cpp
@@ -1,10 +1,12 @@
// license:BSD-3-Clause
// copyright-holders:Olivier Galibert
-#include <cassert>
-
#include "mfi_dsk.h"
+
+#include "ioprocs.h"
+
#include <zlib.h>
+
/*
Mess floppy image structure:
@@ -94,11 +96,12 @@ bool mfi_format::supports_save() const
return true;
}
-int mfi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int mfi_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
header h;
- io_generic_read(io, &h, 0, sizeof(header));
+ size_t actual;
+ io.read_at(0, &h, sizeof(header), actual);
if(memcmp( h.sign, sign, 16 ) == 0 &&
(h.cyl_count & CYLINDER_MASK) <= 84 &&
(h.cyl_count >> RESOLUTION_SHIFT) < 3 &&
@@ -108,15 +111,16 @@ int mfi_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool mfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool mfi_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
header h;
entry entries[84*2*4];
- io_generic_read(io, &h, 0, sizeof(header));
+ io.read_at(0, &h, sizeof(header), actual);
int resolution = h.cyl_count >> RESOLUTION_SHIFT;
h.cyl_count &= CYLINDER_MASK;
- io_generic_read(io, &entries, sizeof(header), (h.cyl_count << resolution)*h.head_count*sizeof(entry));
+ io.read_at(sizeof(header), &entries, (h.cyl_count << resolution)*h.head_count*sizeof(entry), actual);
image->set_form_variant(h.form_factor, h.variant);
@@ -139,7 +143,7 @@ bool mfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
compressed.resize(ent->compressed_size);
- io_generic_read(io, &compressed[0], ent->offset, ent->compressed_size);
+ io.read_at(ent->offset, &compressed[0], ent->compressed_size, actual);
unsigned int cell_count = ent->uncompressed_size/4;
std::vector<uint32_t> &trackbuf = image->get_buffer(cyl >> 2, head, cyl & 3);;
@@ -169,8 +173,9 @@ bool mfi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool mfi_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool mfi_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
int tracks, heads;
image->get_actual_geometry(tracks, heads);
int resolution = image->get_resolution();
@@ -190,7 +195,7 @@ bool mfi_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
h.form_factor = image->get_form_factor();
h.variant = image->get_variant();
- io_generic_write(io, &h, 0, sizeof(header));
+ io.write_at(0, &h, sizeof(header), actual);
memset(entries, 0, sizeof(entries));
@@ -226,11 +231,11 @@ bool mfi_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
entries[epos].write_splice = image->get_write_splice_position(track >> 2, head, track & 3);
epos++;
- io_generic_write(io, postcomp.get(), pos, csize);
+ io.write_at(pos, postcomp.get(), csize, actual);
pos += csize;
}
- io_generic_write(io, entries, sizeof(header), (tracks << resolution)*heads*sizeof(entry));
+ io.write_at(sizeof(header), entries, (tracks << resolution)*heads*sizeof(entry), actual);
return true;
}
diff --git a/src/lib/formats/mfi_dsk.h b/src/lib/formats/mfi_dsk.h
index 129a9ee599e..d0dd36c3d68 100644
--- a/src/lib/formats/mfi_dsk.h
+++ b/src/lib/formats/mfi_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/mfm_hd.cpp b/src/lib/formats/mfm_hd.cpp
index 98d8079443c..738f0999863 100644
--- a/src/lib/formats/mfm_hd.cpp
+++ b/src/lib/formats/mfm_hd.cpp
@@ -294,9 +294,9 @@ int mfmhd_generic_format::chs_to_lba(int cylinder, int head, int sector)
else return -1;
}
-chd_error mfmhd_generic_format::load(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head)
+std::error_condition mfmhd_generic_format::load(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head)
{
- chd_error state = CHDERR_NONE;
+ std::error_condition state;
uint8_t sector_content[16384];
int sectorcount = m_param.sectors_per_track;
@@ -382,8 +382,9 @@ chd_error mfmhd_generic_format::load(chd_file* chdfile, uint16_t* trackimage, in
int lbaposition = chs_to_lba(cylinder, head, sec_number);
if (lbaposition>=0)
{
- chd_error state = chdfile->read_units(lbaposition, sector_content);
- if (state != CHDERR_NONE) break;
+ state = chdfile->read_units(lbaposition, sector_content);
+ if (state)
+ break;
}
else
{
@@ -413,7 +414,7 @@ chd_error mfmhd_generic_format::load(chd_file* chdfile, uint16_t* trackimage, in
if (TRACE_LAYOUT) osd_printf_verbose("\n");
// Gap 4
- if (state == CHDERR_NONE)
+ if (!state)
{
// Fill the rest with 0x4e
mfm_encode(trackimage, position, 0x4e, tracksize-position);
@@ -433,7 +434,7 @@ enum
CHECK_CRC
};
-chd_error mfmhd_generic_format::save(chd_file* chdfile, uint16_t* trackimage, int tracksize, int current_cylinder, int current_head)
+std::error_condition mfmhd_generic_format::save(chd_file* chdfile, uint16_t* trackimage, int tracksize, int current_cylinder, int current_head)
{
if (TRACE_RWTRACK) osd_printf_verbose("%s: write back (c=%d,h=%d) to CHD\n", tag(), current_cylinder, current_head);
@@ -490,7 +491,7 @@ chd_error mfmhd_generic_format::save(chd_file* chdfile, uint16_t* trackimage, in
bool countgap3 = false;
bool countsync = false;
- chd_error chdstate = CHDERR_NONE;
+ std::error_condition chdstate;
if (TRACE_IMAGE)
{
@@ -643,7 +644,7 @@ chd_error mfmhd_generic_format::save(chd_file* chdfile, uint16_t* trackimage, in
if (TRACE_DETAIL) osd_printf_verbose("%s: Writing sector chs=(%d,%d,%d) to CHD\n", tag(), current_cylinder, current_head, sector);
chdstate = chdfile->write_units(chs_to_lba(current_cylinder, current_head, sector), buffer);
- if (chdstate != CHDERR_NONE)
+ if (chdstate)
{
osd_printf_verbose("%s: Write error while writing sector chs=(%d,%d,%d)\n", tag(), cylinder, head, sector);
}
diff --git a/src/lib/formats/mfm_hd.h b/src/lib/formats/mfm_hd.h
index 7d28adc518d..472062d1440 100644
--- a/src/lib/formats/mfm_hd.h
+++ b/src/lib/formats/mfm_hd.h
@@ -151,10 +151,10 @@ public:
virtual ~mfmhd_image_format_t() {};
// Load the image.
- virtual chd_error load(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) = 0;
+ virtual std::error_condition load(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) = 0;
// Save the image.
- virtual chd_error save(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) = 0;
+ virtual std::error_condition save(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) = 0;
// Return the original parameters of the image
mfmhd_layout_params* get_initial_params() { return &m_param_old; }
@@ -196,8 +196,8 @@ class mfmhd_generic_format : public mfmhd_image_format_t
{
public:
mfmhd_generic_format() { m_devtag = std::string("mfmhd_generic_format"); };
- chd_error load(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) override;
- chd_error save(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) override;
+ std::error_condition load(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) override;
+ std::error_condition save(chd_file* chdfile, uint16_t* trackimage, int tracksize, int cylinder, int head) override;
// Yes, we want to save all parameters
virtual bool save_param(mfmhd_param_t type) override { return true; }
diff --git a/src/lib/formats/nfd_dsk.cpp b/src/lib/formats/nfd_dsk.cpp
index 1a0430f9af1..4a51e0db54c 100644
--- a/src/lib/formats/nfd_dsk.cpp
+++ b/src/lib/formats/nfd_dsk.cpp
@@ -77,10 +77,11 @@
*********************************************************************/
- #include <cassert>
-
#include "nfd_dsk.h"
+#include "ioprocs.h"
+
+
nfd_format::nfd_format()
{
}
@@ -100,10 +101,11 @@ const char *nfd_format::extensions() const
return "nfd";
}
-int nfd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int nfd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[16];
- io_generic_read(io, h, 0, 16);
+ size_t actual;
+ io.read_at(0, h, 16, actual);
if (strncmp((const char *)h, "T98FDDIMAGE.R0", 14) == 0 || strncmp((const char *)h, "T98FDDIMAGE.R1", 14) == 0)
return 100;
@@ -111,11 +113,14 @@ int nfd_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool nfd_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
+ size_t actual;
+ uint64_t size;
+ if (io.length(size))
+ return false;
uint8_t h[0x120], hsec[0x10];
- io_generic_read(io, h, 0, 0x120);
+ io.read_at(0, h, 0x120, actual);
int format_version = !strncmp((const char *)h, "T98FDDIMAGE.R0", 14) ? 0 : 1;
// sector map (the 164th entry is only used by rev.1 format, loops with track < 163 are correct for rev.0)
@@ -140,7 +145,7 @@ bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
{
int curr_track_size = 0;
// read sector map absolute location
- io_generic_read(io, hsec, pos, 4);
+ io.read_at(pos, hsec, 4, actual);
pos += 4;
uint32_t secmap_addr = little_endianize_int32(*(uint32_t *)(hsec));
@@ -149,14 +154,14 @@ bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
// read actual sector map for the sectors of this track
// for rev.1 format the first 0x10 are a track summary:
// first WORD is # of sectors, second WORD is # of special data sectors
- io_generic_read(io, hsec, secmap_addr, 0x10);
+ io.read_at(secmap_addr, hsec, 0x10, actual);
secmap_addr += 0x10;
num_secs[track] = little_endianize_int16(*(uint16_t *)(hsec));
num_specials[track] = little_endianize_int16(*(uint16_t *)(hsec + 0x2));
for (int sect = 0; sect < num_secs[track]; sect++)
{
- io_generic_read(io, hsec, secmap_addr, 0x10);
+ io.read_at(secmap_addr, hsec, 0x10, actual);
if (track == 0 && sect == 0)
disk_type = hsec[0xb]; // can this change across the disk? I don't think so...
@@ -175,7 +180,7 @@ bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
{
for (int sect = 0; sect < num_specials[track]; sect++)
{
- io_generic_read(io, hsec, secmap_addr, 0x10);
+ io.read_at(secmap_addr, hsec, 0x10, actual);
secmap_addr += 0x10;
curr_track_size += (hsec[9] + 1) * little_endianize_int32(*(uint32_t *)(hsec + 0x0a));
}
@@ -198,7 +203,7 @@ bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
{
// read sector map for this sector
// for rev.0 format each sector uses 0x10 bytes
- io_generic_read(io, hsec, pos, 0x10);
+ io.read_at(pos, hsec, 0x10, actual);
if (track == 0 && sect == 0)
disk_type = hsec[0xa]; // can this change across the disk? I don't think so...
@@ -245,7 +250,7 @@ bool nfd_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for (int track = 0; track < 163 && pos < size; track++)
{
- io_generic_read(io, sect_data, pos, track_sizes[track]);
+ io.read_at(pos, sect_data, track_sizes[track], actual);
for (int i = 0; i < num_secs[track]; i++)
{
diff --git a/src/lib/formats/nfd_dsk.h b/src/lib/formats/nfd_dsk.h
index 5eb41893c5f..c0030b073a5 100644
--- a/src/lib/formats/nfd_dsk.h
+++ b/src/lib/formats/nfd_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/opd_dsk.cpp b/src/lib/formats/opd_dsk.cpp
index e105d53d678..964b30b75a0 100644
--- a/src/lib/formats/opd_dsk.cpp
+++ b/src/lib/formats/opd_dsk.cpp
@@ -30,12 +30,13 @@ const char *opd_format::extensions() const
return "opd,opu";
}
-int opd_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int opd_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int type = find_size(io, form_factor, variants);
+ int const type = find_size(io, form_factor, variants);
if (type != -1)
return 90;
+
return 0;
}
diff --git a/src/lib/formats/opd_dsk.h b/src/lib/formats/opd_dsk.h
index 9a4205314ec..9236320f154 100644
--- a/src/lib/formats/opd_dsk.h
+++ b/src/lib/formats/opd_dsk.h
@@ -21,7 +21,7 @@ class opd_format : public wd177x_format
public:
opd_format();
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &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;
diff --git a/src/lib/formats/oric_dsk.cpp b/src/lib/formats/oric_dsk.cpp
index 22d70124572..f5b0783a112 100644
--- a/src/lib/formats/oric_dsk.cpp
+++ b/src/lib/formats/oric_dsk.cpp
@@ -8,7 +8,9 @@
*********************************************************************/
-#include "formats/oric_dsk.h"
+#include "oric_dsk.h"
+
+#include "ioprocs.h"
const char *oric_dsk_format::name() const
@@ -31,10 +33,11 @@ bool oric_dsk_format::supports_save() const
return true;
}
-int oric_dsk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int oric_dsk_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[256];
- io_generic_read(io, h, 0, 256);
+ size_t actual;
+ io.read_at(0, h, 256, actual);
if(memcmp(h, "MFM_DISK", 8))
return 0;
@@ -43,27 +46,30 @@ int oric_dsk_format::identify(io_generic *io, uint32_t form_factor, const std::v
int tracks = (h[15] << 24) | (h[14] << 16) | (h[13] << 8) | h[12];
int geom = (h[19] << 24) | (h[18] << 16) | (h[17] << 8) | h[16];
- int size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
if(sides < 0 || sides > 2 || geom != 1 || size != 256+6400*sides*tracks)
return 0;
return 100;
}
-bool oric_dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool oric_dsk_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
uint8_t h[256];
uint8_t t[6250+3];
t[6250] = t[6251] = t[6252] = 0;
- io_generic_read(io, h, 0, 256);
+ io.read_at(0, h, 256, actual);
int sides = (h[11] << 24) | (h[10] << 16) | (h[ 9] << 8) | h[ 8];
int tracks = (h[15] << 24) | (h[14] << 16) | (h[13] << 8) | h[12];
for(int side=0; side<sides; side++)
for(int track=0; track<tracks; track++) {
- io_generic_read(io, t, 256+6400*(tracks*side + track), 6250);
+ io.read_at(256+6400*(tracks*side + track), t, 6250, actual);
std::vector<uint32_t> stream;
int sector_size = 128;
for(int i=0; i<6250; i++) {
@@ -99,8 +105,9 @@ bool oric_dsk_format::load(io_generic *io, uint32_t form_factor, const std::vect
return true;
}
-bool oric_dsk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool oric_dsk_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ // FIXME: surely this should return false, since it does't actually save anything?
return true;
}
@@ -127,28 +134,35 @@ bool oric_jasmin_format::supports_save() const
return true;
}
-int oric_jasmin_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int oric_jasmin_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int size = io_generic_size(io);
- bool can_ds = variants.empty() || has_variant(variants, floppy_image::DSDD);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
+
+ bool const can_ds = variants.empty() || has_variant(variants, floppy_image::DSDD);
if(size == 41*17*256 || (can_ds && size == 41*17*256*2))
return 50;
return 0;
}
-bool oric_jasmin_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool oric_jasmin_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- int size = io_generic_size(io);
- bool can_ds = variants.empty() || has_variant(variants, floppy_image::DSDD);
+ uint64_t size;
+ if(io.length(size))
+ return false;
+
+ bool const can_ds = variants.empty() || has_variant(variants, floppy_image::DSDD);
if(size != 41*17*256 && (!can_ds || size != 41*17*256*2))
return false;
- int heads = size == 41*17*256 ? 1 : 2;
+ int const heads = size == 41*17*256 ? 1 : 2;
std::vector<uint8_t> data(size);
- io_generic_read(io, data.data(), 0, size);
+ size_t actual;
+ io.read_at(0, data.data(), size, actual);
for(int head = 0; head != heads; head++)
for(int track = 0; track != 41; track++) {
@@ -173,7 +187,7 @@ bool oric_jasmin_format::load(io_generic *io, uint32_t form_factor, const std::v
return true;
}
-bool oric_jasmin_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool oric_jasmin_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks, heads;
image->get_actual_geometry(tracks, heads);
@@ -191,8 +205,9 @@ bool oric_jasmin_format::save(io_generic *io, const std::vector<uint32_t> &varia
for(int track = 0; track != 41; track++) {
auto sectors = extract_sectors_from_bitstream_mfm_pc(generate_bitstream_from_track(track, head, 2000, image));
for(unsigned int sector = 0; sector != 17; sector ++) {
- const uint8_t *data = sector+1 < sectors.size() && !sectors[sector+1].empty() ? sectors[sector+1].data() : zero;
- io_generic_write(io, data, 256 * (sector + track*17 + head*17*41), 256);
+ uint8_t const *const data = (sector+1 < sectors.size() && !sectors[sector+1].empty()) ? sectors[sector+1].data() : zero;
+ size_t actual;
+ io.write_at(256 * (sector + track*17 + head*17*41), data, 256, actual);
}
}
return true;
diff --git a/src/lib/formats/oric_dsk.h b/src/lib/formats/oric_dsk.h
index e42b876e52f..6fd1021384b 100644
--- a/src/lib/formats/oric_dsk.h
+++ b/src/lib/formats/oric_dsk.h
@@ -18,9 +18,9 @@ class oric_dsk_format : public floppy_image_format_t
{
public:
oric_dsk_format() = default;
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -35,9 +35,9 @@ class oric_jasmin_format : public floppy_image_format_t
public:
oric_jasmin_format() = default;
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/os9_dsk.cpp b/src/lib/formats/os9_dsk.cpp
index b28e4f8d293..ba1b2427811 100644
--- a/src/lib/formats/os9_dsk.cpp
+++ b/src/lib/formats/os9_dsk.cpp
@@ -48,6 +48,7 @@
#include "imageutl.h"
#include "coretmpl.h" // BIT
+#include "ioprocs.h"
os9_format::os9_format() : wd177x_format(formats)
@@ -69,21 +70,25 @@ const char *os9_format::extensions() const
return "dsk,os9";
}
-int os9_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int os9_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int type = find_size(io, form_factor, variants);
+ int const type = find_size(io, form_factor, variants);
if (type != -1)
return 75;
+
return 0;
}
-int os9_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int os9_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return -1;
uint8_t os9_header[0x60];
- io_generic_read(io, os9_header, 0, sizeof(os9_header));
+ size_t actual;
+ io.read_at(0, os9_header, sizeof(os9_header), actual);
int os9_total_sectors = pick_integer_be(os9_header, 0x00, 3);
int os9_heads = util::BIT(os9_header[0x10], 0) ? 2 : 1;
diff --git a/src/lib/formats/os9_dsk.h b/src/lib/formats/os9_dsk.h
index 57dfbfc9ab5..124c019d155 100644
--- a/src/lib/formats/os9_dsk.h
+++ b/src/lib/formats/os9_dsk.h
@@ -21,8 +21,8 @@ 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, const std::vector<uint32_t> &variants) override;
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track) override;
private:
diff --git a/src/lib/formats/pasti_dsk.cpp b/src/lib/formats/pasti_dsk.cpp
index 0ab6dc2f064..1a418096cd3 100644
--- a/src/lib/formats/pasti_dsk.cpp
+++ b/src/lib/formats/pasti_dsk.cpp
@@ -2,6 +2,8 @@
// copyright-holders:Olivier Galibert
#include "pasti_dsk.h"
+#include "ioprocs.h"
+
// Pasti format supported using the documentation at
// http://www.sarnau.info/atari:pasti_file_format
@@ -36,10 +38,11 @@ bool pasti_format::supports_save() const
return false;
}
-int pasti_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int pasti_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t h[16];
- io_generic_read(io, h, 0, 16);
+ size_t actual;
+ io.read_at(0, h, 16, actual);
if(!memcmp(h, "RSY\0\3\0", 6) &&
(1 || (h[10] >= 80 && h[10] <= 82) || (h[10] >= 160 && h[10] <= 164)))
@@ -58,10 +61,11 @@ static void hexdump(const uint8_t *d, int s)
}
}
-bool pasti_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool pasti_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
uint8_t fh[16];
- io_generic_read(io, fh, 0, 16);
+ io.read_at(0, fh, 16, actual);
std::vector<uint8_t> raw_track;
@@ -76,7 +80,7 @@ bool pasti_format::load(io_generic *io, uint32_t form_factor, const std::vector<
for(int track=0; track < tracks; track++) {
for(int head=0; head < heads; head++) {
uint8_t th[16];
- io_generic_read(io, th, pos, 16);
+ io.read_at(pos, th, 16, actual);
int entry_len = th[0] | (th[1] << 8) | (th[2] << 16) | (th[3] << 24);
int fuzz_len = th[4] | (th[5] << 8) | (th[6] << 16) | (th[7] << 24);
int sect = th[8] | (th[9] << 8);
@@ -87,7 +91,7 @@ bool pasti_format::load(io_generic *io, uint32_t form_factor, const std::vector<
raw_track.resize(entry_len-16);
- io_generic_read(io, &raw_track[0], pos+16, entry_len-16);
+ io.read_at(pos+16, &raw_track[0], entry_len-16, actual);
uint8_t *fuzz = fuzz_len ? &raw_track[16*sect] : nullptr;
uint8_t *bdata = fuzz ? fuzz+fuzz_len : &raw_track[16*sect];
diff --git a/src/lib/formats/pasti_dsk.h b/src/lib/formats/pasti_dsk.h
index b3fc869da4d..2575c12eeb4 100644
--- a/src/lib/formats/pasti_dsk.h
+++ b/src/lib/formats/pasti_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/pc98fdi_dsk.cpp b/src/lib/formats/pc98fdi_dsk.cpp
index 2d503acebe4..61fb8fb8fe3 100644
--- a/src/lib/formats/pc98fdi_dsk.cpp
+++ b/src/lib/formats/pc98fdi_dsk.cpp
@@ -8,9 +8,11 @@
*********************************************************************/
-#include <cassert>
#include "pc98fdi_dsk.h"
+#include "ioprocs.h"
+
+
pc98fdi_format::pc98fdi_format()
{
}
@@ -30,47 +32,53 @@ const char *pc98fdi_format::extensions() const
return "fdi";
}
-int pc98fdi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int pc98fdi_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
- uint8_t h[32];
+ uint64_t size;
+ if(io.length(size))
+ return 0;
- io_generic_read(io, h, 0, 32);
- uint32_t hsize = little_endianize_int32(*(uint32_t *) (h + 0x8));
- uint32_t psize = little_endianize_int32(*(uint32_t *) (h + 0xc));
- uint32_t ssize = little_endianize_int32(*(uint32_t *) (h + 0x10));
- uint32_t scnt = little_endianize_int32(*(uint32_t *) (h + 0x14));
- uint32_t sides = little_endianize_int32(*(uint32_t *) (h + 0x18));
- uint32_t ntrk = little_endianize_int32(*(uint32_t *) (h + 0x1c));
+ uint8_t h[32];
+ size_t actual;
+ io.read_at(0, h, 32, actual);
+
+ uint32_t const hsize = little_endianize_int32(*(uint32_t *) (h + 0x8));
+ uint32_t const psize = little_endianize_int32(*(uint32_t *) (h + 0xc));
+ uint32_t const ssize = little_endianize_int32(*(uint32_t *) (h + 0x10));
+ uint32_t const scnt = little_endianize_int32(*(uint32_t *) (h + 0x14));
+ uint32_t const sides = little_endianize_int32(*(uint32_t *) (h + 0x18));
+ uint32_t const ntrk = little_endianize_int32(*(uint32_t *) (h + 0x1c));
if(size == hsize + psize && psize == ssize*scnt*sides*ntrk)
return 100;
return 0;
}
-bool pc98fdi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool pc98fdi_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint8_t h[32];
+ size_t actual;
- io_generic_read(io, h, 0, 32);
+ uint8_t h[32];
+ io.read_at(0, h, 32, actual);
- uint32_t hsize = little_endianize_int32(*(uint32_t *)(h+0x8));
- uint32_t sector_size = little_endianize_int32(*(uint32_t *)(h+0x10));
- uint32_t sector_count = little_endianize_int32(*(uint32_t *)(h+0x14));
- uint32_t head_count = little_endianize_int32(*(uint32_t *)(h+0x18));
- uint32_t track_count = little_endianize_int32(*(uint32_t *)(h+0x1c));
+ uint32_t const hsize = little_endianize_int32(*(uint32_t *)(h+0x8));
+ uint32_t const sector_size = little_endianize_int32(*(uint32_t *)(h+0x10));
+ uint32_t const sector_count = little_endianize_int32(*(uint32_t *)(h+0x14));
+ uint32_t const head_count = little_endianize_int32(*(uint32_t *)(h+0x18));
+ uint32_t const track_count = little_endianize_int32(*(uint32_t *)(h+0x1c));
- int cell_count = form_factor == floppy_image::FF_35 ? 200000 : 166666;
+ int const cell_count = form_factor == floppy_image::FF_35 ? 200000 : 166666;
- int ssize;
- for(ssize=0; (128 << ssize) < sector_size; ssize++) {};
+ int ssize = 0;
+ while ((128 << ssize) < sector_size)
+ ssize++;
desc_pc_sector sects[256];
uint8_t sect_data[65536];
for(int track=0; track < track_count; track++)
for(int head=0; head < head_count; head++) {
- io_generic_read(io, sect_data, hsize + sector_size*sector_count*(track*head_count + head), sector_size*sector_count);
+ io.read_at(hsize + sector_size*sector_count*(track*head_count + head), sect_data, sector_size*sector_count, actual);
for(int i=0; i<sector_count; i++) {
sects[i].track = track;
diff --git a/src/lib/formats/pc98fdi_dsk.h b/src/lib/formats/pc98fdi_dsk.h
index 1c60f059cbe..1c539f06094 100644
--- a/src/lib/formats/pc98fdi_dsk.h
+++ b/src/lib/formats/pc98fdi_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &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;
diff --git a/src/lib/formats/pc_dsk.cpp b/src/lib/formats/pc_dsk.cpp
index c814afbe6dc..6fe2a82196a 100644
--- a/src/lib/formats/pc_dsk.cpp
+++ b/src/lib/formats/pc_dsk.cpp
@@ -8,10 +8,12 @@
*********************************************************************/
+#include "formats/pc_dsk.h"
+
+#include "ioprocs.h"
+
#include <cstring>
-#include <cassert>
-#include "formats/pc_dsk.h"
pc_format::pc_format() : upd765_format(formats)
{
@@ -32,9 +34,12 @@ const char *pc_format::extensions() const
return "dsk,ima,img,ufi,360";
}
-int pc_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int pc_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size)) {
+ return 0;
+ }
/* some 360K images have a 512-byte header */
if (size == 368640 + 0x200) {
diff --git a/src/lib/formats/pc_dsk.h b/src/lib/formats/pc_dsk.h
index d53879611b9..8c99a35457f 100644
--- a/src/lib/formats/pc_dsk.h
+++ b/src/lib/formats/pc_dsk.h
@@ -20,7 +20,7 @@ class pc_format : public upd765_format
public:
pc_format();
- virtual int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/poly_dsk.cpp b/src/lib/formats/poly_dsk.cpp
index a865729864e..8845643eb72 100644
--- a/src/lib/formats/poly_dsk.cpp
+++ b/src/lib/formats/poly_dsk.cpp
@@ -10,6 +10,9 @@
#include "poly_dsk.h"
+#include "ioprocs.h"
+
+
poly_cpm_format::poly_cpm_format()
{
}
@@ -34,30 +37,35 @@ bool poly_cpm_format::supports_save() const
return true;
}
-int poly_cpm_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int poly_cpm_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint8_t boot[16];
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
// check for valid sizes
if (size == 630784 || size == 622592 || size == 256256)
{
// check for Poly CP/M boot sector
- io_generic_read(io, boot, 0, 16);
+ uint8_t boot[16];
+ size_t actual;
+ io.read_at(0, boot, 16, actual);
if (memcmp(boot, "\x86\xc3\xb7\x00\x00\x8e\x10\xc0\xbf\x00\x01\xbf\xe0\x60\x00\x00", 16) == 0)
{
return 100;
}
}
+
return 0;
}
-bool poly_cpm_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool poly_cpm_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- int total_tracks, spt, bps, head_num;
-
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size) || io.seek(0, SEEK_SET))
+ return false;
+ int total_tracks, spt, bps, head_num;
switch (size)
{
case 622592:
@@ -83,8 +91,7 @@ bool poly_cpm_format::load(io_generic *io, uint32_t form_factor, const std::vect
break;
}
- int cell_count = (form_factor == floppy_image::FF_525) ? 50000 : 100000;
- int offset = 0;
+ int const cell_count = (form_factor == floppy_image::FF_525) ? 50000 : 100000;
for (int track = 0; track < total_tracks; track++)
for (int head = 0; head < head_num; head++)
@@ -105,8 +112,8 @@ bool poly_cpm_format::load(io_generic *io, uint32_t form_factor, const std::vect
sects[i].deleted = false;
sects[i].bad_crc = false;
sects[i].data = &sect_data[sdatapos];
- io_generic_read(io, sects[i].data, offset, bps);
- offset += bps;
+ size_t actual;
+ io.read(sects[i].data, bps, actual);
sdatapos += bps;
}
// gap sizes unverified
diff --git a/src/lib/formats/poly_dsk.h b/src/lib/formats/poly_dsk.h
index 8fd3c9be4a5..8afb6836302 100644
--- a/src/lib/formats/poly_dsk.h
+++ b/src/lib/formats/poly_dsk.h
@@ -20,8 +20,8 @@ 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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
};
diff --git a/src/lib/formats/rx50_dsk.cpp b/src/lib/formats/rx50_dsk.cpp
index d0d8f270c56..f81e2fa5b67 100644
--- a/src/lib/formats/rx50_dsk.cpp
+++ b/src/lib/formats/rx50_dsk.cpp
@@ -29,11 +29,11 @@
FORMAT A: /F:160 on DOS; turn MEDIACHK ON
************************************************************************/
-#include <cassert>
-
-#include "flopimg.h"
#include "formats/rx50_dsk.h"
+#include "ioprocs.h"
+
+
// Controller: WD1793
// TRACK LAYOUT IS UNVERIFED. SEE SOURCES:
// - 'esq_dsk16' (uses WD 1772)
@@ -95,12 +95,17 @@ bool rx50img_format::supports_save() const
return true;
}
-void rx50img_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
+void rx50img_format::find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
{
head_count = 1;
uint32_t expected_size = 0;
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ {
+ track_count = head_count = sector_count = 0;
+ return;
+ }
track_count = 80;
sector_count = 10;
@@ -124,7 +129,7 @@ void rx50img_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &he
track_count = head_count = sector_count = 0;
}
-int rx50img_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int rx50img_format::identify(util::random_read &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);
@@ -135,7 +140,7 @@ int rx50img_format::identify(io_generic *io, uint32_t form_factor, const std::ve
}
// /* Sectors are numbered 1 to 10 */
-bool rx50img_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool rx50img_format::load(util::random_read &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);
@@ -153,7 +158,8 @@ bool rx50img_format::load(io_generic *io, uint32_t form_factor, const std::vecto
int track_size = sector_count*512;
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
- io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.read_at((track*head_count + head)*track_size, sectdata, track_size, actual);
generate_track(rx50_10_desc, track, head, sectors, sector_count, 102064, image); // 98480
}
}
@@ -163,7 +169,7 @@ bool rx50img_format::load(io_generic *io, uint32_t form_factor, const std::vecto
return true;
}
-bool rx50img_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool rx50img_format::save(util::random_read_write &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);
@@ -199,7 +205,8 @@ bool rx50img_format::save(io_generic *io, const std::vector<uint32_t> &variants,
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
get_track_data_mfm_pc(track, head, image, 2000, 512, sector_count, sectdata);
- io_generic_write(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.write_at((track*head_count + head)*track_size, sectdata, track_size, actual);
}
}
return true;
diff --git a/src/lib/formats/rx50_dsk.h b/src/lib/formats/rx50_dsk.h
index 9cac83bd67f..d28ea398d30 100644
--- a/src/lib/formats/rx50_dsk.h
+++ b/src/lib/formats/rx50_dsk.h
@@ -23,9 +23,9 @@ class rx50img_format : public floppy_image_format_t
public:
rx50img_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -35,7 +35,7 @@ public:
static const desc_e rx50_10_desc[];
private:
- void find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
+ void find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
};
extern const floppy_format_type FLOPPY_RX50IMG_FORMAT;
diff --git a/src/lib/formats/sdd_dsk.cpp b/src/lib/formats/sdd_dsk.cpp
index cac33948db0..f3e8df51bda 100644
--- a/src/lib/formats/sdd_dsk.cpp
+++ b/src/lib/formats/sdd_dsk.cpp
@@ -8,10 +8,11 @@
*********************************************************************/
-#include <cassert>
-
#include "formats/sdd_dsk.h"
+#include "ioprocs.h"
+
+
sdd_format::sdd_format() : wd177x_format(formats)
{
}
diff --git a/src/lib/formats/sdf_dsk.cpp b/src/lib/formats/sdf_dsk.cpp
index 223b6dc8d8a..f57540f3c35 100644
--- a/src/lib/formats/sdf_dsk.cpp
+++ b/src/lib/formats/sdf_dsk.cpp
@@ -12,7 +12,9 @@
*********************************************************************/
#include "sdf_dsk.h"
-#include <cassert>
+
+#include "ioprocs.h"
+
sdf_format::sdf_format()
{
@@ -37,18 +39,18 @@ const char *sdf_format::extensions() const
}
-int sdf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int sdf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint8_t header[HEADER_SIZE];
- uint64_t size = io_generic_size(io);
-
- if (size < HEADER_SIZE)
+ uint64_t size;
+ if (io.length(size) || (size < HEADER_SIZE))
{
return 0;
}
- io_generic_read(io, header, 0, HEADER_SIZE);
+ size_t actual;
+ io.read_at(0, header, HEADER_SIZE, actual);
int tracks = header[4];
int heads = header[5];
@@ -74,13 +76,14 @@ int sdf_format::identify(io_generic *io, uint32_t form_factor, const std::vector
}
-bool sdf_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool sdf_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
uint8_t header[HEADER_SIZE];
std::vector<uint8_t> track_data(TOTAL_TRACK_SIZE);
std::vector<uint32_t> raw_track_data;
- io_generic_read(io, header, 0, HEADER_SIZE);
+ io.read_at(0, header, HEADER_SIZE, actual);
const int tracks = header[4];
const int heads = header[5];
@@ -104,7 +107,7 @@ bool sdf_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
raw_track_data.clear();
// Read track
- io_generic_read(io, &track_data[0], HEADER_SIZE + ( heads * track + head ) * TOTAL_TRACK_SIZE, TOTAL_TRACK_SIZE);
+ io.read_at(HEADER_SIZE + (heads * track + head) * TOTAL_TRACK_SIZE, &track_data[0], TOTAL_TRACK_SIZE, actual);
int sector_count = track_data[0];
@@ -181,7 +184,7 @@ bool sdf_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
}
-bool sdf_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool sdf_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/sdf_dsk.h b/src/lib/formats/sdf_dsk.h
index fe3f6eb7a98..b86692f618a 100644
--- a/src/lib/formats/sdf_dsk.h
+++ b/src/lib/formats/sdf_dsk.h
@@ -22,9 +22,9 @@ class sdf_format : public floppy_image_format_t
public:
sdf_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/st_dsk.cpp b/src/lib/formats/st_dsk.cpp
index cb363cbe3e3..d044bc5bdac 100644
--- a/src/lib/formats/st_dsk.cpp
+++ b/src/lib/formats/st_dsk.cpp
@@ -8,10 +8,11 @@
*********************************************************************/
-#include <cassert>
-
#include "formats/st_dsk.h"
+#include "ioprocs.h"
+
+
st_format::st_format()
{
}
@@ -36,18 +37,20 @@ bool st_format::supports_save() const
return true;
}
-void st_format::find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
+void st_format::find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count)
{
- uint64_t size = io_generic_size(io);
- for(track_count=80; track_count <= 82; track_count++)
- for(head_count=1; head_count <= 2; head_count++)
- for(sector_count=9; sector_count <= 11; sector_count++)
- if(size == (uint32_t)512*track_count*head_count*sector_count)
- return;
+ uint64_t size;
+ if(!io.length(size)) {
+ for(track_count=80; track_count <= 82; track_count++)
+ for(head_count=1; head_count <= 2; head_count++)
+ for(sector_count=9; sector_count <= 11; sector_count++)
+ if(size == (uint32_t)512*track_count*head_count*sector_count)
+ return;
+ }
track_count = head_count = sector_count = 0;
}
-int st_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int st_format::identify(util::random_read &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);
@@ -57,7 +60,7 @@ int st_format::identify(io_generic *io, uint32_t form_factor, const std::vector<
return 0;
}
-bool st_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool st_format::load(util::random_read &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);
@@ -73,7 +76,8 @@ bool st_format::load(io_generic *io, uint32_t form_factor, const std::vector<uin
int track_size = sector_count*512;
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
- io_generic_read(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.read_at((track*head_count + head)*track_size, sectdata, track_size, actual);
generate_track(atari_st_fcp_get_desc(track, head, head_count, sector_count),
track, head, sectors, sector_count, 100000, image);
}
@@ -84,7 +88,7 @@ bool st_format::load(io_generic *io, uint32_t form_factor, const std::vector<uin
return true;
}
-bool st_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool st_format::save(util::random_read_write &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);
@@ -109,7 +113,8 @@ bool st_format::save(io_generic *io, const std::vector<uint32_t> &variants, flop
for(int track=0; track < track_count; track++) {
for(int head=0; head < head_count; head++) {
get_track_data_mfm_pc(track, head, image, 2000, 512, sector_count, sectdata);
- io_generic_write(io, sectdata, (track*head_count + head)*track_size, track_size);
+ size_t actual;
+ io.write_at((track*head_count + head)*track_size, sectdata, track_size, actual);
}
}
@@ -141,10 +146,11 @@ bool msa_format::supports_save() const
return true;
}
-void msa_format::read_header(io_generic *io, uint16_t &sign, uint16_t &sect, uint16_t &head, uint16_t &strack, uint16_t &etrack)
+void msa_format::read_header(util::random_read &io, uint16_t &sign, uint16_t &sect, uint16_t &head, uint16_t &strack, uint16_t &etrack)
{
uint8_t h[10];
- io_generic_read(io, h, 0, 10);
+ size_t actual;
+ io.read_at(0, h, 10, actual);
sign = (h[0] << 8) | h[1];
sect = (h[2] << 8) | h[3];
head = (h[4] << 8) | h[5];
@@ -206,7 +212,7 @@ bool msa_format::compress(const uint8_t *buffer, int usize, uint8_t *dest, int &
return dst < usize;
}
-int msa_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int msa_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
uint16_t sign, sect, head, strack, etrack;
read_header(io, sign, sect, head, strack, etrack);
@@ -220,7 +226,7 @@ int msa_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool msa_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool msa_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint16_t sign, sect, heads, strack, etrack;
read_header(io, sign, sect, heads, strack, etrack);
@@ -238,11 +244,12 @@ bool msa_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
for(int track=strack; track <= etrack; track++) {
for(int head=0; head <= heads; head++) {
+ size_t actual;
uint8_t th[2];
- io_generic_read(io, th, pos, 2);
+ io.read_at(pos, th, 2, actual);
pos += 2;
int tsize = (th[0] << 8) | th[1];
- io_generic_read(io, sectdata, pos, tsize);
+ io.read_at(pos, sectdata, tsize, actual);
pos += tsize;
if(tsize < track_size) {
if(!uncompress(sectdata, tsize, track_size))
@@ -258,7 +265,7 @@ bool msa_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
}
-bool msa_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool msa_format::save(util::random_read_write &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);
@@ -289,9 +296,10 @@ bool msa_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
header[8] = 0;
header[9] = track_count-1;
- io_generic_write(io, header, 0, 10);
-
- int pos = 10;
+ if(io.seek(0, SEEK_SET))
+ return false;
+ size_t actual;
+ io.write(header, 10, actual);
uint8_t sectdata[11*512];
uint8_t compdata[11*512];
@@ -305,16 +313,14 @@ bool msa_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
uint8_t th[2];
th[0] = csize >> 8;
th[1] = csize;
- io_generic_write(io, th, pos, 2);
- io_generic_write(io, compdata, pos+2, csize);
- pos += 2+csize;
+ io.write(th, 2, actual);
+ io.write(compdata, csize, actual);
} else {
uint8_t th[2];
th[0] = track_size >> 8;
th[1] = track_size;
- io_generic_write(io, th, pos, 2);
- io_generic_write(io, sectdata, pos+2, track_size);
- pos += 2+track_size;
+ io.write(th, 2, actual);
+ io.write(sectdata, track_size, actual);
}
}
}
diff --git a/src/lib/formats/st_dsk.h b/src/lib/formats/st_dsk.h
index ce501a9f516..34f303bb1ae 100644
--- a/src/lib/formats/st_dsk.h
+++ b/src/lib/formats/st_dsk.h
@@ -19,9 +19,9 @@ class st_format : public floppy_image_format_t
public:
st_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -29,7 +29,7 @@ public:
virtual bool supports_save() const override;
private:
- void find_size(io_generic *io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
+ void find_size(util::random_read &io, uint8_t &track_count, uint8_t &head_count, uint8_t &sector_count);
};
class msa_format : public floppy_image_format_t
@@ -37,9 +37,9 @@ class msa_format : public floppy_image_format_t
public:
msa_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
@@ -49,7 +49,7 @@ public:
private:
bool uncompress(uint8_t *buffer, int csize, int usize);
bool compress(const uint8_t *src, int usize, uint8_t *dest, int &csize);
- void read_header(io_generic *io, uint16_t &sign, uint16_t &sect, uint16_t &head, uint16_t &strack, uint16_t &etrack);
+ void read_header(util::random_read &io, uint16_t &sign, uint16_t &sect, uint16_t &head, uint16_t &strack, uint16_t &etrack);
};
extern const floppy_format_type FLOPPY_ST_FORMAT;
diff --git a/src/lib/formats/svi_dsk.cpp b/src/lib/formats/svi_dsk.cpp
index e3cfa294fcb..0a05bd15c80 100644
--- a/src/lib/formats/svi_dsk.cpp
+++ b/src/lib/formats/svi_dsk.cpp
@@ -10,6 +10,9 @@
#include "svi_dsk.h"
+#include "ioprocs.h"
+
+
svi_format::svi_format()
{
}
@@ -29,9 +32,11 @@ const char *svi_format::extensions() const
return "dsk";
}
-int svi_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int svi_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if (io.length(size))
+ return 0;
if (size == 172032 || size == 346112)
return 50;
@@ -39,11 +44,13 @@ int svi_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool svi_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool svi_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t size = io_generic_size(io);
- int head_count;
+ uint64_t size;
+ if (io.length(size))
+ return false;
+ int head_count;
switch (size)
{
case 172032: head_count = 1; break;
@@ -51,7 +58,8 @@ bool svi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
default: return false;
}
- int file_offset = 0;
+ if (io.seek(0, SEEK_SET))
+ return false;
for (int track = 0; track < 40; track++)
{
@@ -75,10 +83,10 @@ bool svi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
sectors[i].bad_crc = false;
sectors[i].data = &sector_data[sector_offset];
- io_generic_read(io, sectors[i].data, file_offset, sector_size);
+ size_t actual;
+ io.read(sectors[i].data, sector_size, actual);
sector_offset += sector_size;
- file_offset += sector_size;
}
if (track == 0 && head == 0)
@@ -91,9 +99,10 @@ bool svi_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool svi_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool svi_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t file_offset = 0;
+ if (io.seek(0, SEEK_SET))
+ return false;
int track_count, head_count;
image->get_actual_geometry(track_count, head_count);
@@ -104,8 +113,8 @@ bool svi_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
for (int i = 0; i < 18; i++)
{
- io_generic_write(io, sectors[i + 1].data(), file_offset, 128);
- file_offset += 128;
+ size_t actual;
+ io.write(sectors[i + 1].data(), 128, actual);
}
// rest are mfm tracks
@@ -121,8 +130,8 @@ bool svi_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
for (int i = 0; i < 17; i++)
{
- io_generic_write(io, sectors[i + 1].data(), file_offset, 256);
- file_offset += 256;
+ size_t actual;
+ io.write(sectors[i + 1].data(), 256, actual);
}
}
}
diff --git a/src/lib/formats/svi_dsk.h b/src/lib/formats/svi_dsk.h
index 57f4f89ccca..a631bdf498c 100644
--- a/src/lib/formats/svi_dsk.h
+++ b/src/lib/formats/svi_dsk.h
@@ -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, 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
};
diff --git a/src/lib/formats/td0_dsk.cpp b/src/lib/formats/td0_dsk.cpp
index edac0aae010..345a242c86b 100644
--- a/src/lib/formats/td0_dsk.cpp
+++ b/src/lib/formats/td0_dsk.cpp
@@ -16,9 +16,11 @@
#include "flopimg.h"
-#include <cassert>
+#include "ioprocs.h"
+
#include <cstring>
+
#define BUFSZ 512 // new input buffer
/* LZSS Parameters */
@@ -59,7 +61,16 @@ struct tdlzhuf {
struct td0dsk_t
{
- io_generic *floppy_file;
+public:
+ td0dsk_t(util::random_read &f) : floppy_file(f) { }
+
+ void set_floppy_file_offset(uint64_t o) { floppy_file_offset = o; }
+
+ void init_Decode();
+ int Decode(uint8_t *buf, int len);
+
+private:
+ util::random_read &floppy_file;
uint64_t floppy_file_offset;
struct tdlzhuf tdctl;
@@ -87,29 +98,10 @@ struct td0dsk_t
void update(int c);
int16_t DecodeChar();
int16_t DecodePosition();
- void init_Decode();
- int Decode(uint8_t *buf, int len);
};
//static td0dsk_t td0dsk;
-struct floppy_image_legacy
-{
- struct io_generic io;
-
- const struct FloppyFormat *floppy_option;
- struct FloppyCallbacks format;
-
- /* loaded track stuff */
- int loaded_track_head;
- int loaded_track_index;
- uint32_t loaded_track_size;
- void *loaded_track_data;
- uint8_t loaded_track_status;
- uint8_t flags;
-};
-
-
static struct td0dsk_tag *get_tag(floppy_image_legacy *floppy)
{
struct td0dsk_tag *tag;
@@ -332,11 +324,13 @@ static floperr_t td0_get_indexed_sector_info(floppy_image_legacy *floppy, int he
int td0dsk_t::data_read(uint8_t *buf, uint16_t size)
{
- uint64_t image_size = io_generic_size(floppy_file);
+ uint64_t image_size = 0;
+ floppy_file.length(image_size);
if (size > image_size - floppy_file_offset) {
size = image_size - floppy_file_offset;
}
- io_generic_read(floppy_file,buf,floppy_file_offset,size);
+ size_t actual;
+ floppy_file.read_at(floppy_file_offset, buf, size, actual);
floppy_file_offset += size;
return size;
}
@@ -675,7 +669,6 @@ int td0dsk_t::Decode(uint8_t *buf, int len) /* Decoding/Uncompressing */
FLOPPY_CONSTRUCT( td0_dsk_construct )
{
- td0dsk_t state;
struct FloppyCallbacks *callbacks;
struct td0dsk_tag *tag;
uint8_t *header;
@@ -706,9 +699,9 @@ FLOPPY_CONSTRUCT( td0_dsk_construct )
int rd;
int off = 12;
int size = 0;
- state.floppy_file = &(floppy->io);
+ td0dsk_t state(floppy_get_io(floppy));
state.init_Decode();
- state.floppy_file_offset = 12;
+ state.set_floppy_file_offset(12);
do
{
if((rd = state.Decode(obuf, BUFSZ)) > 0) size += rd;
@@ -720,7 +713,7 @@ FLOPPY_CONSTRUCT( td0_dsk_construct )
return FLOPPY_ERROR_OUTOFMEMORY;
}
memcpy(tag->data,obuf,12);
- state.floppy_file_offset = 12;
+ state.set_floppy_file_offset(12);
state.init_Decode();
do
{
@@ -815,20 +808,22 @@ const char *td0_format::extensions() const
return "td0";
}
-int td0_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int td0_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ size_t actual;
uint8_t h[7];
- io_generic_read(io, h, 0, 7);
+ io.read_at(0, h, 7, actual);
if(((h[0] == 'T') && (h[1] == 'D')) || ((h[0] == 't') && (h[1] == 'd')))
{
- return 100;
+ return 100;
}
return 0;
}
-bool td0_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool td0_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
int track_count = 0;
int head_count = 0;
int track_spt;
@@ -837,20 +832,24 @@ bool td0_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
std::vector<uint8_t> imagebuf(max_size);
uint8_t header[12];
- io_generic_read(io, header, 0, 12);
+ io.read_at(0, header, 12, actual);
head_count = header[9];
if(header[0] == 't')
{
- td0dsk_t disk_decode;
+ td0dsk_t disk_decode(io);
- disk_decode.floppy_file = io;
disk_decode.init_Decode();
- disk_decode.floppy_file_offset = 12;
+ disk_decode.set_floppy_file_offset(12);
disk_decode.Decode(&imagebuf[0], max_size);
}
else
- io_generic_read(io, &imagebuf[0], 12, io_generic_size(io));
+ {
+ uint64_t image_size;
+ if(io.length(image_size))
+ return false;
+ io.read_at(12, &imagebuf[0], image_size, actual);
+ }
if(header[7] & 0x80)
offset = 10 + imagebuf[2] + (imagebuf[3] << 8);
@@ -1024,7 +1023,7 @@ bool td0_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
}
-bool td0_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool td0_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
return false;
}
diff --git a/src/lib/formats/td0_dsk.h b/src/lib/formats/td0_dsk.h
index b4656305920..cf625374130 100644
--- a/src/lib/formats/td0_dsk.h
+++ b/src/lib/formats/td0_dsk.h
@@ -13,9 +13,9 @@ class td0_format : public floppy_image_format_t
public:
td0_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/ti99_dsk.cpp b/src/lib/formats/ti99_dsk.cpp
index 06ce98dfda0..507d7dc0ae0 100644
--- a/src/lib/formats/ti99_dsk.cpp
+++ b/src/lib/formats/ti99_dsk.cpp
@@ -43,6 +43,8 @@
#include "ti99_dsk.h"
#include "imageutl.h"
+#include "ioprocs.h"
+
#include "osdcore.h" // osd_printf_* (in osdcore.h)
#include <cstring>
@@ -80,13 +82,16 @@ int ti99_floppy_format::get_encoding(int cell_size)
/*
Load the image from disk and convert it into a sequence of flux levels.
*/
-bool ti99_floppy_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool ti99_floppy_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ uint64_t file_size;
+ if (io.length(file_size))
+ return false;
+
int cell_size = 0;
int sector_count = 0;
int heads = 0;
int log_track_count = 0;
- int file_size = io_generic_size(io);
bool img_high_tpi = false;
bool drive_high_tpi = false;
@@ -211,7 +216,7 @@ bool ti99_floppy_format::load(io_generic *io, uint32_t form_factor, const std::v
/*
Save all tracks to the image file.
*/
-bool ti99_floppy_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool ti99_floppy_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
uint8_t sectordata[9216]; // max size (36*256)
@@ -916,9 +921,12 @@ const char *ti99_sdf_format::extensions() const
return "dsk";
}
-int ti99_sdf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ti99_sdf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t file_size = io_generic_size(io);
+ uint64_t file_size;
+ if (io.length(file_size))
+ return 0;
+
int vote = 0;
// Adding support for another sector image format which adds 768 bytes
@@ -947,7 +955,8 @@ int ti99_sdf_format::identify(io_generic *io, uint32_t form_factor, const std::v
{
// Read first sector (Volume Information Block)
ti99vib vib;
- io_generic_read(io, &vib, 0, sizeof(ti99vib));
+ size_t actual;
+ io.read_at(0, &vib, sizeof(ti99vib), actual);
// Check from contents
if ((vib.id[0]=='D')&&(vib.id[1]=='S')&&(vib.id[2]=='K'))
@@ -964,10 +973,14 @@ int ti99_sdf_format::identify(io_generic *io, uint32_t form_factor, const std::v
return vote;
}
-void ti99_sdf_format::determine_sizes(io_generic *io, int& cell_size, int& sector_count, int& heads, int& tracks)
+void ti99_sdf_format::determine_sizes(util::random_read &io, int& cell_size, int& sector_count, int& heads, int& tracks)
{
- uint64_t file_size = io_generic_size(io);
- ti99vib vib;
+ uint64_t file_size;
+ if (io.length(file_size))
+ {
+ cell_size = sector_count = heads = tracks = 0;
+ return;
+ }
cell_size = 0;
sector_count = 0;
@@ -980,7 +993,9 @@ void ti99_sdf_format::determine_sizes(io_generic *io, int& cell_size, int& secto
file_size -= 768;
// Read first sector
- io_generic_read(io, &vib, 0, sizeof(ti99vib));
+ ti99vib vib;
+ size_t actual;
+ io.read_at(0, &vib, sizeof(ti99vib), actual);
// Check from contents
if ((vib.id[0]=='D')&&(vib.id[1]=='S')&&(vib.id[2]=='K'))
@@ -1059,13 +1074,14 @@ int ti99_sdf_format::get_track_size(int sector_count)
return sector_count * SECTOR_SIZE;
}
-void ti99_sdf_format::load_track(io_generic *io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount)
+void ti99_sdf_format::load_track(util::random_read &io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount)
{
// Calculate the track offset from the beginning of the image file
int logicaltrack = (head==0)? track : (2*trackcount - track - 1);
int position = logicaltrack * get_track_size(sectorcount);
- io_generic_read(io, sectordata, position, sectorcount*SECTOR_SIZE);
+ size_t actual;
+ io.read_at(position, sectordata, sectorcount*SECTOR_SIZE, actual);
// Interleave and skew
int interleave = 7;
@@ -1133,19 +1149,18 @@ std::string ti99_floppy_format::dumpline(uint8_t* line, int address) const
Write the data to the disk. We have a list of sector positions, so we
just need to go through that list and save each sector in the sector data.
*/
-void ti99_sdf_format::write_track(io_generic *io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count)
+void ti99_sdf_format::write_track(util::random_read_write &io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count)
{
- uint8_t* buf;
-
int logicaltrack = head * track_count;
logicaltrack += ((head&1)==0)? track : (track_count - 1 - track);
int trackoffset = logicaltrack * sector_count * SECTOR_SIZE;
for (int i=0; i < sector_count; i++)
{
- buf = sectordata + i * SECTOR_SIZE;
+ uint8_t const *const buf = sectordata + i * SECTOR_SIZE;
LOGMASKED(LOG_DETAIL, "[ti99_dsk] Writing sector %d (offset %06x)\n", sector[i], sector[i] * SECTOR_SIZE);
- io_generic_write(io, buf, trackoffset + sector[i] * SECTOR_SIZE, SECTOR_SIZE);
+ size_t actual;
+ io.write_at(trackoffset + sector[i] * SECTOR_SIZE, buf, SECTOR_SIZE, actual);
}
}
@@ -1209,7 +1224,7 @@ const char *ti99_tdf_format::extensions() const
/*
Determine whether the image file can be interpreted as a track dump
*/
-int ti99_tdf_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int ti99_tdf_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int vote = 0;
uint8_t fulltrack[6872];
@@ -1232,7 +1247,8 @@ int ti99_tdf_format::identify(io_generic *io, uint32_t form_factor, const std::v
LOGMASKED(LOG_INFO, "[ti99_dsk] Image file length matches TDF\n");
// Fetch track 0
- io_generic_read(io, fulltrack, 0, get_track_size(sector_count));
+ size_t actual;
+ io.read_at(0, fulltrack, get_track_size(sector_count), actual);
if (sector_count == 9)
{
@@ -1279,9 +1295,14 @@ int ti99_tdf_format::identify(io_generic *io, uint32_t form_factor, const std::v
Find the proper format for a given image file. Tracks are counted per side.
Note that only two formats are actually compatible with the PC99 emulator.
*/
-void ti99_tdf_format::determine_sizes(io_generic *io, int& cell_size, int& sector_count, int& heads, int& tracks)
+void ti99_tdf_format::determine_sizes(util::random_read &io, int& cell_size, int& sector_count, int& heads, int& tracks)
{
- uint64_t file_size = io_generic_size(io);
+ uint64_t file_size;
+ if (io.length(file_size))
+ {
+ cell_size = sector_count = heads = tracks = 0;
+ return;
+ }
// LOGMASKED(LOG_INFO, "[ti99_dsk] Image size = %ld\n", file_size); // doesn't compile
switch (file_size)
@@ -1336,13 +1357,14 @@ void ti99_tdf_format::determine_sizes(io_generic *io, int& cell_size, int& secto
track from scratch. TDF is not as flexible as it suggests, it does not
allow different gap lengths and so on.
*/
-void ti99_tdf_format::load_track(io_generic *io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount)
+void ti99_tdf_format::load_track(util::random_read &io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount)
{
+ size_t actual;
uint8_t fulltrack[12544]; // space for a full TDF track
// Read beginning of track 0. We need this to get the first gap, according
// to the format
- io_generic_read(io, fulltrack, 0, 100);
+ io.read_at(0, fulltrack, 100, actual);
int offset = 0;
int tracksize = get_track_size(sectorcount);
@@ -1383,7 +1405,7 @@ void ti99_tdf_format::load_track(io_generic *io, uint8_t *sectordata, int *secto
int base = (head * trackcount + track) * tracksize;
int position = 0;
- io_generic_read(io, fulltrack, base, tracksize);
+ io.read_at(base, fulltrack, tracksize, actual);
for (int i=0; i < sectorcount; i++)
{
@@ -1431,7 +1453,7 @@ void ti99_tdf_format::load_track(io_generic *io, uint8_t *sectordata, int *secto
need the sector contents and the sector sequence, which are passed via
sectordata, sector, and sector_count.
*/
-void ti99_tdf_format::write_track(io_generic *io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count)
+void ti99_tdf_format::write_track(util::random_read_write &io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count)
{
uint8_t trackdata[12544];
int offset = ((track_count * head) + track) * get_track_size(sector_count);
@@ -1485,7 +1507,8 @@ void ti99_tdf_format::write_track(io_generic *io, uint8_t *sectordata, int *sect
for (int i=0; i < param[WGAP3]; i++) trackdata[pos++] = param[WGAPBYTE];
}
for (int i=0; i < param[WGAP4]; i++) trackdata[pos++] = param[WGAPBYTE];
- io_generic_write(io, trackdata, offset, get_track_size(sector_count));
+ size_t actual;
+ io.write_at(offset, trackdata, get_track_size(sector_count), actual);
}
int ti99_tdf_format::get_track_size(int sector_count)
diff --git a/src/lib/formats/ti99_dsk.h b/src/lib/formats/ti99_dsk.h
index 5b59b164344..6590d1e7dd2 100644
--- a/src/lib/formats/ti99_dsk.h
+++ b/src/lib/formats/ti99_dsk.h
@@ -23,8 +23,8 @@ class ti99_floppy_format : public floppy_image_format_t
{
public:
bool supports_save() const override { return true; }
- bool load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
- bool save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
protected:
uint8_t get_data_from_encoding(uint16_t raw);
@@ -32,10 +32,10 @@ protected:
virtual int min_heads() =0;
- virtual void determine_sizes(io_generic *io, int& cell_size, int& sector_count, int& heads, int& tracks) =0;
+ virtual void determine_sizes(util::random_read &io, int& cell_size, int& sector_count, int& heads, int& tracks) =0;
virtual int get_track_size(int sector_count) =0;
- virtual void load_track(io_generic *io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount) =0;
- virtual void write_track(io_generic *io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count) =0;
+ virtual void load_track(util::random_read &io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount) =0;
+ virtual void write_track(util::random_read_write &io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count) =0;
int get_encoding(int cell_size);
@@ -53,16 +53,16 @@ protected:
class ti99_sdf_format : public ti99_floppy_format
{
public:
- int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
const char *name() const override;
const char *description() const override;
const char *extensions() const override;
private:
- void determine_sizes(io_generic *io, int& cell_size, int& sector_count, int& heads, int& tracks) override;
+ void determine_sizes(util::random_read &io, int& cell_size, int& sector_count, int& heads, int& tracks) override;
int get_track_size(int sector_count) override;
- void write_track(io_generic *io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count) override;
- void load_track(io_generic *io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sector_count, int track_count) override;
+ void write_track(util::random_read_write &io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count) override;
+ void load_track(util::random_read &io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sector_count, int track_count) override;
// This format supports single-sided images
int min_heads() override { return 1; }
@@ -92,15 +92,15 @@ extern const floppy_format_type FLOPPY_TI99_SDF_FORMAT;
class ti99_tdf_format : public ti99_floppy_format
{
public:
- int identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
const char *name() const override;
const char *description() const override;
const char *extensions() const override;
private:
- void determine_sizes(io_generic *io, int& cell_size, int& sector_count, int& heads, int& tracks) override;
- void load_track(io_generic *io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount) override;
- void write_track(io_generic *io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count) override;
+ void determine_sizes(util::random_read &io, int& cell_size, int& sector_count, int& heads, int& tracks) override;
+ void load_track(util::random_read &io, uint8_t *sectordata, int *sector, int *secoffset, int head, int track, int sectorcount, int trackcount) override;
+ void write_track(util::random_read_write &io, uint8_t *sectordata, int *sector, int track, int head, int sector_count, int track_count) override;
int get_track_size(int sector_count) override;
// This format only supports double-sided images
diff --git a/src/lib/formats/trd_dsk.cpp b/src/lib/formats/trd_dsk.cpp
index 26b6ce5b6a5..4236259cca5 100644
--- a/src/lib/formats/trd_dsk.cpp
+++ b/src/lib/formats/trd_dsk.cpp
@@ -8,10 +8,11 @@
*********************************************************************/
-#include <cassert>
-
#include "formats/trd_dsk.h"
+#include "ioprocs.h"
+
+
trd_format::trd_format() : wd177x_format(formats)
{
}
@@ -31,10 +32,13 @@ const char *trd_format::extensions() const
return "trd";
}
-int trd_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int trd_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ uint64_t size;
+ if (io.length(size))
+ return -1;
+
int index = -1;
- uint64_t size = io_generic_size(io);
for (int i = 0; formats[i].form_factor; i++)
{
const format &f = formats[i];
@@ -47,12 +51,13 @@ int trd_format::find_size(io_generic *io, uint32_t form_factor, const std::vecto
{
index = i; // at least size match, save it for the case if there will be no exact matches
+ size_t actual;
uint8_t sectdata[0x100];
if (f.encoding == floppy_image::MFM)
- io_generic_read(io, sectdata, 0x800, 0x100);
+ io.read_at(0x800, sectdata, 0x100, actual);
else
{
- io_generic_read(io, sectdata, 0x100, 0x100);
+ io.read_at(0x100, sectdata, 0x100, actual);
for (int i = 0; i < 0x100; i++)
sectdata[i] ^= 0xff;
}
diff --git a/src/lib/formats/trd_dsk.h b/src/lib/formats/trd_dsk.h
index 6f19f9976a5..c5a411c60bb 100644
--- a/src/lib/formats/trd_dsk.h
+++ b/src/lib/formats/trd_dsk.h
@@ -24,7 +24,7 @@ public:
private:
static const format formats[];
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
};
extern const floppy_format_type FLOPPY_TRD_FORMAT;
diff --git a/src/lib/formats/trs80_dsk.cpp b/src/lib/formats/trs80_dsk.cpp
index f010a24e570..acd48368239 100644
--- a/src/lib/formats/trs80_dsk.cpp
+++ b/src/lib/formats/trs80_dsk.cpp
@@ -66,6 +66,9 @@ Description of JV3:
#include "trs80_dsk.h"
+#include "ioprocs.h"
+
+
jv1_format::jv1_format() : wd177x_format(formats)
{
}
@@ -132,15 +135,18 @@ const char *jv3_format::extensions() const
return "jv3,dsk";
}
-int jv3_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int jv3_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint32_t image_size = io_generic_size(io);
+ uint64_t image_size;
+ if (io.length(image_size))
+ return 0;
if (image_size < 0x2200)
return 0; // too small, silent return
std::vector<uint8_t> data(image_size);
- io_generic_read(io, data.data(), 0, image_size);
+ size_t actual;
+ io.read_at(0, data.data(), image_size, actual);
const uint32_t entries = 2901;
const uint32_t header_size = entries *3 +1;
@@ -181,20 +187,20 @@ int jv3_format::identify(io_generic *io, uint32_t form_factor, const std::vector
// validate so we don't overrun the array
if (track >= MAX_TRACKS)
{
- printf("jv3_format::identify - track %d exceeds maximum allowed (%d)\n",track,MAX_TRACKS-1);
+ osd_printf_info("jv3_format::identify - track %d exceeds maximum allowed (%d)\n",track,MAX_TRACKS-1);
return 0;
}
if (sector >= MAX_SECTORS)
{
- printf("jv3_format::identify - sector %d exceeds maximum allowed (%d)\n",sector,MAX_SECTORS-1);
+ osd_printf_info("jv3_format::identify - sector %d exceeds maximum allowed (%d)\n",sector,MAX_SECTORS-1);
return 0;
}
// check if sector already exists
if (sector_array[flag_side][track][sector])
{
- printf("jv3_format::identify - side %d track %d sector %d is duplicated\n",flag_side,track,sector);
+ osd_printf_info("jv3_format::identify - side %d track %d sector %d is duplicated\n",flag_side,track,sector);
return 0;
}
@@ -214,21 +220,25 @@ int jv3_format::identify(io_generic *io, uint32_t form_factor, const std::vector
// Is all data in the image? (unused tracks at the end are optional)
if (last_data > image_size)
{
- printf("jv3_format::identify - disk is missing some data. Expected 0x%X, Actual = 0x%X\n",last_data,image_size);
+ osd_printf_info("jv3_format::identify - disk is missing some data. Expected 0x%X, Actual = 0x%X\n",last_data,image_size);
return 0;
}
return 80;
}
-bool jv3_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool jv3_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
// disk has already been validated in every way except if it exceeds drive tracks, we do that below
- printf("Disk detected as JV3\n");fflush(stdout);
+ osd_printf_info("Disk detected as JV3\n");
int drive_tracks, drive_sides;
image->get_maximal_geometry(drive_tracks, drive_sides);
- std::vector<uint8_t> data(io_generic_size(io));
- io_generic_read(io, data.data(), 0, data.size());
+ uint64_t image_size;
+ if (io.length(image_size))
+ return false;
+ std::vector<uint8_t> data(image_size);
+ size_t actual;
+ io.read_at(0, data.data(), data.size(), actual);
const uint32_t entries = 2901;
const uint32_t header_size = entries *3 +1;
bool is_dd = false, is_ds = false;
@@ -313,7 +323,7 @@ bool jv3_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
data_ptr += sector_size;
}
- //printf("Side %d, Track %d, %s density\n",curr_side,curr_track,ddensity ? "Double" : "Single");
+ //osd_printf_verbose("Side %d, Track %d, %s density\n",curr_side,curr_track,ddensity ? "Double" : "Single");
if (ddensity)
{
is_dd = true;
@@ -344,7 +354,7 @@ bool jv3_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool jv3_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool jv3_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int track_count, head_count;
image->get_actual_geometry(track_count, head_count);
@@ -352,10 +362,15 @@ bool jv3_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
if (track_count)
{
// If the disk already exists, find out if it's writable
- std::vector<uint8_t> data(io_generic_size(io));
- io_generic_read(io, data.data(), 0, data.size());
- if ((data.size() >= 0x2200) && (data[0x21ff] == 0))
- return false; // disk is readonly
+ uint64_t image_size;
+ if (!io.length(image_size))
+ {
+ std::vector<uint8_t> data(image_size);
+ size_t actual;
+ io.read_at(0, data.data(), data.size(), actual);
+ if ((data.size() >= 0x2200) && (data[0x21ff] == 0))
+ return false; // disk is readonly
+ }
}
uint32_t data_ptr = 0x2200, sect_ptr = 0;
@@ -396,7 +411,8 @@ bool jv3_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
header[sect_ptr++] = track;
header[sect_ptr++] = i;
header[sect_ptr++] = head ? 0x10 : 0;
- io_generic_write(io, &dummy[0], data_ptr, 256);
+ size_t actual;
+ io.write_at(data_ptr, &dummy[0], 256, actual);
data_ptr += 256;
}
}
@@ -417,14 +433,16 @@ bool jv3_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
flags |= (sectors[i].size() >> 8) ^1;
flags |= head ? 0x10 : 0;
header[sect_ptr++] = flags;
- io_generic_write(io, sectors[i].data(), data_ptr, sectors[i].size());
+ size_t actual;
+ io.write_at(data_ptr, sectors[i].data(), sectors[i].size(), actual);
data_ptr += sectors[i].size();
}
}
}
}
// Save the header
- io_generic_write(io, header, 0, 0x2200);
+ size_t actual;
+ io.write_at(0, header, 0x2200, actual);
return true;
}
diff --git a/src/lib/formats/trs80_dsk.h b/src/lib/formats/trs80_dsk.h
index 60618a93693..31955fe4a5e 100644
--- a/src/lib/formats/trs80_dsk.h
+++ b/src/lib/formats/trs80_dsk.h
@@ -35,9 +35,9 @@ class jv3_format : public floppy_image_format_t
public:
jv3_format();
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual const char *name() const override;
virtual const char *description() const override;
diff --git a/src/lib/formats/uniflex_dsk.cpp b/src/lib/formats/uniflex_dsk.cpp
index fa5d9b50acc..f85da09b75e 100644
--- a/src/lib/formats/uniflex_dsk.cpp
+++ b/src/lib/formats/uniflex_dsk.cpp
@@ -10,7 +10,10 @@
*/
#include "uniflex_dsk.h"
-#include "formats/imageutl.h"
+#include "imageutl.h"
+
+#include "ioprocs.h"
+
uniflex_format::uniflex_format() : wd177x_format(formats)
{
@@ -31,22 +34,26 @@ const char *uniflex_format::extensions() const
return "dsk";
}
-int uniflex_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int uniflex_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int type = find_size(io, form_factor, variants);
+ int const type = find_size(io, form_factor, variants);
if (type != -1)
return 75;
+
return 0;
}
-int uniflex_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int uniflex_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
- uint8_t sir[192];
+ uint64_t size;
+ if (io.length(size))
+ return -1;
// Look at the SIR sector, the second sector.
- io_generic_read(io, sir, 1 * 512, sizeof(sir));
+ uint8_t sir[192];
+ size_t actual;
+ io.read_at(1 * 512, sir, sizeof(sir), actual);
uint16_t fdn_block_count = pick_integer_be(sir, 0x10, 2);
uint32_t last_block_number = pick_integer_be(sir, 0x12, 3);
diff --git a/src/lib/formats/uniflex_dsk.h b/src/lib/formats/uniflex_dsk.h
index fad6741f533..af39a09678e 100644
--- a/src/lib/formats/uniflex_dsk.h
+++ b/src/lib/formats/uniflex_dsk.h
@@ -19,8 +19,8 @@ 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, const std::vector<uint32_t> &variants) override;
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
void build_sector_description(const format &f, uint8_t *sectdata, desc_s *sectors, int track, int head) const override;
private:
diff --git a/src/lib/formats/upd765_dsk.cpp b/src/lib/formats/upd765_dsk.cpp
index e7118dde236..d0afab39352 100644
--- a/src/lib/formats/upd765_dsk.cpp
+++ b/src/lib/formats/upd765_dsk.cpp
@@ -10,14 +10,19 @@
#include "formats/upd765_dsk.h"
+#include "ioprocs.h"
+
upd765_format::upd765_format(const format *_formats) : file_header_skip_bytes(0), file_footer_skip_bytes(0), formats(_formats)
{
}
-int upd765_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) const
+int upd765_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) const
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return -1;
+
for(int i=0; formats[i].form_factor; i++) {
const format &f = formats[i];
if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
@@ -31,7 +36,7 @@ int upd765_format::find_size(io_generic *io, uint32_t form_factor, const std::ve
return -1;
}
-int upd765_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int upd765_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor, variants);
@@ -175,7 +180,7 @@ floppy_image_format_t::desc_e* upd765_format::get_desc_mfm(const format &f, int
return desc;
}
-bool upd765_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool upd765_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
int type = find_size(io, form_factor, variants);
if(type == -1)
@@ -222,7 +227,8 @@ bool upd765_format::load(io_generic *io, uint32_t form_factor, const std::vector
for(int track=0; track < f.track_count; track++)
for(int head=0; head < f.head_count; head++) {
build_sector_description(f, sectdata, sectors, track, head);
- io_generic_read(io, sectdata, file_header_skip_bytes + (track*f.head_count + head)*track_size, track_size);
+ size_t actual;
+ io.read_at(file_header_skip_bytes + (track*f.head_count + head)*track_size, sectdata, track_size, actual);
generate_track(desc, track, head, sectors, f.sector_count, total_size, image);
}
@@ -236,7 +242,7 @@ bool upd765_format::supports_save() const
return true;
}
-bool upd765_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool upd765_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
// Count the number of formats
int formats_count;
@@ -346,7 +352,8 @@ bool upd765_format::save(io_generic *io, const std::vector<uint32_t> &variants,
for(int head=0; head < f.head_count; head++) {
build_sector_description(f, sectdata, sectors, track, head);
extract_sectors(image, f, sectors, track, head);
- io_generic_write(io, sectdata, (track*f.head_count + head)*track_size, track_size);
+ size_t actual;
+ io.write_at((track*f.head_count + head)*track_size, sectdata, track_size, actual);
}
return true;
diff --git a/src/lib/formats/upd765_dsk.h b/src/lib/formats/upd765_dsk.h
index e93a0f24326..48acfc02a88 100644
--- a/src/lib/formats/upd765_dsk.h
+++ b/src/lib/formats/upd765_dsk.h
@@ -39,9 +39,9 @@ public:
// End the array with {}
upd765_format(const format *formats);
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
protected:
@@ -50,7 +50,7 @@ protected:
floppy_image_format_t::desc_e* get_desc_fm(const format &f, int &current_size, int &end_gap_index);
floppy_image_format_t::desc_e* get_desc_mfm(const format &f, int &current_size, int &end_gap_index);
- int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants) const;
+ int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) const;
int compute_track_size(const format &f) const;
virtual void build_sector_description(const format &d, uint8_t *sectdata, desc_s *sectors, int track, int head) const;
void check_compatibility(floppy_image *image, std::vector<int> &candidates);
diff --git a/src/lib/formats/vdk_dsk.cpp b/src/lib/formats/vdk_dsk.cpp
index 57c44f8bb29..759697f852f 100644
--- a/src/lib/formats/vdk_dsk.cpp
+++ b/src/lib/formats/vdk_dsk.cpp
@@ -12,6 +12,9 @@
#include "vdk_dsk.h"
+#include "ioprocs.h"
+
+
vdk_format::vdk_format()
{
}
@@ -31,10 +34,11 @@ const char *vdk_format::extensions() const
return "vdk";
}
-int vdk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int vdk_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
+ size_t actual;
uint8_t id[2];
- io_generic_read(io, id, 0, 2);
+ io.read_at(0, id, 2, actual);
if (id[0] == 'd' && id[1] == 'k')
return 50;
@@ -42,16 +46,21 @@ int vdk_format::identify(io_generic *io, uint32_t form_factor, const std::vector
return 0;
}
-bool vdk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool vdk_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
+ size_t actual;
+ if (io.seek(0, SEEK_SET))
+ return false;
+
uint8_t header[0x100];
- io_generic_read(io, header, 0, 0x100);
+ io.read(header, 0x100, actual);
- int header_size = header[3] * 0x100 + header[2];
- int track_count = header[8];
- int head_count = header[9];
+ int const header_size = header[3] * 0x100 + header[2];
+ int const track_count = header[8];
+ int const head_count = header[9];
- int file_offset = header_size;
+ if (io.seek(header_size, SEEK_SET))
+ return false;
for (int track = 0; track < track_count; track++)
{
@@ -72,10 +81,9 @@ bool vdk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
sectors[i].bad_crc = false;
sectors[i].data = &sector_data[sector_offset];
- io_generic_read(io, sectors[i].data, file_offset, SECTOR_SIZE);
+ io.read(sectors[i].data, SECTOR_SIZE, actual);
sector_offset += SECTOR_SIZE;
- file_offset += SECTOR_SIZE;
}
build_wd_track_mfm(track, head, image, 100000, SECTOR_COUNT, sectors, 22, 32, 24);
@@ -85,9 +93,11 @@ bool vdk_format::load(io_generic *io, uint32_t form_factor, const std::vector<ui
return true;
}
-bool vdk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool vdk_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
- uint64_t file_offset = 0;
+ size_t actual;
+ if (io.seek(0, SEEK_SET))
+ return false;
int track_count, head_count;
image->get_actual_geometry(track_count, head_count);
@@ -108,8 +118,7 @@ bool vdk_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
header[10] = 0;
header[11] = 0;
- io_generic_write(io, header, file_offset, sizeof(header));
- file_offset += sizeof(header);
+ io.write(header, sizeof(header), actual);
// write disk data
for (int track = 0; track < track_count; track++)
@@ -120,10 +129,7 @@ bool vdk_format::save(io_generic *io, const std::vector<uint32_t> &variants, flo
auto sectors = extract_sectors_from_bitstream_mfm_pc(bitstream);
for (int i = 0; i < SECTOR_COUNT; i++)
- {
- io_generic_write(io, sectors[FIRST_SECTOR_ID + i].data(), file_offset, SECTOR_SIZE);
- file_offset += SECTOR_SIZE;
- }
+ io.write(sectors[FIRST_SECTOR_ID + i].data(), SECTOR_SIZE, actual);
}
}
diff --git a/src/lib/formats/vdk_dsk.h b/src/lib/formats/vdk_dsk.h
index 94347b326f6..797d2644972 100644
--- a/src/lib/formats/vdk_dsk.h
+++ b/src/lib/formats/vdk_dsk.h
@@ -25,9 +25,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
private:
diff --git a/src/lib/formats/victor9k_dsk.cpp b/src/lib/formats/victor9k_dsk.cpp
index ace1ec50933..3a142629726 100644
--- a/src/lib/formats/victor9k_dsk.cpp
+++ b/src/lib/formats/victor9k_dsk.cpp
@@ -99,6 +99,8 @@
#include "formats/victor9k_dsk.h"
+#include "ioprocs.h"
+
victor9k_format::victor9k_format()
{
@@ -119,18 +121,22 @@ const char *victor9k_format::extensions() const
return "img";
}
-int victor9k_format::find_size(io_generic *io, uint32_t form_factor)
+int victor9k_format::find_size(util::random_read &io, uint32_t form_factor)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return -1;
+
for(int i=0; formats[i].sector_count; i++) {
const format &f = formats[i];
if(size == (uint32_t) f.sector_count*f.sector_base_size*f.head_count)
return i;
}
+
return -1;
}
-int victor9k_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int victor9k_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
int type = find_size(io, form_factor);
@@ -248,19 +254,24 @@ void victor9k_format::build_sector_description(const format &f, uint8_t *sectdat
}
}
-bool victor9k_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool victor9k_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- int type = find_size(io, form_factor);
+ int const type = find_size(io, form_factor);
if(type == -1)
return false;
const format &f = formats[type];
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
+
std::vector<uint8_t> img;
- img.resize(size);
+ try { img.resize(size); }
+ catch (...) { return false; }
- io_generic_read(io, &img[0], 0, size);
+ size_t actual;
+ io.read_at(0, &img[0], size, actual);
log_boot_sector(&img[0]);
@@ -392,7 +403,7 @@ const int victor9k_format::rpm[9] =
252, 267, 283, 300, 321, 342, 368, 401, 417
};
-bool victor9k_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool victor9k_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
const format &f = formats[0];
@@ -406,7 +417,8 @@ bool victor9k_format::save(io_generic *io, const std::vector<uint32_t> &variants
build_sector_description(f, sectdata, 0, sectors, sector_count);
extract_sectors(image, f, sectors, track, head, sector_count);
- io_generic_write(io, sectdata, offset, track_size);
+ size_t actual;
+ io.write_at(offset, sectdata, track_size, actual);
}
}
diff --git a/src/lib/formats/victor9k_dsk.h b/src/lib/formats/victor9k_dsk.h
index 92d1c664a5f..aafd8fdcb14 100644
--- a/src/lib/formats/victor9k_dsk.h
+++ b/src/lib/formats/victor9k_dsk.h
@@ -34,9 +34,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override { return true; }
static int get_rpm(int head, int track);
@@ -49,7 +49,7 @@ protected:
static const int speed_zone[2][80];
static const int rpm[9];
- int find_size(io_generic *io, uint32_t form_factor);
+ int find_size(util::random_read &io, uint32_t form_factor);
void log_boot_sector(uint8_t *data);
floppy_image_format_t::desc_e* get_sector_desc(const format &f, int &current_size, int sector_count);
void build_sector_description(const format &f, uint8_t *sectdata, uint32_t sect_offs, desc_s *sectors, int sector_count) const;
diff --git a/src/lib/formats/vt_dsk.cpp b/src/lib/formats/vt_dsk.cpp
index d6cc3da4521..15c6955bfcc 100644
--- a/src/lib/formats/vt_dsk.cpp
+++ b/src/lib/formats/vt_dsk.cpp
@@ -10,6 +10,9 @@
#include "formats/vt_dsk.h"
+#include "ioprocs.h"
+
+
// Zero = | 9187 |
// One = | 2237 | 6950 |
// 0.5us ~= 143
@@ -213,9 +216,11 @@ const char *vtech_dsk_format::extensions() const
return "dsk";
}
-int vtech_bin_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int vtech_bin_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
if(size == 40*16*256)
return 50;
@@ -223,14 +228,18 @@ int vtech_bin_format::identify(io_generic *io, uint32_t form_factor, const std::
return 0;
}
-int vtech_dsk_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int vtech_dsk_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return 0;
+
if(size < 256)
return 0;
std::vector<uint8_t> bdata(size);
- io_generic_read(io, bdata.data(), 0, size);
+ size_t actual;
+ io.read_at(0, bdata.data(), size, actual);
// Structurally validate the presence of sector headers and data
int count_sh = 0, count_sd = 0;
@@ -246,25 +255,29 @@ int vtech_dsk_format::identify(io_generic *io, uint32_t form_factor, const std::
return count_sh >= 30*16 && count_sd >= 30*16 ? 100 : 0;
}
-bool vtech_bin_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool vtech_bin_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- int size = io_generic_size(io);
- if(size != 40*16*256)
+ uint64_t size;
+ if(io.length(size) || (size != 40*16*256))
return false;
std::vector<uint8_t> bdata(size);
- io_generic_read(io, bdata.data(), 0, size);
+ size_t actual;
+ io.read_at(0, bdata.data(), size, actual);
image_to_flux(bdata, image);
image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD);
return true;
}
-bool vtech_dsk_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool vtech_dsk_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- int size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return false;
std::vector<uint8_t> bdata(size);
- io_generic_read(io, bdata.data(), 0, size);
+ size_t actual;
+ io.read_at(0, bdata.data(), size, actual);
std::vector<uint8_t> bdatax(128*16*40, 0);
@@ -327,7 +340,7 @@ bool vtech_dsk_format::load(io_generic *io, uint32_t form_factor, const std::vec
return true;
}
-bool vtech_bin_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool vtech_bin_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks, heads;
image->get_maximal_geometry(tracks, heads);
@@ -335,11 +348,12 @@ bool vtech_bin_format::save(io_generic *io, const std::vector<uint32_t> &variant
return false;
auto bdata = flux_to_image(image);
- io_generic_write(io, bdata.data(), 0, bdata.size());
+ size_t actual;
+ io.write_at(0, bdata.data(), bdata.size(), actual);
return true;
}
-bool vtech_dsk_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool vtech_dsk_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
int tracks, heads;
image->get_maximal_geometry(tracks, heads);
@@ -387,7 +401,8 @@ bool vtech_dsk_format::save(io_generic *io, const std::vector<uint32_t> &variant
}
}
- io_generic_write(io, bdatax.data(), 0, bdatax.size());
+ size_t actual;
+ io.write_at(0, bdatax.data(), bdatax.size(), actual);
return true;
}
diff --git a/src/lib/formats/vt_dsk.h b/src/lib/formats/vt_dsk.h
index 739e5234a3f..4bc46871e7e 100644
--- a/src/lib/formats/vt_dsk.h
+++ b/src/lib/formats/vt_dsk.h
@@ -34,9 +34,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
};
class vtech_dsk_format : public vtech_common_format {
@@ -47,9 +47,9 @@ public:
virtual const char *description() const override;
virtual const char *extensions() const 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
};
extern const floppy_format_type FLOPPY_VTECH_BIN_FORMAT;
diff --git a/src/lib/formats/wd177x_dsk.cpp b/src/lib/formats/wd177x_dsk.cpp
index 22309f32a12..da900b03db5 100644
--- a/src/lib/formats/wd177x_dsk.cpp
+++ b/src/lib/formats/wd177x_dsk.cpp
@@ -10,6 +10,8 @@
#include "formats/wd177x_dsk.h"
+#include "ioprocs.h"
+
wd177x_format::wd177x_format(const format *_formats)
{
@@ -29,9 +31,12 @@ const wd177x_format::format &wd177x_format::get_track_format(const format &f, in
/*
Default implementation for find_size. May be overwritten by subclasses.
*/
-int wd177x_format::find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int wd177x_format::find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- uint64_t size = io_generic_size(io);
+ uint64_t size;
+ if(io.length(size))
+ return -1;
+
for(int i=0; formats[i].form_factor; i++) {
const format &f = formats[i];
if(form_factor != floppy_image::FF_UNKNOWN && form_factor != f.form_factor)
@@ -49,15 +54,17 @@ int wd177x_format::find_size(io_generic *io, uint32_t form_factor, const std::ve
if(size == format_size)
return i;
}
+
return -1;
}
-int wd177x_format::identify(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants)
+int wd177x_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants)
{
- int type = find_size(io, form_factor, variants);
+ int const type = find_size(io, form_factor, variants);
if(type != -1)
return 50;
+
return 0;
}
@@ -197,9 +204,9 @@ floppy_image_format_t::desc_e* wd177x_format::get_desc_mfm(const format &f, int
return desc;
}
-bool wd177x_format::load(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
+bool wd177x_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image)
{
- int type = find_size(io, form_factor, variants);
+ int const type = find_size(io, form_factor, variants);
if(type == -1)
return false;
@@ -251,7 +258,8 @@ bool wd177x_format::load(io_generic *io, uint32_t form_factor, const std::vector
build_sector_description(tf, sectdata, sectors, track, head);
int track_size = compute_track_size(tf);
- io_generic_read(io, sectdata, get_image_offset(f, head, track), track_size);
+ size_t actual;
+ io.read_at(get_image_offset(f, head, track), sectdata, track_size, actual);
generate_track(desc, track, head, sectors, tf.sector_count, total_size, image);
}
@@ -265,7 +273,7 @@ bool wd177x_format::supports_save() const
return true;
}
-bool wd177x_format::save(io_generic *io, const std::vector<uint32_t> &variants, floppy_image *image)
+bool wd177x_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image)
{
// Count the number of formats
int formats_count;
@@ -377,7 +385,8 @@ bool wd177x_format::save(io_generic *io, const std::vector<uint32_t> &variants,
build_sector_description(tf, sectdata, sectors, track, head);
extract_sectors(image, tf, sectors, track, head);
int track_size = compute_track_size(tf);
- io_generic_write(io, sectdata, get_image_offset(f, head, track), track_size);
+ size_t actual;
+ io.write_at(get_image_offset(f, head, track), sectdata, track_size, actual);
}
}
diff --git a/src/lib/formats/wd177x_dsk.h b/src/lib/formats/wd177x_dsk.h
index 4cae9ffa754..a7bd92994e6 100644
--- a/src/lib/formats/wd177x_dsk.h
+++ b/src/lib/formats/wd177x_dsk.h
@@ -38,9 +38,9 @@ public:
// End the array with {}
wd177x_format(const format *formats);
- 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 int identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) override;
+ virtual bool load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image *image) override;
+ virtual bool save(util::random_read_write &io, const std::vector<uint32_t> &variants, floppy_image *image) override;
virtual bool supports_save() const override;
protected:
@@ -51,7 +51,7 @@ protected:
virtual const wd177x_format::format &get_track_format(const format &f, int head, int track);
virtual floppy_image_format_t::desc_e* get_desc_fm(const format &f, int &current_size, int &end_gap_index);
virtual floppy_image_format_t::desc_e* get_desc_mfm(const format &f, int &current_size, int &end_gap_index);
- virtual int find_size(io_generic *io, uint32_t form_factor, const std::vector<uint32_t> &variants);
+ virtual int find_size(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants);
virtual int get_image_offset(const format &f, int head, int track);
virtual int get_track_dam_fm(const format &f, int head, int track);
virtual int get_track_dam_mfm(const format &f, int head, int track);