mirror/86Box
1
0
Fork 0
mirror of https://github.com/86Box/86Box.git synced 2026-02-23 01:48:21 -07:00
Code Issues Packages Projects Releases Activity

More sonarlint work

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-06-09 23:46:54 -04:00
parent 0d1d069af4
commit ee695e71f9
218 changed files with 6282 additions and 3845 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/floppy/fdc.c
View File

@@ -916,7 +916,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_bad_command(fdc);
break;
}
/*FALLTHROUGH*/
[[fallthrough]];
case 0x07: /*Recalibrate*/
fdc->pnum = 0;
fdc->ptot = 1;
@@ -959,7 +959,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
fdc_bad_command(fdc);
break;
}
/*FALLTHROUGH*/
[[fallthrough]];
case 0x10: /*Get version*/
case 0x14: /*Unlock*/
case 0x94: /*Lock*/
@@ -1081,7 +1081,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
case 0x16: /* Verify */
if (fdc->params[0] & 0x80)
fdc->sc = fdc->params[7];
/*FALLTHROUGH*/
[[fallthrough]];
case 0x06: /* Read data */
case 0x0c: /* Read deleted data */
fdc_io_command_phase1(fdc, 0);

5
src/floppy/fdd.c
View File

@@ -64,7 +64,7 @@
#define FLAG_IGNORE_DENSEL 512
#define FLAG_PS2 1024
typedef struct {
typedef struct fdd_t {
int type;
int track;
int densel;
@@ -586,6 +586,9 @@ fdd_get_bitcell_period(int rate)
case 3: /*Extended density*/
bit_rate = 1000;
break;
default:
break;
}
return 1000000 / bit_rate * 2; /*Bitcell period in ns*/

188
src/floppy/fdd_86f.c
View File

@@ -180,7 +180,7 @@ typedef struct sector_t {
* specifies the entire bitcell count
*/
typedef struct d86f_t {
FILE *f;
FILE *fp;
uint8_t state;
uint8_t fill;
uint8_t sector_count;
@@ -1659,7 +1659,7 @@ d86f_write_sector_data(int drive, int side, int mfm, uint16_t am)
d86f_handler[drive].write_data(drive, side, dev->data_find.bytes_obtained - 1, dev->current_byte[side]);
} else {
/* We're in the data field of the sector, use a CRC byte. */
dev->current_byte[side] = dev->calc_crc.bytes[(dev->data_find.bytes_obtained & 1)];
dev->current_byte[side] = dev->calc_crc.bytes[dev->data_find.bytes_obtained & 1];
}
dev->current_bit[side] = (15 - (dev->data_find.bits_obtained & 15)) >> 1;
@@ -1951,7 +1951,7 @@ d86f_format_track(int drive, int side, int do_write)
if (dev->datac == 3)
fdc_stop_id_request(d86f_fdc);
}
/*FALLTHROUGH*/
[[fallthrough]];
case FMT_PRETRK_SYNC:
case FMT_SECTOR_DATA_SYNC:
@@ -2294,7 +2294,7 @@ d86f_turbo_poll(int drive, int side)
case STATE_0D_SPIN_TO_INDEX:
dev->sector_count = 0;
dev->datac = 5;
/*FALLTHROUGH*/
[[fallthrough]];
case STATE_02_SPIN_TO_INDEX:
dev->state++;
@@ -2339,7 +2339,7 @@ d86f_turbo_poll(int drive, int side)
dev->last_sector.id.r = dev->req_sector.id.r;
dev->last_sector.id.n = dev->req_sector.id.n;
d86f_handler[drive].set_sector(drive, side, dev->last_sector.id.c, dev->last_sector.id.h, dev->last_sector.id.r, dev->last_sector.id.n);
/*FALLTHROUGH*/
[[fallthrough]];
case STATE_0A_FIND_ID:
dev->turbo_pos = 0;
@@ -2905,12 +2905,12 @@ d86f_read_track(int drive, int track, int thin_track, int side, uint16_t *da, ui
if (dev->track_offset[logical_track]) {
if (!thin_track) {
if (fseek(dev->f, dev->track_offset[logical_track], SEEK_SET) == -1)
if (fseek(dev->fp, dev->track_offset[logical_track], SEEK_SET) == -1)
fatal("d86f_read_track(): Error seeking to offset dev->track_offset[logical_track]\n");
if (fread(&(dev->side_flags[side]), 1, 2, dev->f) != 2)
if (fread(&(dev->side_flags[side]), 1, 2, dev->fp) != 2)
fatal("d86f_read_track(): Error reading side flags\n");
if (d86f_has_extra_bit_cells(drive)) {
if (fread(&(dev->extra_bit_cells[side]), 1, 4, dev->f) != 4)
if (fread(&(dev->extra_bit_cells[side]), 1, 4, dev->fp) != 4)
fatal("d86f_read_track(): Error reading number of extra bit cells\n");
/* If RPM shift is 0% and direction is 1, do not adjust extra bit cells,
as that is the whole track length. */
@@ -2922,13 +2922,13 @@ d86f_read_track(int drive, int track, int thin_track, int side, uint16_t *da, ui
}
} else
dev->extra_bit_cells[side] = 0;
(void) !fread(&(dev->index_hole_pos[side]), 4, 1, dev->f);
(void) !fread(&(dev->index_hole_pos[side]), 4, 1, dev->fp);
} else
fseek(dev->f, dev->track_offset[logical_track] + d86f_track_header_size(drive), SEEK_SET);
fseek(dev->fp, dev->track_offset[logical_track] + d86f_track_header_size(drive), SEEK_SET);
array_size = d86f_get_array_size(drive, side, 0);
(void) !fread(da, 1, array_size, dev->f);
(void) !fread(da, 1, array_size, dev->fp);
if (d86f_has_surface_desc(drive))
(void) !fread(sa, 1, array_size, dev->f);
(void) !fread(sa, 1, array_size, dev->fp);
} else {
if (!thin_track) {
switch ((dev->disk_flags >> 1) & 3) {
@@ -3125,22 +3125,22 @@ d86f_writeback(int drive)
#endif
header_size = d86f_header_size(drive);
if (!dev->f)
if (!dev->fp)
return;
/* First write the track offsets table. */
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("86F write_back(): Error seeking to the beginning of the file\n");
if (fread(header, 1, header_size, dev->f) != header_size)
if (fread(header, 1, header_size, dev->fp) != header_size)
fatal("86F write_back(): Error reading header size\n");
if (fseek(dev->f, 8, SEEK_SET) == -1)
if (fseek(dev->fp, 8, SEEK_SET) == -1)
fatal("86F write_back(): Error seeking\n");
size = d86f_get_track_table_size(drive);
if (fwrite(dev->track_offset, 1, size, dev->f) != size)
if (fwrite(dev->track_offset, 1, size, dev->fp) != size)
fatal("86F write_back(): Error writing data\n");
d86f_write_tracks(drive, &dev->f, NULL);
d86f_write_tracks(drive, &dev->fp, NULL);
#ifdef D86F_COMPRESS
if (dev->is_compressed) {
@@ -3152,16 +3152,16 @@ d86f_writeback(int drive)
/* Write the header to the original file. */
fwrite(header, 1, header_size, cf);
fseek(dev->f, 0, SEEK_END);
len = ftell(dev->f);
fseek(dev->fp, 0, SEEK_END);
len = ftell(dev->fp);
len -= header_size;
fseek(dev->f, header_size, SEEK_SET);
fseek(dev->fp, header_size, SEEK_SET);
/* Compress data from the temporary uncompressed file to the original, compressed file. */
dev->filebuf = (uint8_t *) malloc(len);
dev->outbuf = (uint8_t *) malloc(len - 1);
fread(dev->filebuf, 1, len, dev->f);
fread(dev->filebuf, 1, len, dev->fp);
ret = lzf_compress(dev->filebuf, len, dev->outbuf, len - 1);
if (!ret)
@@ -3421,7 +3421,7 @@ d86f_export(int drive, char *fn)
uint32_t tt[512];
d86f_t *dev = d86f[drive];
d86f_t *temp86;
FILE *f;
FILE *fp;
int tracks = 86;
int inc = 1;
uint32_t magic = 0x46423638;
@@ -3430,19 +3430,19 @@ d86f_export(int drive, char *fn)
memset(tt, 0, 512 * sizeof(uint32_t));
f = plat_fopen(fn, "wb");
if (!f)
fp = plat_fopen(fn, "wb");
if (!fp)
return 0;
/* Allocate a temporary drive for conversion. */
temp86 = (d86f_t *) malloc(sizeof(d86f_t));
memcpy(temp86, dev, sizeof(d86f_t));
fwrite(&magic, 4, 1, f);
fwrite(&version, 2, 1, f);
fwrite(&disk_flags, 2, 1, f);
fwrite(&magic, 4, 1, fp);
fwrite(&version, 2, 1, fp);
fwrite(&disk_flags, 2, 1, fp);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), f);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), fp);
/* In the case of a thick track drive, always increment track
by two, since two tracks are going to get output at once. */
@@ -3455,17 +3455,17 @@ d86f_export(int drive, char *fn)
else
fdd_do_seek(drive, i);
dev->cur_track = i;
d86f_write_tracks(drive, &f, tt);
d86f_write_tracks(drive, &fp, tt);
}
fclose(f);
fclose(fp);
f = plat_fopen(fn, "rb+");
fp = plat_fopen(fn, "rb+");
fseek(f, 8, SEEK_SET);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), f);
fseek(fp, 8, SEEK_SET);
fwrite(tt, 1, ((d86f_get_sides(drive) == 2) ? 2048 : 1024), fp);
fclose(f);
fclose(fp);
fdd_do_seek(drive, fdd_current_track(drive));
@@ -3492,10 +3492,10 @@ d86f_load(int drive, char *fn)
writeprot[drive] = 0;
dev->f = plat_fopen(fn, "rb+");
if (!dev->f) {
dev->f = plat_fopen(fn, "rb");
if (!dev->f) {
dev->fp = plat_fopen(fn, "rb+");
if (!dev->fp) {
dev->fp = plat_fopen(fn, "rb");
if (!dev->fp) {
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3508,16 +3508,16 @@ d86f_load(int drive, char *fn)
}
fwriteprot[drive] = writeprot[drive];
fseek(dev->f, 0, SEEK_END);
len = ftell(dev->f);
fseek(dev->f, 0, SEEK_SET);
fseek(dev->fp, 0, SEEK_END);
len = ftell(dev->fp);
fseek(dev->fp, 0, SEEK_SET);
(void) !fread(&magic, 4, 1, dev->f);
(void) !fread(&magic, 4, 1, dev->fp);
if (len < 16) {
/* File is WAY too small, abort. */
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3526,13 +3526,13 @@ d86f_load(int drive, char *fn)
if ((magic != 0x46423638) && (magic != 0x66623638)) {
/* File is not of the valid format, abort. */
d86f_log("86F: Unrecognized magic bytes: %08X\n", magic);
fclose(dev->f);
fclose(dev->fp);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
}
if (fread(&(dev->version), 1, 2, dev->f) != 2)
if (fread(&(dev->version), 1, 2, dev->fp) != 2)
fatal("d86f_load(): Error reading format version\n");
if (dev->version != D86FVER) {
@@ -3544,8 +3544,8 @@ d86f_load(int drive, char *fn)
} else {
d86f_log("86F: Unrecognized file version: %i.%02i\n", dev->version >> 8, dev->version & 0xff);
}
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3553,7 +3553,7 @@ d86f_load(int drive, char *fn)
d86f_log("86F: Recognized file version: %i.%02i\n", dev->version >> 8, dev->version & 0xff);
}
(void) !fread(&(dev->disk_flags), 2, 1, dev->f);
(void) !fread(&(dev->disk_flags), 2, 1, dev->fp);
if (d86f_has_surface_desc(drive)) {
for (uint8_t i = 0; i < 2; i++)
@@ -3572,31 +3572,31 @@ d86f_load(int drive, char *fn)
if (len < 51052) {
#endif
/* File too small, abort. */
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
}
#ifdef DO_CRC64
fseek(dev->f, 8, SEEK_SET);
fread(&read_crc64, 1, 8, dev->f);
fseek(dev->fp, 8, SEEK_SET);
fread(&read_crc64, 1, 8, dev->fp);
fseek(dev->f, 0, SEEK_SET);
fseek(dev->fp, 0, SEEK_SET);
crc64 = 0xffffffffffffffff;
dev->filebuf = malloc(len);
fread(dev->filebuf, 1, len, dev->f);
fread(dev->filebuf, 1, len, dev->fp);
*(uint64_t *) &(dev->filebuf[8]) = 0xffffffffffffffff;
crc64 = (uint64_t) crc64speed(0, dev->filebuf, len);
free(dev->filebuf);
if (crc64 != read_crc64) {
d86f_log("86F: CRC64 error\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -3608,11 +3608,11 @@ d86f_load(int drive, char *fn)
memcpy(temp_file_name, drive ? nvr_path("TEMP$$$1.$$$") : nvr_path("TEMP$$$0.$$$"), 256);
memcpy(dev->original_file_name, fn, strlen(fn) + 1);
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
dev->f = plat_fopen(temp_file_name, "wb");
if (!dev->f) {
dev->fp = plat_fopen(temp_file_name, "wb");
if (!dev->fp) {
d86f_log("86F: Unable to create temporary decompressed file\n");
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
@@ -3621,9 +3621,9 @@ d86f_load(int drive, char *fn)
tf = plat_fopen(fn, "rb");
for (i = 0; i < 8; i++) {
for (uint8_t i = 0; i < 8; i++) {
fread(&temp, 1, 2, tf);
fwrite(&temp, 1, 2, dev->f);
fwrite(&temp, 1, 2, dev->fp);
}
dev->filebuf = (uint8_t *) malloc(len);
@@ -3631,14 +3631,14 @@ d86f_load(int drive, char *fn)
fread(dev->filebuf, 1, len, tf);
temp = lzf_decompress(dev->filebuf, len, dev->outbuf, 67108864);
if (temp) {
fwrite(dev->outbuf, 1, temp, dev->f);
fwrite(dev->outbuf, 1, temp, dev->fp);
}
free(dev->outbuf);
free(dev->filebuf);
fclose(tf);
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
if (!temp) {
d86f_log("86F: Error decompressing file\n");
@@ -3648,15 +3648,15 @@ d86f_load(int drive, char *fn)
return;
}
dev->f = plat_fopen(temp_file_name, "rb+");
dev->fp = plat_fopen(temp_file_name, "rb+");
}
#endif
if (dev->disk_flags & 0x100) {
/* Zoned disk. */
d86f_log("86F: Disk is zoned (Apple or Sony)\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
#ifdef D86F_COMPRESS
if (dev->is_compressed)
plat_remove(temp_file_name);
@@ -3669,8 +3669,8 @@ d86f_load(int drive, char *fn)
if (dev->disk_flags & 0x600) {
/* Zone type is not 0 but the disk is fixed-RPM. */
d86f_log("86F: Disk is fixed-RPM but zone type is not 0\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
#ifdef D86F_COMPRESS
if (dev->is_compressed)
plat_remove(temp_file_name);
@@ -3686,29 +3686,29 @@ d86f_load(int drive, char *fn)
}
if (writeprot[drive]) {
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
#ifdef D86F_COMPRESS
if (dev->is_compressed)
dev->f = plat_fopen(temp_file_name, "rb");
dev->fp = plat_fopen(temp_file_name, "rb");
else
#endif
dev->f = plat_fopen(fn, "rb");
dev->fp = plat_fopen(fn, "rb");
}
/* OK, set the drive data, other code needs it. */
d86f[drive] = dev;
fseek(dev->f, 8, SEEK_SET);
fseek(dev->fp, 8, SEEK_SET);
(void) !fread(dev->track_offset, 1, d86f_get_track_table_size(drive), dev->f);
(void) !fread(dev->track_offset, 1, d86f_get_track_table_size(drive), dev->fp);
if (!(dev->track_offset[0])) {
/* File has no track 0 side 0, abort. */
d86f_log("86F: No Track 0 side 0\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
d86f[drive] = NULL;
@@ -3718,8 +3718,8 @@ d86f_load(int drive, char *fn)
if ((d86f_get_sides(drive) == 2) && !(dev->track_offset[1])) {
/* File is 2-sided but has no track 0 side 1, abort. */
d86f_log("86F: No Track 0 side 1\n");
fclose(dev->f);
dev->f = NULL;
fclose(dev->fp);
dev->fp = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
d86f[drive] = NULL;
@@ -3727,12 +3727,12 @@ d86f_load(int drive, char *fn)
}
/* Load track 0 flags as default. */
if (fseek(dev->f, dev->track_offset[0], SEEK_SET) == -1)
if (fseek(dev->fp, dev->track_offset[0], SEEK_SET) == -1)
fatal("d86f_load(): Track 0: Error seeking to the beginning of the file\n");
if (fread(&(dev->side_flags[0]), 1, 2, dev->f) != 2)
if (fread(&(dev->side_flags[0]), 1, 2, dev->fp) != 2)
fatal("d86f_load(): Track 0: Error reading side flags\n");
if (dev->disk_flags & 0x80) {
if (fread(&(dev->extra_bit_cells[0]), 1, 4, dev->f) != 4)
if (fread(&(dev->extra_bit_cells[0]), 1, 4, dev->fp) != 4)
fatal("d86f_load(): Track 0: Error reading the amount of extra bit cells\n");
if ((dev->disk_flags & 0x1060) != 0x1000) {
if (dev->extra_bit_cells[0] < -32768)
@@ -3745,12 +3745,12 @@ d86f_load(int drive, char *fn)
}
if (d86f_get_sides(drive) == 2) {
if (fseek(dev->f, dev->track_offset[1], SEEK_SET) == -1)
if (fseek(dev->fp, dev->track_offset[1], SEEK_SET) == -1)
fatal("d86f_load(): Track 1: Error seeking to the beginning of the file\n");
if (fread(&(dev->side_flags[1]), 1, 2, dev->f) != 2)
if (fread(&(dev->side_flags[1]), 1, 2, dev->fp) != 2)
fatal("d86f_load(): Track 1: Error reading side flags\n");
if (dev->disk_flags & 0x80) {
if (fread(&(dev->extra_bit_cells[1]), 1, 4, dev->f) != 4)
if (fread(&(dev->extra_bit_cells[1]), 1, 4, dev->fp) != 4)
fatal("d86f_load(): Track 4: Error reading the amount of extra bit cells\n");
if ((dev->disk_flags & 0x1060) != 0x1000) {
if (dev->extra_bit_cells[1] < -32768)
@@ -3781,10 +3781,10 @@ d86f_load(int drive, char *fn)
dev->extra_bit_cells[1] = 0;
}
fseek(dev->f, 0, SEEK_END);
dev->file_size = ftell(dev->f);
fseek(dev->fp, 0, SEEK_END);
dev->file_size = ftell(dev->fp);
fseek(dev->f, 0, SEEK_SET);
fseek(dev->fp, 0, SEEK_SET);
d86f_register_86f(drive);
@@ -3847,9 +3847,9 @@ d86f_close(int drive)
}
}
if (dev->f) {
fclose(dev->f);
dev->f = NULL;
if (dev->fp) {
fclose(dev->fp);
dev->fp = NULL;
}
#ifdef D86F_COMPRESS
if (dev->is_compressed)

20
src/floppy/fdd_fdi.c
View File

@@ -36,8 +36,8 @@
#include <86box/fdc.h>
#include <fdi2raw.h>
typedef struct {
FILE *f;
typedef struct fdi_t {
FILE *fp;
FDI *h;
int lasttrack;
@@ -291,7 +291,7 @@ fdi_seek(int drive, int track)
d86f_set_cur_track(drive, track);
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (track < 0)
@@ -327,16 +327,16 @@ fdi_load(int drive, char *fn)
d86f_unregister(drive);
dev->f = plat_fopen(fn, "rb");
if (fread(header, 1, 25, dev->f) != 25)
dev->fp = plat_fopen(fn, "rb");
if (fread(header, 1, 25, dev->fp) != 25)
fatal("fdi_load(): Error reading header\n");
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("fdi_load(): Error seeking to the beginning of the file\n");
header[25] = 0;
if (strcmp(header, "Formatted Disk Image file") != 0) {
/* This is a Japanese FDI file. */
fdi_log("fdi_load(): Japanese FDI file detected, redirecting to IMG loader\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
img_load(drive, fn);
return;
@@ -345,7 +345,7 @@ fdi_load(int drive, char *fn)
/* Set up the drive unit. */
fdi[drive] = dev;
dev->h = fdi2raw_header(dev->f);
dev->h = fdi2raw_header(dev->fp);
dev->lasttrack = fdi2raw_get_last_track(dev->h);
dev->sides = fdi2raw_get_last_head(dev->h) + 1;
@@ -386,8 +386,8 @@ fdi_close(int drive)
if (dev->h)
fdi2raw_header_free(dev->h);
if (dev->f)
fclose(dev->f);
if (dev->fp)
fclose(dev->fp);
/* Release the memory. */
free(dev);

68
src/floppy/fdd_imd.c
View File

@@ -31,7 +31,7 @@
#include <86box/fdd_imd.h>
#include <86box/fdc.h>
typedef struct {
typedef struct imd_track_t {
uint8_t is_present;
uint32_t file_offs;
uint8_t params[5];
@@ -47,8 +47,8 @@ typedef struct {
uint8_t max_sector_size;
} imd_track_t;
typedef struct {
FILE *f;
typedef struct imd_t {
FILE *fp;
char *buffer;
uint32_t start_offs;
int track_count;
@@ -150,7 +150,7 @@ track_is_xdf(int drive, int side, int track)
effective_sectors = xdf_sectors = high_sectors = low_sectors = 0;
for (i = 0; i < 256; i++)
for (uint16_t i = 0; i < 256; i++)
dev->xdf_ordered_pos[i][side] = 0;
if (dev->tracks[track][side].params[2] & 0xC0)
@@ -175,7 +175,7 @@ track_is_xdf(int drive, int side, int track)
expected_low_count = 0;
}
for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
if ((r_map[i] >= 0x81) && (r_map[i] <= max_high_id)) {
high_sectors++;
dev->xdf_ordered_pos[(int) r_map[i]][side] = i;
@@ -196,7 +196,7 @@ track_is_xdf(int drive, int side, int track)
n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs);
for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
effective_sectors++;
if (!(r_map[i]) && !(n_map[i]))
effective_sectors--;
@@ -310,7 +310,7 @@ imd_seek(int drive, int track)
uint8_t *data;
int flags = 0x00;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive))
@@ -526,26 +526,26 @@ imd_writeback(int drive)
for (int side = 0; side < dev->sides; side++) {
if (dev->tracks[track][side].is_present) {
fseek(dev->f, dev->tracks[track][side].file_offs, SEEK_SET);
fseek(dev->fp, dev->tracks[track][side].file_offs, SEEK_SET);
h = dev->tracks[track][side].params[2];
spt = dev->tracks[track][side].params[3];
n = dev->tracks[track][side].params[4];
fwrite(dev->tracks[track][side].params, 1, 5, dev->f);
fwrite(dev->tracks[track][side].params, 1, 5, dev->fp);
if (h & 0x80)
fwrite(dev->buffer + dev->tracks[track][side].c_map_offs, 1, spt, dev->f);
fwrite(dev->buffer + dev->tracks[track][side].c_map_offs, 1, spt, dev->fp);
if (h & 0x40)
fwrite(dev->buffer + dev->tracks[track][side].h_map_offs, 1, spt, dev->f);
fwrite(dev->buffer + dev->tracks[track][side].h_map_offs, 1, spt, dev->fp);
if (n == 0xFF) {
n_map = dev->buffer + dev->tracks[track][side].n_map_offs;
fwrite(n_map, 1, spt, dev->f);
fwrite(n_map, 1, spt, dev->fp);
}
for (uint8_t i = 0; i < spt; i++) {
ssize = (n == 0xFF) ? n_map[i] : n;
ssize = 128 << ssize;
fwrite(dev->buffer + dev->tracks[track][side].sector_data_offs[i], 1, ssize, dev->f);
fwrite(dev->buffer + dev->tracks[track][side].sector_data_offs[i], 1, ssize, dev->fp);
}
}
}
@@ -637,10 +637,10 @@ imd_load(int drive, char *fn)
dev = (imd_t *) malloc(sizeof(imd_t));
memset(dev, 0x00, sizeof(imd_t));
dev->f = plat_fopen(fn, "rb+");
if (dev->f == NULL) {
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb+");
if (dev->fp == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
return;
@@ -652,40 +652,40 @@ imd_load(int drive, char *fn)
writeprot[drive] = 1;
fwriteprot[drive] = writeprot[drive];
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("imd_load(): Error seeking to the beginning of the file\n");
if (fread(&magic, 1, 4, dev->f) != 4)
if (fread(&magic, 1, 4, dev->fp) != 4)
fatal("imd_load(): Error reading the magic number\n");
if (magic != 0x20444D49) {
imd_log("IMD: Not a valid ImageDisk image\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
} else
imd_log("IMD: Valid ImageDisk image\n");
if (fseek(dev->f, 0, SEEK_END) == -1)
if (fseek(dev->fp, 0, SEEK_END) == -1)
fatal("imd_load(): Error seeking to the end of the file\n");
fsize = ftell(dev->f);
fsize = ftell(dev->fp);
if (fsize <= 0) {
imd_log("IMD: Too small ImageDisk image\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
}
if (fseek(dev->f, 0, SEEK_SET) == -1)
if (fseek(dev->fp, 0, SEEK_SET) == -1)
fatal("imd_load(): Error seeking to the beginning of the file again\n");
dev->buffer = malloc(fsize);
if (fread(dev->buffer, 1, fsize, dev->f) != fsize)
if (fread(dev->buffer, 1, fsize, dev->fp) != fsize)
fatal("imd_load(): Error reading data\n");
buffer = dev->buffer;
buffer2 = memchr(buffer, 0x1A, fsize);
if (buffer2 == NULL) {
imd_log("IMD: No ASCII EOF character\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -696,7 +696,7 @@ imd_load(int drive, char *fn)
buffer2++;
if ((buffer2 - buffer) == fsize) {
imd_log("IMD: File ends after ASCII EOF character\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -775,7 +775,7 @@ imd_load(int drive, char *fn)
dev->tracks[track][side].data_offs = last_offset;
for (i = 0; i < track_spt; i++) {
for (int i = 0; i < track_spt; i++) {
data_size = buffer2[i];
data_size = 128 << data_size;
dev->tracks[track][side].sector_data_offs[i] = last_offset;
@@ -784,7 +784,7 @@ imd_load(int drive, char *fn)
/* Invalid sector data type, possibly a malformed HxC IMG image (it outputs data errored
sectors with a variable amount of bytes, against the specification). */
imd_log("IMD: Invalid sector data type %02X\n", dev->buffer[dev->tracks[track][side].sector_data_offs[i]]);
fclose(dev->f);
fclose(dev->fp);
free(dev);
imd[drive] = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -807,7 +807,7 @@ imd_load(int drive, char *fn)
} else {
dev->tracks[track][side].data_offs = last_offset;
for (i = 0; i < track_spt; i++) {
for (int i = 0; i < track_spt; i++) {
data_size = sector_size;
data_size = 128 << data_size;
dev->tracks[track][side].sector_data_offs[i] = last_offset;
@@ -816,7 +816,7 @@ imd_load(int drive, char *fn)
/* Invalid sector data type, possibly a malformed HxC IMG image (it outputs data errored
sectors with a variable amount of bytes, against the specification). */
imd_log("IMD: Invalid sector data type %02X\n", dev->buffer[dev->tracks[track][side].sector_data_offs[i]]);
fclose(dev->f);
fclose(dev->fp);
free(dev);
imd[drive] = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -865,7 +865,7 @@ imd_load(int drive, char *fn)
if (size_diff < gap_sum) {
/* If we can't fit the sectors with a reasonable minimum gap even at 2% slower RPM, abort. */
imd_log("IMD: Unable to fit the %i sectors in a track\n", track_spt);
fclose(dev->f);
fclose(dev->fp);
free(dev);
imd[drive] = NULL;
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -931,10 +931,10 @@ imd_close(int drive)
d86f_unregister(drive);
if (dev->f != NULL) {
if (dev->fp != NULL) {
free(dev->buffer);
fclose(dev->f);
fclose(dev->fp);
}
/* Release the memory. */

214
src/floppy/fdd_img.c
View File

@@ -40,8 +40,8 @@
#include <86box/fdd_img.h>
#include <86box/fdc.h>
typedef struct {
FILE *f;
typedef struct img_t {
FILE *fp;
uint8_t track_data[2][688128];
int sectors, tracks, sides;
uint8_t sector_size;
@@ -418,17 +418,17 @@ write_back(int drive)
int ssize = 128 << ((int) dev->sector_size);
int size;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (dev->disk_at_once)
return;
if (fseek(dev->f, dev->base + (dev->track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
if (fseek(dev->fp, dev->base + (dev->track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
pclog("IMG write_back(): Error seeking to the beginning of the file\n");
for (int side = 0; side < dev->sides; side++) {
size = dev->sectors * ssize;
if (fwrite(dev->track_data[side], 1, size, dev->f) != size)
if (fwrite(dev->track_data[side], 1, size, dev->fp) != size)
fatal("IMG write_back(): Error writing data\n");
}
}
@@ -507,7 +507,7 @@ img_seek(int drive, int track)
int ssize = 128 << ((int) dev->sector_size);
uint32_t cur_pos = 0;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive))
@@ -519,7 +519,7 @@ img_seek(int drive, int track)
is_t0 = (track == 0) ? 1 : 0;
if (!dev->disk_at_once) {
if (fseek(dev->f, dev->base + (track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
if (fseek(dev->fp, dev->base + (track * dev->sectors * ssize * dev->sides), SEEK_SET) == -1)
fatal("img_seek(): Error seeking\n");
}
@@ -528,7 +528,7 @@ img_seek(int drive, int track)
cur_pos = (track * dev->sectors * ssize * dev->sides) + (side * dev->sectors * ssize);
memcpy(dev->track_data[side], dev->disk_data + cur_pos, (size_t) dev->sectors * ssize);
} else {
read_bytes = fread(dev->track_data[side], 1, (size_t) dev->sectors * ssize, dev->f);
read_bytes = fread(dev->track_data[side], 1, (size_t) dev->sectors * ssize, dev->fp);
if (read_bytes < (dev->sectors * ssize))
memset(dev->track_data[side] + read_bytes, 0xf6, (dev->sectors * ssize) - read_bytes);
}
@@ -682,10 +682,10 @@ img_load(int drive, char *fn)
dev = (img_t *) malloc(sizeof(img_t));
memset(dev, 0x00, sizeof(img_t));
dev->f = plat_fopen(fn, "rb+");
if (dev->f == NULL) {
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb+");
if (dev->fp == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -710,23 +710,23 @@ img_load(int drive, char *fn)
if (!strcasecmp(ext, "FDI")) {
/* This is a Japanese FDI image, so let's read the header */
img_log("img_load(): File is a Japanese FDI image...\n");
fseek(dev->f, 0x10, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->f);
fseek(dev->f, 0x0C, SEEK_SET);
(void) !fread(&size, 1, 4, dev->f);
fseek(dev->fp, 0x10, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->fp);
fseek(dev->fp, 0x0C, SEEK_SET);
(void) !fread(&size, 1, 4, dev->fp);
bpb_total = size / bpb_bps;
fseek(dev->f, 0x08, SEEK_SET);
(void) !fread(&(dev->base), 1, 4, dev->f);
fseek(dev->f, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->f);
fseek(dev->fp, 0x08, SEEK_SET);
(void) !fread(&(dev->base), 1, 4, dev->fp);
fseek(dev->fp, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->fp);
if (bpb_mid < 0xF0)
bpb_mid = 0xF0;
fseek(dev->f, 0x14, SEEK_SET);
bpb_sectors = fgetc(dev->f);
fseek(dev->f, 0x18, SEEK_SET);
bpb_sides = fgetc(dev->f);
fseek(dev->f, dev->base, SEEK_SET);
first_byte = fgetc(dev->f);
fseek(dev->fp, 0x14, SEEK_SET);
bpb_sectors = fgetc(dev->fp);
fseek(dev->fp, 0x18, SEEK_SET);
bpb_sides = fgetc(dev->fp);
fseek(dev->fp, dev->base, SEEK_SET);
first_byte = fgetc(dev->fp);
fdi = 1;
cqm = 0;
@@ -734,53 +734,53 @@ img_load(int drive, char *fn)
fdf = 0;
} else {
/* Read the first four bytes. */
fseek(dev->f, 0x00, SEEK_SET);
first_byte = fgetc(dev->f);
fseek(dev->f, 0x01, SEEK_SET);
second_byte = fgetc(dev->f);
fseek(dev->f, 0x02, SEEK_SET);
third_byte = fgetc(dev->f);
fseek(dev->f, 0x03, SEEK_SET);
fourth_byte = fgetc(dev->f);
fseek(dev->fp, 0x00, SEEK_SET);
first_byte = fgetc(dev->fp);
fseek(dev->fp, 0x01, SEEK_SET);
second_byte = fgetc(dev->fp);
fseek(dev->fp, 0x02, SEEK_SET);
third_byte = fgetc(dev->fp);
fseek(dev->fp, 0x03, SEEK_SET);
fourth_byte = fgetc(dev->fp);
if ((first_byte == 0x1A) && (second_byte == 'F') && (third_byte == 'D') && (fourth_byte == 'F')) {
/* This is a FDF image. */
img_log("img_load(): File is a FDF image...\n");
fwriteprot[drive] = writeprot[drive] = 1;
fclose(dev->f);
dev->f = plat_fopen(fn, "rb");
fclose(dev->fp);
dev->fp = plat_fopen(fn, "rb");
fdf = 1;
cqm = 0;
dev->disk_at_once = 1;
fseek(dev->f, 0x50, SEEK_SET);
(void) !fread(&dev->tracks, 1, 4, dev->f);
fseek(dev->fp, 0x50, SEEK_SET);
(void) !fread(&dev->tracks, 1, 4, dev->fp);
/* Decode the entire file - pass 1, no write to buffer, determine length. */
fseek(dev->f, 0x80, SEEK_SET);
fseek(dev->fp, 0x80, SEEK_SET);
size = 0;
track_bytes = 0;
bpos = dev->disk_data;
while (!feof(dev->f)) {
while (!feof(dev->fp)) {
if (!track_bytes) {
/* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
first_byte = fgetc(dev->f);
(void) !fread(&track_bytes, 1, 2, dev->f);
first_byte = fgetc(dev->fp);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("Block header: %02X %04X ", first_byte, track_bytes);
/* Read the length of encoded data block. */
(void) !fread(&track_bytes, 1, 2, dev->f);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("%04X\n", track_bytes);
}
if (feof(dev->f))
if (feof(dev->fp))
break;
if (first_byte == 0xFF)
break;
if (first_byte) {
run = fgetc(dev->f);
run = fgetc(dev->fp);
/* I *HAVE* to read something because fseek tries to be smart and never hits EOF, causing an infinite loop. */
track_bytes--;
@@ -788,12 +788,12 @@ img_load(int drive, char *fn)
if (run & 0x80) {
/* Repeat. */
track_bytes--;
rep_byte = fgetc(dev->f);
rep_byte = fgetc(dev->fp);
} else {
/* Literal. */
track_bytes -= (run & 0x7f);
literal = (uint8_t *) malloc(run & 0x7f);
(void) !fread(literal, 1, (run & 0x7f), dev->f);
(void) !fread(literal, 1, (run & 0x7f), dev->fp);
free(literal);
}
size += (run & 0x7f);
@@ -803,12 +803,12 @@ img_load(int drive, char *fn)
/* Literal block. */
size += (track_bytes - fdf_suppress_final_byte);
literal = (uint8_t *) malloc(track_bytes);
(void) !fread(literal, 1, track_bytes, dev->f);
(void) !fread(literal, 1, track_bytes, dev->fp);
free(literal);
track_bytes = 0;
}
if (feof(dev->f))
if (feof(dev->fp))
break;
}
@@ -816,28 +816,28 @@ img_load(int drive, char *fn)
dev->disk_data = (uint8_t *) malloc(size);
/* Decode the entire file - pass 2, write to buffer. */
fseek(dev->f, 0x80, SEEK_SET);
fseek(dev->fp, 0x80, SEEK_SET);
track_bytes = 0;
bpos = dev->disk_data;
while (!feof(dev->f)) {
while (!feof(dev->fp)) {
if (!track_bytes) {
/* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
first_byte = fgetc(dev->f);
(void) !fread(&track_bytes, 1, 2, dev->f);
first_byte = fgetc(dev->fp);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("Block header: %02X %04X ", first_byte, track_bytes);
/* Read the length of encoded data block. */
(void) !fread(&track_bytes, 1, 2, dev->f);
(void) !fread(&track_bytes, 1, 2, dev->fp);
img_log("%04X\n", track_bytes);
}
if (feof(dev->f))
if (feof(dev->fp))
break;
if (first_byte == 0xFF)
break;
if (first_byte) {
run = fgetc(dev->f);
run = fgetc(dev->fp);
real_run = (run & 0x7f);
/* I *HAVE* to read something because fseek tries to be smart and never hits EOF, causing an infinite loop. */
@@ -848,14 +848,14 @@ img_load(int drive, char *fn)
track_bytes--;
if (!track_bytes)
real_run -= fdf_suppress_final_byte;
rep_byte = fgetc(dev->f);
rep_byte = fgetc(dev->fp);
if (real_run)
memset(bpos, rep_byte, real_run);
} else {
/* Literal. */
track_bytes -= real_run;
literal = (uint8_t *) malloc(real_run);
(void) !fread(literal, 1, real_run, dev->f);
(void) !fread(literal, 1, real_run, dev->fp);
if (!track_bytes)
real_run -= fdf_suppress_final_byte;
if (run & 0x7f)
@@ -866,14 +866,14 @@ img_load(int drive, char *fn)
} else {
/* Literal block. */
literal = (uint8_t *) malloc(track_bytes);
(void) !fread(literal, 1, track_bytes, dev->f);
(void) !fread(literal, 1, track_bytes, dev->fp);
memcpy(bpos, literal, track_bytes - fdf_suppress_final_byte);
free(literal);
bpos += (track_bytes - fdf_suppress_final_byte);
track_bytes = 0;
}
if (feof(dev->f))
if (feof(dev->fp))
break;
}
@@ -892,48 +892,48 @@ img_load(int drive, char *fn)
if (((first_byte == 'C') && (second_byte == 'Q')) || ((first_byte == 'c') && (second_byte == 'q'))) {
img_log("img_load(): File is a CopyQM image...\n");
fwriteprot[drive] = writeprot[drive] = 1;
fclose(dev->f);
dev->f = plat_fopen(fn, "rb");
fclose(dev->fp);
dev->fp = plat_fopen(fn, "rb");
fseek(dev->f, 0x03, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->f);
fseek(dev->fp, 0x03, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->fp);
#if 0
fseek(dev->f, 0x0B, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->f);
fseek(dev->fp, 0x0B, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->fp);
#endif
fseek(dev->f, 0x10, SEEK_SET);
bpb_sectors = fgetc(dev->f);
fseek(dev->f, 0x12, SEEK_SET);
bpb_sides = fgetc(dev->f);
fseek(dev->f, 0x5B, SEEK_SET);
dev->tracks = fgetc(dev->f);
fseek(dev->fp, 0x10, SEEK_SET);
bpb_sectors = fgetc(dev->fp);
fseek(dev->fp, 0x12, SEEK_SET);
bpb_sides = fgetc(dev->fp);
fseek(dev->fp, 0x5B, SEEK_SET);
dev->tracks = fgetc(dev->fp);
bpb_total = ((uint16_t) bpb_sectors) * ((uint16_t) bpb_sides) * dev->tracks;
fseek(dev->f, 0x74, SEEK_SET);
dev->interleave = fgetc(dev->f);
fseek(dev->f, 0x76, SEEK_SET);
dev->skew = fgetc(dev->f);
fseek(dev->fp, 0x74, SEEK_SET);
dev->interleave = fgetc(dev->fp);
fseek(dev->fp, 0x76, SEEK_SET);
dev->skew = fgetc(dev->fp);
dev->disk_data = (uint8_t *) malloc(((uint32_t) bpb_total) * ((uint32_t) bpb_bps));
memset(dev->disk_data, 0xf6, ((uint32_t) bpb_total) * ((uint32_t) bpb_bps));
fseek(dev->f, 0x6F, SEEK_SET);
(void) !fread(&comment_len, 1, 2, dev->f);
fseek(dev->fp, 0x6F, SEEK_SET);
(void) !fread(&comment_len, 1, 2, dev->fp);
fseek(dev->f, -1, SEEK_END);
size = ftell(dev->f) + 1;
fseek(dev->fp, -1, SEEK_END);
size = ftell(dev->fp) + 1;
fseek(dev->f, 133 + comment_len, SEEK_SET);
fseek(dev->fp, 133 + comment_len, SEEK_SET);
cur_pos = 0;
while (!feof(dev->f)) {
(void) !fread(&block_len, 1, 2, dev->f);
while (!feof(dev->fp)) {
(void) !fread(&block_len, 1, 2, dev->fp);
if (!feof(dev->f)) {
if (!feof(dev->fp)) {
if (block_len < 0) {
rep_byte = fgetc(dev->f);
rep_byte = fgetc(dev->fp);
block_len = -block_len;
if ((cur_pos + block_len) > ((uint32_t) bpb_total) * ((uint32_t) bpb_bps)) {
block_len = ((uint32_t) bpb_total) * ((uint32_t) bpb_bps) - cur_pos;
@@ -946,10 +946,10 @@ img_load(int drive, char *fn)
} else if (block_len > 0) {
if ((cur_pos + block_len) > ((uint32_t) bpb_total) * ((uint32_t) bpb_bps)) {
block_len = ((uint32_t) bpb_total) * ((uint32_t) bpb_bps) - cur_pos;
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->f);
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->fp);
break;
} else {
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->f);
(void) !fread(dev->disk_data + cur_pos, 1, block_len, dev->fp);
cur_pos += block_len;
}
}
@@ -969,22 +969,22 @@ img_load(int drive, char *fn)
fwriteprot[drive] = writeprot[drive] = 1;
} else
img_log("img_load(): File is a raw image...\n");
fseek(dev->f, dev->base + 0x0B, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->f);
fseek(dev->f, dev->base + 0x13, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->f);
fseek(dev->f, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->f);
fseek(dev->f, dev->base + 0x18, SEEK_SET);
bpb_sectors = fgetc(dev->f);
fseek(dev->f, dev->base + 0x1A, SEEK_SET);
bpb_sides = fgetc(dev->f);
fseek(dev->fp, dev->base + 0x0B, SEEK_SET);
(void) !fread(&bpb_bps, 1, 2, dev->fp);
fseek(dev->fp, dev->base + 0x13, SEEK_SET);
(void) !fread(&bpb_total, 1, 2, dev->fp);
fseek(dev->fp, dev->base + 0x15, SEEK_SET);
bpb_mid = fgetc(dev->fp);
fseek(dev->fp, dev->base + 0x18, SEEK_SET);
bpb_sectors = fgetc(dev->fp);
fseek(dev->fp, dev->base + 0x1A, SEEK_SET);
bpb_sides = fgetc(dev->fp);
cqm = 0;
}
fseek(dev->f, -1, SEEK_END);
size = ftell(dev->f) + 1;
fseek(dev->fp, -1, SEEK_END);
size = ftell(dev->fp) + 1;
if (ddi)
size -= 0x2400;
@@ -1125,7 +1125,7 @@ jump_if_fdf:
dev->tracks = 86;
} else {
img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -1138,9 +1138,9 @@ jump_if_fdf:
/* The BPB readings appear to be valid, so let's set the values. */
if (fdi) {
/* The image is a Japanese FDI, therefore we read the number of tracks from the header. */
if (fseek(dev->f, 0x1C, SEEK_SET) == -1)
if (fseek(dev->fp, 0x1C, SEEK_SET) == -1)
fatal("Japanese FDI: Failed when seeking to 0x1C\n");
(void) !fread(&(dev->tracks), 1, 4, dev->f);
(void) !fread(&(dev->tracks), 1, 4, dev->fp);
} else {
if (!cqm && !fdf) {
/* Number of tracks = number of total sectors divided by sides times sectors per track. */
@@ -1182,7 +1182,7 @@ jump_if_fdf:
if (temp_rate == 0xFF) {
img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -1199,7 +1199,7 @@ jump_if_fdf:
}
if (!dev->gap3_size) {
img_log("ERROR: Floppy image of unknown format was inserted into drive %c:!\n", drive + 0x41);
fclose(dev->f);
fclose(dev->fp);
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -1259,9 +1259,9 @@ img_close(int drive)
d86f_unregister(drive);
if (dev->f != NULL) {
fclose(dev->f);
dev->f = NULL;
if (dev->fp != NULL) {
fclose(dev->fp);
dev->fp = NULL;
}
if (dev->disk_data != NULL)

35
src/floppy/fdd_json.c
View File

@@ -62,7 +62,7 @@
#define NSIDES 2
#define NSECTORS 256
typedef struct {
typedef struct sector_t {
uint8_t track; /* ID: track number */
uint8_t side; /* side number */
uint8_t sector; /* sector number 1.. */
@@ -70,8 +70,8 @@ typedef struct {
uint8_t *data; /* allocated data for it */
} sector_t;
typedef struct {
FILE *f;
typedef struct json_t {
FILE *fp;
/* Geometry. */
uint8_t tracks; /* number of tracks */
@@ -215,7 +215,7 @@ load_image(json_t *dev)
int level;
char *ptr;
if (dev->f == NULL) {
if (dev->fp == NULL) {
json_log("JSON: no file loaded!\n");
return 0;
}
@@ -232,8 +232,8 @@ load_image(json_t *dev)
level = state = 0;
while (state >= 0) {
/* Get a character from the input. */
c = fgetc(dev->f);
if ((c == EOF) || ferror(dev->f)) {
c = fgetc(dev->fp);
if ((c == EOF) || ferror(dev->fp)) {
state = -1;
break;
}
@@ -372,6 +372,9 @@ load_image(json_t *dev)
}
dev->track++;
break;
default:
break;
}
}
@@ -396,7 +399,7 @@ json_seek(int drive, int track)
int rsec;
int asec;
if (dev->f == NULL) {
if (dev->fp == NULL) {
json_log("JSON: seek: no file loaded!\n");
return;
}
@@ -530,8 +533,8 @@ json_load(int drive, char *fn)
memset(dev, 0x00, sizeof(json_t));
/* Open the image file. */
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
free(dev);
memset(fn, 0x00, sizeof(char));
return;
@@ -546,7 +549,7 @@ json_load(int drive, char *fn)
/* Load all sectors from the image file. */
if (!load_image(dev)) {
json_log("JSON: failed to initialize\n");
(void) fclose(dev->f);
(void) fclose(dev->fp);
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(char));
@@ -608,8 +611,8 @@ json_load(int drive, char *fn)
if (temp_rate == 0xff) {
json_log("JSON: invalid image (temp_rate=0xff)\n");
(void) fclose(dev->f);
dev->f = NULL;
(void) fclose(dev->fp);
dev->fp = NULL;
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(char));
@@ -630,8 +633,8 @@ json_load(int drive, char *fn)
if (!dev->gap3_len) {
json_log("JSON: image of unknown format was inserted into drive %c:!\n",
'C' + drive);
(void) fclose(dev->f);
dev->f = NULL;
(void) fclose(dev->fp);
dev->fp = NULL;
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(char));
@@ -692,8 +695,8 @@ json_close(int drive)
}
}
if (dev->f != NULL)
(void) fclose(dev->f);
if (dev->fp != NULL)
(void) fclose(dev->fp);
/* Release the memory. */
free(dev);

32
src/floppy/fdd_mfm.c
View File

@@ -32,7 +32,7 @@
#include <86box/fdc.h>
#pragma pack(push, 1)
typedef struct {
typedef struct mfm_header_t {
uint8_t hdr_name[7];
uint16_t tracks_no;
@@ -45,14 +45,14 @@ typedef struct {
uint32_t track_list_offset;
} mfm_header_t;
typedef struct {
typedef struct mfm_track_t {
uint16_t track_no;
uint8_t side_no;
uint32_t track_size;
uint32_t track_offset;
} mfm_track_t;
typedef struct {
typedef struct mfm_adv_track_t {
uint16_t track_no;
uint8_t side_no;
uint16_t rpm;
@@ -62,8 +62,8 @@ typedef struct {
} mfm_adv_track_t;
#pragma pack(pop)
typedef struct {
FILE *f;
typedef struct mfm_t {
FILE *fp;
mfm_header_t hdr;
mfm_track_t *tracks;
@@ -345,12 +345,12 @@ mfm_read_side(int drive, int side)
memset(dev->track_data[side], 0x00, track_bytes);
else {
if (dev->hdr.if_type & 0x80)
ret = fseek(dev->f, dev->adv_tracks[track_index].track_offset, SEEK_SET);
ret = fseek(dev->fp, dev->adv_tracks[track_index].track_offset, SEEK_SET);
else
ret = fseek(dev->f, dev->tracks[track_index].track_offset, SEEK_SET);
ret = fseek(dev->fp, dev->tracks[track_index].track_offset, SEEK_SET);
if (ret == -1)
fatal("mfm_read_side(): Error seeking to the beginning of the file\n");
if (fread(dev->track_data[side], 1, track_bytes, dev->f) != track_bytes)
if (fread(dev->track_data[side], 1, track_bytes, dev->fp) != track_bytes)
fatal("mfm_read_side(): Error reading track bytes\n");
}
@@ -373,7 +373,7 @@ mfm_seek(int drive, int track)
dev->cur_track = track;
d86f_set_cur_track(drive, track);
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (track < 0)
@@ -399,8 +399,8 @@ mfm_load(int drive, char *fn)
dev = (mfm_t *) malloc(sizeof(mfm_t));
memset(dev, 0x00, sizeof(mfm_t));
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
free(dev);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
@@ -410,7 +410,7 @@ mfm_load(int drive, char *fn)
/* Read the header. */
size = sizeof(mfm_header_t);
if (fread(&dev->hdr, 1, size, dev->f) != size)
if (fread(&dev->hdr, 1, size, dev->fp) != size)
fatal("mfm_load(): Error reading header\n");
/* Calculate tracks * sides, allocate the tracks array, and read it. */
@@ -418,12 +418,12 @@ mfm_load(int drive, char *fn)
if (dev->hdr.if_type & 0x80) {
dev->adv_tracks = (mfm_adv_track_t *) malloc(dev->total_tracks * sizeof(mfm_adv_track_t));
size = dev->total_tracks * sizeof(mfm_adv_track_t);
if (fread(dev->adv_tracks, 1, size, dev->f) != size)
if (fread(dev->adv_tracks, 1, size, dev->fp) != size)
fatal("mfm_load(): Error reading advanced tracks\n");
} else {
dev->tracks = (mfm_track_t *) malloc(dev->total_tracks * sizeof(mfm_track_t));
size = dev->total_tracks * sizeof(mfm_track_t);
if (fread(dev->tracks, 1, size, dev->f) != size)
if (fread(dev->tracks, 1, size, dev->fp) != size)
fatal("mfm_load(): Error reading tracks\n");
}
@@ -504,8 +504,8 @@ mfm_close(int drive)
if (dev->adv_tracks)
free(dev->adv_tracks);
if (dev->f)
fclose(dev->f);
if (dev->fp)
fclose(dev->fp);
/* Release the memory. */
free(dev);

47
src/floppy/fdd_td0.c
View File

@@ -60,7 +60,7 @@
/* update when cumulative frequency */
/* reaches to this value */
typedef struct {
typedef struct tdlzhuf_t {
uint16_t r;
uint16_t bufcnt; /* string buffer */
uint16_t bufndx; /* string buffer */
@@ -72,7 +72,7 @@ typedef struct {
uint8_t inbuf[BUFSZ]; /* input buffer */
} tdlzhuf;
typedef struct {
typedef struct td0dsk_t {
FILE *fdd_file;
off_t fdd_file_offset;
@@ -93,7 +93,7 @@ typedef struct {
uint8_t getlen;
} td0dsk_t;
typedef struct {
typedef struct td0_sector_t {
uint8_t track;
uint8_t head;
uint8_t sector;
@@ -103,8 +103,8 @@ typedef struct {
uint8_t *data;
} td0_sector_t;
typedef struct {
FILE *f;
typedef struct td0_t {
FILE *fp;
int tracks;
int track_width;
@@ -227,9 +227,9 @@ fdd_image_read(int drive, char *buffer, uint32_t offset, uint32_t len)
{
td0_t *dev = td0[drive];
if (fseek(dev->f, offset, SEEK_SET) == -1)
if (fseek(dev->fp, offset, SEEK_SET) == -1)
fatal("fdd_image_read(): Error seeking to the beginning of the file\n");
if (fread(buffer, 1, len, dev->f) != len)
if (fread(buffer, 1, len, dev->fp) != len)
fatal("fdd_image_read(): Error reading data\n");
}
@@ -627,13 +627,13 @@ td0_initialize(int drive)
int size_diff;
int gap_sum;
if (dev->f == NULL) {
if (dev->fp == NULL) {
td0_log("TD0: Attempted to initialize without loading a file first\n");
return 0;
}
fseek(dev->f, 0, SEEK_END);
file_size = ftell(dev->f);
fseek(dev->fp, 0, SEEK_END);
file_size = ftell(dev->fp);
if (file_size < 12) {
td0_log("TD0: File is too small to even contain the header\n");
@@ -645,21 +645,21 @@ td0_initialize(int drive)
return 0;
}
fseek(dev->f, 0, SEEK_SET);
(void) !fread(header, 1, 12, dev->f);
fseek(dev->fp, 0, SEEK_SET);
(void) !fread(header, 1, 12, dev->fp);
head_count = header[9];
if (header[0] == 't') {
td0_log("TD0: File is compressed\n");
disk_decode.fdd_file = dev->f;
disk_decode.fdd_file = dev->fp;
state_init_Decode(&disk_decode);
disk_decode.fdd_file_offset = 12;
state_Decode(&disk_decode, dev->imagebuf, TD0_MAX_BUFSZ);
} else {
td0_log("TD0: File is uncompressed\n");
if (fseek(dev->f, 12, SEEK_SET) == -1)
if (fseek(dev->fp, 12, SEEK_SET) == -1)
fatal("td0_initialize(): Error seeking to offet 12\n");
if (fread(dev->imagebuf, 1, file_size - 12, dev->f) != (file_size - 12))
if (fread(dev->imagebuf, 1, file_size - 12, dev->fp) != (file_size - 12))
fatal("td0_initialize(): Error reading image buffer\n");
}
@@ -710,6 +710,9 @@ td0_initialize(int drive)
dev->default_track_flags = (density == 1) ? 0x00 : ((density == 2) ? 0x03 : 0x02);
dev->max_sector_size = (density == 1) ? 6 : ((density == 2) ? 7 : 5); /* 16384, 8192, or 4096 bytes. */
break;
default:
break;
}
dev->disk_flags = header[5] & 0x06;
@@ -1064,7 +1067,7 @@ td0_seek(int drive, int track)
int fm;
int sector_adjusted;
if (dev->f == NULL)
if (dev->fp == NULL)
return;
if (!dev->track_width && fdd_doublestep_40(drive))
@@ -1182,8 +1185,8 @@ td0_abort(int drive)
free(dev->imagebuf);
if (dev->processed_buf)
free(dev->processed_buf);
if (dev->f)
fclose(dev->f);
if (dev->fp)
fclose(dev->fp);
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
free(dev);
td0[drive] = NULL;
@@ -1203,8 +1206,8 @@ td0_load(int drive, char *fn)
memset(dev, 0x00, sizeof(td0_t));
td0[drive] = dev;
dev->f = plat_fopen(fn, "rb");
if (dev->f == NULL) {
dev->fp = plat_fopen(fn, "rb");
if (dev->fp == NULL) {
memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
return;
}
@@ -1285,8 +1288,8 @@ td0_close(int drive)
memset(dev->sects[i][j], 0, sizeof(td0_sector_t));
}
if (dev->f != NULL)
fclose(dev->f);
if (dev->fp != NULL)
fclose(dev->fp);
/* Release resources. */
free(dev);

57
src/floppy/fdi2raw.c
View File

@@ -36,7 +36,9 @@
#include <fdi2raw.h>
#include <86box/plat_unused.h>
#ifdef DEBUG
#undef DEBUG
#endif
#define VERBOSE
#undef VERBOSE
@@ -96,24 +98,24 @@ static int fdi_allocated;
#ifdef DEBUG
static void
fdi_free(void *p)
fdi_free(void *priv)
{
int size;
if (!p)
if (!priv)
return;
size = ((int *) p)[-1];
size = ((int *) priv)[-1];
fdi_allocated -= size;
write_log("%d freed (%d)\n", size, fdi_allocated);
free((int *) p - 1);
free((int *) priv - 1);
}
static void *
fdi_malloc(int size)
{
void *p = xmalloc(size + sizeof(int));
((int *) p)[0] = size;
void *priv = xmalloc(size + sizeof(int));
((int *) prv)[0] = size;
fdi_allocated += size;
write_log("%d allocated (%d)\n", size, fdi_allocated);
return (int *) p + 1;
return (int *) priv + 1;
}
#else
# define fdi_free free
@@ -1290,6 +1292,9 @@ track_atari_st(struct fdi *fdi, int max_sector)
case 10:
gap3 = 24;
break;
default:
break;
}
s15(fdi);
for (int i = 0; i < max_sector; i++) {
@@ -1944,8 +1949,8 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
uint32_t maxidx;
uint32_t totalavg;
uint32_t weakbits;
int i;
int j;
int k;
int len;
int pulses;
int indexoffset;
@@ -1974,7 +1979,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
maxp = (uint32_t *) fdi_decompress(pulses, p1 + 6, p1 + len, &max_free);
len += get_u24(p1 + 6) & 0x3fffff;
/* Computes the real min and max values */
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
maxp[i] = avgp[i] + minp[i] - maxp[i];
minp[i] = avgp[i] - minp[i];
}
@@ -2000,7 +2005,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
} else {
idxp = fdi_malloc(pulses * 2);
idx_free = 1;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
idxp[i * 2 + 0] = 2;
idxp[i * 2 + 1] = 0;
}
@@ -2011,43 +2016,43 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
maxidx = 0;
indexoffset = 0;
p1 = idxp;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
if ((uint32_t) p1[idx_off1] + (uint32_t) p1[idx_off2] > maxidx)
maxidx = p1[idx_off1] + p1[idx_off2];
p1 += idx_off3;
}
p1 = idxp;
for (i = 0; (i < pulses) && (p1[idx_off2] != 0); i++) /* falling edge, replace with idx_off1 for rising edge */
for (k = 0; (k < pulses) && (p1[idx_off2] != 0); k++) /* falling edge, replace with idx_off1 for rising edge */
p1 += idx_off3;
if (i < pulses) {
j = i;
if (k < pulses) {
j = k;
do {
i++;
k++;
p1 += idx_off3;
if (i >= pulses) {
i = 0;
if (k >= pulses) {
k = 0;
p1 = idxp;
}
} while ((i != j) && (p1[idx_off2] == 0)); /* falling edge, replace with idx_off1 for rising edge */
if (i != j) /* index pulse detected */
} while ((k != j) && (p1[idx_off2] == 0)); /* falling edge, replace with idx_off1 for rising edge */
if (k != j) /* index pulse detected */
{
while ((i != j) && (p1[idx_off1] > p1[idx_off2])) { /* falling edge, replace with "<" for rising edge */
i++;
while ((k != j) && (p1[idx_off1] > p1[idx_off2])) { /* falling edge, replace with "<" for rising edge */
k++;
p1 += idx_off3;
if (i >= pulses) {
i = 0;
if (k >= pulses) {
k = 0;
p1 = idxp;
}
}
if (i != j)
indexoffset = i; /* index position detected */
if (k != j)
indexoffset = k; /* index position detected */
}
}
p1 = idxp;
p2 = avgp;
totalavg = 0;
weakbits = 0;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
uint32_t sum = p1[idx_off1] + p1[idx_off2];
if (sum >= maxidx) {
totalavg += *p2;