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

Constification

Browse Source
This commit is contained in:
Jasmine Iwanek
2023-07-20 18:58:26 -04:00
parent db66543959
commit 998cfe5cc8
163 changed files with 1086 additions and 1071 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/floppy/fdd.c
View File

@@ -451,10 +451,10 @@ fdd_get_densel(int drive)
void
fdd_load(int drive, char *fn)
{
int c = 0;
int size;
char *p;
FILE *f;
int c = 0;
int size;
const char *p;
FILE * f;
fdd_log("FDD: loading drive %d with '%s'\n", drive, fn);
@@ -548,8 +548,8 @@ fdd_set_motor_enable(int drive, int motor_enable)
static void
fdd_poll(void *priv)
{
int drive;
DRIVE *drv = (DRIVE *) priv;
int drive;
const DRIVE *drv = (DRIVE *) priv;
drive = drv->id;

88
src/floppy/fdd_86f.c
View File

@@ -355,7 +355,7 @@ d86f_reverse_bytes(int drive)
uint16_t
d86f_disk_flags(int drive)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
return dev->disk_flags;
}
@@ -363,7 +363,7 @@ d86f_disk_flags(int drive)
uint32_t
d86f_index_hole_pos(int drive, int side)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
return dev->index_hole_pos[side];
}
@@ -413,7 +413,7 @@ null_format_conditions(UNUSED(int drive))
int32_t
d86f_extra_bit_cells(int drive, int side)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
return dev->extra_bit_cells[side];
}
@@ -441,8 +441,8 @@ common_read_revolution(UNUSED(int drive))
uint16_t
d86f_side_flags(int drive)
{
d86f_t *dev = d86f[drive];
int side;
const d86f_t *dev = d86f[drive];
int side;
side = fdd_get_head(drive);
@@ -811,9 +811,9 @@ d86f_is_mfm(int drive)
uint32_t
d86f_get_data_len(int drive)
{
d86f_t *dev = d86f[drive];
uint32_t i;
uint32_t ret = 128;
const d86f_t *dev = d86f[drive];
uint32_t i;
uint32_t ret = 128;
if (dev->req_sector.id.n)
ret = (uint32_t) 128 << dev->req_sector.id.n;
@@ -1243,8 +1243,8 @@ d86f_calccrc(d86f_t *dev, uint8_t byte)
int
d86f_word_is_aligned(int drive, int side, uint32_t base_pos)
{
d86f_t *dev = d86f[drive];
uint32_t adjusted_track_pos = dev->track_pos;
const d86f_t *dev = d86f[drive];
uint32_t adjusted_track_pos = dev->track_pos;
if (base_pos == 0xFFFFFFFF)
return 0;
@@ -1841,7 +1841,7 @@ d86f_write_direct_common(int drive, int side, uint16_t byte, uint8_t type, uint3
void
d86f_write_direct(int drive, int side, uint16_t byte, uint8_t type)
{
d86f_t *dev = d86f[drive];
const d86f_t *dev = d86f[drive];
d86f_write_direct_common(drive, side, byte, type, dev->track_pos >> 4);
}
@@ -2108,9 +2108,9 @@ d86f_initialize_last_sector_id(int drive, int c, int h, int r, int n)
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;
sector_t *t;
const d86f_t *dev = d86f[drive];
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2259,9 +2259,9 @@ d86f_turbo_format(int drive, int side, int nop)
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;
sector_t *t;
const d86f_t *dev = d86f[drive];
sector_t *s;
sector_t *t;
if (dev->last_side_sector[side]) {
s = dev->last_side_sector[side];
@@ -2806,22 +2806,22 @@ d86f_construct_encoded_buffer(int drive, int side)
/* *_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;
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];
uint16_t *src1 = dev->thin_track_encoded_data[0][side];
uint16_t *src1_s = dev->thin_track_surface_data[0][side];
uint16_t *src2 = dev->thin_track_encoded_data[1][side];
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
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];
const uint16_t *src1 = dev->thin_track_encoded_data[0][side];
const uint16_t *src1_s = dev->thin_track_surface_data[0][side];
const uint16_t *src2 = dev->thin_track_encoded_data[1][side];
const uint16_t *src2_s = dev->thin_track_surface_data[1][side];
len = d86f_get_array_size(drive, side, 1);
for (uint32_t i = 0; i < len; i++) {
@@ -2858,17 +2858,17 @@ d86f_construct_encoded_buffer(int drive, int side)
void
d86f_decompose_encoded_buffer(int drive, int side)
{
d86f_t *dev = d86f[drive];
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];
uint16_t *src1_s = dev->thin_track_surface_data[0][side];
uint16_t *src2 = dev->thin_track_encoded_data[1][side];
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
dst = d86f_handler[drive].encoded_data(drive, side);
len = d86f_get_array_size(drive, side, 1);
d86f_t *dev = d86f[drive];
uint16_t temp;
uint16_t temp2;
uint32_t len;
const uint16_t *dst = dev->track_encoded_data[side];
uint16_t *src1 = dev->thin_track_encoded_data[0][side];
uint16_t *src1_s = dev->thin_track_surface_data[0][side];
uint16_t *src2 = dev->thin_track_encoded_data[1][side];
uint16_t *src2_s = dev->thin_track_surface_data[1][side];
dst = d86f_handler[drive].encoded_data(drive, side);
len = d86f_get_array_size(drive, side, 1);
for (uint32_t i = 0; i < len; i++) {
if (d86f_has_surface_desc(drive)) {

16
src/floppy/fdd_fdi.c
View File

@@ -176,10 +176,10 @@ fdi_density(void)
static int32_t
extra_bit_cells(int drive, int side)
{
fdi_t *dev = fdi[drive];
int density = 0;
int raw_size = 0;
int is_300_rpm = 0;
const fdi_t *dev = fdi[drive];
int density = 0;
int raw_size = 0;
int is_300_rpm = 0;
density = fdi_density();
@@ -249,8 +249,8 @@ read_revolution(int drive)
static uint32_t
index_hole_pos(int drive, int side)
{
fdi_t *dev = fdi[drive];
int density;
const fdi_t *dev = fdi[drive];
int density;
density = fdi_density();
@@ -260,8 +260,8 @@ index_hole_pos(int drive, int side)
static uint32_t
get_raw_size(int drive, int side)
{
fdi_t *dev = fdi[drive];
int density;
const fdi_t *dev = fdi[drive];
int density;
density = fdi_density();

198
src/floppy/fdd_imd.c
View File

@@ -136,17 +136,16 @@ get_raw_tsize(int side_flags, int slower_rpm)
static int
track_is_xdf(int drive, int side, int track)
{
imd_t *dev = imd[drive];
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;
imd_t *dev = imd[drive];
int effective_sectors;
int xdf_sectors;
int high_sectors;
int low_sectors;
int max_high_id;
int expected_high_count;
int expected_low_count;
const uint8_t *r_map;
const uint8_t *n_map;
effective_sectors = xdf_sectors = high_sectors = low_sectors = 0;
@@ -224,10 +223,10 @@ track_is_xdf(int drive, int side, int track)
static int
track_is_interleave(int drive, int side, int track)
{
imd_t *dev = imd[drive];
int effective_sectors;
char *r_map;
int track_spt;
imd_t *dev = imd[drive];
int effective_sectors;
const char *r_map;
int track_spt;
effective_sectors = 0;
@@ -263,9 +262,9 @@ track_is_interleave(int drive, int side, int track)
static void
sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, int len)
{
imd_t *dev = imd[drive];
int type = dev->buffer[dev->tracks[track][side].sector_data_offs[sector]];
uint8_t fill_char;
const imd_t *dev = imd[drive];
int type = dev->buffer[dev->tracks[track][side].sector_data_offs[sector]];
uint8_t fill_char;
if (type == 0)
memset(buffer, 0x00, len);
@@ -282,33 +281,33 @@ sector_to_buffer(int drive, int track, int side, uint8_t *buffer, int sector, in
static void
imd_seek(int drive, int track)
{
uint32_t track_buf_pos[2] = { 0, 0 };
uint8_t id[4] = { 0, 0, 0, 0 };
uint8_t type;
imd_t *dev = imd[drive];
int sector;
int current_pos;
int c = 0;
int h;
int n;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
int track_gap3 = 12;
int xdf_type = 0;
int interleave_type = 0;
int is_trackx = 0;
int xdf_spt = 0;
int xdf_sector = 0;
int ordered_pos = 0;
int real_sector = 0;
int actual_sector = 0;
char *c_map = NULL;
char *h_map = NULL;
char *r_map;
char *n_map = NULL;
uint8_t *data;
int flags = 0x00;
uint32_t track_buf_pos[2] = { 0, 0 };
uint8_t id[4] = { 0, 0, 0, 0 };
uint8_t type;
imd_t *dev = imd[drive];
int sector;
int current_pos;
int c = 0;
int h;
int n;
int ssize = 512;
int track_rate = 0;
int track_gap2 = 22;
int track_gap3 = 12;
int xdf_type = 0;
int interleave_type = 0;
int is_trackx = 0;
int xdf_spt = 0;
int xdf_sector = 0;
int ordered_pos = 0;
int real_sector = 0;
int actual_sector = 0;
const char *c_map = NULL;
const char *h_map = NULL;
const char *r_map;
const char *n_map = NULL;
uint8_t *data;
int flags = 0x00;
if (dev->fp == NULL)
return;
@@ -452,7 +451,7 @@ imd_seek(int drive, int track)
static uint16_t
disk_flags(int drive)
{
imd_t *dev = imd[drive];
const imd_t *dev = imd[drive];
return (dev->disk_flags);
}
@@ -460,9 +459,9 @@ disk_flags(int drive)
static uint16_t
side_flags(int drive)
{
imd_t *dev = imd[drive];
int side = 0;
uint16_t sflags = 0;
const imd_t *dev = imd[drive];
int side = 0;
uint16_t sflags = 0;
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
@@ -473,19 +472,19 @@ side_flags(int drive)
static void
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 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];
sn = dev->tracks[track][side].params[4];
imd_t *dev = imd[drive];
int track = dev->track;
int sc;
int sh;
int sn;
const char *c_map = NULL;
const char *h_map = NULL;
const char *r_map = NULL;
const 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];
sn = dev->tracks[track][side].params[4];
if (sh & 0x80)
c_map = dev->buffer + dev->tracks[track][side].c_map_offs;
@@ -513,13 +512,13 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
static void
imd_writeback(int drive)
{
imd_t *dev = imd[drive];
int track = dev->track;
char *n_map = 0;
uint8_t h;
uint8_t n;
uint8_t spt;
uint32_t ssize;
imd_t *dev = imd[drive];
int track = dev->track;
const char *n_map = 0;
uint8_t h;
uint8_t n;
uint8_t spt;
uint32_t ssize;
if (writeprot[drive])
return;
@@ -554,8 +553,8 @@ imd_writeback(int drive)
static uint8_t
poll_read_data(int drive, int side, uint16_t pos)
{
imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
const imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
if ((type == 0) || (type > 8))
return 0xf6; /* Should never happen. */
@@ -569,8 +568,8 @@ poll_read_data(int drive, int side, uint16_t pos)
static void
poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
{
imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
const imd_t *dev = imd[drive];
int type = dev->current_data[side][0];
if (writeprot[drive])
return;
@@ -584,10 +583,10 @@ poll_write_data(int drive, int side, uint16_t pos, uint8_t data)
static int
format_conditions(int drive)
{
imd_t *dev = imd[drive];
int track = dev->track;
int side;
int temp;
const imd_t *dev = imd[drive];
int track = dev->track;
int side;
int temp;
side = fdd_get_head(drive);
temp = (fdc_get_format_sectors(imd_fdc) == dev->tracks[track][side].params[3]);
@@ -605,29 +604,28 @@ imd_init(void)
void
imd_load(int drive, char *fn)
{
uint32_t magic = 0;
uint32_t fsize = 0;
char *buffer;
char *buffer2;
imd_t *dev;
int i = 0;
int track_spt = 0;
int sector_size = 0;
int track = 0;
int side = 0;
int extra = 0;
uint32_t last_offset = 0;
uint32_t data_size = 512;
uint32_t mfm = 0;
uint32_t pre_sector = 0;
uint32_t track_total = 0;
uint32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
uint8_t converted_rate;
uint8_t type;
int size_diff;
int gap_sum;
uint32_t magic = 0;
uint32_t fsize = 0;
const char *buffer;
const char *buffer2;
imd_t *dev;
int track_spt = 0;
int sector_size = 0;
int track = 0;
int side = 0;
int extra = 0;
uint32_t last_offset = 0;
uint32_t data_size = 512;
uint32_t mfm = 0;
uint32_t pre_sector = 0;
uint32_t track_total = 0;
uint32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
uint8_t converted_rate;
uint8_t type;
int size_diff;
int gap_sum;
d86f_unregister(drive);

10
src/floppy/fdd_img.c
View File

@@ -436,7 +436,7 @@ write_back(int drive)
static uint16_t
disk_flags(int drive)
{
img_t *dev = img[drive];
const img_t *dev = img[drive];
return (dev->disk_flags);
}
@@ -444,7 +444,7 @@ disk_flags(int drive)
static uint16_t
side_flags(int drive)
{
img_t *dev = img[drive];
const img_t *dev = img[drive];
return (dev->track_flags);
}
@@ -461,7 +461,7 @@ set_sector(int drive, UNUSED(int side), UNUSED(uint8_t c), uint8_t h, uint8_t r,
static uint8_t
poll_read_data(int drive, UNUSED(int side), uint16_t pos)
{
img_t *dev = img[drive];
const img_t *dev = img[drive];
return (dev->track_data[dev->current_sector_pos_side][dev->current_sector_pos + pos]);
}
@@ -477,8 +477,8 @@ poll_write_data(int drive, UNUSED(int side), uint16_t pos, uint8_t data)
static int
format_conditions(int drive)
{
img_t *dev = img[drive];
int temp = (fdc_get_format_sectors(img_fdc) == dev->sectors);
const img_t *dev = img[drive];
int temp = (fdc_get_format_sectors(img_fdc) == dev->sectors);
temp = temp && (fdc_get_format_n(img_fdc) == dev->sector_size);
temp = temp && (dev->xdf_type == 0);

16
src/floppy/fdd_json.c
View File

@@ -467,7 +467,7 @@ json_seek(int drive, int track)
static uint16_t
disk_flags(int drive)
{
json_t *dev = images[drive];
const json_t *dev = images[drive];
return (dev->disk_flags);
}
@@ -475,7 +475,7 @@ disk_flags(int drive)
static uint16_t
track_flags(int drive)
{
json_t *dev = images[drive];
const json_t *dev = images[drive];
return (dev->track_flags);
}
@@ -505,8 +505,8 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
static uint8_t
poll_read_data(int drive, int side, uint16_t pos)
{
json_t *dev = images[drive];
uint8_t sec = dev->sector[side];
const json_t *dev = images[drive];
uint8_t sec = dev->sector[side];
return (dev->sects[dev->track][side][sec].data[pos]);
}
@@ -520,10 +520,10 @@ json_init(void)
void
json_load(int drive, char *fn)
{
double bit_rate;
int temp_rate;
sector_t *sec;
json_t *dev;
double bit_rate;
int temp_rate;
const sector_t *sec;
json_t *dev;
/* Just in case- remove ourselves from 86F. */
d86f_unregister(drive);

30
src/floppy/fdd_mfm.c
View File

@@ -105,8 +105,8 @@ mfm_log(const char *fmt, ...)
static int
get_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int ret = -1;
const mfm_t *dev = mfm[drive];
int ret = -1;
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->tracks[i].track_no == track) && (dev->tracks[i].side_no == side)) {
@@ -121,8 +121,8 @@ get_track_index(int drive, int side, int track)
static int
get_adv_track_index(int drive, int side, int track)
{
mfm_t *dev = mfm[drive];
int ret = -1;
const mfm_t *dev = mfm[drive];
int ret = -1;
for (int i = 0; i < dev->total_tracks; i++) {
if ((dev->adv_tracks[i].track_no == track) && (dev->adv_tracks[i].side_no == side)) {
@@ -137,9 +137,9 @@ get_adv_track_index(int drive, int side, int track)
static void
get_adv_track_bitrate(int drive, int side, int track, int *br, int *rpm)
{
mfm_t *dev = mfm[drive];
int track_index;
double dbr;
const mfm_t *dev = mfm[drive];
int track_index;
double dbr;
track_index = get_adv_track_index(drive, side, track);
@@ -197,7 +197,7 @@ set_disk_flags(int drive)
static uint16_t
disk_flags(int drive)
{
mfm_t *dev = mfm[drive];
const mfm_t *dev = mfm[drive];
return dev->disk_flags;
}
@@ -257,8 +257,8 @@ set_side_flags(int drive, int side)
static uint16_t
side_flags(int drive)
{
mfm_t *dev = mfm[drive];
int side;
const mfm_t *dev = mfm[drive];
int side;
side = fdd_get_head(drive);
@@ -268,11 +268,11 @@ side_flags(int drive)
static uint32_t
get_raw_size(int drive, int side)
{
mfm_t *dev = mfm[drive];
int track_index;
int is_300_rpm;
int br = 250;
int rpm = 300;
const mfm_t *dev = mfm[drive];
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);

72
src/floppy/fdd_td0.c
View File

@@ -595,37 +595,37 @@ get_raw_tsize(int side_flags, int slower_rpm)
static int
td0_initialize(int drive)
{
td0_t *dev = td0[drive];
uint8_t header[12];
int fm;
int head;
int track;
int track_count = 0;
int head_count = 0;
int track_spt;
int track_spt_adjusted;
int offset = 0;
int density = 0;
int temp_rate = 0;
uint32_t file_size;
uint16_t len;
uint16_t rep;
td0dsk_t disk_decode;
uint8_t *hs;
uint16_t size;
uint8_t *dbuf = dev->processed_buf;
uint32_t total_size = 0;
uint32_t id_field = 0;
uint32_t pre_sector = 0;
int32_t track_size = 0;
int32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
int i;
int j;
int k;
int size_diff;
int gap_sum;
td0_t *dev = td0[drive];
uint8_t header[12];
int fm;
int head;
int track;
int track_count = 0;
int head_count = 0;
int track_spt;
int track_spt_adjusted;
int offset = 0;
int density = 0;
int temp_rate = 0;
uint32_t file_size;
uint16_t len;
uint16_t rep;
td0dsk_t disk_decode;
const uint8_t *hs;
uint16_t size;
uint8_t *dbuf = dev->processed_buf;
uint32_t total_size = 0;
uint32_t id_field = 0;
uint32_t pre_sector = 0;
int32_t track_size = 0;
int32_t raw_tsize = 0;
uint32_t minimum_gap3 = 0;
uint32_t minimum_gap4 = 0;
int i;
int j;
int k;
int size_diff;
int gap_sum;
if (dev->fp == NULL) {
td0_log("TD0: Attempted to initialize without loading a file first\n");
@@ -889,7 +889,7 @@ td0_initialize(int drive)
static uint16_t
disk_flags(int drive)
{
td0_t *dev = td0[drive];
const td0_t *dev = td0[drive];
return (dev->disk_flags);
}
@@ -897,9 +897,9 @@ disk_flags(int drive)
static uint16_t
side_flags(int drive)
{
td0_t *dev = td0[drive];
int side = 0;
uint16_t sflags = 0;
const td0_t *dev = td0[drive];
int side = 0;
uint16_t sflags = 0;
side = fdd_get_head(drive);
sflags = dev->current_side_flags[side];
@@ -926,7 +926,7 @@ set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
static uint8_t
poll_read_data(int drive, int side, uint16_t pos)
{
td0_t *dev = td0[drive];
const td0_t *dev = td0[drive];
return (dev->sects[dev->track][side][dev->current_sector_index[side]].data[pos]);
}

56
src/floppy/fdi2raw.c
View File

@@ -1920,9 +1920,9 @@ 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;
uint16_t *pt;
double avg_bit_len;
const uint16_t *pt2;
uint16_t *pt;
double avg_bit_len;
avg_bit_len = (double) totalavg / (double) bitoffset;
pt2 = fdi->track_dst_buffer_timing;
@@ -1940,27 +1940,27 @@ fdi2_celltiming(FDI *fdi, uint32_t totalavg, int bitoffset, uint16_t *out)
static int
decode_lowlevel_track(FDI *fdi, int track, struct fdi_cache *cache)
{
uint8_t *p1;
uint32_t *p2;
uint32_t *avgp;
uint32_t *minp = 0;
uint32_t *maxp = 0;
uint8_t *idxp = 0;
uint32_t maxidx;
uint32_t totalavg;
uint32_t weakbits;
int j;
int k;
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;
uint8_t *p1;
const uint32_t *p2;
uint32_t *avgp;
uint32_t *minp = 0;
uint32_t *maxp = 0;
uint8_t *idxp = 0;
uint32_t maxidx;
uint32_t totalavg;
uint32_t weakbits;
int j;
int k;
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);
@@ -2259,7 +2259,7 @@ fdi2raw_loadrevolution_2(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int
*tracklength = len;
for (int i = 0; i < (len + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
const uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}
fdi2_celltiming(fdi, cache->totalavg, len, tracktiming);
@@ -2278,7 +2278,7 @@ fdi2raw_loadrevolution(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int tr
int
fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track, int *tracklength, int *indexoffsetp, int *multirev, int mfm)
{
uint8_t *p;
const uint8_t *p;
int outlen;
struct fdi_cache *cache = &fdi->cache[track];
@@ -2352,8 +2352,8 @@ fdi2raw_loadtrack(FDI *fdi, uint16_t *mfmbuf, uint16_t *tracktiming, int track,
return fdi2raw_loadrevolution_2(fdi, mfmbuf, tracktiming, track, tracklength, indexoffsetp, multirev, mfm);
*tracklength = fdi->out;
for (int i = 0; i < ((*tracklength) + 15) / (2 * 8); i++) {
uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
const uint8_t *data = fdi->track_dst_buffer + i * 2;
*mfmbuf++ = 256 * *data + *(data + 1);
}
}
return outlen;