claunia/86Box
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More fixes for sonarcloud findings

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-05-16 15:43:20 -04:00
parent ab733b7f6c
commit ce451a2bf4
25 changed files with 688 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
src/floppy/fdc.c
View File

@@ -146,7 +146,7 @@ fdc_card_available(int card)
if (fdc_cards[card].device)
return (device_available(fdc_cards[card].device));
return (1);
return 1;
}
const device_t *
@@ -159,7 +159,7 @@ int
fdc_card_has_config(int card)
{
if (!fdc_cards[card].device)
return (0);
return 0;
return (device_has_config(fdc_cards[card].device) ? 1 : 0);
}
@@ -177,11 +177,11 @@ fdc_card_get_from_internal_name(char *s)
while (fdc_cards[c].device != NULL) {
if (!strcmp((char *) fdc_cards[c].device->internal_name, s))
return (c);
return c;
c++;
}
return (0);
return 0;
}
void
@@ -710,7 +710,9 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
{
fdc_t *fdc = (fdc_t *) priv;
int drive, i, drive_num;
int drive;
int i;
int drive_num;
fdc_log("Write FDC %04X %02X\n", addr, val);
@@ -1630,7 +1632,7 @@ fdc_callback(void *priv)
fdc_poll_readwrite_finish(fdc, compare);
return;
}
if ((fdd_get_head(real_drive(fdc, fdc->drive)) == 0)) {
if (fdd_get_head(real_drive(fdc, fdc->drive)) == 0) {
fdc->sector = 1;
fdc->head |= 1;
fdd_set_head(real_drive(fdc, fdc->drive), 1);
@@ -1883,7 +1885,7 @@ fdc_is_verify(fdc_t *fdc)
int
fdc_data(fdc_t *fdc, uint8_t data, int last)
{
int i, result = 0;
int result = 0;
int n;
if (fdc->deleted & 2) {
@@ -1945,7 +1947,7 @@ fdc_data(fdc_t *fdc, uint8_t data, int last)
if (fdc->fifobufpos > 0)
fdc->fifobufpos = 0;
for (i = 0; i <= n; i++) {
for (int i = 0; i <= n; i++) {
result = dma_channel_write(fdc->dma_ch, fdc->fifobuf[i]);
if (result & DMA_OVER) {
@@ -2057,7 +2059,7 @@ fdc_writeprotect(fdc_t *fdc)
int
fdc_getdata(fdc_t *fdc, int last)
{
int i, data = 0;
int data = 0;
if ((fdc->flags & FDC_FLAG_PCJR) || !fdc->dma) {
if ((fdc->flags & FDC_FLAG_PCJR) || !fdc->fifo || (fdc->tfifo < 1)) {
@@ -2085,7 +2087,7 @@ fdc_getdata(fdc_t *fdc, int last)
}
} else {
if (fdc->fifobufpos == 0) {
for (i = 0; i <= fdc->tfifo; i++) {
for (int i = 0; i <= fdc->tfifo; i++) {
data = dma_channel_read(fdc->dma_ch);
fdc->fifobuf[i] = data;
@@ -2242,7 +2244,6 @@ fdc_remove(fdc_t *fdc)
void
fdc_reset(void *priv)
{
int i = 0;
uint8_t default_rwc;
fdc_t *fdc = (fdc_t *) priv;
@@ -2313,7 +2314,7 @@ fdc_reset(void *priv)
current_drive = 0;
for (i = 0; i < FDD_NUM; i++)
for (uint8_t i = 0; i < FDD_NUM; i++)
ui_sb_update_icon(SB_FLOPPY | i, 0);
}

23
src/floppy/fdd.c
View File

@@ -80,12 +80,14 @@ char *fdd_image_history[FDD_NUM][FLOPPY_IMAGE_HISTORY];
pc_timer_t fdd_poll_time[FDD_NUM];
static int fdd_notfound = 0,
driveloaders[FDD_NUM];
static int fdd_notfound = 0;
static int driveloaders[FDD_NUM];
int writeprot[FDD_NUM], fwriteprot[FDD_NUM],
fdd_changed[FDD_NUM], ui_writeprot[FDD_NUM] = { 0, 0, 0, 0 },
drive_empty[FDD_NUM] = { 1, 1, 1, 1 };
int writeprot[FDD_NUM];
int fwriteprot[FDD_NUM];
int fdd_changed[FDD_NUM];
int ui_writeprot[FDD_NUM] = { 0, 0, 0, 0 };
int drive_empty[FDD_NUM] = { 1, 1, 1, 1 };
DRIVE drives[FDD_NUM];
@@ -296,9 +298,7 @@ fdd_current_track(int drive)
void
fdd_set_densel(int densel)
{
int i = 0;
for (i = 0; i < FDD_NUM; i++) {
for (uint8_t i = 0; i < FDD_NUM; i++) {
if (drive_types[fdd[i].type].flags & FLAG_INVERT_DENSEL)
fdd[i].densel = densel ^ 1;
else
@@ -451,7 +451,8 @@ fdd_get_densel(int drive)
void
fdd_load(int drive, char *fn)
{
int c = 0, size;
int c = 0;
int size;
char *p;
FILE *f;
@@ -593,9 +594,7 @@ fdd_get_bitcell_period(int rate)
void
fdd_reset(void)
{
int i;
for (i = 0; i < FDD_NUM; i++) {
for (uint8_t i = 0; i < FDD_NUM; i++) {
drives[i].id = i;
timer_add(&(fdd_poll_time[i]), fdd_poll, &drives[i], 0);
}

131
src/floppy/fdd_86f.c
View File

@@ -231,7 +231,7 @@ static const uint8_t encoded_mfm[64] = {
static d86f_t *d86f[FDD_NUM];
static uint16_t CRCTable[256];
static fdc_t *d86f_fdc;
uint64_t poly = 0x42F0E1EBA9EA3693ll; /* ECMA normal */
uint64_t poly = 0x42F0E1EBA9EA3693LL; /* ECMA normal */
uint16_t d86f_side_flags(int drive);
int d86f_is_mfm(int drive);
@@ -261,7 +261,8 @@ d86f_log(const char *fmt, ...)
static void
setup_crc(uint16_t poly)
{
int c = 256, bc;
int c = 256;
int bc;
uint16_t temp;
while (c--) {
@@ -283,7 +284,8 @@ void
d86f_destroy_linked_lists(int drive, int side)
{
d86f_t *dev = d86f[drive];
sector_t *s, *t;
sector_t *s;
sector_t *t;
if (dev == NULL)
return;
@@ -432,7 +434,9 @@ d86f_side_flags(int drive)
uint16_t
d86f_track_flags(int drive)
{
uint16_t dr, rr, tf;
uint16_t dr;
uint16_t rr;
uint16_t tf;
tf = d86f_handler[drive].side_flags(drive);
rr = tf & 0x67;
@@ -468,10 +472,12 @@ uint32_t
common_get_raw_size(int drive, int side)
{
double rate = 0.0;
double rpm, rpm_diff;
double rpm;
double rpm_diff;
double size = 100000.0;
int mfm;
int rm, ssd;
int rm;
int ssd;
uint32_t extra_bc = 0;
mfm = d86f_is_mfm(drive);
@@ -601,7 +607,8 @@ int
d86f_get_array_size(int drive, int side, int words)
{
int array_size;
int hole, rm;
int hole;
int rm;
int ssd;
rm = d86f_get_rpm_mode(drive);
@@ -692,7 +699,8 @@ d86f_get_array_size(int drive, int side, int words)
int
d86f_valid_bit_rate(int drive)
{
int hole, rate;
int hole;
int rate;
rate = fdc_get_bit_rate(d86f_fdc);
hole = (d86f_handler[drive].disk_flags(drive) & 6) >> 1;
@@ -786,7 +794,8 @@ uint32_t
d86f_get_data_len(int drive)
{
d86f_t *dev = d86f[drive];
uint32_t i, ret = 128;
uint32_t i;
uint32_t ret = 128;
if (dev->req_sector.id.n)
ret = (uint32_t) 128 << dev->req_sector.id.n;
@@ -930,7 +939,9 @@ d86f_encode_byte(int drive, int sync, decoded_t b, decoded_t prev_b)
uint8_t bits89AB = prev_b.nibbles.nibble0;
uint8_t bits7654 = b.nibbles.nibble1;
uint8_t bits3210 = b.nibbles.nibble0;
uint16_t encoded_7654, encoded_3210, result;
uint16_t encoded_7654;
uint16_t encoded_3210;
uint16_t result;
if (encoding > 1)
return 0xffff;
@@ -1246,7 +1257,7 @@ d86f_find_address_mark_fm(int drive, int side, find_t *find, uint16_t req_am, ui
return;
}
if ((wrong_am) && (dev->last_word[side] == wrong_am)) {
if (wrong_am && (dev->last_word[side] == wrong_am)) {
dev->data_find.sync_marks = dev->data_find.bits_obtained = dev->data_find.bytes_obtained = 0;
dev->error_condition = 0;
dev->state = STATE_IDLE;
@@ -1311,7 +1322,7 @@ d86f_find_address_mark_mfm(int drive, int side, find_t *find, uint16_t req_am, u
return;
}
if ((wrong_am) && (dev->last_word[side] == wrong_am) && (find->sync_marks >= 3)) {
if (wrong_am && (dev->last_word[side] == wrong_am) && (find->sync_marks >= 3)) {
dev->data_find.sync_marks = dev->data_find.bits_obtained = dev->data_find.bytes_obtained = 0;
dev->error_condition = 0;
dev->state = STATE_IDLE;
@@ -1469,7 +1480,8 @@ uint8_t
d86f_get_data(int drive, int base)
{
d86f_t *dev = d86f[drive];
int data, byte_count;
int data;
int byte_count;
if (fdd_get_turbo(drive) && (dev->version == 0x0063))
byte_count = dev->turbo_pos;
@@ -1749,8 +1761,13 @@ void
d86f_write_direct_common(int drive, int side, uint16_t byte, uint8_t type, uint32_t pos)
{
d86f_t *dev = d86f[drive];
uint16_t encoded_byte = 0, mask_data, mask_surface, mask_hole, mask_fuzzy;
decoded_t dbyte, dpbyte;
uint16_t encoded_byte = 0;
uint16_t mask_data;
uint16_t mask_surface;
uint16_t mask_hole;
uint16_t mask_fuzzy;
decoded_t dbyte;
decoded_t dpbyte;
if (fdc_get_diswr(d86f_fdc))
return;
@@ -2062,7 +2079,8 @@ static uint8_t
d86f_sector_flags(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
d86f_t *dev = d86f[drive];
sector_t *s, *t;
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2169,7 +2187,6 @@ d86f_turbo_format(int drive, int side, int nop)
int dat;
uint16_t sc;
uint16_t dtl;
int i;
sc = fdc_get_format_sectors(d86f_fdc);
dtl = 128 << fdc_get_format_n(d86f_fdc);
@@ -2187,7 +2204,7 @@ d86f_turbo_format(int drive, int side, int nop)
}
} else if (dev->datac == 4) {
if (!nop) {
for (i = 0; i < dtl; i++)
for (uint16_t i = 0; i < dtl; i++)
d86f_handler[drive].write_data(drive, side, i, dev->fill);
}
@@ -2213,7 +2230,8 @@ int
d86f_sector_is_present(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
d86f_t *dev = d86f[drive];
sector_t *s, *t;
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2354,7 +2372,8 @@ void
d86f_poll(int drive)
{
d86f_t *dev = d86f[drive];
int mfm, side;
int mfm;
int side;
side = fdd_get_head(drive);
if (!fdd_is_double_sided(drive))
@@ -2750,11 +2769,18 @@ void
d86f_construct_encoded_buffer(int drive, int side)
{
d86f_t *dev = d86f[drive];
uint32_t i = 0;
/* *_fuzm are fuzzy bit masks, *_holm are hole masks, dst_neim are masks is mask for bits that are neither fuzzy nor holes in both,
and src1_d and src2_d are filtered source data. */
uint16_t src1_fuzm, src2_fuzm, dst_fuzm, src1_holm, src2_holm, dst_holm, dst_neim, src1_d, src2_d;
uint16_t src1_fuzm;
uint16_t src2_fuzm;
uint16_t dst_fuzm;
uint16_t src1_holm;
uint16_t src2_holm;
uint16_t dst_holm;
uint16_t dst_neim;
uint16_t src1_d;
uint16_t src2_d;
uint32_t len;
uint16_t *dst = dev->track_encoded_data[side];
uint16_t *dst_s = dev->track_surface_data[side];
@@ -2764,7 +2790,7 @@ d86f_construct_encoded_buffer(int drive, int side)
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
len = d86f_get_array_size(drive, side, 1);
for (i = 0; i < len; i++) {
for (uint32_t i = 0; i < len; i++) {
/* The two bits differ. */
if (d86f_has_surface_desc(drive)) {
/* Source image has surface description data, so we have some more handling to do. */
@@ -2799,8 +2825,8 @@ void
d86f_decompose_encoded_buffer(int drive, int side)
{
d86f_t *dev = d86f[drive];
uint32_t i = 0;
uint16_t temp, temp2;
uint16_t temp;
uint16_t temp2;
uint32_t len;
uint16_t *dst = dev->track_encoded_data[side];
uint16_t *src1 = dev->thin_track_encoded_data[0][side];
@@ -2810,7 +2836,7 @@ d86f_decompose_encoded_buffer(int drive, int side)
dst = d86f_handler[drive].encoded_data(drive, side);
len = d86f_get_array_size(drive, side, 1);
for (i = 0; i < len; i++) {
for (uint32_t i = 0; i < len; i++) {
if (d86f_has_surface_desc(drive)) {
/* Source image has surface description data, so we have some more handling to do.
We need hole masks for both buffers. Holes have data bit clear and surface bit set. */
@@ -2901,10 +2927,10 @@ void
d86f_zero_track(int drive)
{
d86f_t *dev = d86f[drive];
int sides, side;
int sides;
sides = d86f_get_sides(drive);
for (side = 0; side < sides; side++) {
for (int side = 0; side < sides; side++) {
if (d86f_has_surface_desc(drive))
memset(dev->track_surface_data[side], 0, 106096);
memset(dev->track_encoded_data[side], 0, 106096);
@@ -2916,7 +2942,8 @@ d86f_seek(int drive, int track)
{
d86f_t *dev = d86f[drive];
int sides;
int side, thin_track;
int side;
int thin_track;
sides = d86f_get_sides(drive);
/* If the drive has thick tracks, shift the track number by 1. */
@@ -2995,8 +3022,9 @@ void
d86f_write_tracks(int drive, FILE **f, uint32_t *track_table)
{
d86f_t *dev = d86f[drive];
int sides, fdd_side;
int side, thin_track;
int sides;
int fdd_side;
int side;
int logical_track = 0;
uint32_t *tbl;
tbl = dev->track_offset;
@@ -3011,7 +3039,7 @@ d86f_write_tracks(int drive, FILE **f, uint32_t *track_table)
if (sides == 2)
d86f_decompose_encoded_buffer(drive, 1);
for (thin_track = 0; thin_track < 2; thin_track++) {
for (uint8_t thin_track = 0; thin_track < 2; thin_track++) {
for (side = 0; side < sides; side++) {
fdd_set_head(drive, side);
@@ -3060,7 +3088,8 @@ d86f_writeback(int drive)
{
d86f_t *dev = d86f[drive];
uint8_t header[32];
int header_size, size;
int header_size;
int size;
#ifdef D86F_COMPRESS
uint32_t len;
int ret = 0;
@@ -3264,8 +3293,8 @@ void
d86f_common_format(int drive, int side, int rate, uint8_t fill, int proxy)
{
d86f_t *dev = d86f[drive];
uint32_t i = 0;
uint16_t temp, temp2;
uint16_t temp;
uint16_t temp2;
uint32_t array_size;
if (writeprot[drive]) {
@@ -3297,7 +3326,7 @@ d86f_common_format(int drive, int side, int rate, uint8_t fill, int proxy)
if (d86f_has_surface_desc(drive)) {
/* Preserve the physical holes but get rid of the fuzzy bytes. */
for (i = 0; i < array_size; i++) {
for (uint32_t i = 0; i < array_size; i++) {
temp = dev->track_encoded_data[side][i] ^ 0xffff;
temp2 = dev->track_surface_data[side][i];
temp &= temp2;
@@ -3366,7 +3395,6 @@ d86f_export(int drive, char *fn)
d86f_t *temp86;
FILE *f;
int tracks = 86;
int i;
int inc = 1;
uint32_t magic = 0x46423638;
uint16_t version = 0x020C;
@@ -3393,7 +3421,7 @@ d86f_export(int drive, char *fn)
if (!fdd_doublestep_40(drive))
inc = 2;
for (i = 0; i < tracks; i += inc) {
for (int i = 0; i < tracks; i += inc) {
if (inc == 2)
fdd_do_seek(drive, i >> 1);
else
@@ -3426,7 +3454,6 @@ d86f_load(int drive, char *fn)
d86f_t *dev = d86f[drive];
uint32_t magic = 0;
uint32_t len = 0;
int i = 0, j = 0;
#ifdef D86F_COMPRESS
char temp_file_name[2048];
uint16_t temp = 0;
@@ -3501,11 +3528,11 @@ d86f_load(int drive, char *fn)
(void) !fread(&(dev->disk_flags), 2, 1, dev->f);
if (d86f_has_surface_desc(drive)) {
for (i = 0; i < 2; i++)
for (uint8_t i = 0; i < 2; i++)
dev->track_surface_data[i] = (uint16_t *) malloc(53048 * sizeof(uint16_t));
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++)
for (uint8_t i = 0; i < 2; i++) {
for (uint8_t j = 0; j < 2; j++)
dev->thin_track_surface_data[i][j] = (uint16_t *) malloc(53048 * sizeof(uint16_t));
}
}
@@ -3750,11 +3777,9 @@ d86f_load(int drive, char *fn)
void
d86f_init(void)
{
int i;
setup_crc(0x1021);
for (i = 0; i < FDD_NUM; i++)
for (uint8_t i = 0; i < FDD_NUM; i++)
d86f[i] = NULL;
}
@@ -3767,8 +3792,6 @@ d86f_set_fdc(void *fdc)
void
d86f_close(int drive)
{
int i, j;
char temp_file_name[2048];
d86f_t *dev = d86f[drive];
@@ -3779,15 +3802,15 @@ d86f_close(int drive)
memcpy(temp_file_name, drive ? nvr_path("TEMP$$$1.$$$") : nvr_path("TEMP$$$0.$$$"), 26);
if (d86f_has_surface_desc(drive)) {
for (i = 0; i < 2; i++) {
for (uint8_t i = 0; i < 2; i++) {
if (dev->track_surface_data[i]) {
free(dev->track_surface_data[i]);
dev->track_surface_data[i] = NULL;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
for (uint8_t i = 0; i < 2; i++) {
for (uint8_t j = 0; j < 2; j++) {
if (dev->thin_track_surface_data[i][j]) {
free(dev->thin_track_surface_data[i][j]);
dev->thin_track_surface_data[i][j] = NULL;
@@ -3828,23 +3851,21 @@ d86f_setup(int drive)
void
d86f_destroy(int drive)
{
int i, j;
d86f_t *dev = d86f[drive];
if (dev == NULL)
return;
if (d86f_has_surface_desc(drive)) {
for (i = 0; i < 2; i++) {
for (uint8_t i = 0; i < 2; i++) {
if (dev->track_surface_data[i]) {
free(dev->track_surface_data[i]);
dev->track_surface_data[i] = NULL;
}
}
for (i = 0; i < 2; i++) {
for (j = 0; j < 2; j++) {
for (uint8_t i = 0; i < 2; i++) {
for (uint8_t j = 0; j < 2; j++) {
if (dev->thin_track_surface_data[i][j]) {
free(dev->thin_track_surface_data[i][j]);
dev->thin_track_surface_data[i][j] = NULL;

10
src/floppy/fdd_common.c
View File

@@ -398,7 +398,7 @@ fdd_sector_size_code(int size)
break;
}
return (ret);
return ret;
}
int
@@ -410,15 +410,13 @@ fdd_sector_code_size(uint8_t code)
int
fdd_bps_valid(uint16_t bps)
{
int i;
for (i = 0; i <= 8; i++) {
for (uint8_t i = 0; i <= 8; i++) {
if (bps == (128 << i)) {
return 1;
}
}
return (0);
return 0;
}
int
@@ -435,5 +433,5 @@ fdd_interleave(int sector, int skew, int spt)
adjusted_r += (adjust + add);
}
return (adjusted_r);
return adjusted_r;
}

23
src/floppy/fdd_fdi.c
View File

@@ -104,7 +104,7 @@ disk_flags(int drive)
*/
temp_disk_flags |= 0x800;
return (temp_disk_flags);
return temp_disk_flags;
}
static uint16_t
@@ -143,34 +143,34 @@ side_flags(int drive)
*/
temp_side_flags |= 0x08;
return (temp_side_flags);
return temp_side_flags;
}
static int
fdi_density(void)
{
if (!fdc_is_mfm(fdi_fdc))
return (0);
return 0;
switch (fdc_get_bit_rate(fdi_fdc)) {
case 0:
return (2);
return 2;
case 1:
return (1);
return 1;
case 2:
return (1);
return 1;
case 3:
case 5:
return (3);
return 3;
default:
break;
}
return (1);
return 1;
}
static int32_t
@@ -207,14 +207,15 @@ extra_bit_cells(int drive, int side)
raw_size = is_300_rpm ? 100000 : 83333;
}
return ((dev->tracklen[side][density] - raw_size));
return (dev->tracklen[side][density] - raw_size);
}
static void
read_revolution(int drive)
{
fdi_t *dev = fdi[drive];
int c, den, side;
int c;
int den;
int track = dev->track;
if (track > dev->lasttrack) {
@@ -227,7 +228,7 @@ read_revolution(int drive)
}
for (den = 0; den < 4; den++) {
for (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
c = fdi2raw_loadtrack(dev->h,
(uint16_t *) dev->track_data[side][den],
(uint16_t *) dev->track_timing[side][den],

91
src/floppy/fdd_imd.c
View File

@@ -129,16 +129,21 @@ get_raw_tsize(int side_flags, int slower_rpm)
break;
}
return (size);
return size;
}
static int
track_is_xdf(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int i, effective_sectors, xdf_sectors;
int high_sectors, low_sectors;
int max_high_id, expected_high_count, expected_low_count;
int i;
int effective_sectors;
int xdf_sectors;
int high_sectors;
int low_sectors;
int max_high_id;
int expected_high_count;
int expected_low_count;
uint8_t *r_map;
uint8_t *n_map;
@@ -148,16 +153,16 @@ track_is_xdf(int drive, int side, int track)
dev->xdf_ordered_pos[i][side] = 0;
if (dev->tracks[track][side].params[2] & 0xC0)
return (0);
return 0;
if ((dev->tracks[track][side].params[3] != 16) && (dev->tracks[track][side].params[3] != 19))
return (0);
return 0;
r_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].r_map_offs);
if (!track) {
if (dev->tracks[track][side].params[4] != 2)
return (0);
return 0;
if (!side) {
max_high_id = (dev->tracks[track][side].params[3] == 19) ? 0x8B : 0x88;
@@ -183,10 +188,10 @@ track_is_xdf(int drive, int side, int track)
return ((dev->tracks[track][side].params[3] == 19) ? 2 : 1);
}
}
return (0);
return 0;
} else {
if (dev->tracks[track][side].params[4] != 0xFF)
return (0);
return 0;
n_map = (uint8_t *) (dev->buffer + dev->tracks[track][side].n_map_offs);
@@ -203,31 +208,31 @@ track_is_xdf(int drive, int side, int track)
if ((effective_sectors == 3) && (xdf_sectors == 3)) {
dev->current_side_flags[side] = 0x28;
return (1); /* 5.25" 2HD XDF */
return 1; /* 5.25" 2HD XDF */
}
if ((effective_sectors == 4) && (xdf_sectors == 4)) {
dev->current_side_flags[side] = 0x08;
return (2); /* 3.5" 2HD XDF */
return 2; /* 3.5" 2HD XDF */
}
return (0);
return 0;
}
return (0);
return 0;
}
static int
track_is_interleave(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int i, effective_sectors;
int effective_sectors;
char *r_map;
int track_spt;
effective_sectors = 0;
for (i = 0; i < 256; i++)
for (uint16_t i = 0; i < 256; i++)
dev->interleave_ordered_pos[i][side] = 0;
track_spt = dev->tracks[track][side].params[3];
@@ -235,15 +240,15 @@ track_is_interleave(int drive, int side, int track)
r_map = dev->buffer + dev->tracks[track][side].r_map_offs;
if (dev->tracks[track][side].params[2] & 0xC0)
return (0);
return 0;
if (track_spt != 21)
return (0);
return 0;
if (dev->tracks[track][side].params[4] != 2)
return (0);
return 0;
for (i = 0; i < track_spt; i++) {
for (int i = 0; i < track_spt; i++) {
if ((r_map[i] >= 1) && (r_map[i] <= track_spt)) {
effective_sectors++;
dev->interleave_ordered_pos[(int) r_map[i]][side] = i;
@@ -251,9 +256,9 @@ track_is_interleave(int drive, int side, int track)
}
if (effective_sectors == track_spt)
return (1);
return 1;
return (0);
return 0;
}
static void
@@ -282,8 +287,11 @@ imd_seek(int drive, int track)
uint8_t id[4] = { 0, 0, 0, 0 };
uint8_t type;
imd_t *dev = imd[drive];
int sector, current_pos;
int side, c = 0, h, n;
int sector;
int current_pos;
int c = 0;
int h;
int n;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
@@ -329,7 +337,7 @@ imd_seek(int drive, int track)
if (track > dev->track_count)
return;
for (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
if (!dev->tracks[track][side].is_present)
continue;
@@ -460,7 +468,7 @@ side_flags(int drive)
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
return (sflags);
return sflags;
}
static void
@@ -468,8 +476,13 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
imd_t *dev = imd[drive];
int track = dev->track;
int i, sc, sh, sn;
char *c_map = NULL, *h_map = NULL, *r_map = NULL, *n_map = NULL;
int sc;
int sh;
int sn;
char *c_map = NULL;
char *h_map = NULL;
char *r_map = NULL;
char *n_map = NULL;
uint8_t id[4] = { 0, 0, 0, 0 };
sc = dev->tracks[track][side].params[1];
sh = dev->tracks[track][side].params[2];
@@ -487,7 +500,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
if (c != dev->track)
return;
for (i = 0; i < dev->tracks[track][side].params[3]; i++) {
for (uint8_t i = 0; i < dev->tracks[track][side].params[3]; i++) {
id[0] = (sh & 0x80) ? c_map[i] : sc;
id[1] = (sh & 0x40) ? h_map[i] : (sh & 1);
id[2] = r_map[i];
@@ -502,17 +515,17 @@ static void
imd_writeback(int drive)
{
imd_t *dev = imd[drive];
int side;
int track = dev->track;
int i = 0;
char *n_map = 0;
uint8_t h, n, spt;
uint8_t h;
uint8_t n;
uint8_t spt;
uint32_t ssize;
if (writeprot[drive])
return;
for (side = 0; side < dev->sides; side++) {
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);
h = dev->tracks[track][side].params[2];
@@ -530,7 +543,7 @@ imd_writeback(int drive)
n_map = dev->buffer + dev->tracks[track][side].n_map_offs;
fwrite(n_map, 1, spt, dev->f);
}
for (i = 0; i < spt; i++) {
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);
@@ -546,7 +559,7 @@ poll_read_data(int drive, int side, uint16_t pos)
int type = dev->current_data[side][0];
if ((type == 0) || (type > 8))
return (0xf6); /* Should never happen. */
return 0xf6; /* Should never happen. */
if (type & 1)
return (dev->current_data[side][pos + 1]);
@@ -574,13 +587,14 @@ format_conditions(int drive)
{
imd_t *dev = imd[drive];
int track = dev->track;
int side, temp;
int side;
int temp;
side = fdd_get_head(drive);
temp = (fdc_get_format_sectors(imd_fdc) == dev->tracks[track][side].params[3]);
temp = temp && (fdc_get_format_n(imd_fdc) == dev->tracks[track][side].params[4]);
return (temp);
return temp;
}
void
@@ -613,7 +627,8 @@ imd_load(int drive, char *fn)
uint32_t minimum_gap4 = 0;
uint8_t converted_rate;
uint8_t type;
int size_diff, gap_sum;
int size_diff;
int gap_sum;
d86f_unregister(drive);
@@ -708,7 +723,7 @@ imd_load(int drive, char *fn)
dev->tracks[track][side].side_flags = (buffer2[0] % 3);
if (!dev->tracks[track][side].side_flags)
dev->disk_flags |= (0x02);
dev->disk_flags |= 0x02;
dev->tracks[track][side].side_flags |= (!(buffer2[0] - dev->tracks[track][side].side_flags) ? 0 : 8);
mfm = dev->tracks[track][side].side_flags & 8;
track_total = mfm ? 146 : 73;

65
src/floppy/fdd_img.c
View File

@@ -42,7 +42,7 @@
typedef struct {
FILE *f;
uint8_t track_data[2][50000];
uint8_t track_data[2][688128];
int sectors, tracks, sides;
uint8_t sector_size;
int xdf_type; /* 0 = not XDF, 1-5 = one of the five XDF types */
@@ -71,10 +71,10 @@ static fdc_t *img_fdc;
static double bit_rate_300;
static char *ext;
static uint8_t first_byte,
second_byte,
third_byte,
fourth_byte;
static uint8_t first_byte;
static uint8_t second_byte;
static uint8_t third_byte;
static uint8_t fourth_byte;
static uint8_t fdf_suppress_final_byte = 0; /* This is hard-coded to 0 -
* if you really need to read
* those NT 3.1 Beta floppy
@@ -339,43 +339,41 @@ sector_size_code(int sector_size)
{
switch (sector_size) {
case 128:
return (0);
return 0;
case 256:
return (1);
return 1;
default:
case 512:
return (2);
return 2;
case 1024:
return (3);
return 3;
case 2048:
return (4);
return 4;
case 4096:
return (5);
return 5;
case 8192:
return (6);
return 6;
case 16384:
return (7);
return 7;
}
}
static int
bps_is_valid(uint16_t bps)
{
int i;
for (i = 0; i <= 8; i++) {
for (uint8_t i = 0; i <= 8; i++) {
if (bps == (128 << i))
return (1);
return 1;
}
return (0);
return 0;
}
static int
@@ -385,13 +383,13 @@ first_byte_is_valid(uint8_t first_byte)
case 0x60:
case 0xE9:
case 0xEB:
return (1);
return 1;
default:
break;
}
return (0);
return 0;
}
#define xdf_img_sector xdf_img_layout[current_xdft][!is_t0][sector]
@@ -410,7 +408,7 @@ interleave(int sector, int skew, int track_spt)
if (skewed_i & 1)
adjusted_r += (adjust + add);
return (adjusted_r);
return adjusted_r;
}
static void
@@ -418,7 +416,7 @@ write_back(int drive)
{
img_t *dev = img[drive];
int ssize = 128 << ((int) dev->sector_size);
int side, size;
int size;
if (dev->f == NULL)
return;
@@ -428,7 +426,7 @@ write_back(int drive)
if (fseek(dev->f, 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 (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
size = dev->sectors * ssize;
if (fwrite(dev->track_data[side], 1, size, dev->f) != size)
fatal("IMG write_back(): Error writing data\n");
@@ -485,7 +483,7 @@ format_conditions(int drive)
temp = temp && (fdc_get_format_n(img_fdc) == dev->sector_size);
temp = temp && (dev->xdf_type == 0);
return (temp);
return temp;
}
static void
@@ -496,7 +494,16 @@ img_seek(int drive, int track)
int current_xdft = dev->xdf_type - 1;
int read_bytes = 0;
uint8_t id[4] = { 0, 0, 0, 0 };
int is_t0, sector, current_pos, img_pos, sr, sside, total, array_sector, buf_side, buf_pos;
int is_t0;
int sector;
int current_pos;
int img_pos;
int sr;
int sside;
int total;
int array_sector;
int buf_side;
int buf_pos;
int ssize = 128 << ((int) dev->sector_size);
uint32_t cur_pos = 0;
@@ -647,7 +654,10 @@ img_load(int drive, char *fn)
uint8_t bpb_mid; /* Media type ID. */
uint8_t bpb_sectors;
uint8_t bpb_sides;
uint8_t cqm, ddi, fdf, fdi;
uint8_t cqm;
uint8_t ddi;
uint8_t fdf;
uint8_t fdi;
uint16_t comment_len = 0;
int16_t block_len = 0;
uint32_t cur_pos = 0;
@@ -661,7 +671,6 @@ img_load(int drive, char *fn)
int temp_rate;
int guess = 0;
int size;
int i;
ext = path_get_extension(fn);
@@ -1152,7 +1161,7 @@ jump_if_fdf:
temp_rate = 0xFF;
}
for (i = 0; i < 6; i++) {
for (uint8_t i = 0; i < 6; i++) {
if ((dev->sectors <= maximum_sectors[dev->sector_size][i]) || (dev->sectors == xdf_sectors[dev->sector_size][i])) {
bit_rate_300 = bit_rates_300[i];
temp_rate = rates[i];

49
src/floppy/fdd_json.c
View File

@@ -125,10 +125,11 @@ static void
handle(json_t *dev, char *name, char *str)
{
sector_t *sec = NULL;
uint32_t l, pat;
uint32_t l;
uint32_t pat;
uint8_t *p;
char *sp;
int i, s;
int s;
/* Point to the currently selected sector. */
sec = &dev->sects[dev->track][dev->side][dev->dmf - 1];
@@ -163,7 +164,7 @@ handle(json_t *dev, char *name, char *str)
sec->data = (uint8_t *) malloc(sec->size);
p = sec->data;
s = (sec->size / sizeof(uint32_t));
for (i = 0; i < s; i++) {
for (int i = 0; i < s; i++) {
l = pat;
*p++ = (l & 0x000000ff);
l >>= 8;
@@ -207,18 +208,21 @@ unexpect(int c, int state, int level)
static int
load_image(json_t *dev)
{
char buff[4096], name[32];
int c, i, j, state, level;
char buff[4096];
char name[32];
int c;
int state;
int level;
char *ptr;
if (dev->f == NULL) {
json_log("JSON: no file loaded!\n");
return (0);
return 0;
}
/* Initialize. */
for (i = 0; i < NTRACKS; i++) {
for (j = 0; j < NSIDES; j++)
for (uint16_t i = 0; i < NTRACKS; i++) {
for (uint8_t j = 0; j < NSIDES; j++)
memset(dev->sects[i][j], 0x00, sizeof(sector_t));
}
dev->track = dev->side = dev->dmf = 0; /* "dmf" is "sector#" */
@@ -375,7 +379,7 @@ load_image(json_t *dev)
dev->tracks = dev->track;
dev->sides = dev->side;
return (1);
return 1;
}
/* Seek the heads to a track, and prepare to read data from that track. */
@@ -384,9 +388,13 @@ json_seek(int drive, int track)
{
uint8_t id[4] = { 0, 0, 0, 0 };
json_t *dev = images[drive];
int side, sector;
int rate, gap2, gap3, pos;
int ssize, rsec, asec;
int rate;
int gap2;
int gap3;
int pos;
int ssize;
int rsec;
int asec;
if (dev->f == NULL) {
json_log("JSON: seek: no file loaded!\n");
@@ -412,7 +420,7 @@ json_seek(int drive, int track)
return;
}
for (side = 0; side < dev->sides; side++) {
for (uint8_t side = 0; side < dev->sides; side++) {
/* Get transfer rate for this side. */
rate = dev->track_flags & 0x07;
if (!rate && (dev->track_flags & 0x20))
@@ -428,7 +436,7 @@ json_seek(int drive, int track)
pos = d86f_prepare_pretrack(drive, side, 0);
for (sector = 0; sector < dev->spt[track][side]; sector++) {
for (uint8_t sector = 0; sector < dev->spt[track][side]; sector++) {
rsec = dev->sects[track][side][sector].sector;
asec = sector;
@@ -473,7 +481,6 @@ static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
json_t *dev = images[drive];
int i;
dev->sector[side] = 0;
@@ -485,7 +492,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
dev->side = side;
/* Now loop over all sector ID's on this side to find our sector. */
for (i = 0; i < dev->spt[c][side]; i++) {
for (uint8_t i = 0; i < dev->spt[c][side]; i++) {
if ((dev->sects[dev->track][side][i].track == c) && (dev->sects[dev->track][side][i].side == h) && (dev->sects[dev->track][side][i].sector == r) && (dev->sects[dev->track][side][i].size == n)) {
dev->sector[side] = i;
}
@@ -514,7 +521,6 @@ json_load(int drive, char *fn)
int temp_rate;
sector_t *sec;
json_t *dev;
int i;
/* Just in case- remove ourselves from 86F. */
d86f_unregister(drive);
@@ -571,7 +577,7 @@ json_load(int drive, char *fn)
temp_rate = 0xff;
sec = &dev->sects[0][0][0];
for (i = 0; i < 6; i++) {
for (uint8_t i = 0; i < 6; i++) {
if (dev->spt[0][0] > fdd_max_sectors[sec->size][i])
continue;
@@ -667,7 +673,6 @@ void
json_close(int drive)
{
json_t *dev = images[drive];
int t, h, s;
if (dev == NULL)
return;
@@ -676,10 +681,10 @@ json_close(int drive)
d86f_unregister(drive);
/* Release all the sector buffers. */
for (t = 0; t < 256; t++) {
for (h = 0; h < 2; h++) {
for (uint16_t t = 0; t < 256; t++) {
for (uint8_t h = 0; h < 2; h++) {
memset(dev->sects[t][h], 0x00, sizeof(sector_t));
for (s = 0; s < 256; s++) {
for (uint16_t s = 0; s < 256; s++) {
if (dev->sects[t][h][s].data != NULL)
free(dev->sects[t][h][s].data);
dev->sects[t][h][s].data = NULL;

30
src/floppy/fdd_mfm.c
View File

@@ -103,9 +103,9 @@ static int
get_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int i, ret = -1;
int ret = -1;
for (i = 0; i < dev->total_tracks; i++) {
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->tracks[i].track_no == track) && (dev->tracks[i].side_no == side)) {
ret = i;
break;
@@ -119,9 +119,9 @@ static int
get_adv_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int i, ret = -1;
int ret = -1;
for (i = 0; i < dev->total_tracks; i++) {
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->adv_tracks[i].track_no == track) && (dev->adv_tracks[i].side_no == side)) {
ret = i;
break;
@@ -154,7 +154,8 @@ get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
static void
set_disk_flags(int drive)
{
int br = 250, rpm = 300;
int br = 250;
int rpm = 300;
mfm_t *dev = mfm[drive];
uint16_t temp_disk_flags = 0x1080; /* We ALWAYS claim to have extra bit cells, even if the actual amount is 0;
Bit 12 = 1, bits 6, 5 = 0 - extra bit cells field specifies the entire
@@ -203,7 +204,8 @@ set_side_flags(int drive, int side)
{
mfm_t *dev = mfm[drive];
uint16_t temp_side_flags = 0;
int br = 250, rpm = 300;
int br = 250;
int rpm = 300;
if (dev->hdr.if_type & 0x80)
get_adv_track_bitrate(drive, side, dev->cur_track, &br, &rpm);
@@ -264,8 +266,10 @@ static uint32_t
get_raw_size(int drive, int side)
{
mfm_t *dev = mfm[drive];
int track_index, is_300_rpm;
int br = 250, rpm = 300;
int track_index;
int is_300_rpm;
int br = 250;
int rpm = 300;
if (dev->hdr.if_type & 0x80) {
track_index = get_adv_track_index(drive, side, dev->cur_track);
@@ -319,8 +323,10 @@ void
mfm_read_side(int drive, int side)
{
mfm_t *dev = mfm[drive];
int track_index, track_size;
int track_bytes, ret;
int track_index;
int track_size;
int track_bytes;
int ret;
if (dev->hdr.if_type & 0x80)
track_index = get_adv_track_index(drive, side, dev->cur_track);
@@ -382,7 +388,7 @@ mfm_load(int drive, char *fn)
{
mfm_t *dev;
double dbr;
int i, size;
int size;
writeprot[drive] = fwriteprot[drive] = 1;
@@ -427,7 +433,7 @@ mfm_load(int drive, char *fn)
dev->hdr.tracks_no >>= 1;
dev->hdr.sides_no <<= 1;
for (i = 0; i < dev->total_tracks; i++) {
for (int i = 0; i < dev->total_tracks; i++) {
if (dev->hdr.if_type & 0x80) {
dev->adv_tracks[i].side_no <<= 1;
dev->adv_tracks[i].side_no |= (dev->adv_tracks[i].track_no & 1);

137
src/floppy/fdd_td0.c
View File

@@ -237,11 +237,11 @@ dsk_identify(int drive)
fdd_image_read(drive, header, 0, 2);
if (header[0] == 'T' && header[1] == 'D')
return (1);
return 1;
else if (header[0] == 't' && header[1] == 'd')
return (1);
return 1;
return (0);
return 0;
}
static int
@@ -259,7 +259,7 @@ state_data_read(td0dsk_t *state, uint8_t *buf, uint16_t size)
fatal("TD0: Error reading data in state_data_read()\n");
state->fdd_file_offset += size;
return (size);
return size;
}
static int
@@ -277,7 +277,7 @@ state_next_word(td0dsk_t *state)
state->getlen += 8;
}
return (0);
return 0;
}
/* get one bit */
@@ -293,9 +293,9 @@ state_GetBit(td0dsk_t *state)
state->getbuf <<= 1;
state->getlen--;
if (i < 0)
return (1);
return 1;
return (0);
return 0;
}
/* get a byte */
@@ -305,7 +305,7 @@ state_GetByte(td0dsk_t *state)
uint16_t i;
if (state_next_word(state) != 0)
return (-1);
return -1;
i = state->getbuf;
state->getbuf <<= 8;
@@ -319,7 +319,8 @@ state_GetByte(td0dsk_t *state)
static void
state_StartHuff(td0dsk_t *state)
{
int i, j;
int i;
int j;
for (i = 0; i < N_CHAR; i++) {
state->freq[i] = 1;
@@ -343,8 +344,11 @@ state_StartHuff(td0dsk_t *state)
static void
state_reconst(td0dsk_t *state)
{
int16_t i, j, k;
uint16_t f, l;
int16_t i;
int16_t j;
int16_t k;
uint16_t f;
uint16_t l;
/* halven cumulative freq for leaf nodes */
j = 0;
@@ -385,7 +389,10 @@ state_reconst(td0dsk_t *state)
static void
state_update(td0dsk_t *state, int c)
{
int i, j, k, l;
int i;
int j;
int k;
int l;
if (state->freq[R] == MAX_FREQ)
state_reconst(state);
@@ -444,14 +451,16 @@ state_DecodeChar(td0dsk_t *state)
state_update(state, c);
return (c);
return c;
}
static int16_t
state_DecodePosition(td0dsk_t *state)
{
int16_t bit;
uint16_t i, j, c;
uint16_t i;
uint16_t j;
uint16_t c;
/* decode upper 6 bits from given table */
if ((bit = state_GetByte(state)) < 0)
@@ -476,15 +485,13 @@ state_DecodePosition(td0dsk_t *state)
static void
state_init_Decode(td0dsk_t *state)
{
int i;
state->getbuf = 0;
state->getlen = 0;
state->tdctl.ibufcnt = state->tdctl.ibufndx = 0; /* input buffer is empty */
state->tdctl.bufcnt = 0;
state_StartHuff(state);
for (i = 0; i < N - F; i++)
for (uint16_t i = 0; i < N - F; i++)
state->text_buf[i] = ' ';
state->tdctl.r = N - F;
@@ -494,13 +501,14 @@ state_init_Decode(td0dsk_t *state)
static int
state_Decode(td0dsk_t *state, uint8_t *buf, int len)
{
int16_t c, pos;
int16_t c;
int16_t pos;
int count; /* was an unsigned long, seems unnecessary */
for (count = 0; count < len;) {
if (state->tdctl.bufcnt == 0) {
if ((c = state_DecodeChar(state)) < 0)
return (count); /* fatal error */
return count; /* fatal error */
if (c < 256) {
*(buf++) = c & 0xff;
state->text_buf[state->tdctl.r++] = c & 0xff;
@@ -508,7 +516,7 @@ state_Decode(td0dsk_t *state, uint8_t *buf, int len)
count++;
} else {
if ((pos = state_DecodePosition(state)) < 0)
return (count); /* fatal error */
return count; /* fatal error */
state->tdctl.bufpos = (state->tdctl.r - pos - 1) & (N - 1);
state->tdctl.bufcnt = c - 255 + THRESHOLD;
state->tdctl.bufndx = 0;
@@ -530,7 +538,7 @@ state_Decode(td0dsk_t *state, uint8_t *buf, int len)
}
}
return (count); /* count == len, success */
return count; /* count == len, success */
}
static uint32_t
@@ -578,7 +586,7 @@ get_raw_tsize(int side_flags, int slower_rpm)
break;
}
return (size);
return size;
}
static int
@@ -586,15 +594,19 @@ td0_initialize(int drive)
{
td0_t *dev = td0[drive];
uint8_t header[12];
int fm, head, track;
int fm;
int head;
int track;
int track_count = 0;
int head_count = 0;
int track_spt, track_spt_adjusted;
int track_spt;
int track_spt_adjusted;
int offset = 0;
int density = 0;
int temp_rate = 0;
uint32_t file_size;
uint16_t len, rep;
uint16_t len;
uint16_t rep;
td0dsk_t disk_decode;
uint8_t *hs;
uint16_t size;
@@ -606,12 +618,15 @@ td0_initialize(int drive)
int32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
int i, j, k;
int size_diff, gap_sum;
int i;
int j;
int k;
int size_diff;
int gap_sum;
if (dev->f == NULL) {
td0_log("TD0: Attempted to initialize without loading a file first\n");
return (0);
return 0;
}
fseek(dev->f, 0, SEEK_END);
@@ -619,12 +634,12 @@ td0_initialize(int drive)
if (file_size < 12) {
td0_log("TD0: File is too small to even contain the header\n");
return (0);
return 0;
}
if (file_size > TD0_MAX_BUFSZ) {
td0_log("TD0: File exceeds the maximum size\n");
return (0);
return 0;
}
fseek(dev->f, 0, SEEK_SET);
@@ -652,14 +667,14 @@ td0_initialize(int drive)
if (track_spt == 255) {
/* Empty file? */
td0_log("TD0: File has no tracks\n");
return (0);
return 0;
}
density = (header[5] >> 1) & 3;
if (density == 3) {
td0_log("TD0: Unknown density\n");
return (0);
return 0;
}
/*
@@ -737,7 +752,7 @@ td0_initialize(int drive)
size = 128 << hs[3];
if ((total_size + size) >= TD0_MAX_BUFSZ) {
td0_log("TD0: Processed buffer overflow\n");
return (0);
return 0;
}
if (hs[4] & 0x30)
@@ -747,7 +762,7 @@ td0_initialize(int drive)
switch (hs[8]) {
default:
td0_log("TD0: Image uses an unsupported sector data encoding: %i\n", hs[8]);
return (0);
return 0;
case 0:
memcpy(dbuf, &dev->imagebuf[offset], size);
@@ -862,7 +877,7 @@ td0_initialize(int drive)
td0_log("TD0: File loaded: %i tracks, %i sides, disk flags: %02X, side flags: %02X, %02X, GAP3 length: %02X\n", dev->tracks, dev->sides, dev->disk_flags, dev->current_side_flags[0], dev->current_side_flags[1], dev->gap3_len);
return (1);
return 1;
}
static uint16_t
@@ -883,19 +898,19 @@ side_flags(int drive)
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
return (sflags);
return sflags;
}
static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
td0_t *dev = td0[drive];
int i = 0, cyl = c;
int cyl = c;
dev->current_sector_index[side] = 0;
if (cyl != dev->track)
return;
for (i = 0; i < dev->track_spt[cyl][side]; i++) {
for (uint8_t i = 0; i < dev->track_spt[cyl][side]; i++) {
if ((dev->sects[cyl][side][i].track == c) && (dev->sects[cyl][side][i].head == h) && (dev->sects[cyl][side][i].sector == r) && (dev->sects[cyl][side][i].size == n)) {
dev->current_sector_index[side] = i;
}
@@ -915,9 +930,14 @@ track_is_xdf(int drive, int side, int track)
{
td0_t *dev = td0[drive];
uint8_t id[4] = { 0, 0, 0, 0 };
int i, effective_sectors, xdf_sectors;
int high_sectors, low_sectors;
int max_high_id, expected_high_count, expected_low_count;
int i;
int effective_sectors;
int xdf_sectors;
int high_sectors;
int low_sectors;
int max_high_id;
int expected_high_count;
int expected_low_count;
effective_sectors = xdf_sectors = high_sectors = low_sectors = 0;
@@ -976,23 +996,24 @@ track_is_xdf(int drive, int side, int track)
if ((effective_sectors == 3) && (xdf_sectors == 3)) {
dev->current_side_flags[side] = 0x28;
return (1); /* 5.25" 2HD XDF */
return 1; /* 5.25" 2HD XDF */
}
if ((effective_sectors == 4) && (xdf_sectors == 4)) {
dev->current_side_flags[side] = 0x08;
return (2); /* 3.5" 2HD XDF */
return 2; /* 3.5" 2HD XDF */
}
}
return (0);
return 0;
}
static int
track_is_interleave(int drive, int side, int track)
{
td0_t *dev = td0[drive];
int i, effective_sectors;
int i;
int effective_sectors;
int track_spt;
effective_sectors = 0;
@@ -1003,7 +1024,7 @@ track_is_interleave(int drive, int side, int track)
track_spt = dev->track_spt[track][side];
if (track_spt != 21)
return (0);
return 0;
for (i = 0; i < track_spt; i++) {
if ((dev->sects[track][side][i].track == track) && (dev->sects[track][side][i].head == side) && (dev->sects[track][side][i].sector >= 1) && (dev->sects[track][side][i].sector <= track_spt) && (dev->sects[track][side][i].size == 2)) {
@@ -1013,18 +1034,18 @@ track_is_interleave(int drive, int side, int track)
}
if (effective_sectors == track_spt)
return (1);
return 1;
return (0);
return 0;
}
static void
td0_seek(int drive, int track)
{
td0_t *dev = td0[drive];
int side;
uint8_t id[4] = { 0, 0, 0, 0 };
int sector, current_pos;
int sector;
int current_pos;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
@@ -1037,7 +1058,8 @@ td0_seek(int drive, int track)
int ordered_pos = 0;
int real_sector = 0;
int actual_sector = 0;
int fm, sector_adjusted;
int fm;
int sector_adjusted;
if (dev->f == NULL)
return;
@@ -1064,7 +1086,7 @@ td0_seek(int drive, int track)
return;
}
for (side = 0; side < dev->sides; side++) {
for (int side = 0; side < dev->sides; side++) {
track_rate = dev->current_side_flags[side] & 7;
/* Make sure 300 kbps @ 360 rpm is treated the same as 250 kbps @ 300 rpm. */
if (!track_rate && (dev->current_side_flags[side] & 0x20))
@@ -1234,7 +1256,6 @@ void
td0_close(int drive)
{
td0_t *dev = td0[drive];
int i, j, k;
if (dev == NULL)
return;
@@ -1246,18 +1267,18 @@ td0_close(int drive)
if (dev->processed_buf)
free(dev->processed_buf);
for (i = 0; i < 256; i++) {
for (j = 0; j < 2; j++) {
for (k = 0; k < 256; k++)
for (uint16_t i = 0; i < 256; i++) {
for (uint8_t j = 0; j < 2; j++) {
for (uint16_t k = 0; k < 256; k++)
dev->sects[i][j][k].data = NULL;
}
}
for (i = 0; i < 256; i++) {
for (uint16_t i = 0; i < 256; i++) {
memset(dev->side_flags[i], 0, 4);
memset(dev->track_in_file[i], 0, 2);
memset(dev->calculated_gap3_lengths[i], 0, 2);
for (j = 0; j < 2; j++)
for (uint8_t j = 0; j < 2; j++)
memset(dev->sects[i][j], 0, sizeof(td0_sector_t));
}

172
src/floppy/fdi2raw.c
View File

@@ -188,7 +188,8 @@ struct node {
};
typedef struct node NODE;
static uint8_t temp, temp2;
static uint8_t temp;
static uint8_t temp2;
static uint8_t *
expand_tree(uint8_t *stream, NODE *node)
@@ -280,8 +281,9 @@ sign_extend8(uint32_t v)
static void
fdi_decode(uint8_t *stream, int size, uint8_t *out)
{
int i;
uint8_t sign_extend, sixteen_bit, sub_stream_shift;
uint8_t sign_extend;
uint8_t sixteen_bit;
uint8_t sub_stream_shift;
NODE root;
NODE *current_node;
@@ -310,7 +312,7 @@ fdi_decode(uint8_t *stream, int size, uint8_t *out)
/* sub-stream data decode */
temp2 = 0;
for (i = 0; i < size; i++) {
for (int i = 0; i < size; i++) {
uint32_t v;
uint8_t decode = 1;
current_node = &root;
@@ -462,8 +464,7 @@ bit_dedrop(FDI *fdi)
static void
byte_add(FDI *fdi, uint8_t v)
{
int i;
for (i = 7; i >= 0; i--)
for (uint8_t i = 7; i >= 0; i--)
bit_add(fdi, v & (1 << i));
}
/* add one word */
@@ -477,24 +478,21 @@ word_add(FDI *fdi, uint16_t v)
static void
byte_mfm_add(FDI *fdi, uint8_t v)
{
int i;
for (i = 7; i >= 0; i--)
for (uint8_t i = 7; i >= 0; i--)
bit_mfm_add(fdi, v & (1 << i));
}
/* add multiple bytes and mfm encode them */
static void
bytes_mfm_add(FDI *fdi, uint8_t v, int len)
{
int i;
for (i = 0; i < len; i++)
for (int i = 0; i < len; i++)
byte_mfm_add(fdi, v);
}
/* add one mfm encoded word and re-mfm encode it */
static void
word_post_mfm_add(FDI *fdi, uint16_t v)
{
int i;
for (i = 14; i >= 0; i -= 2)
for (uint8_t i = 14; i >= 0; i -= 2)
bit_mfm_add(fdi, v & (1 << i));
}
@@ -557,7 +555,8 @@ s09(FDI *fdi)
static void
s0a(FDI *fdi)
{
int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
int i;
int bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
uint8_t b;
fdi->track_src += 2;
fdi2raw_log("s0a:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
@@ -578,7 +577,8 @@ s0a(FDI *fdi)
static void
s0b(FDI *fdi)
{
int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
int i;
int bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
uint8_t b;
fdi->track_src += 2;
fdi2raw_log("s0b:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
@@ -599,7 +599,8 @@ s0b(FDI *fdi)
static void
s0c(FDI *fdi)
{
int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
int i;
int bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
uint8_t b;
fdi->track_src += 2;
bit_drop_next(fdi);
@@ -621,7 +622,8 @@ s0c(FDI *fdi)
static void
s0d(FDI *fdi)
{
int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
int i;
int bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
uint8_t b;
fdi->track_src += 2;
bit_drop_next(fdi);
@@ -854,10 +856,11 @@ static void
amiga_data(FDI *fdi, uint8_t *secbuf)
{
uint16_t mfmbuf[4 + 512];
uint32_t dodd, deven, dck;
int i;
uint32_t dodd;
uint32_t deven;
uint32_t dck;
for (i = 0; i < 512; i += 4) {
for (uint16_t i = 0; i < 512; i += 4) {
deven = ((secbuf[i + 0] << 24) | (secbuf[i + 1] << 16)
| (secbuf[i + 2] << 8) | (secbuf[i + 3]));
dodd = deven >> 1;
@@ -869,7 +872,7 @@ amiga_data(FDI *fdi, uint8_t *secbuf)
mfmbuf[(i >> 1) + 256 + 5] = (uint16_t) deven;
}
dck = 0;
for (i = 4; i < 4 + 512; i += 2)
for (uint32_t i = 4; i < 4 + 512; i += 2)
dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
deven = dodd = dck;
dodd >>= 1;
@@ -880,17 +883,19 @@ amiga_data(FDI *fdi, uint8_t *secbuf)
mfmbuf[2] = (uint16_t) (deven >> 16);
mfmbuf[3] = (uint16_t) deven;
for (i = 0; i < 4 + 512; i++)
for (uint32_t i = 0; i < 4 + 512; i++)
word_post_mfm_add(fdi, mfmbuf[i]);
}
static void
amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int untilgap)
{
uint8_t headerbuf[4], databuf[16];
uint32_t deven, dodd, hck;
uint8_t headerbuf[4];
uint8_t databuf[16];
uint32_t deven;
uint32_t dodd;
uint32_t hck;
uint16_t mfmbuf[24];
int i;
byte_mfm_add(fdi, 0);
byte_mfm_add(fdi, 0);
@@ -918,7 +923,7 @@ amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int un
mfmbuf[1] = (uint16_t) dodd;
mfmbuf[2] = (uint16_t) (deven >> 16);
mfmbuf[3] = (uint16_t) deven;
for (i = 0; i < 16; i += 4) {
for (uint8_t i = 0; i < 16; i += 4) {
deven = ((databuf[i] << 24) | (databuf[i + 1] << 16)
| (databuf[i + 2] << 8) | (databuf[i + 3]));
dodd = deven >> 1;
@@ -930,7 +935,7 @@ amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int un
mfmbuf[(i >> 1) + 8 + 5] = (uint16_t) deven;
}
hck = 0;
for (i = 0; i < 4 + 16; i += 2)
for (uint32_t i = 0; i < 4 + 16; i += 2)
hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
deven = dodd = hck;
dodd >>= 1;
@@ -941,7 +946,7 @@ amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int un
mfmbuf[22] = (uint16_t) (deven >> 16);
mfmbuf[23] = (uint16_t) deven;
for (i = 0; i < 4 + 16 + 4; i++)
for (uint32_t i = 0; i < 4 + 16 + 4; i++)
word_post_mfm_add(fdi, mfmbuf[i]);
}
@@ -1025,11 +1030,10 @@ static uint16_t
ibm_crc(uint8_t byte, int reset)
{
static uint16_t crc;
int i;
if (reset)
crc = 0xcdb4;
for (i = 0; i < 8; i++) {
for (uint8_t i = 0; i < 8; i++) {
if (crc & 0x8000) {
crc <<= 1;
if (!(byte & 0x80))
@@ -1047,7 +1051,6 @@ ibm_crc(uint8_t byte, int reset)
static void
ibm_data(FDI *fdi, uint8_t *data, uint8_t *crc, int len)
{
int i;
uint8_t crcbuf[2];
uint16_t crcv = 0;
@@ -1056,7 +1059,7 @@ ibm_data(FDI *fdi, uint8_t *data, uint8_t *crc, int len)
word_add(fdi, 0x4489);
byte_mfm_add(fdi, 0xfb);
ibm_crc(0xfb, 1);
for (i = 0; i < len; i++) {
for (int i = 0; i < len; i++) {
byte_mfm_add(fdi, data[i]);
crcv = ibm_crc(data[i], 0);
}
@@ -1075,7 +1078,6 @@ ibm_sector_header(FDI *fdi, uint8_t *data, uint8_t *crc, int secnum, int pre)
uint8_t secbuf[5];
uint8_t crcbuf[2];
uint16_t crcv;
int i;
if (pre)
bytes_mfm_add(fdi, 0, 12);
@@ -1103,7 +1105,7 @@ ibm_sector_header(FDI *fdi, uint8_t *data, uint8_t *crc, int secnum, int pre)
crcbuf[1] = (uint8_t) crcv;
}
/* data */
for (i = 0; i < 5; i++)
for (uint8_t i = 0; i < 5; i++)
byte_mfm_add(fdi, secbuf[i]);
/* crc */
byte_mfm_add(fdi, crcbuf[0]);
@@ -1263,11 +1265,9 @@ static decode_described_track_func decode_sectors_described_track[] = {
static void
track_amiga(struct fdi *fdi, int first_sector, int max_sector)
{
int i;
bit_add(fdi, 0);
bit_drop_next(fdi);
for (i = 0; i < max_sector; i++) {
for (int i = 0; i < max_sector; i++) {
amiga_sector_header(fdi, 0, 0, first_sector, max_sector - i);
amiga_data(fdi, fdi->track_src + first_sector * 512);
first_sector++;
@@ -1279,7 +1279,7 @@ track_amiga(struct fdi *fdi, int first_sector, int max_sector)
static void
track_atari_st(struct fdi *fdi, int max_sector)
{
int i, gap3 = 0;
int gap3 = 0;
uint8_t *p = fdi->track_src;
switch (max_sector) {
@@ -1291,7 +1291,7 @@ track_atari_st(struct fdi *fdi, int max_sector)
break;
}
s15(fdi);
for (i = 0; i < max_sector; i++) {
for (int i = 0; i < max_sector; i++) {
byte_mfm_add(fdi, 0x4e);
byte_mfm_add(fdi, 0x4e);
ibm_sector_header(fdi, 0, 0, fdi->current_track, 1);
@@ -1304,7 +1304,7 @@ track_atari_st(struct fdi *fdi, int max_sector)
static void
track_pc(struct fdi *fdi, int max_sector)
{
int i, gap3;
int gap3;
uint8_t *p = fdi->track_src;
switch (max_sector) {
@@ -1319,7 +1319,7 @@ track_pc(struct fdi *fdi, int max_sector)
break;
}
s11(fdi);
for (i = 0; i < max_sector; i++) {
for (int i = 0; i < max_sector; i++) {
byte_mfm_add(fdi, 0x4e);
byte_mfm_add(fdi, 0x4e);
ibm_sector_header(fdi, 0, 0, fdi->current_track, 1);
@@ -1402,9 +1402,15 @@ static decode_normal_track_func decode_normal_track[] = {
static void
fix_mfm_sync(FDI *fdi)
{
int i, pos, off1, off2, off3, mask1, mask2, mask3;
int pos;
int off1;
int off2;
int off3;
int mask1;
int mask2;
int mask3;
for (i = 0; i < fdi->mfmsync_offset; i++) {
for (int i = 0; i < fdi->mfmsync_offset; i++) {
pos = fdi->mfmsync_buffer[i];
off1 = (pos - 1) >> 3;
off2 = (pos + 1) >> 3;
@@ -1464,7 +1470,7 @@ fdi_decompress(int pulses, uint8_t *sizep, uint8_t *src, int *dofree)
uint32_t *dst2;
int len = size & 0x3fffff;
uint8_t *dst;
int mode = size >> 22, i;
int mode = size >> 22;
*dofree = 0;
if (mode == 0 && pulses * 2 > len)
@@ -1472,7 +1478,7 @@ fdi_decompress(int pulses, uint8_t *sizep, uint8_t *src, int *dofree)
if (mode == 0) {
dst2 = (uint32_t *) src;
dst = src;
for (i = 0; i < pulses; i++) {
for (int i = 0; i < pulses; i++) {
*dst2++ = get_u32(src);
src += 4;
}
@@ -1526,9 +1532,7 @@ static int totaldiv;
static void
init_array(uint32_t standard_MFM_2_bit_cell_size, int nb_of_bits)
{
int i;
for (i = 0; i < FDI_MAX_ARRAY; i++) {
for (uint8_t i = 0; i < FDI_MAX_ARRAY; i++) {
psarray[i].size = standard_MFM_2_bit_cell_size; /* That is (total track length / 50000) for Amiga double density */
total += psarray[i].size;
psarray[i].number_of_bits = nb_of_bits;
@@ -1672,11 +1676,18 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
uint32_t adjusted_pulse;
uint32_t standard_MFM_2_bit_cell_size = totalavg / 50000;
uint32_t standard_MFM_8_bit_cell_size = totalavg / 12500;
int real_size, i, j, nexti, eodat, outstep, randval;
int real_size;
int i;
int j;
int nexti;
int eodat;
int outstep;
int randval;
int indexoffset = *indexoffsetp;
uint8_t *d = fdi->track_dst_buffer;
uint16_t *pt = fdi->track_dst_buffer_timing;
uint32_t ref_pulse, pulse;
uint32_t ref_pulse;
uint32_t pulse;
int32_t jitter;
/* detects a long-enough stable pulse coming just after another stable pulse */
@@ -1714,7 +1725,9 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
/* gets the next long-enough pulse (this may require more than one pulse) */
pulse = 0;
while (pulse < ((avg_size / 4) - (avg_size / 16))) {
uint32_t avg_pulse, min_pulse, max_pulse;
uint32_t avg_pulse;
uint32_t min_pulse;
uint32_t max_pulse;
i++;
if (i >= pulses)
i = 0;
@@ -1742,7 +1755,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
randval = rand();
if (randval < (RAND_MAX / 2)) {
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1751,7 +1764,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
} else {
randval -= RAND_MAX / 2;
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1777,7 +1790,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
randval = rand();
if (randval < (RAND_MAX / 2)) {
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1786,7 +1799,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
} else {
randval -= RAND_MAX / 2;
if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
if (randval <= ((3LL * (uint64_t) RAND_MAX) / 8))
randval = (2 * randval) - (RAND_MAX / 4);
else
randval = (4 * randval) - RAND_MAX;
@@ -1899,14 +1912,14 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_
static void
fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
{
uint16_t *pt2, *pt;
uint16_t *pt2;
uint16_t *pt;
double avg_bit_len;
int i;
avg_bit_len = (double) totalavg / (double) bitoffset;
pt2 = fdi->track_dst_buffer_timing;
pt = out;
for (i = 0; i < bitoffset / 8; i++) {
for (int i = 0; i < bitoffset / 8; i++) {
double v = (pt2[0] + pt2[1] + pt2[2] + pt2[3] + pt2[4] + pt2[5] + pt2[6] + pt2[7]) / 8.0;
v = 1000.0 * v / avg_bit_len;
*pt++ = (uint16_t) v;
@@ -1921,12 +1934,25 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
{
uint8_t *p1;
uint32_t *p2;
uint32_t *avgp, *minp = 0, *maxp = 0;
uint32_t *avgp;
uint32_t *minp = 0;
uint32_t *maxp = 0;
uint8_t *idxp = 0;
uint32_t maxidx, totalavg, weakbits;
int i, j, len, pulses, indexoffset;
int avg_free, min_free = 0, max_free = 0, idx_free;
int idx_off1 = 0, idx_off2 = 0, idx_off3 = 0;
uint32_t maxidx;
uint32_t totalavg;
uint32_t weakbits;
int i;
int j;
int len;
int pulses;
int indexoffset;
int avg_free;
int min_free = 0;
int max_free = 0;
int idx_free;
int idx_off1 = 0;
int idx_off2 = 0;
int idx_off3 = 0;
p1 = fdi->track_src;
pulses = get_u32(p1);
@@ -2056,13 +2082,11 @@ static int bit_rate_table[16] = { 125, 150, 250, 300, 500, 1000 };
void
fdi2raw_header_free(FDI *fdi)
{
int i;
fdi_free(fdi->mfmsync_buffer);
fdi_free(fdi->track_src_buffer);
fdi_free(fdi->track_dst_buffer);
fdi_free(fdi->track_dst_buffer_timing);
for (i = 0; i < MAX_TRACKS; i++) {
for (uint8_t i = 0; i < MAX_TRACKS; i++) {
struct fdi_cache *c = &fdi->cache[i];
if (c->idx_free)
fdi_free(c->idxp);
@@ -2130,8 +2154,11 @@ fdi2raw_get_tpi(FDI *fdi)
FDI *
fdi2raw_header(FILE *f)
{
long i, offset, oldseek;
uint8_t type, size;
long i;
long offset;
long oldseek;
uint8_t type;
uint8_t size;
FDI *fdi;
fdi2raw_log("ALLOC: memory allocated %d\n", fdi_allocated);
@@ -2204,7 +2231,8 @@ static int
fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{
struct fdi_cache *cache = &fdi->cache[track];
int len, i, idx;
int len;
int idx;
memset(fdi->track_dst_buffer, 0, MAX_DST_BUFFER);
idx = cache->indexoffset;
@@ -2218,7 +2246,7 @@ fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int
*multirev = 1;
*tracklength = len;
for (i = 0; i < (len + 15) / (2 * 8); i++) {
for (int i = 0; i < (len + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}
@@ -2239,7 +2267,7 @@ int
fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{
uint8_t *p;
int outlen, i;
int outlen;
struct fdi_cache *cache = &fdi->cache[track];
track ^= fdi->reversed_side;
@@ -2285,7 +2313,7 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
outlen = handle_sectors_described_track(fdi);
} else if ((fdi->track_type & 0xf0)) {
} else if (fdi->track_type & 0xf0) {
zxx(fdi);
outlen = -1;
@@ -2309,7 +2337,7 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
if (cache->lowlevel)
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
*tracklength = fdi->out;
for (i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
for (int i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}