summaryrefslogtreecommitdiffstatshomepage
path: root/src/lib/formats/upd765_dsk.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/formats/upd765_dsk.cpp')
-rw-r--r--src/lib/formats/upd765_dsk.cpp106
1 files changed, 55 insertions, 51 deletions
diff --git a/src/lib/formats/upd765_dsk.cpp b/src/lib/formats/upd765_dsk.cpp
index 4265aea6a36..589ab1e1666 100644
--- a/src/lib/formats/upd765_dsk.cpp
+++ b/src/lib/formats/upd765_dsk.cpp
@@ -2,7 +2,7 @@
// copyright-holders:Olivier Galibert
/*********************************************************************
- formats/upd765_dsk.h
+ formats/upd765_dsk.cpp
helper for simple upd765-formatted disk images
@@ -10,31 +10,42 @@
#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)
+#include "osdcore.h" // osd_printf_*
+
+#include <cstring>
+
+
+upd765_format::upd765_format(const format *_formats) : formats(_formats)
{
}
-int upd765_format::find_size(io_generic *io, uint32_t form_factor) 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)
continue;
+ if(!variants.empty() && !has_variant(variants, f.variant))
+ continue;
- if(size == file_header_skip_bytes + (uint64_t) compute_track_size(f) * f.track_count * f.head_count + file_footer_skip_bytes)
+ if(size == compute_track_size(f) * f.track_count * f.head_count)
return i;
}
return -1;
}
-int upd765_format::identify(io_generic *io, uint32_t form_factor)
+int upd765_format::identify(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants) const
{
- int type = find_size(io, form_factor);
+ int type = find_size(io, form_factor, variants);
if(type != -1)
- return 50;
+ return FIFID_SIZE;
return 0;
}
@@ -74,7 +85,7 @@ void upd765_format::build_sector_description(const format &f, uint8_t *sectdata,
}
}
-floppy_image_format_t::desc_e* upd765_format::get_desc_fm(const format &f, int &current_size, int &end_gap_index)
+floppy_image_format_t::desc_e* upd765_format::get_desc_fm(const format &f, int &current_size, int &end_gap_index) const
{
static floppy_image_format_t::desc_e desc[26] = {
/* 00 */ { FM, 0xff, f.gap_4a },
@@ -119,7 +130,7 @@ floppy_image_format_t::desc_e* upd765_format::get_desc_fm(const format &f, int &
return desc;
}
-floppy_image_format_t::desc_e* upd765_format::get_desc_mfm(const format &f, int &current_size, int &end_gap_index)
+floppy_image_format_t::desc_e* upd765_format::get_desc_mfm(const format &f, int &current_size, int &end_gap_index) const
{
static floppy_image_format_t::desc_e desc[29] = {
/* 00 */ { MFM, 0x4e, 0 },
@@ -173,16 +184,16 @@ 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, floppy_image *image)
+bool upd765_format::load(util::random_read &io, uint32_t form_factor, const std::vector<uint32_t> &variants, floppy_image &image) const
{
- int type = find_size(io, form_factor);
+ int type = find_size(io, form_factor, variants);
if(type == -1)
return false;
// format shouldn't exceed image geometry
const format &f = formats[type];
int img_tracks, img_heads;
- image->get_maximal_geometry(img_tracks, img_heads);
+ image.get_maximal_geometry(img_tracks, img_heads);
if (f.track_count > img_tracks || f.head_count > img_heads)
return false;
@@ -220,21 +231,21 @@ bool upd765_format::load(io_generic *io, uint32_t form_factor, floppy_image *ima
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);
+ /*auto const [err, actual] =*/ read_at(io, (track*f.head_count + head)*track_size, sectdata, track_size); // FIXME: check for errors and premature EOF
generate_track(desc, track, head, sectors, f.sector_count, total_size, image);
}
- image->set_variant(f.variant);
+ image.set_form_variant(f.form_factor, f.variant);
return true;
}
-bool upd765_format::supports_save() const
+bool upd765_format::supports_save() const noexcept
{
return true;
}
-bool upd765_format::save(io_generic *io, floppy_image *image)
+bool upd765_format::save(util::random_read_write &io, const std::vector<uint32_t> &variants, const floppy_image &image) const
{
// Count the number of formats
int formats_count;
@@ -254,8 +265,8 @@ bool upd765_format::save(io_generic *io, floppy_image *image)
int cur_cell_size = 0;
candidates.clear();
for(int i=0; i != formats_count; i++) {
- if(image->get_form_factor() == floppy_image::FF_UNKNOWN ||
- image->get_form_factor() == formats[i].form_factor) {
+ if(image.get_form_factor() == floppy_image::FF_UNKNOWN ||
+ image.get_form_factor() == formats[i].form_factor) {
if(formats[i].cell_size == cur_cell_size)
candidates.push_back(i);
else if((!cur_cell_size || formats[i].cell_size < cur_cell_size) &&
@@ -292,7 +303,7 @@ bool upd765_format::save(io_generic *io, floppy_image *image)
// Otherwise, find the best
int tracks, heads;
- image->get_actual_geometry(tracks, heads);
+ image.get_actual_geometry(tracks, heads);
chosen_candidate = candidates[0];
for(unsigned int i=1; i != candidates.size(); i++) {
const format &cc = formats[chosen_candidate];
@@ -333,40 +344,36 @@ bool upd765_format::save(io_generic *io, floppy_image *image)
if(chosen_candidate == -1)
chosen_candidate = 0;
-
const format &f = formats[chosen_candidate];
int track_size = compute_track_size(f);
uint8_t sectdata[40*512];
desc_s sectors[40];
- for(int track=0; track < f.track_count; track++)
+ 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);
extract_sectors(image, f, sectors, track, head);
- io_generic_write(io, sectdata, (track*f.head_count + head)*track_size, track_size);
+ /*auto const [err, actual] =*/ write_at(io, (track*f.head_count + head)*track_size, sectdata, track_size); // FIXME: check for errors
}
+ }
return true;
}
-void upd765_format::check_compatibility(floppy_image *image, std::vector<int> &candidates)
+void upd765_format::check_compatibility(const floppy_image &image, std::vector<int> &candidates) const
{
- uint8_t bitstream[500000/8];
- uint8_t sectdata[50000];
- desc_xs sectors[256];
- int track_size;
-
// Extract the sectors
- generate_bitstream_from_track(0, 0, formats[candidates[0]].cell_size, bitstream, track_size, image);
+ auto bitstream = generate_bitstream_from_track(0, 0, formats[candidates[0]].cell_size, image);
+ std::vector<std::vector<uint8_t>> sectors;
switch (formats[candidates[0]].encoding)
{
case floppy_image::FM:
- extract_sectors_from_bitstream_fm_pc(bitstream, track_size, sectors, sectdata, sizeof(sectdata));
+ sectors = extract_sectors_from_bitstream_fm_pc(bitstream);
break;
case floppy_image::MFM:
- extract_sectors_from_bitstream_mfm_pc(bitstream, track_size, sectors, sectdata, sizeof(sectdata));
+ sectors = extract_sectors_from_bitstream_mfm_pc(bitstream);
break;
}
@@ -375,8 +382,8 @@ void upd765_format::check_compatibility(floppy_image *image, std::vector<int> &c
for(unsigned int i=0; i != candidates.size(); i++) {
const format &f = formats[candidates[i]];
int ns = 0;
- for(int j=0; j<256; j++)
- if(sectors[j].data) {
+ for(unsigned int j=0; j != sectors.size(); j++)
+ if(!sectors[j].empty()) {
int sid;
if(f.sector_base_id == -1) {
for(sid=0; sid < f.sector_count; sid++)
@@ -387,10 +394,10 @@ void upd765_format::check_compatibility(floppy_image *image, std::vector<int> &c
if(sid < 0 || sid > f.sector_count)
goto fail;
if(f.sector_base_size) {
- if(sectors[j].size != f.sector_base_size)
+ if(sectors[j].size() != f.sector_base_size)
goto fail;
} else {
- if(sectors[j].size != f.per_sector_size[sid])
+ if(sectors[j].size() != f.per_sector_size[sid])
goto fail;
}
ns++;
@@ -404,35 +411,32 @@ void upd765_format::check_compatibility(floppy_image *image, std::vector<int> &c
}
-void upd765_format::extract_sectors(floppy_image *image, const format &f, desc_s *sdesc, int track, int head)
+void upd765_format::extract_sectors(const floppy_image &image, const format &f, desc_s *sdesc, int track, int head) const
{
- uint8_t bitstream[500000/8];
- uint8_t sectdata[50000];
- desc_xs sectors[256];
- int track_size;
-
// Extract the sectors
- generate_bitstream_from_track(track, head, f.cell_size, bitstream, track_size, image);
+ auto bitstream = generate_bitstream_from_track(track, head, f.cell_size, image);
+ std::vector<std::vector<uint8_t>> sectors;
switch (f.encoding)
{
case floppy_image::FM:
- extract_sectors_from_bitstream_fm_pc(bitstream, track_size, sectors, sectdata, sizeof(sectdata));
+ sectors = extract_sectors_from_bitstream_fm_pc(bitstream);
break;
case floppy_image::MFM:
- extract_sectors_from_bitstream_mfm_pc(bitstream, track_size, sectors, sectdata, sizeof(sectdata));
+ sectors = extract_sectors_from_bitstream_mfm_pc(bitstream);
break;
}
for(int i=0; i<f.sector_count; i++) {
desc_s &ds = sdesc[i];
- desc_xs &xs = sectors[ds.sector_id];
- if(!xs.data)
+ if(ds.sector_id >= sectors.size() || sectors[ds.sector_id].empty())
memset((void *)ds.data, 0, ds.size);
- else if(xs.size < ds.size) {
- memcpy((void *)ds.data, xs.data, xs.size);
- memset((uint8_t *)ds.data + xs.size, 0, xs.size - ds.size);
+
+ else if(sectors[ds.sector_id].size() < ds.size) {
+ memcpy((void *)ds.data, sectors[ds.sector_id].data(), sectors[ds.sector_id].size());
+ memset((uint8_t *)ds.data + sectors[ds.sector_id].size(), 0, ds.size - sectors[ds.sector_id].size());
+
} else
- memcpy((void *)ds.data, xs.data, ds.size);
+ memcpy((void *)ds.data, sectors[ds.sector_id].data(), ds.size);
}
}