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

Applied a whole slew of patches, getting RAM usage down by a further 10 MB.

Browse Source
This commit is contained in:
OBattler
2018-03-19 01:02:04 +01:00
parent b6c393cc91
commit b1efb99ed6
222 changed files with 9538 additions and 9980 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
src/floppy/fdd_json.c
View File

@@ -1,18 +1,48 @@
/*
* 86Box A hypervisor and IBM PC system emulator that specializes in
* running old operating systems and software designed for IBM
* PC systems and compatibles from 1981 through fairly recent
* system designs based on the PCI bus.
* VARCem Virtual ARchaeological Computer EMulator.
* An emulator of (mostly) x86-based PC systems and devices,
* using the ISA,EISA,VLB,MCA and PCI system buses, roughly
* spanning the era between 1981 and 1995.
*
* This file is part of the 86Box distribution.
* This file is part of the VARCem Project.
*
* Implementation of the PCjs JSON floppy image format.
*
* Version: @(#)fdd_json.c 1.0.11 2018/03/14
* Version: @(#)fdd_json.c 1.0.4 2018/03/17
*
* Author: Fred N. van Kempen, <decwiz@yahoo.com>
*
* Copyright 2017,2018 Fred N. van Kempen.
*
* Redistribution and use in source and binary forms, with
* or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain the entire
* above notice, this list of conditions and the following
* disclaimer.
*
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the
* following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names
* of its contributors may be used to endorse or promote
* products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdint.h>
@@ -71,11 +101,11 @@ typedef struct {
} json_t;
static json_t images[FDD_NUM];
static json_t *images[FDD_NUM];
static void
handle(json_t *img, char *name, char *str)
handle(json_t *dev, char *name, char *str)
{
sector_t *sec = NULL;
uint32_t l, pat;
@@ -84,7 +114,7 @@ handle(json_t *img, char *name, char *str)
int i, s;
/* Point to the currently selected sector. */
sec = &img->sects[img->track][img->side][img->dmf-1];
sec = &dev->sects[dev->track][dev->side][dev->dmf-1];
/* If no name given, assume sector is done. */
if (name == NULL) {
@@ -98,8 +128,8 @@ handle(json_t *img, char *name, char *str)
sec->size = fdd_sector_size_code(sec->size);
/* Set up the rest of the Sector ID. */
sec->track = img->track;
sec->side = img->side;
sec->track = dev->track;
sec->side = dev->side;
return;
}
@@ -159,13 +189,13 @@ unexpect(int c, int state, int level)
static int
load_image(json_t *img)
load_image(json_t *dev)
{
char buff[4096], name[32];
int c, i, j, state, level;
char *ptr;
if (img->f == NULL) {
if (dev->f == NULL) {
pclog("JSON: no file loaded!\n");
return(0);
}
@@ -173,17 +203,17 @@ load_image(json_t *img)
/* Initialize. */
for (i=0; i<NTRACKS; i++) {
for (j=0; j<NSIDES; j++)
memset(img->sects[i][j], 0x00, sizeof(sector_t));
memset(dev->sects[i][j], 0x00, sizeof(sector_t));
}
img->track = img->side = img->dmf = 0; /* "dmf" is "sector#" */
dev->track = dev->side = dev->dmf = 0; /* "dmf" is "sector#" */
/* Now run the state machine. */
ptr = NULL;
level = state = 0;
while (state >= 0) {
/* Get a character from the input. */
c = fgetc(img->f);
if ((c == EOF) || ferror(img->f)) {
c = fgetc(dev->f);
if ((c == EOF) || ferror(dev->f)) {
state = -1;
break;
}
@@ -191,7 +221,7 @@ load_image(json_t *img)
/* Process it. */
switch(state) {
case 0: /* read level header */
img->dmf = 1;
dev->dmf = 1;
if (c != '[') {
state = unexpect(c, state, level);
} else {
@@ -239,7 +269,7 @@ load_image(json_t *img)
case ',':
case '}':
*ptr = '\0';
handle(img, name, buff);
handle(dev, name, buff);
if (c == '}')
state = 7; /* done */
@@ -264,10 +294,10 @@ load_image(json_t *img)
break;
case 7: /* sector done */
handle(img, NULL, NULL);
handle(dev, NULL, NULL);
switch(c) {
case ',': /* next sector */
img->dmf++;
dev->dmf++;
state = 1;
break;
@@ -297,14 +327,14 @@ load_image(json_t *img)
default:
state = unexpect(c, state, level);
}
img->spt[img->track][img->side] = img->dmf;
img->side++;
dev->spt[dev->track][dev->side] = dev->dmf;
dev->side++;
break;
case 9: /* track done */
switch(c) {
case ',': /* next track */
img->side = 0;
dev->side = 0;
state = 0;
break;
@@ -317,15 +347,15 @@ load_image(json_t *img)
default:
state = unexpect(c, state, level);
}
img->track++;
dev->track++;
break;
}
}
/* Save derived values. */
img->tracks = img->track;
img->sides = img->side;
dev->tracks = dev->track;
dev->sides = dev->side;
return(1);
}
@@ -336,69 +366,71 @@ static void
json_seek(int drive, int track)
{
uint8_t id[4] = { 0,0,0,0 };
json_t *img = &images[drive];
json_t *dev = images[drive];
int side, sector;
int rate, gap2, gap3, pos;
int ssize, rsec, asec;
int interleave_type;
if (img->f == NULL) {
if (dev->f == NULL) {
pclog("JSON: seek: no file loaded!\n");
return;
}
/* Allow for doublestepping tracks. */
if (! img->track_width && fdd_doublestep_40(drive)) track /= 2;
if (! dev->track_width && fdd_doublestep_40(drive)) track /= 2;
/* Set the new track. */
img->track = track;
dev->track = track;
d86f_set_cur_track(drive, track);
/* Reset the 86F state machine. */
d86f_reset_index_hole_pos(drive, 0);
d86f_reset_index_hole_pos(drive, 1);
d86f_destroy_linked_lists(drive, 0);
d86f_reset_index_hole_pos(drive, 1);
d86f_destroy_linked_lists(drive, 1);
interleave_type = 0;
if (track > img->tracks) {
if (track > dev->tracks) {
d86f_zero_track(drive);
return;
}
for (side=0; side<img->sides; side++) {
for (side=0; side<dev->sides; side++) {
/* Get transfer rate for this side. */
rate = img->track_flags & 0x07;
if (!rate && (img->track_flags & 0x20)) rate = 4;
rate = dev->track_flags & 0x07;
if (!rate && (dev->track_flags & 0x20)) rate = 4;
/* Get correct GAP3 value for this side. */
gap3 = fdd_get_gap3_size(rate,
img->sects[track][side][0].size,
img->spt[track][side]);
dev->sects[track][side][0].size,
dev->spt[track][side]);
/* Get correct GAP2 value for this side. */
gap2 = ((img->track_flags & 0x07) >= 3) ? 41 : 22;
gap2 = ((dev->track_flags & 0x07) >= 3) ? 41 : 22;
pos = d86f_prepare_pretrack(drive, side, 0);
for (sector=0; sector<img->spt[track][side]; sector++) {
for (sector=0; sector<dev->spt[track][side]; sector++) {
if (interleave_type == 0) {
rsec = img->sects[track][side][sector].sector;
rsec = dev->sects[track][side][sector].sector;
asec = sector;
} else {
rsec = fdd_dmf_r[sector];
asec = img->interleave_ordered[rsec][side];
asec = dev->interleave_ordered[rsec][side];
}
id[0] = track;
id[1] = side;
id[2] = rsec;
id[3] = img->sects[track][side][asec].size;
ssize = fdd_sector_code_size(img->sects[track][side][asec].size);
if (dev->sects[track][side][asec].size > 255)
perror("fdd_json.c: json_seek: sector size too big.");
id[3] = dev->sects[track][side][asec].size & 0xff;
ssize = fdd_sector_code_size(dev->sects[track][side][asec].size & 0xff);
pos = d86f_prepare_sector(
drive, side, pos, id,
img->sects[track][side][asec].data,
dev->sects[track][side][asec].data,
ssize, gap2, gap3,
0, /*deleted flag*/
0 /*bad_crc flag*/
@@ -414,38 +446,42 @@ json_seek(int drive, int track)
static uint16_t
disk_flags(int drive)
{
return(images[drive].disk_flags);
json_t *dev = images[drive];
return(dev->disk_flags);
}
static uint16_t
track_flags(int drive)
{
return(images[drive].track_flags);
json_t *dev = images[drive];
return(dev->track_flags);
}
static void
set_sector(int drive, int side, uint8_t c, uint8_t h, uint8_t r, uint8_t n)
{
json_t *img = &images[drive];
json_t *dev = images[drive];
int i;
img->sector[side] = 0;
dev->sector[side] = 0;
/* Make sure we are on the desired track. */
if (c != img->track) return;
if (c != dev->track) return;
/* Set the desired side. */
img->side = side;
dev->side = side;
/* Now loop over all sector ID's on this side to find our sector. */
for (i=0; i<img->spt[c][side]; i++) {
if ((img->sects[img->track][side][i].track == c) &&
(img->sects[img->track][side][i].side == h) &&
(img->sects[img->track][side][i].sector == r) &&
(img->sects[img->track][side][i].size == n)) {
img->sector[side] = i;
for (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;
}
}
}
@@ -454,10 +490,10 @@ 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 *img = &images[drive];
uint8_t sec = img->sector[side];
json_t *dev = images[drive];
uint8_t sec = dev->sector[side];
return(img->sects[img->track][side][sec].data[pos]);
return(dev->sects[dev->track][side][sec].data[pos]);
}
@@ -471,21 +507,23 @@ json_init(void)
void
json_load(int drive, wchar_t *fn)
{
json_t *img = &images[drive];
sector_t *sec;
double bit_rate;
int temp_rate;
sector_t *sec;
json_t *dev;
int i;
/* Just in case- remove ourselves from 86F. */
d86f_unregister(drive);
/* Zap any old data. */
memset(img, 0x00, sizeof(json_t));
/* Allocate a drive block. */
dev = (json_t *)malloc(sizeof(json_t));
memset(dev, 0x00, sizeof(json_t));
/* Open the image file. */
img->f = plat_fopen(fn, L"rb");
if (img->f == NULL) {
dev->f = plat_fopen(fn, L"rb");
if (dev->f == NULL) {
free(dev);
memset(fn, 0x00, sizeof(wchar_t));
return;
}
@@ -493,66 +531,70 @@ json_load(int drive, wchar_t *fn)
/* Our images are always RO. */
writeprot[drive] = 1;
/* Set up the drive unit. */
images[drive] = dev;
/* Load all sectors from the image file. */
if (! load_image(img)) {
if (! load_image(dev)) {
pclog("JSON: failed to initialize\n");
(void)fclose(img->f);
img->f = NULL;
(void)fclose(dev->f);
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(wchar_t));
return;
}
pclog("JSON(%d): %ls (%i tracks, %i sides, %i sectors)\n",
drive, fn, img->tracks, img->sides, img->spt[0][0]);
drive, fn, dev->tracks, dev->sides, dev->spt[0][0]);
/*
* If the image has more than 43 tracks, then
* the tracks are thin (96 tpi).
*/
img->track_width = (img->tracks > 43) ? 1 : 0;
dev->track_width = (dev->tracks > 43) ? 1 : 0;
/* If the image has 2 sides, mark it as such. */
img->disk_flags = 0x00;
if (img->sides == 2)
img->disk_flags |= 0x08;
dev->disk_flags = 0x00;
if (dev->sides == 2)
dev->disk_flags |= 0x08;
/* JSON files are always assumed to be MFM-encoded. */
img->track_flags = 0x08;
dev->track_flags = 0x08;
img->interleave = 0;
dev->interleave = 0;
#if 0
img->skew = 0;
dev->skew = 0;
#endif
temp_rate = 0xff;
sec = &img->sects[0][0][0];
sec = &dev->sects[0][0][0];
for (i=0; i<6; i++) {
if (img->spt[0][0] > fdd_max_sectors[sec->size][i]) continue;
if (dev->spt[0][0] > fdd_max_sectors[sec->size][i]) continue;
bit_rate = fdd_bit_rates_300[i];
temp_rate = fdd_rates[i];
img->disk_flags |= (fdd_holes[i] << 1);
dev->disk_flags |= (fdd_holes[i] << 1);
if ((bit_rate == 500.0) && (img->spt[0][0] == 21) &&
(sec->size == 2) && (img->tracks >= 80) &&
(img->tracks <= 82) && (img->sides == 2)) {
if ((bit_rate == 500.0) && (dev->spt[0][0] == 21) &&
(sec->size == 2) && (dev->tracks >= 80) &&
(dev->tracks <= 82) && (dev->sides == 2)) {
/*
* This is a DMF floppy, set the flag so
* we know to interleave the sectors.
*/
img->dmf = 1;
dev->dmf = 1;
} else {
if ((bit_rate == 500.0) && (img->spt[0][0] == 22) &&
(sec->size == 2) && (img->tracks >= 80) &&
(img->tracks <= 82) && (img->sides == 2)) {
if ((bit_rate == 500.0) && (dev->spt[0][0] == 22) &&
(sec->size == 2) && (dev->tracks >= 80) &&
(dev->tracks <= 82) && (dev->sides == 2)) {
/*
* This is marked specially because of the
* track flag (a RPM slow down is needed).
*/
img->interleave = 2;
dev->interleave = 2;
}
img->dmf = 0;
dev->dmf = 0;
}
break;
@@ -560,41 +602,44 @@ json_load(int drive, wchar_t *fn)
if (temp_rate == 0xff) {
pclog("JSON: invalid image (temp_rate=0xff)\n");
(void)fclose(img->f);
img->f = NULL;
(void)fclose(dev->f);
dev->f = NULL;
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(wchar_t));
return;
}
if (img->interleave == 2) {
img->interleave = 1;
img->disk_flags |= 0x60;
if (dev->interleave == 2) {
dev->interleave = 1;
dev->disk_flags |= 0x60;
}
img->gap2_len = (temp_rate == 3) ? 41 : 22;
if (img->dmf) {
img->gap3_len = 8;
} else {
img->gap3_len = fdd_get_gap3_size(temp_rate,sec->size,img->spt[0][0]);
}
dev->gap2_len = (temp_rate == 3) ? 41 : 22;
if (dev->dmf)
dev->gap3_len = 8;
else
dev->gap3_len = fdd_get_gap3_size(temp_rate,sec->size,dev->spt[0][0]);
if (! img->gap3_len) {
if (! dev->gap3_len) {
pclog("JSON: image of unknown format was inserted into drive %c:!\n",
'C'+drive);
(void)fclose(img->f);
img->f = NULL;
(void)fclose(dev->f);
dev->f = NULL;
free(dev);
images[drive] = NULL;
memset(fn, 0x00, sizeof(wchar_t));
return;
}
img->track_flags |= (temp_rate & 0x03); /* data rate */
dev->track_flags |= (temp_rate & 0x03); /* data rate */
if (temp_rate & 0x04)
img->track_flags |= 0x20; /* RPM */
dev->track_flags |= 0x20; /* RPM */
pclog(" disk_flags: 0x%02x, track_flags: 0x%02x, GAP3 length: %i\n",
img->disk_flags, img->track_flags, img->gap3_len);
dev->disk_flags, dev->track_flags, dev->gap3_len);
pclog(" bit rate 300: %.2f, temporary rate: %i, hole: %i, DMF: %i\n",
bit_rate, temp_rate, (img->disk_flags >> 1), img->dmf);
bit_rate, temp_rate, (dev->disk_flags >> 1), dev->dmf);
/* Set up handlers for 86F layer. */
d86f_handler[drive].disk_flags = disk_flags;
@@ -622,26 +667,30 @@ json_load(int drive, wchar_t *fn)
void
json_close(int drive)
{
json_t *img = &images[drive];
json_t *dev = images[drive];
int t, h, s;
if (dev == NULL) return;
/* Unlink image from the system. */
d86f_unregister(drive);
/* Release all the sector buffers. */
for (t=0; t<256; t++) {
for (h=0; h<2; h++) {
memset(img->sects[t][h], 0x00, sizeof(sector_t));
memset(dev->sects[t][h], 0x00, sizeof(sector_t));
for (s=0; s<256; s++) {
if (img->sects[t][h][s].data != NULL)
free(img->sects[t][h][s].data);
img->sects[t][h][s].data = NULL;
if (dev->sects[t][h][s].data != NULL)
free(dev->sects[t][h][s].data);
dev->sects[t][h][s].data = NULL;
}
}
}
if (img->f != NULL) {
(void)fclose(img->f);
img->f = NULL;
}
if (dev->f != NULL)
(void)fclose(dev->f);
/* Release the memory. */
free(dev);
images[drive] = NULL;
}