80486DX2-66/86Box-fork
1
0
Fork 0
Code Issues Pull Requests Activity

Update fdi2raw

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-01-07 00:04:47 -05:00
parent ca0ff1ab89
commit 3ba87a5e35
2 changed files with 281 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

463
src/floppy/fdi2raw.c
View File

@@ -20,7 +20,7 @@
* *
* Copyright 2001-2004 Toni Wilen. * Copyright 2001-2004 Toni Wilen.
* Copyright 2001-2004 Vincent Joguin. * Copyright 2001-2004 Vincent Joguin.
* Copyright 2001 Thomas Harte. * Copyright 2001-2016 Thomas Harte.
*/ */
#define STATIC_INLINE #define STATIC_INLINE
#include <stdarg.h> #include <stdarg.h>
@@ -65,7 +65,7 @@ fdi2raw_log(const char *fmt, ...)
#ifdef ENABLE_FDI2RAW_LOG #ifdef ENABLE_FDI2RAW_LOG
# ifdef DEBUG # ifdef DEBUG
static char * static char *
datalog(uae_u8 *src, int len) datalog(uint8_t *src, int len)
{ {
static char buf[1000]; static char buf[1000];
static int offset; static int offset;
@@ -88,7 +88,7 @@ datalog(uae_u8 *src, int len)
} }
# else # else
static char * static char *
datalog(uae_u8 *src, int len) datalog(uint8_t *src, int len)
{ {
return ""; return "";
} }
@@ -130,37 +130,38 @@ fdi_malloc(int size)
#define MAX_TRACKS 166 #define MAX_TRACKS 166
struct fdi_cache { struct fdi_cache {
uae_u32 *avgp, *minp, *maxp; uint32_t *avgp, *minp, *maxp;
uae_u8 *idxp; uint8_t *idxp;
int avg_free, idx_free, min_free, max_free; int avg_free, idx_free, min_free, max_free;
uae_u32 totalavg, pulses, maxidx, indexoffset; uint32_t totalavg, pulses, maxidx, indexoffset;
int weakbits; int weakbits;
int lowlevel; int lowlevel;
}; };
struct fdi { struct fdi {
uae_u8 *track_src_buffer; uint8_t *track_src_buffer;
uae_u8 *track_src; uint8_t *track_src;
int track_src_len; int32_t track_src_len;
uae_u8 *track_dst_buffer; uint8_t *track_dst_buffer;
uae_u8 *track_dst; uint8_t *track_dst;
uae_u16 *track_dst_buffer_timing; uint16_t *track_dst_buffer_timing;
uae_u8 track_len; uint8_t track_len;
uae_u8 track_type; uint8_t track_type;
int current_track; int current_track;
int last_track; int last_track;
int last_head; int last_head;
int rotation_speed; int rotation_speed;
int bit_rate; int bit_rate;
int disk_type; int disk_type;
int write_protect; bool write_protect;
int err; int reversed_side;
uae_u8 header[2048]; int err;
int track_offsets[MAX_TRACKS]; uint8_t header[2048];
FILE *file; int32_t track_offsets[MAX_TRACKS];
int out; FILE *file;
int mfmsync_offset; int out;
int *mfmsync_buffer; int mfmsync_offset;
int *mfmsync_buffer;
/* sector described only */ /* sector described only */
int index_offset; int index_offset;
int encoding_type; int encoding_type;
@@ -172,7 +173,7 @@ struct fdi {
#define get_u32(x) ((((x)[0]) << 24) | (((x)[1]) << 16) | (((x)[2]) << 8) | ((x)[3])) #define get_u32(x) ((((x)[0]) << 24) | (((x)[1]) << 16) | (((x)[2]) << 8) | ((x)[3]))
#define get_u24(x) ((((x)[0]) << 16) | (((x)[1]) << 8) | ((x)[2])) #define get_u24(x) ((((x)[0]) << 16) | (((x)[1]) << 8) | ((x)[2]))
STATIC_INLINE void STATIC_INLINE void
put_u32(uae_u8 *d, uae_u32 v) put_u32(uint8_t *d, uint32_t v)
{ {
d[0] = v >> 24; d[0] = v >> 24;
d[1] = v >> 16; d[1] = v >> 16;
@@ -181,16 +182,16 @@ put_u32(uae_u8 *d, uae_u32 v)
} }
struct node { struct node {
uae_u16 v; uint16_t v;
struct node *left; struct node *left;
struct node *right; struct node *right;
}; };
typedef struct node NODE; typedef struct node NODE;
static uae_u8 temp, temp2; static uint8_t temp, temp2;
static uae_u8 * static uint8_t *
expand_tree(uae_u8 *stream, NODE *node) expand_tree(uint8_t *stream, NODE *node)
{ {
if (temp & temp2) { if (temp & temp2) {
if (node->left) { if (node->left) {
@@ -208,7 +209,7 @@ expand_tree(uae_u8 *stream, NODE *node)
} }
return stream; return stream;
} else { } else {
uae_u8 *stream_temp; uint8_t *stream_temp;
temp2 >>= 1; temp2 >>= 1;
if (!temp2) { if (!temp2) {
temp = *stream++; temp = *stream++;
@@ -223,27 +224,27 @@ expand_tree(uae_u8 *stream, NODE *node)
} }
} }
static uae_u8 * static uint8_t *
values_tree8(uae_u8 *stream, NODE *node) values_tree8(uint8_t *stream, NODE *node)
{ {
if (node->left == 0) { if (node->left == 0) {
node->v = *stream++; node->v = *stream++;
return stream; return stream;
} else { } else {
uae_u8 *stream_temp = values_tree8(stream, node->left); uint8_t *stream_temp = values_tree8(stream, node->left);
return values_tree8(stream_temp, node->right); return values_tree8(stream_temp, node->right);
} }
} }
static uae_u8 * static uint8_t *
values_tree16(uae_u8 *stream, NODE *node) values_tree16(uint8_t *stream, NODE *node)
{ {
if (node->left == 0) { if (node->left == 0) {
uae_u16 high_8_bits = (*stream++) << 8; uint16_t high_8_bits = (*stream++) << 8;
node->v = high_8_bits | (*stream++); node->v = high_8_bits | (*stream++);
return stream; return stream;
} else { } else {
uae_u8 *stream_temp = values_tree16(stream, node->left); uint8_t *stream_temp = values_tree16(stream, node->left);
return values_tree16(stream_temp, node->right); return values_tree16(stream_temp, node->right);
} }
} }
@@ -258,16 +259,18 @@ free_nodes(NODE *node)
} }
} }
static uae_u32 /// @returns the 32-bit sign extended version of the 16-bit value in the low part of @c v.
sign_extend16(uae_u32 v) static uint32_t
sign_extend16(uint32_t v)
{ {
if (v & 0x8000) if (v & 0x8000)
v |= 0xffff0000; v |= 0xffff0000;
return v; return v;
} }
static uae_u32 /// @returns the 32-bit sign extended version of the 8-bit value in the low part of @c v.
sign_extend8(uae_u32 v) static uint32_t
sign_extend8(uint32_t v)
{ {
if (v & 0x80) if (v & 0x80)
v |= 0xffffff00; v |= 0xffffff00;
@@ -275,12 +278,12 @@ sign_extend8(uae_u32 v)
} }
static void static void
fdi_decode(uae_u8 *stream, int size, uae_u8 *out) fdi_decode(uint8_t *stream, int size, uint8_t *out)
{ {
int i; int i;
uae_u8 sign_extend, sixteen_bit, sub_stream_shift; uint8_t sign_extend, sixteen_bit, sub_stream_shift;
NODE root; NODE root;
NODE *current_node; NODE *current_node;
memset(out, 0, size * 4); memset(out, 0, size * 4);
sub_stream_shift = 1; sub_stream_shift = 1;
@@ -308,9 +311,9 @@ fdi_decode(uae_u8 *stream, int size, uae_u8 *out)
/* sub-stream data decode */ /* sub-stream data decode */
temp2 = 0; temp2 = 0;
for (i = 0; i < size; i++) { for (i = 0; i < size; i++) {
uae_u32 v; uint32_t v;
uae_u8 decode = 1; uint8_t decode = 1;
current_node = &root; current_node = &root;
while (decode) { while (decode) {
if (current_node->left == 0) { if (current_node->left == 0) {
decode = 0; decode = 0;
@@ -326,7 +329,7 @@ fdi_decode(uae_u8 *stream, int size, uae_u8 *out)
current_node = current_node->left; current_node = current_node->left;
} }
} }
v = ((uae_u32 *) out)[i]; v = ((uint32_t *) out)[i];
if (sign_extend) { if (sign_extend) {
if (sixteen_bit) if (sixteen_bit)
v |= sign_extend16(current_node->v) << sub_stream_shift; v |= sign_extend16(current_node->v) << sub_stream_shift;
@@ -335,7 +338,7 @@ fdi_decode(uae_u8 *stream, int size, uae_u8 *out)
} else { } else {
v |= current_node->v << sub_stream_shift; v |= current_node->v << sub_stream_shift;
} }
((uae_u32 *) out)[i] = v; ((uint32_t *) out)[i] = v;
} }
free_nodes(root.left); free_nodes(root.left);
root.left = 0; root.left = 0;
@@ -457,7 +460,7 @@ bit_dedrop(FDI *fdi)
/* add one byte */ /* add one byte */
static void static void
byte_add(FDI *fdi, uae_u8 v) byte_add(FDI *fdi, uint8_t v)
{ {
int i; int i;
for (i = 7; i >= 0; i--) for (i = 7; i >= 0; i--)
@@ -465,14 +468,14 @@ byte_add(FDI *fdi, uae_u8 v)
} }
/* add one word */ /* add one word */
static void static void
word_add(FDI *fdi, uae_u16 v) word_add(FDI *fdi, uint16_t v)
{ {
byte_add(fdi, (uae_u8) (v >> 8)); byte_add(fdi, (uint8_t) (v >> 8));
byte_add(fdi, (uae_u8) v); byte_add(fdi, (uint8_t) v);
} }
/* add one byte and mfm encode it */ /* add one byte and mfm encode it */
static void static void
byte_mfm_add(FDI *fdi, uae_u8 v) byte_mfm_add(FDI *fdi, uint8_t v)
{ {
int i; int i;
for (i = 7; i >= 0; i--) for (i = 7; i >= 0; i--)
@@ -480,7 +483,7 @@ byte_mfm_add(FDI *fdi, uae_u8 v)
} }
/* add multiple bytes and mfm encode them */ /* add multiple bytes and mfm encode them */
static void static void
bytes_mfm_add(FDI *fdi, uae_u8 v, int len) bytes_mfm_add(FDI *fdi, uint8_t v, int len)
{ {
int i; int i;
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
@@ -488,7 +491,7 @@ bytes_mfm_add(FDI *fdi, uae_u8 v, int len)
} }
/* add one mfm encoded word and re-mfm encode it */ /* add one mfm encoded word and re-mfm encode it */
static void static void
word_post_mfm_add(FDI *fdi, uae_u16 v) word_post_mfm_add(FDI *fdi, uint16_t v)
{ {
int i; int i;
for (i = 14; i >= 0; i -= 2) for (i = 14; i >= 0; i -= 2)
@@ -529,8 +532,8 @@ s04(FDI *fdi)
static void static void
s08(FDI *fdi) s08(FDI *fdi)
{ {
int bytes = *fdi->track_src++; int bytes = *fdi->track_src++;
uae_u8 byte = *fdi->track_src++; uint8_t byte = *fdi->track_src++;
if (bytes == 0) if (bytes == 0)
bytes = 256; bytes = 256;
fdi2raw_log("s08:len=%d,data=%02.2X", bytes, byte); fdi2raw_log("s08:len=%d,data=%02.2X", bytes, byte);
@@ -541,8 +544,8 @@ s08(FDI *fdi)
static void static void
s09(FDI *fdi) s09(FDI *fdi)
{ {
int bytes = *fdi->track_src++; int bytes = *fdi->track_src++;
uae_u8 byte = *fdi->track_src++; uint8_t byte = *fdi->track_src++;
if (bytes == 0) if (bytes == 0)
bytes = 256; bytes = 256;
bit_drop_next(fdi); bit_drop_next(fdi);
@@ -554,8 +557,8 @@ s09(FDI *fdi)
static void static void
s0a(FDI *fdi) s0a(FDI *fdi)
{ {
int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1]; int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
uae_u8 b; uint8_t b;
fdi->track_src += 2; fdi->track_src += 2;
fdi2raw_log("s0a:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8)); fdi2raw_log("s0a:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
while (bits >= 8) { while (bits >= 8) {
@@ -575,8 +578,8 @@ s0a(FDI *fdi)
static void static void
s0b(FDI *fdi) s0b(FDI *fdi)
{ {
int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536; int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
uae_u8 b; uint8_t b;
fdi->track_src += 2; fdi->track_src += 2;
fdi2raw_log("s0b:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8)); fdi2raw_log("s0b:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
while (bits >= 8) { while (bits >= 8) {
@@ -596,8 +599,8 @@ s0b(FDI *fdi)
static void static void
s0c(FDI *fdi) s0c(FDI *fdi)
{ {
int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1]; int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
uae_u8 b; uint8_t b;
fdi->track_src += 2; fdi->track_src += 2;
bit_drop_next(fdi); bit_drop_next(fdi);
fdi2raw_log("s0c:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8)); fdi2raw_log("s0c:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
@@ -618,8 +621,8 @@ s0c(FDI *fdi)
static void static void
s0d(FDI *fdi) s0d(FDI *fdi)
{ {
int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536; int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
uae_u8 b; uint8_t b;
fdi->track_src += 2; fdi->track_src += 2;
bit_drop_next(fdi); bit_drop_next(fdi);
fdi2raw_log("s0d:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8)); fdi2raw_log("s0d:bits=%d,data=%s", bits, datalog(fdi->track_src, (bits + 7) / 8));
@@ -643,7 +646,7 @@ s0d(FDI *fdi)
/* just for testing integrity of Amiga sectors */ /* just for testing integrity of Amiga sectors */
/*static void rotateonebit (uae_u8 *start, uae_u8 *end, int shift) /*static void rotateonebit (uint8_t *start, uint8_t *end, int shift)
{ {
if (shift == 0) if (shift == 0)
return; return;
@@ -654,21 +657,21 @@ s0d(FDI *fdi)
} }
}*/ }*/
/*static uae_u16 getmfmword (uae_u8 *mbuf) /*static uint16_t getmfmword (uint8_t *mbuf)
{ {
uae_u32 v; uint32_t v;
v = (mbuf[0] << 8) | (mbuf[1] << 0); v = (mbuf[0] << 8) | (mbuf[1] << 0);
if (check_offset == 0) if (check_offset == 0)
return v; return (uint16_t)v;
v <<= 8; v <<= 8;
v |= mbuf[2]; v |= mbuf[2];
v >>= check_offset; v >>= check_offset;
return v; return (uint16_t)v;
}*/ }*/
#define MFMMASK 0x55555555 #define MFMMASK 0x55555555
/*static uae_u32 getmfmlong (uae_u8 * mbuf) /*static uint32_t getmfmlong (uint8_t * mbuf)
{ {
return ((getmfmword (mbuf) << 16) | getmfmword (mbuf + 2)) & MFMMASK; return ((getmfmword (mbuf) << 16) | getmfmword (mbuf + 2)) & MFMMASK;
}*/ }*/
@@ -680,13 +683,13 @@ static int amiga_check_track (FDI *fdi)
int fwlen = fdi->out / 8; int fwlen = fdi->out / 8;
int length = 2 * fwlen; int length = 2 * fwlen;
int drvsec = 11; int drvsec = 11;
uae_u32 odd, even, chksum, id, dlong; uint32_t odd, even, chksum, id, dlong;
uae_u8 *secdata; uint8_t *secdata;
uae_u8 secbuf[544]; uint8_t secbuf[544];
uae_u8 bigmfmbuf[60000]; uint8_t bigmfmbuf[60000];
uae_u8 *mbuf, *mbuf2, *mend; uint8_t *mbuf, *mbuf2, *mend;
char sectable[22]; char sectable[22];
uae_u8 *raw = fdi->track_dst_buffer; uint8_t *raw = fdi->track_dst_buffer;
int slabel, off; int slabel, off;
int ok = 1; int ok = 1;
@@ -782,7 +785,7 @@ static int amiga_check_track (FDI *fdi)
continue; continue;
} }
fdi2raw_log("sector %d header crc ok\n", trackoffs); fdi2raw_log("sector %d header crc ok\n", trackoffs);
if (((id & 0x00ff0000) >> 16) != (uae_u32)fdi->current_track) { if (((id & 0x00ff0000) >> 16) != (uint32_t)fdi->current_track) {
fdi2raw_log("illegal track number %d <> %d\n",fdi->current_track,(id & 0x00ff0000) >> 16); fdi2raw_log("illegal track number %d <> %d\n",fdi->current_track,(id & 0x00ff0000) >> 16);
ok++; ok++;
mbuf = mbuf2; mbuf = mbuf2;
@@ -798,10 +801,10 @@ static int amiga_check_track (FDI *fdi)
even = getmfmlong (mbuf + 256 * 2); even = getmfmlong (mbuf + 256 * 2);
mbuf += 2 * 2; mbuf += 2 * 2;
dlong = (odd << 1) | even; dlong = (odd << 1) | even;
*secdata++ = (uae_u8) (dlong >> 24); *secdata++ = (uint8_t) (dlong >> 24);
*secdata++ = (uae_u8) (dlong >> 16); *secdata++ = (uint8_t) (dlong >> 16);
*secdata++ = (uae_u8) (dlong >> 8); *secdata++ = (uint8_t) (dlong >> 8);
*secdata++ = (uae_u8) dlong; *secdata++ = (uint8_t) dlong;
chksum ^= odd ^ even; chksum ^= odd ^ even;
} }
mbuf += 256 * 2; mbuf += 256 * 2;
@@ -831,10 +834,10 @@ static int amiga_check_track (FDI *fdi)
#endif #endif
static void static void
amiga_data_raw(FDI *fdi, uae_u8 *secbuf, uae_u8 *crc, int len) amiga_data_raw(FDI *fdi, uint8_t *secbuf, uint8_t *crc, int len)
{ {
int i; int i;
uae_u8 crcbuf[4]; uint8_t crcbuf[4];
if (!crc) { if (!crc) {
memset(crcbuf, 0, 4); memset(crcbuf, 0, 4);
@@ -848,11 +851,11 @@ amiga_data_raw(FDI *fdi, uae_u8 *secbuf, uae_u8 *crc, int len)
} }
static void static void
amiga_data(FDI *fdi, uae_u8 *secbuf) amiga_data(FDI *fdi, uint8_t *secbuf)
{ {
uae_u16 mfmbuf[4 + 512]; uint16_t mfmbuf[4 + 512];
uae_u32 dodd, deven, dck; uint32_t dodd, deven, dck;
int i; int i;
for (i = 0; i < 512; i += 4) { for (i = 0; i < 512; i += 4) {
deven = ((secbuf[i + 0] << 24) | (secbuf[i + 1] << 16) deven = ((secbuf[i + 0] << 24) | (secbuf[i + 1] << 16)
@@ -860,10 +863,10 @@ amiga_data(FDI *fdi, uae_u8 *secbuf)
dodd = deven >> 1; dodd = deven >> 1;
deven &= 0x55555555; deven &= 0x55555555;
dodd &= 0x55555555; dodd &= 0x55555555;
mfmbuf[(i >> 1) + 4] = (uae_u16) (dodd >> 16); mfmbuf[(i >> 1) + 4] = (uint16_t) (dodd >> 16);
mfmbuf[(i >> 1) + 5] = (uae_u16) dodd; mfmbuf[(i >> 1) + 5] = (uint16_t) dodd;
mfmbuf[(i >> 1) + 256 + 4] = (uae_u16) (deven >> 16); mfmbuf[(i >> 1) + 256 + 4] = (uint16_t) (deven >> 16);
mfmbuf[(i >> 1) + 256 + 5] = (uae_u16) deven; mfmbuf[(i >> 1) + 256 + 5] = (uint16_t) deven;
} }
dck = 0; dck = 0;
for (i = 4; i < 4 + 512; i += 2) for (i = 4; i < 4 + 512; i += 2)
@@ -872,22 +875,22 @@ amiga_data(FDI *fdi, uae_u8 *secbuf)
dodd >>= 1; dodd >>= 1;
deven &= 0x55555555; deven &= 0x55555555;
dodd &= 0x55555555; dodd &= 0x55555555;
mfmbuf[0] = (uae_u16) (dodd >> 16); mfmbuf[0] = (uint16_t) (dodd >> 16);
mfmbuf[1] = (uae_u16) dodd; mfmbuf[1] = (uint16_t) dodd;
mfmbuf[2] = (uae_u16) (deven >> 16); mfmbuf[2] = (uint16_t) (deven >> 16);
mfmbuf[3] = (uae_u16) deven; mfmbuf[3] = (uint16_t) deven;
for (i = 0; i < 4 + 512; i++) for (i = 0; i < 4 + 512; i++)
word_post_mfm_add(fdi, mfmbuf[i]); word_post_mfm_add(fdi, mfmbuf[i]);
} }
static void static void
amiga_sector_header(FDI *fdi, uae_u8 *header, uae_u8 *data, int sector, int untilgap) amiga_sector_header(FDI *fdi, uint8_t *header, uint8_t *data, int sector, int untilgap)
{ {
uae_u8 headerbuf[4], databuf[16]; uint8_t headerbuf[4], databuf[16];
uae_u32 deven, dodd, hck; uint32_t deven, dodd, hck;
uae_u16 mfmbuf[24]; uint16_t mfmbuf[24];
int i; int i;
byte_mfm_add(fdi, 0); byte_mfm_add(fdi, 0);
byte_mfm_add(fdi, 0); byte_mfm_add(fdi, 0);
@@ -897,9 +900,9 @@ amiga_sector_header(FDI *fdi, uae_u8 *header, uae_u8 *data, int sector, int unti
memcpy(headerbuf, header, 4); memcpy(headerbuf, header, 4);
} else { } else {
headerbuf[0] = 0xff; headerbuf[0] = 0xff;
headerbuf[1] = (uae_u8) fdi->current_track; headerbuf[1] = (uint8_t) fdi->current_track;
headerbuf[2] = (uae_u8) sector; headerbuf[2] = (uint8_t) sector;
headerbuf[3] = (uae_u8) untilgap; headerbuf[3] = (uint8_t) untilgap;
} }
if (data) if (data)
memcpy(databuf, data, 16); memcpy(databuf, data, 16);
@@ -911,20 +914,20 @@ amiga_sector_header(FDI *fdi, uae_u8 *header, uae_u8 *data, int sector, int unti
dodd = deven >> 1; dodd = deven >> 1;
deven &= 0x55555555; deven &= 0x55555555;
dodd &= 0x55555555; dodd &= 0x55555555;
mfmbuf[0] = (uae_u16) (dodd >> 16); mfmbuf[0] = (uint16_t) (dodd >> 16);
mfmbuf[1] = (uae_u16) dodd; mfmbuf[1] = (uint16_t) dodd;
mfmbuf[2] = (uae_u16) (deven >> 16); mfmbuf[2] = (uint16_t) (deven >> 16);
mfmbuf[3] = (uae_u16) deven; mfmbuf[3] = (uint16_t) deven;
for (i = 0; i < 16; i += 4) { for (i = 0; i < 16; i += 4) {
deven = ((databuf[i] << 24) | (databuf[i + 1] << 16) deven = ((databuf[i] << 24) | (databuf[i + 1] << 16)
| (databuf[i + 2] << 8) | (databuf[i + 3])); | (databuf[i + 2] << 8) | (databuf[i + 3]));
dodd = deven >> 1; dodd = deven >> 1;
deven &= 0x55555555; deven &= 0x55555555;
dodd &= 0x55555555; dodd &= 0x55555555;
mfmbuf[(i >> 1) + 0 + 4] = (uae_u16) (dodd >> 16); mfmbuf[(i >> 1) + 0 + 4] = (uint16_t) (dodd >> 16);
mfmbuf[(i >> 1) + 0 + 5] = (uae_u16) dodd; mfmbuf[(i >> 1) + 0 + 5] = (uint16_t) dodd;
mfmbuf[(i >> 1) + 8 + 4] = (uae_u16) (deven >> 16); mfmbuf[(i >> 1) + 8 + 4] = (uint16_t) (deven >> 16);
mfmbuf[(i >> 1) + 8 + 5] = (uae_u16) deven; mfmbuf[(i >> 1) + 8 + 5] = (uint16_t) deven;
} }
hck = 0; hck = 0;
for (i = 0; i < 4 + 16; i += 2) for (i = 0; i < 4 + 16; i += 2)
@@ -933,10 +936,10 @@ amiga_sector_header(FDI *fdi, uae_u8 *header, uae_u8 *data, int sector, int unti
dodd >>= 1; dodd >>= 1;
deven &= 0x55555555; deven &= 0x55555555;
dodd &= 0x55555555; dodd &= 0x55555555;
mfmbuf[20] = (uae_u16) (dodd >> 16); mfmbuf[20] = (uint16_t) (dodd >> 16);
mfmbuf[21] = (uae_u16) dodd; mfmbuf[21] = (uint16_t) dodd;
mfmbuf[22] = (uae_u16) (deven >> 16); mfmbuf[22] = (uint16_t) (deven >> 16);
mfmbuf[23] = (uae_u16) deven; mfmbuf[23] = (uint16_t) deven;
for (i = 0; i < 4 + 16 + 4; i++) for (i = 0; i < 4 + 16 + 4; i++)
word_post_mfm_add(fdi, mfmbuf[i]); word_post_mfm_add(fdi, mfmbuf[i]);
@@ -1018,11 +1021,11 @@ s27(FDI *fdi)
/* IBM */ /* IBM */
/* *** */ /* *** */
static uae_u16 static uint16_t
ibm_crc(uae_u8 byte, int reset) ibm_crc(uint8_t byte, int reset)
{ {
static uae_u16 crc; static uint16_t crc;
int i; int i;
if (reset) if (reset)
crc = 0xcdb4; crc = 0xcdb4;
@@ -1042,11 +1045,11 @@ ibm_crc(uae_u8 byte, int reset)
} }
static void static void
ibm_data(FDI *fdi, uae_u8 *data, uae_u8 *crc, int len) ibm_data(FDI *fdi, uint8_t *data, uint8_t *crc, int len)
{ {
int i; int i;
uae_u8 crcbuf[2]; uint8_t crcbuf[2];
uae_u16 crcv = 0; uint16_t crcv = 0;
word_add(fdi, 0x4489); word_add(fdi, 0x4489);
word_add(fdi, 0x4489); word_add(fdi, 0x4489);
@@ -1059,20 +1062,20 @@ ibm_data(FDI *fdi, uae_u8 *data, uae_u8 *crc, int len)
} }
if (!crc) { if (!crc) {
crc = crcbuf; crc = crcbuf;
crc[0] = (uae_u8) (crcv >> 8); crc[0] = (uint8_t) (crcv >> 8);
crc[1] = (uae_u8) crcv; crc[1] = (uint8_t) crcv;
} }
byte_mfm_add(fdi, crc[0]); byte_mfm_add(fdi, crc[0]);
byte_mfm_add(fdi, crc[1]); byte_mfm_add(fdi, crc[1]);
} }
static void static void
ibm_sector_header(FDI *fdi, uae_u8 *data, uae_u8 *crc, int secnum, int pre) ibm_sector_header(FDI *fdi, uint8_t *data, uint8_t *crc, int secnum, int pre)
{ {
uae_u8 secbuf[5]; uint8_t secbuf[5];
uae_u8 crcbuf[2]; uint8_t crcbuf[2];
uae_u16 crcv; uint16_t crcv;
int i; int i;
if (pre) if (pre)
bytes_mfm_add(fdi, 0, 12); bytes_mfm_add(fdi, 0, 12);
@@ -1081,9 +1084,9 @@ ibm_sector_header(FDI *fdi, uae_u8 *data, uae_u8 *crc, int secnum, int pre)
word_add(fdi, 0x4489); word_add(fdi, 0x4489);
secbuf[0] = 0xfe; secbuf[0] = 0xfe;
if (secnum >= 0) { if (secnum >= 0) {
secbuf[1] = (uae_u8) (fdi->current_track / 2); secbuf[1] = (uint8_t) (fdi->current_track / 2);
secbuf[2] = (uae_u8) (fdi->current_track % 2); secbuf[2] = (uint8_t) (fdi->current_track % 2);
secbuf[3] = (uae_u8) secnum; secbuf[3] = (uint8_t) secnum;
secbuf[4] = 2; secbuf[4] = 2;
} else { } else {
memcpy(secbuf + 1, data, 4); memcpy(secbuf + 1, data, 4);
@@ -1096,8 +1099,8 @@ ibm_sector_header(FDI *fdi, uae_u8 *data, uae_u8 *crc, int secnum, int pre)
if (crc) { if (crc) {
memcpy(crcbuf, crc, 2); memcpy(crcbuf, crc, 2);
} else { } else {
crcbuf[0] = (uae_u8) (crcv >> 8); crcbuf[0] = (uint8_t) (crcv >> 8);
crcbuf[1] = (uae_u8) crcv; crcbuf[1] = (uint8_t) crcv;
} }
/* data */ /* data */
for (i = 0; i < 5; i++) for (i = 0; i < 5; i++)
@@ -1276,8 +1279,8 @@ track_amiga(struct fdi *fdi, int first_sector, int max_sector)
static void static void
track_atari_st(struct fdi *fdi, int max_sector) track_atari_st(struct fdi *fdi, int max_sector)
{ {
int i, gap3 = 0; int i, gap3 = 0;
uae_u8 *p = fdi->track_src; uint8_t *p = fdi->track_src;
switch (max_sector) { switch (max_sector) {
case 9: case 9:
@@ -1301,8 +1304,8 @@ track_atari_st(struct fdi *fdi, int max_sector)
static void static void
track_pc(struct fdi *fdi, int max_sector) track_pc(struct fdi *fdi, int max_sector)
{ {
int i, gap3; int i, gap3;
uae_u8 *p = fdi->track_src; uint8_t *p = fdi->track_src;
switch (max_sector) { switch (max_sector) {
case 8: case 8:
@@ -1331,7 +1334,7 @@ track_pc(struct fdi *fdi, int max_sector)
static void static void
track_amiga_dd(struct fdi *fdi) track_amiga_dd(struct fdi *fdi)
{ {
uae_u8 *p = fdi->track_src; uint8_t *p = fdi->track_src;
track_amiga(fdi, fdi->track_len >> 4, 11); track_amiga(fdi, fdi->track_len >> 4, 11);
fdi->track_src = p + (fdi->track_len & 15) * 512; fdi->track_src = p + (fdi->track_len & 15) * 512;
} }
@@ -1339,7 +1342,7 @@ track_amiga_dd(struct fdi *fdi)
static void static void
track_amiga_hd(struct fdi *fdi) track_amiga_hd(struct fdi *fdi)
{ {
uae_u8 *p = fdi->track_src; uint8_t *p = fdi->track_src;
track_amiga(fdi, 0, 22); track_amiga(fdi, 0, 22);
fdi->track_src = p + fdi->track_len * 256; fdi->track_src = p + fdi->track_len * 256;
} }
@@ -1420,8 +1423,8 @@ static int
handle_sectors_described_track(FDI *fdi) handle_sectors_described_track(FDI *fdi)
{ {
#ifdef ENABLE_FDI2RAW_LOG #ifdef ENABLE_FDI2RAW_LOG
int oldout; int oldout;
uae_u8 *start_src = fdi->track_src; uint8_t *start_src = fdi->track_src;
#endif #endif
fdi->encoding_type = *fdi->track_src++; fdi->encoding_type = *fdi->track_src++;
fdi->index_offset = get_u32(fdi->track_src); fdi->index_offset = get_u32(fdi->track_src);
@@ -1454,20 +1457,20 @@ handle_sectors_described_track(FDI *fdi)
return fdi->out; return fdi->out;
} }
static uae_u8 * static uint8_t *
fdi_decompress(int pulses, uae_u8 *sizep, uae_u8 *src, int *dofree) fdi_decompress(int pulses, uint8_t *sizep, uint8_t *src, int *dofree)
{ {
uae_u32 size = get_u24(sizep); uint32_t size = get_u24(sizep);
uae_u32 *dst2; uint32_t *dst2;
int len = size & 0x3fffff; int len = size & 0x3fffff;
uae_u8 *dst; uint8_t *dst;
int mode = size >> 22, i; int mode = size >> 22, i;
*dofree = 0; *dofree = 0;
if (mode == 0 && pulses * 2 > len) if (mode == 0 && pulses * 2 > len)
mode = 1; mode = 1;
if (mode == 0) { if (mode == 0) {
dst2 = (uae_u32 *) src; dst2 = (uint32_t *) src;
dst = src; dst = src;
for (i = 0; i < pulses; i++) { for (i = 0; i < pulses; i++) {
*dst2++ = get_u32(src); *dst2++ = get_u32(src);
@@ -1484,7 +1487,7 @@ fdi_decompress(int pulses, uae_u8 *sizep, uae_u8 *src, int *dofree)
} }
static void static void
dumpstream(int track, uae_u8 *stream, int len) dumpstream(int track, uint8_t *stream, int len)
{ {
#if 0 #if 0
char name[100]; char name[100];
@@ -1499,8 +1502,8 @@ dumpstream(int track, uae_u8 *stream, int len)
static int bitoffset; static int bitoffset;
STATIC_INLINE void static inline void
addbit(uae_u8 *p, int bit) addbit(uint8_t *p, int bit)
{ {
int off1 = bitoffset / 8; int off1 = bitoffset / 8;
int off2 = bitoffset % 8; int off2 = bitoffset % 8;
@@ -1517,7 +1520,7 @@ struct pulse_sample {
static int pulse_limitval = 15; /* tolerance of 15% */ static int pulse_limitval = 15; /* tolerance of 15% */
static struct pulse_sample psarray[FDI_MAX_ARRAY]; static struct pulse_sample psarray[FDI_MAX_ARRAY];
static int array_index; static int array_index;
static unsigned long total; static uint32_t total;
static int totaldiv; static int totaldiv;
static void static void
@@ -1536,7 +1539,7 @@ init_array(uint32_t standard_MFM_2_bit_cell_size, int nb_of_bits)
#if 0 #if 0
static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *maxp, uae_u8 *idx, int maxidx, int *indexoffsetp, int pulses, int mfm) static void fdi2_decode (FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp, uint8_t *idx, int maxidx, int *indexoffsetp, int pulses, int mfm)
{ {
uint32_t adjust; uint32_t adjust;
uint32_t adjusted_pulse; uint32_t adjusted_pulse;
@@ -1544,9 +1547,9 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
uint32_t standard_MFM_8_bit_cell_size = totalavg / 12500; uint32_t standard_MFM_8_bit_cell_size = totalavg / 12500;
int real_size, i, j, eodat, outstep; int real_size, i, j, eodat, outstep;
int indexoffset = *indexoffsetp; int indexoffset = *indexoffsetp;
uae_u8 *d = fdi->track_dst_buffer; uint8_t *d = fdi->track_dst_buffer;
uae_u16 *pt = fdi->track_dst_buffer_timing; uint16_t *pt = fdi->track_dst_buffer_timing;
uae_u32 ref_pulse, pulse; uint32_t ref_pulse, pulse;
/* detects a long-enough stable pulse coming just after another stable pulse */ /* detects a long-enough stable pulse coming just after another stable pulse */
i = 1; i = 1;
@@ -1570,8 +1573,8 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
while (outstep < 2) { while (outstep < 2) {
/* calculates the current average bitrate from previous decoded data */ /* calculates the current average bitrate from previous decoded data */
uae_u32 avg_size = (total << 3) / totaldiv; /* this is the new average size for one MFM bit */ uint32_t avg_size = (total << 3) / totaldiv; /* this is the new average size for one MFM bit */
/* uae_u32 avg_size = (uae_u32)((((float)total)*8.0) / ((float)totaldiv)); */ /* uint32_t avg_size = (uint32_t)((((float)total)*8.0) / ((float)totaldiv)); */
/* you can try tighter ranges than 25%, or wider ranges. I would probably go for tighter... */ /* you can try tighter ranges than 25%, or wider ranges. I would probably go for tighter... */
if ((avg_size < (standard_MFM_8_bit_cell_size - (pulse_limitval * standard_MFM_8_bit_cell_size / 100))) || if ((avg_size < (standard_MFM_8_bit_cell_size - (pulse_limitval * standard_MFM_8_bit_cell_size / 100))) ||
(avg_size > (standard_MFM_8_bit_cell_size + (pulse_limitval * standard_MFM_8_bit_cell_size / 100)))) { (avg_size > (standard_MFM_8_bit_cell_size + (pulse_limitval * standard_MFM_8_bit_cell_size / 100)))) {
@@ -1641,7 +1644,7 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
addbit (d, 0); addbit (d, 0);
addbit (d, 1); addbit (d, 1);
for (j = 0; j < real_size; j++) for (j = 0; j < real_size; j++)
*pt++ = (uae_u16)(pulse / real_size); *pt++ = (uint16_t)(pulse / real_size);
} }
/* prepares for the next pulse */ /* prepares for the next pulse */
@@ -1663,18 +1666,18 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
#else #else
static void static void
fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *maxp, uae_u8 *idx, int maxidx, int *indexoffsetp, int pulses, int mfm) fdi2_decode(FDI *fdi, uint32_t totalavg, uint32_t *avgp, uint32_t *minp, uint32_t *maxp, uint8_t *idx, int maxidx, int *indexoffsetp, int pulses, int mfm)
{ {
uint32_t adjust; uint32_t adjust;
uint32_t adjusted_pulse; uint32_t adjusted_pulse;
uint32_t standard_MFM_2_bit_cell_size = totalavg / 50000; uint32_t standard_MFM_2_bit_cell_size = totalavg / 50000;
uint32_t standard_MFM_8_bit_cell_size = totalavg / 12500; uint32_t standard_MFM_8_bit_cell_size = totalavg / 12500;
int real_size, i, j, nexti, eodat, outstep, randval; int real_size, i, j, nexti, eodat, outstep, randval;
int indexoffset = *indexoffsetp; int indexoffset = *indexoffsetp;
uae_u8 *d = fdi->track_dst_buffer; uint8_t *d = fdi->track_dst_buffer;
uae_u16 *pt = fdi->track_dst_buffer_timing; uint16_t *pt = fdi->track_dst_buffer_timing;
uae_u32 ref_pulse, pulse; uint32_t ref_pulse, pulse;
long jitter; int32_t jitter;
/* detects a long-enough stable pulse coming just after another stable pulse */ /* detects a long-enough stable pulse coming just after another stable pulse */
i = 1; i = 1;
@@ -1698,8 +1701,8 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
while (outstep < 2) { while (outstep < 2) {
/* calculates the current average bitrate from previous decoded data */ /* calculates the current average bitrate from previous decoded data */
uae_u32 avg_size = (total << (2 + mfm)) / totaldiv; /* this is the new average size for one MFM bit */ uint32_t avg_size = (uint32_t) ((total << (2 + mfm)) / totaldiv); /* this is the new average size for one MFM bit */
/* uae_u32 avg_size = (uae_u32)((((float)total)*((float)(mfm+1))*4.0) / ((float)totaldiv)); */ /* uint32_t avg_size = (uint32_t)((((float)total)*((float)(mfm+1))*4.0) / ((float)totaldiv)); */
/* you can try tighter ranges than 25%, or wider ranges. I would probably go for tighter... */ /* you can try tighter ranges than 25%, or wider ranges. I would probably go for tighter... */
if ((avg_size < (standard_MFM_8_bit_cell_size - (pulse_limitval * standard_MFM_8_bit_cell_size / 100))) || (avg_size > (standard_MFM_8_bit_cell_size + (pulse_limitval * standard_MFM_8_bit_cell_size / 100)))) { if ((avg_size < (standard_MFM_8_bit_cell_size - (pulse_limitval * standard_MFM_8_bit_cell_size / 100))) || (avg_size > (standard_MFM_8_bit_cell_size + (pulse_limitval * standard_MFM_8_bit_cell_size / 100)))) {
avg_size = standard_MFM_8_bit_cell_size; avg_size = standard_MFM_8_bit_cell_size;
@@ -1711,7 +1714,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
/* gets the next long-enough pulse (this may require more than one pulse) */ /* gets the next long-enough pulse (this may require more than one pulse) */
pulse = 0; pulse = 0;
while (pulse < ((avg_size / 4) - (avg_size / 16))) { while (pulse < ((avg_size / 4) - (avg_size / 16))) {
uae_u32 avg_pulse, min_pulse, max_pulse; uint32_t avg_pulse, min_pulse, max_pulse;
i++; i++;
if (i >= pulses) if (i >= pulses)
i = 0; i = 0;
@@ -1739,7 +1742,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
randval = rand(); randval = rand();
if (randval < (RAND_MAX / 2)) { if (randval < (RAND_MAX / 2)) {
if (randval > (RAND_MAX / 4)) { if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * RAND_MAX) / 8))) if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
randval = (2 * randval) - (RAND_MAX / 4); randval = (2 * randval) - (RAND_MAX / 4);
else else
randval = (4 * randval) - RAND_MAX; randval = (4 * randval) - RAND_MAX;
@@ -1748,7 +1751,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
} else { } else {
randval -= RAND_MAX / 2; randval -= RAND_MAX / 2;
if (randval > (RAND_MAX / 4)) { if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * RAND_MAX) / 8))) if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
randval = (2 * randval) - (RAND_MAX / 4); randval = (2 * randval) - (RAND_MAX / 4);
else else
randval = (4 * randval) - RAND_MAX; randval = (4 * randval) - RAND_MAX;
@@ -1774,7 +1777,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
randval = rand(); randval = rand();
if (randval < (RAND_MAX / 2)) { if (randval < (RAND_MAX / 2)) {
if (randval > (RAND_MAX / 4)) { if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * RAND_MAX) / 8))) if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
randval = (2 * randval) - (RAND_MAX / 4); randval = (2 * randval) - (RAND_MAX / 4);
else else
randval = (4 * randval) - RAND_MAX; randval = (4 * randval) - RAND_MAX;
@@ -1783,7 +1786,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
} else { } else {
randval -= RAND_MAX / 2; randval -= RAND_MAX / 2;
if (randval > (RAND_MAX / 4)) { if (randval > (RAND_MAX / 4)) {
if (randval <= (((3LL * RAND_MAX) / 8))) if (randval <= (((3LL * (uint64_t) RAND_MAX) / 8)))
randval = (2 * randval) - (RAND_MAX / 4); randval = (2 * randval) - (RAND_MAX / 4);
else else
randval = (4 * randval) - RAND_MAX; randval = (4 * randval) - RAND_MAX;
@@ -1872,7 +1875,7 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
addbit(d, 0); addbit(d, 0);
addbit(d, 1); addbit(d, 1);
for (j = 0; j < real_size; j++) for (j = 0; j < real_size; j++)
*pt++ = (uae_u16) (pulse / real_size); *pt++ = (uint16_t) (pulse / real_size);
} }
/* prepares for the next pulse */ /* prepares for the next pulse */
@@ -1894,11 +1897,11 @@ fdi2_decode(FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *minp, uae_u32 *
#endif #endif
static void static void
fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uae_u16 *out) fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
{ {
uae_u16 *pt2, *pt; uint16_t *pt2, *pt;
double avg_bit_len; double avg_bit_len;
int i; int i;
avg_bit_len = (double) totalavg / (double) bitoffset; avg_bit_len = (double) totalavg / (double) bitoffset;
pt2 = fdi->track_dst_buffer_timing; pt2 = fdi->track_dst_buffer_timing;
@@ -1906,7 +1909,7 @@ fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uae_u16 *out)
for (i = 0; i < bitoffset / 8; i++) { for (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; 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; v = 1000.0 * v / avg_bit_len;
*pt++ = (uae_u16) v; *pt++ = (uint16_t) v;
pt2 += 8; pt2 += 8;
} }
*pt++ = out[0]; *pt++ = out[0];
@@ -1916,14 +1919,14 @@ fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uae_u16 *out)
static int static int
decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache) decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
{ {
uae_u8 *p1; uint8_t *p1;
uae_u32 *p2; uint32_t *p2;
uae_u32 *avgp, *minp = 0, *maxp = 0; uint32_t *avgp, *minp = 0, *maxp = 0;
uae_u8 *idxp = 0; uint8_t *idxp = 0;
uae_u32 maxidx, totalavg, weakbits; uint32_t maxidx, totalavg, weakbits;
int i, j, len, pulses, indexoffset; int i, j, len, pulses, indexoffset;
int avg_free, min_free = 0, max_free = 0, idx_free; int avg_free, min_free = 0, max_free = 0, idx_free;
int idx_off1 = 0, idx_off2 = 0, idx_off3 = 0; int idx_off1 = 0, idx_off2 = 0, idx_off3 = 0;
p1 = fdi->track_src; p1 = fdi->track_src;
pulses = get_u32(p1); pulses = get_u32(p1);
@@ -1931,15 +1934,15 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
return -1; return -1;
p1 += 4; p1 += 4;
len = 12; len = 12;
avgp = (uae_u32 *) fdi_decompress(pulses, p1 + 0, p1 + len, &avg_free); avgp = (uint32_t *) fdi_decompress(pulses, p1 + 0, p1 + len, &avg_free);
dumpstream(track, (uae_u8 *) avgp, pulses); dumpstream(track, (uint8_t *) avgp, pulses);
len += get_u24(p1 + 0) & 0x3fffff; len += get_u24(p1 + 0) & 0x3fffff;
if (!avgp) if (!avgp)
return -1; return -1;
if (get_u24(p1 + 3) && get_u24(p1 + 6)) { if (get_u24(p1 + 3) && get_u24(p1 + 6)) {
minp = (uae_u32 *) fdi_decompress(pulses, p1 + 3, p1 + len, &min_free); minp = (uint32_t *) fdi_decompress(pulses, p1 + 3, p1 + len, &min_free);
len += get_u24(p1 + 3) & 0x3fffff; len += get_u24(p1 + 3) & 0x3fffff;
maxp = (uae_u32 *) fdi_decompress(pulses, p1 + 6, p1 + len, &max_free); maxp = (uint32_t *) fdi_decompress(pulses, p1 + 6, p1 + len, &max_free);
len += get_u24(p1 + 6) & 0x3fffff; len += get_u24(p1 + 6) & 0x3fffff;
/* Computes the real min and max values */ /* Computes the real min and max values */
for (i = 0; i < pulses; i++) { for (i = 0; i < pulses; i++) {
@@ -2048,7 +2051,7 @@ decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
} }
static unsigned char fdiid[] = { "Formatted Disk Image file" }; static unsigned char fdiid[] = { "Formatted Disk Image file" };
static int bit_rate_table[16] = { 125, 150, 250, 300, 500, 1000 }; static int bit_rate_table[16] = { 125, 150, 250, 300, 500, 1000 };
void void
fdi2raw_header_free(FDI *fdi) fdi2raw_header_free(FDI *fdi)
@@ -2106,13 +2109,13 @@ fdi2raw_get_bit_rate(FDI *fdi)
return fdi->bit_rate; return fdi->bit_rate;
} }
int FDI2RawDiskType
fdi2raw_get_type(FDI *fdi) fdi2raw_get_type(FDI *fdi)
{ {
return fdi->disk_type; return fdi->disk_type;
} }
int bool
fdi2raw_get_write_protect(FDI *fdi) fdi2raw_get_write_protect(FDI *fdi)
{ {
return fdi->write_protect; return fdi->write_protect;
@@ -2127,9 +2130,9 @@ fdi2raw_get_tpi(FDI *fdi)
FDI * FDI *
fdi2raw_header(FILE *f) fdi2raw_header(FILE *f)
{ {
int i, offset, oldseek; long i, offset, oldseek;
uae_u8 type, size; uint8_t type, size;
FDI *fdi; FDI *fdi;
fdi2raw_log("ALLOC: memory allocated %d\n", fdi_allocated); fdi2raw_log("ALLOC: memory allocated %d\n", fdi_allocated);
fdi = fdi_malloc(sizeof(FDI)); fdi = fdi_malloc(sizeof(FDI));
@@ -2167,7 +2170,7 @@ fdi2raw_header(FILE *f)
fdi->last_head = fdi->header[144]; fdi->last_head = fdi->header[144];
fdi->disk_type = fdi->header[145]; fdi->disk_type = fdi->header[145];
fdi->rotation_speed = fdi->header[146] + 128; fdi->rotation_speed = fdi->header[146] + 128;
fdi->write_protect = fdi->header[147] & 1; fdi->write_protect = !!(fdi->header[147] & 1);
fdi2raw_log("FDI version %d.%d\n", fdi->header[140], fdi->header[141]); fdi2raw_log("FDI version %d.%d\n", fdi->header[140], fdi->header[141]);
fdi2raw_log("last_track=%d rotation_speed=%d\n", fdi->last_track, fdi->rotation_speed); fdi2raw_log("last_track=%d rotation_speed=%d\n", fdi->last_track, fdi->rotation_speed);
@@ -2197,8 +2200,8 @@ fdi2raw_header(FILE *f)
return fdi; return fdi;
} }
int static int
fdi2raw_loadrevolution_2(FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm) 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]; struct fdi_cache *cache = &fdi->cache[track];
int len, i, idx; int len, i, idx;
@@ -2216,8 +2219,8 @@ fdi2raw_loadrevolution_2(FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int tr
*tracklength = len; *tracklength = len;
for (i = 0; i < (len + 15) / (2 * 8); i++) { for (i = 0; i < (len + 15) / (2 * 8); i++) {
uae_u8 *data = fdi->track_dst_buffer + i * 2; uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1); *mfmbuf++ = 256 * *data + *(data + 1);
} }
fdi2_celltiming(fdi, cache->totalavg, len, tracktiming); fdi2_celltiming(fdi, cache->totalavg, len, tracktiming);
if (indexoffsetp) if (indexoffsetp)
@@ -2226,18 +2229,20 @@ fdi2raw_loadrevolution_2(FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int tr
} }
int int
fdi2raw_loadrevolution(FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int track, int *tracklength, int mfm) fdi2raw_loadrevolution(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int mfm)
{ {
track ^= fdi->reversed_side;
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, 0, 0, mfm); return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, 0, 0, mfm);
} }
int int
fdi2raw_loadtrack(FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm) fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{ {
uae_u8 *p; uint8_t *p;
int outlen, i; int outlen, i;
struct fdi_cache *cache = &fdi->cache[track]; struct fdi_cache *cache = &fdi->cache[track];
track ^= fdi->reversed_side;
if (cache->lowlevel) if (cache->lowlevel)
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm); return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
@@ -2305,8 +2310,8 @@ fdi2raw_loadtrack(FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int track, in
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm); return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
*tracklength = fdi->out; *tracklength = fdi->out;
for (i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) { for (i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
uae_u8 *data = fdi->track_dst_buffer + i * 2; uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1); *mfmbuf++ = 256 * *data + *(data + 1);
} }
} }
return outlen; return outlen;

64
src/include/fdi2raw.h
View File

@@ -16,36 +16,66 @@
* *
* Copyright 2001-2004 Toni Wilen. * Copyright 2001-2004 Toni Wilen.
* Copyright 2001-2004 Vincent Joguin. * Copyright 2001-2004 Vincent Joguin.
* Copyright 2001 Thomas Harte. * Copyright 2001-2016 Thomas Harte.
*/ */
#ifndef __FDI2RAW_H #ifndef __FDI2RAW_H
#define __FDI2RAW_H #define __FDI2RAW_H
#define uae_u8 uint8_t #include <stdint.h>
#define uae_u16 uint16_t #include <stdbool.h>
#define uae_u32 uint32_t
#include <stdio.h> #include <stdio.h>
typedef struct fdi FDI; typedef struct fdi FDI;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
extern int fdi2raw_loadtrack(FDI *, uae_u16 *mfmbuf, uae_u16 *tracktiming, int track, int *tracklength, int *indexoffset, int *multirev, int mfm); /*!
Attempts to parse and return an FDI header from the file @c file.
extern int fdi2raw_loadrevolution(FDI *, uae_u16 *mfmbuf, uae_u16 *tracktiming, int track, int *tracklength, int mfm); @parameter file the file from which to attempt to read the FDI.
@returns a newly-allocated `FDI` if parsing succeeded; @c NULL otherwise.
*/
extern FDI *fdi2raw_header(FILE *file);
extern FDI *fdi2raw_header(FILE *f); /*!
extern void fdi2raw_header_free(FDI *); Release all memory associated with @c file.
extern int fdi2raw_get_last_track(FDI *); */
extern int fdi2raw_get_num_sector(FDI *); extern void fdi2raw_header_free(FDI *file);
extern int fdi2raw_get_last_head(FDI *);
extern int fdi2raw_get_type(FDI *); extern int fdi2raw_loadtrack(FDI *, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffset, int *multirev, int mfm);
extern int fdi2raw_get_bit_rate(FDI *); extern int fdi2raw_loadrevolution(FDI *, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int mfm);
extern int fdi2raw_get_rotation(FDI *);
extern int fdi2raw_get_write_protect(FDI *); typedef enum {
extern int fdi2raw_get_tpi(FDI *); FDI2RawDiskType8Inch = 0,
FDI2RawDiskType5_25Inch = 1,
FDI2RawDiskType3_5Inch = 2,
FDI2RawDiskType3Inch = 3,
} FDI2RawDiskType;
/// @returns the disk type described by @c fdi.
extern FDI2RawDiskType fdi2raw_get_type(FDI *fdi);
/// @returns the bit rate at which @c fdi is sampled if spinning at the intended rate, in Kbit/s.
extern int fdi2raw_get_bit_rate(FDI *fdi);
/// @returns the intended rotation speed of @c fdi, in rotations per minute.
extern int fdi2raw_get_rotation(FDI *fdi);
/// @returns whether the imaged disk was write protected.
extern bool fdi2raw_get_write_protect(FDI *fdi);
/// @returns the final enumerated track represented in @c fdi.
extern int fdi2raw_get_last_track(FDI *fdi);
/// @returns the final enumerated head represented in @c fdi.
extern int fdi2raw_get_last_head(FDI *fdi);
/// @returns @c 22 if track 0 is a standard Amiga high-density; @c 11 otherwise.
extern int fdi2raw_get_num_sector(FDI *fdi);
extern int fdi2raw_get_tpi(FDI *fdi);
#ifdef __cplusplus #ifdef __cplusplus
} }