Changes to logging - nothing (other than some parts of pc.c) uses the global pclog anymore (and logs will be almost empty (until the base set logging flags is agreed upon);

Fixes to various hard disk controllers; Added the Packard Bell PB640; Fixed the InPort mouse emulation - now it works correctly on Windows NT 3.1; Removed the status window and the associated variables; Completely removed the Green B 486 machine; Fixed the MDSI Genius; Fixed the single-sided 5.25" floppy drive; Ported a CPU-related commit from VARCem.
2018-05-21 19:04:05 +02:00
parent 534ed6ea32
commit 5d8deea63b
130 changed files with 5062 additions and 3262 deletions
--- a/src/floppy/fdc.c
+++ b/src/floppy/fdc.c
@@ -9,7 +9,7 @@
 *		Implementation of the NEC uPD-765 and compatible floppy disk
 *		controller.
 *
- * Version:	@(#)fdc.c	1.0.7	2018/04/26
+ * Version:	@(#)fdc.c	1.0.8	2018/05/09
 *
 * Authors:	Miran Grca, <mgrca8@gmail.com>
 *		Sarah Walker, <tommowalker@tommowalker.co.uk>
@@ -613,7 +613,7 @@ void
 fdc_seek(fdc_t *fdc, int drive, int params)
 {
    fdd_seek(real_drive(fdc, drive), params);
-    fdc->time = 5000 * TIMER_SHIFT;
+    fdc->time = 5000LL * (1 << TIMER_SHIFT);

    fdc->stat |= (1 << fdc->drive);
 }
@@ -992,6 +992,10 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
 						fdc->read_track_sector.id.h = fdc->params[2];
 						fdc->read_track_sector.id.r = 1;
 						fdc->read_track_sector.id.n = fdc->params[4];
+						if ((fdc->head & 0x01) && !fdd_is_double_sided(real_drive(fdc, fdc->drive))) {
+							fdc_noidam(fdc);
+							return;
+						}
 						fdd_readsector(real_drive(fdc, fdc->drive), SECTOR_FIRST, fdc->params[1], fdc->head, fdc->rate, fdc->params[4]);
 						break;
 					case 3: /*Specify*/
@@ -1017,12 +1021,20 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
 					case 5: /*Write data*/
 					case 9: /*Write deleted data*/
 						fdc_io_command_phase1(fdc, 1);
+						if ((fdc->head & 0x01) && !fdd_is_double_sided(real_drive(fdc, fdc->drive))) {
+							fdc_noidam(fdc);
+							return;
+						}
 	                                	fdd_writesector(real_drive(fdc, fdc->drive), fdc->sector, fdc->params[1], fdc->head, fdc->rate, fdc->params[4]);
 						break;
 					case 0x11: /*Scan equal*/
 					case 0x19: /*Scan low or equal*/
 					case 0x1D: /*Scan high or equal*/
 						fdc_io_command_phase1(fdc, 1);
+						if ((fdc->head & 0x01) && !fdd_is_double_sided(real_drive(fdc, fdc->drive))) {
+							fdc_noidam(fdc);
+							return;
+						}
 						fdd_comparesector(real_drive(fdc, fdc->drive), fdc->sector, fdc->params[1], fdc->head, fdc->rate, fdc->params[4]);
 						break;
 					case 0x16: /*Verify*/
@@ -1032,6 +1044,10 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
 					case 0xC: /*Read deleted data*/
 						fdc_io_command_phase1(fdc, 0);
 						fdc_log("Reading sector (drive %i) (%i) (%i %i %i %i) (%i %i %i)\n", fdc->drive, fdc->params[0], fdc->params[1], fdc->params[2], fdc->params[3], fdc->params[4], fdc->params[5], fdc->params[6], fdc->params[7]);
+						if ((fdc->head & 0x01) && !fdd_is_double_sided(real_drive(fdc, fdc->drive))) {
+							fdc_noidam(fdc);
+							return;
+						}
 						if (((dma_mode(2) & 0x0C) == 0x00) && !(fdc->flags & FDC_FLAG_PCJR) && fdc->dma) {
 							/* DMA is in verify mode, treat this like a VERIFY command. */
 							fdc_log("Verify-mode read!\n");
@@ -1065,7 +1081,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
 						if ((real_drive(fdc, fdc->drive) != 1) || fdc->drv2en)
 							fdc_seek(fdc, fdc->drive, -fdc->max_track);
 						fdc_log("Recalibrating...\n");
-						fdc->time = 5000LL;
+						fdc->time = 5000LL * (1 << TIMER_SHIFT);
 						fdc->step = fdc->seek_dir = 1;
 						break;
 					case 0x0d: /*Format*/
@@ -1119,7 +1135,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
 									fdc_seek(fdc, fdc->drive, -fdc->params[1]);
 									fdc->pcn[fdc->params[0] & 3] -= fdc->params[1];
 								}
-								fdc->time = 5000LL;
+								fdc->time = 5000LL * (1 << TIMER_SHIFT);
 								fdc->step = 1;
 							} else {
 								fdc->st0 = 0x20 | (fdc->params[0] & 7);
@@ -1146,7 +1162,7 @@ fdc_write(uint16_t addr, uint8_t val, void *priv)
 								fdc->seek_dir = 1;
 							fdc_seek(fdc, fdc->drive, fdc->params[1] - fdc->pcn[fdc->params[0] & 3]);
 							fdc->pcn[fdc->params[0] & 3] = fdc->params[1];
-							fdc->time = 5000LL;
+							fdc->time = 5000LL * (1 << TIMER_SHIFT);
 							fdc->step = 1;
 							fdc_log("fdc->time = %i\n", fdc->time);
 						}
@@ -1447,7 +1463,9 @@ fdc_callback(void *priv)
 		fdc->inread = 1;
 		return;
 	case 4: /*Sense drive status*/
-		fdc->res[10] = (fdc->params[0] & 7) | 0x28;
+		fdc->res[10] = (fdc->params[0] & 7) | 0x20;
+		if (fdd_is_double_sided(real_drive(fdc, fdc->drive)))
+			fdc->res[10] |= 0x08;
 		if ((real_drive(fdc, fdc->drive) != 1) || fdc->drv2en) {
 			if (fdd_track0(real_drive(fdc, fdc->drive)))
 				fdc->res[10] |= 0x10;
@@ -1539,10 +1557,14 @@ fdc_callback(void *priv)
 					fdc_poll_readwrite_finish(fdc, compare);
 				return;
 			}
-			if ((fdc->command & 0x80) && (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);
+				if (!fdd_is_double_sided(real_drive(fdc, fdc->drive))) {
+					fdc_noidam(fdc);
+					return;
+				}
 			}
 		} else if (fdc->sector < fdc->params[5])
 			fdc->sector++;
@@ -1688,6 +1710,10 @@ fdc_error(fdc_t *fdc, int st5, int st6)
 	fdc->fintr = 0;
    fdc->stat = 0xD0;
    fdc->st0 = fdc->res[4] = 0x40 | (fdd_get_head(real_drive(fdc, fdc->drive)) ? 4 : 0) | fdc->rw_drive;
+    if (fdc->head && !fdd_is_double_sided(real_drive(fdc, fdc->drive))) {
+	pclog("Head 1 on 1-sided drive\n");
+	fdc->st0 |= 0x08;
+    }
    fdc->res[5] = st5;
    fdc->res[6] = st6;
    fdc_log("FDC Error: %02X %02X %02X\n", fdc->res[4], fdc->res[5], fdc->res[6]);
--- a/src/floppy/fdd.c
+++ b/src/floppy/fdd.c
@@ -8,7 +8,7 @@
 *
 *		Implementation of the floppy drive emulation.
 *
- * Version:	@(#)fdd.c	1.0.7	2018/04/28
+ * Version:	@(#)fdd.c	1.0.9	2018/05/13
 *
 * Authors:	Fred N. van Kempen, <decwiz@yahoo.com>
 *		Miran Grca, <mgrca8@gmail.com>
@@ -36,10 +36,12 @@
 *   Boston, MA 02111-1307
 *   USA.
 */
-#include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "../machine/machine.h"
 #include "../mem.h"
@@ -227,6 +229,27 @@ static const struct
        }
 };

+#ifdef ENABLE_FDD_LOG
+int fdd_do_log = ENABLE_FDD_LOG;
+#endif
+
+
+static void
+fdd_log(const char *fmt, ...)
+{
+#ifdef ENABLE_FDD_LOG
+   va_list ap;
+
+   if (fdd_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 char *fdd_getname(int type)
 {
        return (char *)drive_types[type].name;
@@ -358,7 +381,7 @@ int fdd_can_read_medium(int drive)
 {
 	int hole = fdd_hole(drive);

-	hole = 1 << (hole + 3);
+	hole = 1 << (hole + 4);

 	return (drive_types[fdd[drive].type].flags & hole) ? 1 : 0;
 }
@@ -410,11 +433,16 @@ int fdd_is_double_sided(int drive)

 void fdd_set_head(int drive, int head)
 {
-	fdd[drive].head = head;
+	if (head && !fdd_is_double_sided(drive))
+		fdd[drive].head = 0;
+	else
+		fdd[drive].head = head;
 }

 int fdd_get_head(int drive)
 {
+	if (!fdd_is_double_sided(drive))
+		return 0;
 	return fdd[drive].head;
 }

@@ -456,7 +484,7 @@ void fdd_load(int drive, wchar_t *fn)
        wchar_t *p;
        FILE *f;

-	pclog("FDD: loading drive %d with '%ls'\n", drive, fn);
+	fdd_log("FDD: loading drive %d with '%ls'\n", drive, fn);

        if (!fn) return;
        p = plat_get_extension(fn);
@@ -481,7 +509,7 @@ void fdd_load(int drive, wchar_t *fn)
                }
                c++;
        }
-        pclog("FDD: could not load '%ls' %s\n",fn,p);
+        fdd_log("FDD: could not load '%ls' %s\n",fn,p);
        drive_empty[drive] = 1;
 	fdd_set_head(drive, 0);
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -490,7 +518,7 @@ void fdd_load(int drive, wchar_t *fn)

 void fdd_close(int drive)
 {
-	pclog("FDD: closing drive %d\n", drive);
+	fdd_log("FDD: closing drive %d\n", drive);

        if (loaders[driveloaders[drive]].close) loaders[driveloaders[drive]].close(drive);
        drive_empty[drive] = 1;
--- a/src/floppy/fdd_86f.c
+++ b/src/floppy/fdd_86f.c
@@ -10,7 +10,7 @@
 *		data in the form of FM/MFM-encoded transitions) which also
 *		forms the core of the emulator's floppy disk emulation.
 *
- * Version:	@(#)fdd_86f.c	1.0.8	2018/04/11
+ * Version:	@(#)fdd_86f.c	1.0.9	2018/05/06
 *
 * Authors:	Fred N. van Kempen, <decwiz@yahoo.com>
 *		Miran Grca, <mgrca8@gmail.com>
@@ -55,7 +55,9 @@
 #include "fdd.h"
 #include "fdc.h"
 #include "fdd_86f.h"
+#ifdef D86F_COMPRESS
 #include "lzf/lzf.h"
+#endif


 /*
@@ -226,7 +228,9 @@ typedef struct {
    uint16_t	current_bit[2];
    int		cur_track;
    uint32_t	error_condition;
+#ifdef D86F_COMPRESS
    int		is_compressed;
+#endif
    int		id_found;
    wchar_t	original_file_name[2048];
    uint8_t	*filebuf;
@@ -3085,9 +3089,11 @@ d86f_writeback(int drive)
    d86f_t *dev = d86f[drive];
    uint8_t header[32];
    int header_size;
+#ifdef D86F_COMPRESS
    uint32_t len;
    int ret = 0;
    FILE *cf;
+#endif
    header_size = d86f_header_size(drive);

    if (! dev->f) return;
@@ -3101,6 +3107,7 @@ d86f_writeback(int drive)

    d86f_write_tracks(drive, &dev->f, NULL);

+#ifdef D86F_COMPRESS
    if (dev->is_compressed) {
 	/* The image is compressed. */

@@ -3129,6 +3136,7 @@ d86f_writeback(int drive)
 	free(dev->outbuf);
 	free(dev->filebuf);
    }
+#endif
 }


@@ -3451,13 +3459,15 @@ d86f_export(int drive, wchar_t *fn)
 void
 d86f_load(int drive, wchar_t *fn)
 {
-    wchar_t temp_file_name[2048];
    d86f_t *dev = d86f[drive];
    uint32_t magic = 0;
    uint32_t len = 0;
-    uint16_t temp = 0;
    int i = 0, j = 0;
+#ifdef D86F_COMPRESS
+    wchar_t temp_file_name[2048];
+    uint16_t temp = 0;
    FILE *tf;
+#endif

    d86f_unregister(drive);

@@ -3534,8 +3544,12 @@ d86f_load(int drive, wchar_t *fn)
 	}
    }

+#ifdef D86F_COMPRESS
    dev->is_compressed = (magic == 0x66623638) ? 1 : 0;
    if ((len < 51052) && !dev->is_compressed) {
+#else
+    if (len < 51052) {
+#endif
 	/* File too small, abort. */
 	fclose(dev->f);
 	dev->f = NULL;
@@ -3568,6 +3582,7 @@ d86f_load(int drive, wchar_t *fn)
    }
 #endif

+#ifdef D86F_COMPRESS
    if (dev->is_compressed) {
 	memcpy(temp_file_name, drive ? nvr_path(L"TEMP$$$1.$$$") : nvr_path(L"TEMP$$$0.$$$"), 256);
 	memcpy(dev->original_file_name, fn, (wcslen(fn) << 1) + 2);
@@ -3614,15 +3629,17 @@ d86f_load(int drive, wchar_t *fn)

 	dev->f = plat_fopen(temp_file_name, L"rb+");
    }
+#endif

    if (dev->disk_flags & 0x100) {
 	/* Zoned disk. */
 	d86f_log("86F: Disk is zoned (Apple or Sony)\n");
 	fclose(dev->f);
 	dev->f = NULL;
-	if (dev->is_compressed) {
+#ifdef D86F_COMPRESS
+	if (dev->is_compressed)
 		plat_remove(temp_file_name);
-	}
+#endif
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	free(dev);
 	return;
@@ -3633,8 +3650,10 @@ d86f_load(int drive, wchar_t *fn)
 	d86f_log("86F: Disk is fixed-RPM but zone type is not 0\n");
 	fclose(dev->f);
 	dev->f = NULL;
+#ifdef D86F_COMPRESS
 	if (dev->is_compressed)
 		plat_remove(temp_file_name);
+#endif
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	free(dev);
 	return;
@@ -3649,9 +3668,11 @@ d86f_load(int drive, wchar_t *fn)
 	fclose(dev->f);
 	dev->f = NULL;

+#ifdef D86F_COMPRESS
 	if (dev->is_compressed)
 		dev->f = plat_fopen(temp_file_name, L"rb");
-	  else
+	else
+#endif
 		dev->f = plat_fopen(fn, L"rb");
    }

@@ -3736,9 +3757,14 @@ d86f_load(int drive, wchar_t *fn)
    d86f_common_handlers(drive);
    drives[drive].format = d86f_format;

+#ifdef D86F_COMPRESS
    d86f_log("86F: Disk is %scompressed and does%s have surface description data\n",
 	dev->is_compressed ? "" : "not ",
 	d86f_has_surface_desc(drive) ? "" : " not");
+#else
+    d86f_log("86F: Disk does%s have surface description data\n",
+	d86f_has_surface_desc(drive) ? "" : " not");
+#endif
 }


@@ -3796,8 +3822,10 @@ d86f_close(int drive)
 	fclose(dev->f);
 	dev->f = NULL;
    }
+#ifdef D86F_COMPRESS
    if (dev->is_compressed)
 	plat_remove(temp_file_name);
+#endif
 }


--- a/src/floppy/fdd_fdi.c
+++ b/src/floppy/fdd_fdi.c
@@ -9,7 +9,7 @@
 *		Implementation of the FDI floppy stream image format
 *		interface to the FDI2RAW module.
 *
- * Version:	@(#)fdd_fdi.c	1.0.2	2018/03/17
+ * Version:	@(#)fdd_fdi.c	1.0.3	2018/04/29
 *
 * Authors:	Fred N. van Kempen, <decwiz@yahoo.com>
 *		Miran Grca, <mgrca8@gmail.com>
@@ -37,11 +37,13 @@
 *   Boston, MA 02111-1307
 *   USA.
 */
-#include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "../plat.h"
 #include "fdd.h"
@@ -71,6 +73,27 @@ static fdi_t	*fdi[FDD_NUM];
 static fdc_t	*fdi_fdc;


+#ifdef ENABLE_FDI_LOG
+int fdi_do_log = ENABLE_FDI_LOG;
+#endif
+
+
+static void
+fdi_log(const char *fmt, ...)
+{
+#ifdef ENABLE_FDI_LOG
+   va_list ap;
+
+   if (fdi_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 static uint16_t
 disk_flags(int drive)
 {
@@ -339,7 +362,7 @@ fdi_load(int drive, wchar_t *fn)
    header[25] = 0;
    if (strcmp(header, "Formatted Disk Image file") != 0) {
 	/* This is a Japanese FDI file. */
-	pclog("fdi_load(): Japanese FDI file detected, redirecting to IMG loader\n");
+	fdi_log("fdi_load(): Japanese FDI file detected, redirecting to IMG loader\n");
 	fclose(dev->f);
 	free(dev);
 	img_load(drive, fn);
@@ -372,7 +395,7 @@ fdi_load(int drive, wchar_t *fn)

    drives[drive].seek = fdi_seek;

-    pclog("Loaded as FDI\n");
+    fdi_log("Loaded as FDI\n");
 }


--- a/src/floppy/fdd_imd.c
+++ b/src/floppy/fdd_imd.c
@@ -8,7 +8,7 @@
 *
 *		Implementation of the IMD floppy image format.
 *
- * Version:	@(#)fdd_imd.c	1.0.6	2018/03/19
+ * Version:	@(#)fdd_imd.c	1.0.7	2018/04/29
 *
 * Authors:	Fred N. van Kempen, <decwiz@yahoo.com>
 *		Miran Grca, <mgrca8@gmail.com>
@@ -34,11 +34,13 @@
 *   Boston, MA 02111-1307
 *   USA.
 */
-#include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "../plat.h"
 #include "fdd.h"
@@ -82,6 +84,27 @@ static imd_t	*imd[FDD_NUM];
 static fdc_t	*imd_fdc;


+#ifdef ENABLE_IMD_LOG
+int imd_do_log = ENABLE_IMD_LOG;
+#endif
+
+
+static void
+imd_log(const char *fmt, ...)
+{
+#ifdef ENABLE_IMD_LOG
+   va_list ap;
+
+   if (imd_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 static uint32_t
 get_raw_tsize(int side_flags, int slower_rpm)
 {
@@ -617,13 +640,13 @@ imd_load(int drive, wchar_t *fn)
    fseek(dev->f, 0, SEEK_SET);
    fread(&magic, 1, 4, dev->f);
    if (magic != 0x20444D49) {
-	pclog("IMD: Not a valid ImageDisk image\n");
+	imd_log("IMD: Not a valid ImageDisk image\n");
 	fclose(dev->f);
 	free(dev);;
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	return;
    } else {
-	pclog("IMD: Valid ImageDisk image\n");
+	imd_log("IMD: Valid ImageDisk image\n");
    }

    fseek(dev->f, 0, SEEK_END);
@@ -635,24 +658,24 @@ imd_load(int drive, wchar_t *fn)

    buffer2 = strchr(buffer, 0x1A);
    if (buffer2 == NULL) {
-	pclog("IMD: No ASCII EOF character\n");
+	imd_log("IMD: No ASCII EOF character\n");
 	fclose(dev->f);
 	free(dev);
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	return;
    } else {
-	pclog("IMD: ASCII EOF character found at offset %08X\n", buffer2 - buffer);
+	imd_log("IMD: ASCII EOF character found at offset %08X\n", buffer2 - buffer);
    }

    buffer2++;
    if ((buffer2 - buffer) == fsize) {
-	pclog("IMD: File ends after ASCII EOF character\n");
+	imd_log("IMD: File ends after ASCII EOF character\n");
 	fclose(dev->f);
 	free(dev);
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	return;
    } else {
-	pclog("IMD: File continues after ASCII EOF character\n");
+	imd_log("IMD: File continues after ASCII EOF character\n");
    }

    dev->start_offs = (buffer2 - buffer);
@@ -691,7 +714,7 @@ imd_load(int drive, wchar_t *fn)
 		dev->tracks[track][side].side_flags |= 0x20;
 	if ((dev->tracks[track][side].side_flags & 7) == 1)
 		dev->tracks[track][side].side_flags |= 0x20;
-	/* pclog("Side flags for (%02i)(%01i): %02X\n", track, side, dev->tracks[track][side].side_flags); */
+	/* imd_log("Side flags for (%02i)(%01i): %02X\n", track, side, dev->tracks[track][side].side_flags); */
 	dev->tracks[track][side].is_present = 1;
 	dev->tracks[track][side].file_offs = (buffer2 - buffer);
 	memcpy(dev->tracks[track][side].params, buffer2, 5);
@@ -766,7 +789,7 @@ imd_load(int drive, wchar_t *fn)
 			dev->disk_flags |= (3 << 5);
 			if ((raw_tsize - track_total + (mfm ? 146 : 73)) < (minimum_gap3 + minimum_gap4)) {
 				/* If we can't fit the sectors with a reasonable minimum gap even at 2% slower RPM, abort. */
-				pclog("IMD: Unable to fit the %i sectors in a track\n", track_spt);
+				imd_log("IMD: Unable to fit the %i sectors in a track\n", track_spt);
 				fclose(dev->f);
 				free(dev);
 				imd[drive] = NULL;
@@ -779,7 +802,7 @@ imd_load(int drive, wchar_t *fn)
 	} else if (gap3_sizes[converted_rate][sector_size][track_spt] != 0x00)
 		dev->tracks[track][side].gap3_len = gap3_sizes[converted_rate][sector_size][track_spt];

-	/* pclog("GAP3 length for (%02i)(%01i): %i bytes\n", track, side, dev->tracks[track][side].gap3_len); */
+	/* imd_log("GAP3 length for (%02i)(%01i): %i bytes\n", track, side, dev->tracks[track][side].gap3_len); */

 	if (track > dev->track_count)
 		dev->track_count = track;
@@ -797,7 +820,7 @@ imd_load(int drive, wchar_t *fn)
    if (dev->sides == 2)
 	dev->disk_flags |= 8;

-    /* pclog("%i tracks, %i sides\n", dev->track_count, dev->sides); */
+    /* imd_log("%i tracks, %i sides\n", dev->track_count, dev->sides); */

    /* Attach this format to the D86F engine. */
    d86f_handler[drive].disk_flags = disk_flags;
--- a/src/floppy/fdd_img.c
+++ b/src/floppy/fdd_img.c
@@ -13,7 +13,7 @@
 *		re-merged with the other files. Much of it is generic to
 *		all formats.
 *
- * Version:	@(#)fdd_img.c	1.0.6	2018/04/28
+ * Version:	@(#)fdd_img.c	1.0.8	2018/05/09
 *
 * Authors:	Fred N. van Kempen, <decwiz@yahoo.com>
 *		Miran Grca, <mgrca8@gmail.com>
@@ -41,11 +41,13 @@
 *   Boston, MA 02111-1307
 *   USA.
 */
-#include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "../config.h"
 #include "../plat.h"
@@ -297,6 +299,27 @@ const int gap3_sizes[5][8][48] = {	{	{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } };


+#ifdef ENABLE_IMG_LOG
+int img_do_log = ENABLE_IMG_LOG;
+#endif
+
+
+static void
+img_log(const char *fmt, ...)
+{
+#ifdef ENABLE_IMG_LOG
+   va_list ap;
+
+   if (img_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 /* Generic */
 static int
 sector_size_code(int sector_size)
@@ -605,7 +628,7 @@ img_load(int drive, wchar_t *fn)
    uint8_t bpb_mid;	/* Media type ID. */
    uint8_t bpb_sectors;
    uint8_t bpb_sides;
-    uint8_t fdi, cqm, fdf, ddi;
+    uint8_t cqm, ddi, fdf, fdi;
    uint16_t comment_len = 0;
    int16_t block_len = 0;
    uint32_t cur_pos = 0;
@@ -646,7 +669,7 @@ img_load(int drive, wchar_t *fn)
 		writeprot[drive] = 1;
    fwriteprot[drive] = writeprot[drive];

-    fdi = cqm = ddi = 0;
+    cqm = ddi = fdf = fdi = 0;

    dev->interleave = dev->skew = 0;

@@ -658,7 +681,7 @@ img_load(int drive, wchar_t *fn)

    if (! wcscasecmp(ext, L"FDI")) {
 	/* This is a Japanese FDI image, so let's read the header */
-	pclog("img_load(): File is a Japanese FDI image...\n");
+	img_log("img_load(): File is a Japanese FDI image...\n");
 	fseek(dev->f, 0x10, SEEK_SET);
 	(void)fread(&bpb_bps, 1, 2, dev->f);
 	fseek(dev->f, 0x0C, SEEK_SET);
@@ -695,7 +718,7 @@ img_load(int drive, wchar_t *fn)
 	if ((first_byte == 0x1A) && (second_byte == 'F') &&
 	    (third_byte == 'D') && (fourth_byte == 'F')) {
 		/* This is a FDF image. */
-		pclog("img_load(): File is a FDF image...\n");
+		img_log("img_load(): File is a FDF image...\n");
 		fwriteprot[drive] = writeprot[drive] = 1;
 		fclose(dev->f);
 		dev->f = plat_fopen(fn, L"rb");
@@ -717,10 +740,10 @@ img_load(int drive, wchar_t *fn)
 				/* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
 				first_byte = fgetc(dev->f);
 				fread(&track_bytes, 1, 2, dev->f);
-				pclog("Block header: %02X %04X ", first_byte, track_bytes);
+				img_log("Block header: %02X %04X ", first_byte, track_bytes);
 				/* Read the length of encoded data block. */
 				fread(&track_bytes, 1, 2, dev->f);
-				pclog("%04X\n", track_bytes);
+				img_log("%04X\n", track_bytes);
 			}

 			if (feof(dev->f)) break;
@@ -771,10 +794,10 @@ img_load(int drive, wchar_t *fn)
 				/* Skip first 3 bytes - their meaning is unknown to us but could be a checksum. */
 				first_byte = fgetc(dev->f);
 				fread(&track_bytes, 1, 2, dev->f);
-				pclog("Block header: %02X %04X ", first_byte, track_bytes);
+				img_log("Block header: %02X %04X ", first_byte, track_bytes);
 				/* Read the length of encoded data block. */
 				fread(&track_bytes, 1, 2, dev->f);
-				pclog("%04X\n", track_bytes);
+				img_log("%04X\n", track_bytes);
 			}

 			if (feof(dev->f)) break;
@@ -835,7 +858,7 @@ img_load(int drive, wchar_t *fn)

 	if (((first_byte == 'C') && (second_byte == 'Q')) ||
 	    ((first_byte == 'c') && (second_byte == 'q'))) {
-		pclog("img_load(): File is a CopyQM image...\n");
+		img_log("img_load(): File is a CopyQM image...\n");
 		fwriteprot[drive] = writeprot[drive] = 1;
 		fclose(dev->f);
 		dev->f = plat_fopen(fn, L"rb");
@@ -900,7 +923,7 @@ img_load(int drive, wchar_t *fn)
 				}
 			}
 		}
-		pclog("Finished reading CopyQM image data\n");
+		img_log("Finished reading CopyQM image data\n");

 		cqm = 1;
 		dev->disk_at_once = 1;
@@ -910,10 +933,10 @@ img_load(int drive, wchar_t *fn)
 		dev->disk_at_once = 0;
 		/* Read the BPB */
 		if (ddi) {
-			pclog("img_load(): File is a DDI image...\n");
+			img_log("img_load(): File is a DDI image...\n");
 			fwriteprot[drive] = writeprot[drive] = 1;
 		} else
-			pclog("img_load(): File is a raw image...\n");
+			img_log("img_load(): File is a raw image...\n");
 		fseek(dev->f, dev->base + 0x0B, SEEK_SET);
 		fread(&bpb_bps, 1, 2, dev->f);
 		fseek(dev->f, dev->base + 0x13, SEEK_SET);
@@ -942,7 +965,7 @@ jump_if_fdf:
    dev->sides = 2;
    dev->sector_size = 2;

-    pclog("BPB reports %i sides and %i bytes per sector (%i sectors total)\n",
+    img_log("BPB reports %i sides and %i bytes per sector (%i sectors total)\n",
 	bpb_sides, bpb_bps, bpb_total);

    guess = (bpb_sides < 1);
@@ -1069,7 +1092,7 @@ jump_if_fdf:
 		dev->sectors = 42;
 		dev->tracks = 86;
 	} else {
-		pclog("Image is bigger than can fit on an ED floppy, ejecting...\n");
+		img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
 		fclose(dev->f);
 		free(dev);
 		memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -1119,13 +1142,13 @@ jump_if_fdf:
 			dev->dmf = 0;
 		}

-		pclog("Image parameters: bit rate 300: %f, temporary rate: %i, hole: %i, DMF: %i, XDF type: %i\n", bit_rate_300, temp_rate, dev->disk_flags >> 1, dev->dmf, dev->xdf_type);
+		img_log("Image parameters: bit rate 300: %f, temporary rate: %i, hole: %i, DMF: %i, XDF type: %i\n", bit_rate_300, temp_rate, dev->disk_flags >> 1, dev->dmf, dev->xdf_type);
 		break;
 	}
    }

    if (temp_rate == 0xFF) {
-	pclog("Image is bigger than can fit on an ED floppy, ejecting...\n");
+	img_log("Image is bigger than can fit on an ED floppy, ejecting...\n");
 	fclose(dev->f);
 	free(dev);
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -1138,7 +1161,7 @@ jump_if_fdf:
      else
 	dev->gap3_size = gap3_sizes[temp_rate][dev->sector_size][dev->sectors];
    if (! dev->gap3_size) {
-	pclog("ERROR: Floppy image of unknown format was inserted into drive %c:!\n", drive + 0x41);
+	img_log("ERROR: Floppy image of unknown format was inserted into drive %c:!\n", drive + 0x41);
 	fclose(dev->f);
 	free(dev);
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
@@ -1162,7 +1185,7 @@ jump_if_fdf:

    dev->is_cqm = cqm;

-    pclog("Disk flags: %i, track flags: %i\n",
+    img_log("Disk flags: %i, track flags: %i\n",
 		dev->disk_flags, dev->track_flags);

    /* Set up the drive unit. */
--- a/src/floppy/fdd_json.c
+++ b/src/floppy/fdd_json.c
@@ -8,7 +8,7 @@
 *
 *		Implementation of the PCjs JSON floppy image format.
 *
- * Version:	@(#)fdd_json.c	1.0.4	2018/03/17
+ * Version:	@(#)fdd_json.c	1.0.5	2018/04/29
 *
 * Author:	Fred N. van Kempen, <decwiz@yahoo.com>
 *
@@ -44,11 +44,13 @@
 * (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 <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "../plat.h"
 #include "fdd.h"
@@ -104,6 +106,27 @@ typedef struct {
 static json_t	*images[FDD_NUM];


+#ifdef ENABLE_JSON_LOG
+int json_do_log = ENABLE_JSON_LOG;
+#endif
+
+
+static void
+json_log(const char *fmt, ...)
+{
+#ifdef ENABLE_JSON_LOG
+   va_list ap;
+
+   if (json_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 static void
 handle(json_t *dev, char *name, char *str)
 {
@@ -182,7 +205,7 @@ handle(json_t *dev, char *name, char *str)
 static int
 unexpect(int c, int state, int level)
 {
-    pclog("JSON: Unexpected '%c' in state %d/%d.\n", c, state, level);
+    json_log("JSON: Unexpected '%c' in state %d/%d.\n", c, state, level);

    return(-1);
 }
@@ -196,7 +219,7 @@ load_image(json_t *dev)
    char *ptr;

    if (dev->f == NULL) {
-	pclog("JSON: no file loaded!\n");
+	json_log("JSON: no file loaded!\n");
 	return(0);
    }

@@ -373,7 +396,7 @@ json_seek(int drive, int track)
    int interleave_type;

    if (dev->f == NULL) {
-	pclog("JSON: seek: no file loaded!\n");
+	json_log("JSON: seek: no file loaded!\n");
 	return;
    }

@@ -536,7 +559,7 @@ json_load(int drive, wchar_t *fn)

    /* Load all sectors from the image file. */
    if (! load_image(dev)) {
-	pclog("JSON: failed to initialize\n");
+	json_log("JSON: failed to initialize\n");
 	(void)fclose(dev->f);
 	free(dev);
 	images[drive] = NULL;
@@ -544,7 +567,7 @@ json_load(int drive, wchar_t *fn)
 	return;
    }

-    pclog("JSON(%d): %ls (%i tracks, %i sides, %i sectors)\n",
+    json_log("JSON(%d): %ls (%i tracks, %i sides, %i sectors)\n",
 	drive, fn, dev->tracks, dev->sides, dev->spt[0][0]);

    /*
@@ -601,7 +624,7 @@ json_load(int drive, wchar_t *fn)
    }

    if (temp_rate == 0xff) {
-	pclog("JSON: invalid image (temp_rate=0xff)\n");
+	json_log("JSON: invalid image (temp_rate=0xff)\n");
 	(void)fclose(dev->f);
 	dev->f = NULL;
 	free(dev);
@@ -622,7 +645,7 @@ json_load(int drive, wchar_t *fn)
 	dev->gap3_len = fdd_get_gap3_size(temp_rate,sec->size,dev->spt[0][0]);

    if (! dev->gap3_len) {
-	pclog("JSON: image of unknown format was inserted into drive %c:!\n",
+	json_log("JSON: image of unknown format was inserted into drive %c:!\n",
 								'C'+drive);
 	(void)fclose(dev->f);
 	dev->f = NULL;
@@ -636,9 +659,9 @@ json_load(int drive, wchar_t *fn)
    if (temp_rate & 0x04)
 	dev->track_flags |= 0x20;		/* RPM */

-    pclog("      disk_flags: 0x%02x, track_flags: 0x%02x, GAP3 length: %i\n",
+    json_log("      disk_flags: 0x%02x, track_flags: 0x%02x, GAP3 length: %i\n",
 	dev->disk_flags, dev->track_flags, dev->gap3_len);
-    pclog("      bit rate 300: %.2f, temporary rate: %i, hole: %i, DMF: %i\n",
+    json_log("      bit rate 300: %.2f, temporary rate: %i, hole: %i, DMF: %i\n",
 		bit_rate, temp_rate, (dev->disk_flags >> 1), dev->dmf);

    /* Set up handlers for 86F layer. */
--- a/src/floppy/fdd_td0.c
+++ b/src/floppy/fdd_td0.c
@@ -8,7 +8,7 @@
 *
 *		Implementation of the Teledisk floppy image format.
 *
- * Version:	@(#)fdd_td0.c	1.0.5	2018/03/19
+ * Version:	@(#)fdd_td0.c	1.0.6	2018/04/29
 *
 * Authors:	Fred N. van Kempen, <decwiz@yahoo.com>
 *		Miran Grca, <mgrca8@gmail.com>
@@ -46,11 +46,13 @@
 *   Boston, MA 02111-1307
 *   USA.
 */
-#include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <wchar.h>
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "../plat.h"
 #include "fdd.h"
@@ -218,6 +220,27 @@ static const uint8_t d_len[256] = {
 static td0_t	*td0[FDD_NUM];


+#ifdef ENABLE_TD0_LOG
+int td0_do_log = ENABLE_TD0_LOG;
+#endif
+
+
+static void
+td0_log(const char *fmt, ...)
+{
+#ifdef ENABLE_TD0_LOG
+   va_list ap;
+
+   if (td0_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 static void
 fdd_image_read(int drive, char *buffer, uint32_t offset, uint32_t len)
 {
@@ -611,7 +634,7 @@ td0_initialize(int drive)
    int i, j, k;

    if (dev->f == NULL) {
-	pclog("TD0: Attempted to initialize without loading a file first\n");
+	td0_log("TD0: Attempted to initialize without loading a file first\n");
 	return(0);
    }

@@ -619,12 +642,12 @@ td0_initialize(int drive)
    file_size = ftell(dev->f);

    if (file_size < 12) {
-	pclog("TD0: File is too small to even contain the header\n");
+	td0_log("TD0: File is too small to even contain the header\n");
 	return(0);
    }

    if (file_size > TD0_MAX_BUFSZ) {
-	pclog("TD0: File exceeds the maximum size\n");
+	td0_log("TD0: File exceeds the maximum size\n");
 	return(0);
    }

@@ -633,13 +656,13 @@ td0_initialize(int drive)
    head_count = header[9];

    if (header[0] == 't') {
-	pclog("TD0: File is compressed\n");
+	td0_log("TD0: File is compressed\n");
 	disk_decode.fdd_file = dev->f;
 	state_init_Decode(&disk_decode);
 	disk_decode.fdd_file_offset = 12;
 	state_Decode(&disk_decode, dev->imagebuf, TD0_MAX_BUFSZ);
    } else {
-	pclog("TD0: File is uncompressed\n");
+	td0_log("TD0: File is uncompressed\n");
 	fseek(dev->f, 12, SEEK_SET);
 	fread(dev->imagebuf, 1, file_size - 12, dev->f);
    }
@@ -650,14 +673,14 @@ td0_initialize(int drive)
    track_spt = dev->imagebuf[offset];
    if (track_spt == 255) {
 	/* Empty file? */
-	pclog("TD0: File has no tracks\n");
+	td0_log("TD0: File has no tracks\n");
 	return(0);
    }

    density = (header[5] >> 1) & 3;

    if (density == 3) {
-	pclog("TD0: Unknown density\n");
+	td0_log("TD0: Unknown density\n");
 	return(0);
    }

@@ -725,7 +748,7 @@ td0_initialize(int drive)

 		size = 128 << hs[3];
 		if ((total_size + size) >= TD0_MAX_BUFSZ) {
-			pclog("TD0: Processed buffer overflow\n");
+			td0_log("TD0: Processed buffer overflow\n");
 			return(0);
 		}

@@ -735,7 +758,7 @@ td0_initialize(int drive)
 			offset += 3;
 			switch (hs[8]) {
 				default:
-					pclog("TD0: Image uses an unsupported sector data encoding\n");
+					td0_log("TD0: Image uses an unsupported sector data encoding\n");
 					return(0);

 				case 0:
@@ -803,7 +826,7 @@ td0_initialize(int drive)
 			dev->disk_flags |= (3 << 5);
 			if ((raw_tsize - track_size + (fm ? 73 : 146)) < (minimum_gap3 + minimum_gap4)) {
 				/* If we can't fit the sectors with a reasonable minimum gap even at 2% slower RPM, abort. */
-				pclog("TD0: Unable to fit the %i sectors in a track\n", track_spt);
+				td0_log("TD0: Unable to fit the %i sectors in a track\n", track_spt);
 				return 0;
 			}
 		}
@@ -814,7 +837,7 @@ td0_initialize(int drive)
    }

    if ((dev->disk_flags & 0x60) == 0x60)
-	pclog("TD0: Disk will rotate 2% below perfect RPM\n");
+	td0_log("TD0: Disk will rotate 2% below perfect RPM\n");

    dev->tracks = track_count + 1;

@@ -836,7 +859,7 @@ td0_initialize(int drive)
    dev->current_side_flags[0] = dev->side_flags[0][0];
    dev->current_side_flags[1] = dev->side_flags[0][1];

-    pclog("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);
+    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);
 }
@@ -1136,13 +1159,13 @@ td0_load(int drive, wchar_t *fn)
    fwriteprot[drive] = writeprot[drive];

    if (! dsk_identify(drive)) {
-	pclog("TD0: Not a valid Teledisk image\n");
+	td0_log("TD0: Not a valid Teledisk image\n");
 	fclose(dev->f);
 	dev->f = NULL;
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	return;
    } else {
-	pclog("TD0: Valid Teledisk image\n");
+	td0_log("TD0: Valid Teledisk image\n");
    }

    /* Allocate the processing buffers. */
@@ -1153,14 +1176,14 @@ td0_load(int drive, wchar_t *fn)
    memset(dev->processed_buf, 0x00, i);

    if (! td0_initialize(drive)) {
-	pclog("TD0: Failed to initialize\n");
+	td0_log("TD0: Failed to initialize\n");
 	fclose(dev->f);
 	free(dev->imagebuf);
 	free(dev->processed_buf);
 	memset(floppyfns[drive], 0, sizeof(floppyfns[drive]));
 	return;
    } else {
-	pclog("TD0: Initialized successfully\n");
+	td0_log("TD0: Initialized successfully\n");
    }

    /* Attach this format to the D86F engine. */
--- a/src/floppy/fdi2raw.c
+++ b/src/floppy/fdi2raw.c
@@ -12,7 +12,7 @@
 *		addition of get_last_head and C++ callability by Thomas
 *		Harte.
 *
- * Version:	@(#)fdi2raw.c	1.0.2	2018/03/12
+ * Version:	@(#)fdi2raw.c	1.0.3	2018/04/29
 *
 * Authors:	Toni Wilen, <twilen@arabuusimiehet.com>
 *		and Vincent Joguin,
@@ -41,8 +41,9 @@
 *   USA.
 */
 #define STATIC_INLINE
-#include <stdio.h>
+#include <stdarg.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <wchar.h>
@@ -53,6 +54,7 @@
 #include "zfile.h"*/
 /* ELSE */
 #define xmalloc malloc
+#define HAVE_STDARG_H
 #include "../86box.h"
 #include "fdi2raw.h"

@@ -62,6 +64,27 @@
 #undef VERBOSE


+#ifdef ENABLE_FDI2RAW_LOG
+int fdi2raw_do_log = ENABLE_FDI2RAW_LOG;
+#endif
+
+
+static void
+fdi2raw_log(const char *fmt, ...)
+{
+#ifdef ENABLE_FDI2RAW_LOG
+   va_list ap;
+
+   if (fdi2raw_do_log)
+   {
+	va_start(ap, fmt);
+	pclog_ex(fmt, ap);
+	va_end(ap);
+   }
+#endif
+}
+
+
 #ifdef DEBUG
 static char *datalog(uae_u8 *src, int len)
 {
@@ -86,9 +109,6 @@ static char *datalog(uae_u8 *src, int len)
 static char *datalog(uae_u8 *src, int len) { return ""; }
 #endif

-#define outlog pclog
-#define debuglog pclog
-
 static int fdi_allocated;
 #ifdef DEBUG
 static void fdi_free (void *p)
@@ -333,13 +353,13 @@ static int decode_raw_track (FDI *fdi)
 /* unknown track */
 static void zxx (FDI *fdi)
 {
-	outlog ("track %d: unknown track type 0x%02.2X\n", fdi->current_track, fdi->track_type);
+	fdi2raw_log("track %d: unknown track type 0x%02.2X\n", fdi->current_track, fdi->track_type);
 }
 /* unsupported track */
 #if 0
 static void zyy (FDI *fdi)
 {
-	outlog ("track %d: unsupported track type 0x%02.2X\n", fdi->current_track, fdi->track_type);
+	fdi2raw_log("track %d: unsupported track type 0x%02.2X\n", fdi->current_track, fdi->track_type);
 }
 #endif
 /* empty track */
@@ -351,17 +371,9 @@ static void track_empty (FDI *fdi)
 /* unknown sector described type */
 static void dxx (FDI *fdi)
 {
-	outlog ("\ntrack %d: unknown sector described type 0x%02.2X\n", fdi->current_track, fdi->track_type);
+	fdi2raw_log("\ntrack %d: unknown sector described type 0x%02.2X\n", fdi->current_track, fdi->track_type);
 	fdi->err = 1;
 }
-/* unsupported sector described type */
-#if 0
-static void dyy (FDI *fdi)
-{
-	outlog ("\ntrack %d: unsupported sector described 0x%02.2X\n", fdi->current_track, fdi->track_type);
-	fdi->err = 1;
-}
-#endif
 /* add position of mfm sync bit */
 static void add_mfm_sync_bit (FDI *fdi)
 {
@@ -371,12 +383,12 @@ static void add_mfm_sync_bit (FDI *fdi)
 	}
 	fdi->mfmsync_buffer[fdi->mfmsync_offset++] = fdi->out;
 	if (fdi->out == 0) {
-		outlog ("illegal position for mfm sync bit, offset=%d\n",fdi->out);
+		fdi2raw_log("illegal position for mfm sync bit, offset=%d\n",fdi->out);
 		fdi->err = 1;
 	}
 	if (fdi->mfmsync_offset >= MAX_MFM_SYNC_BUFFER) {
 		fdi->mfmsync_offset = 0;
-		outlog ("mfmsync buffer overflow\n");
+		fdi2raw_log("mfmsync buffer overflow\n");
 		fdi->err = 1;
 	}
 	fdi->out++;
@@ -397,7 +409,7 @@ static void bit_add (FDI *fdi, int bit)
 		fdi->track_dst[BIT_BYTEOFFSET] |= (1 << BIT_BITOFFSET);
 	fdi->out++;
 	if (fdi->out >= MAX_DST_BUFFER * 8) {
-		outlog ("destination buffer overflow\n");
+		fdi2raw_log("destination buffer overflow\n");
 		fdi->err = 1;
 		fdi->out = 1;
 	}
@@ -412,13 +424,13 @@ static void bit_mfm_add (FDI *fdi, int bit)
 static void bit_drop_next (FDI *fdi)
 {
 	if (fdi->nextdrop > 0) {
-		outlog("multiple bit_drop_next() called");
+		fdi2raw_log("multiple bit_drop_next() called");
 	} else if (fdi->nextdrop < 0) {
 		fdi->nextdrop = 0;
-		debuglog(":DNN:");
+		fdi2raw_log(":DNN:");
 		return;
 	}
-	debuglog(":DN:");
+	fdi2raw_log(":DN:");
 	fdi->nextdrop = 1;
 }

@@ -426,10 +438,10 @@ static void bit_drop_next (FDI *fdi)
 static void bit_dedrop (FDI *fdi)
 {
 	if (fdi->nextdrop) {
-		outlog("bit_drop_next called before bit_dedrop");
+		fdi2raw_log("bit_drop_next called before bit_dedrop");
 	}
 	fdi->nextdrop = -1;
-	debuglog(":BDD:");
+	fdi2raw_log(":BDD:");
 }

 /* add one byte */
@@ -482,7 +494,7 @@ static void s08(FDI *fdi)
 	int bytes = *fdi->track_src++;
 	uae_u8 byte = *fdi->track_src++;
 	if (bytes == 0) bytes = 256;
-	debuglog ("s08:len=%d,data=%02.2X",bytes,byte);
+	fdi2raw_log("s08:len=%d,data=%02.2X",bytes,byte);
 	while(bytes--) byte_add (fdi, byte);
 }
 /* RLE MFM-decoded data */
@@ -492,7 +504,7 @@ static void s09(FDI *fdi)
 	uae_u8 byte = *fdi->track_src++;
 	if (bytes == 0) bytes = 256;
 	bit_drop_next (fdi);
-	debuglog ("s09:len=%d,data=%02.2X",bytes,byte);
+	fdi2raw_log("s09:len=%d,data=%02.2X",bytes,byte);
 	while(bytes--) byte_mfm_add (fdi, byte);
 }
 /* MFM-encoded data */
@@ -501,7 +513,7 @@ static void s0a(FDI *fdi)
 	int i, bits = (fdi->track_src[0] << 8) | fdi->track_src[1];
 	uae_u8 b;
 	fdi->track_src += 2;
-	debuglog ("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) {
 		byte_add (fdi, *fdi->track_src++);
 		bits -= 8;
@@ -521,7 +533,7 @@ static void s0b(FDI *fdi)
 	int i, bits = ((fdi->track_src[0] << 8) | fdi->track_src[1]) + 65536;
 	uae_u8 b;
 	fdi->track_src += 2;
-	debuglog ("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) {
 		byte_add (fdi, *fdi->track_src++);
 		bits -= 8;
@@ -542,7 +554,7 @@ static void s0c(FDI *fdi)
 	uae_u8 b;
 	fdi->track_src += 2;
 	bit_drop_next (fdi);
-	debuglog ("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));
 	while (bits >= 8) {
 		byte_mfm_add (fdi, *fdi->track_src++);
 		bits -= 8;
@@ -563,7 +575,7 @@ static void s0d(FDI *fdi)
 	uae_u8 b;
 	fdi->track_src += 2;
 	bit_drop_next (fdi);
-	debuglog ("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));
 	while (bits >= 8) {
 		byte_mfm_add (fdi, *fdi->track_src++);
 		bits -= 8;
@@ -692,13 +704,13 @@ static int amiga_check_track (FDI *fdi)

 		trackoffs = (id & 0xff00) >> 8;
 		if (trackoffs + 1 > drvsec) {
-			outlog("illegal sector offset %d\n",trackoffs);
+			fdi2raw_log("illegal sector offset %d\n",trackoffs);
 			ok = 0;
 			mbuf = mbuf2;
 			continue;
 		}
 		if ((id >> 24) != 0xff) {
-			outlog ("sector %d format type %02.2X?\n", trackoffs, id >> 24);
+			fdi2raw_log("sector %d format type %02.2X?\n", trackoffs, id >> 24);
 			ok = 0;
 		}
 		chksum = odd ^ even;
@@ -717,14 +729,14 @@ static int amiga_check_track (FDI *fdi)
 		even = getmfmlong (mbuf + 2 * 2);
 		mbuf += 4 * 2;
 		if (((odd << 1) | even) != chksum) {
-			outlog("sector %d header crc error\n", trackoffs);
+			fdi2raw_log("sector %d header crc error\n", trackoffs);
 			ok = 0;
 			mbuf = mbuf2;
 			continue;
 		}
-		outlog("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) {
-			outlog("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++;
 			mbuf = mbuf2;
 			continue;
@@ -747,14 +759,14 @@ static int amiga_check_track (FDI *fdi)
 		}
 		mbuf += 256 * 2;
 		if (chksum) {
-			outlog("sector %d data checksum error\n",trackoffs);
+			fdi2raw_log("sector %d data checksum error\n",trackoffs);
 			ok = 0;
 		} else if (sectable[trackoffs]) {
-			outlog("sector %d already found?\n", trackoffs);
+			fdi2raw_log("sector %d already found?\n", trackoffs);
 			mbuf = mbuf2;
 		} else {
-			outlog("sector %d ok\n",trackoffs);
-			if (slabel) outlog("(non-empty sector header)\n");
+			fdi2raw_log("sector %d ok\n",trackoffs);
+			if (slabel) fdi2raw_log("(non-empty sector header)\n");
 			sectable[trackoffs] = 1;
 			secwritten++;
 			if (trackoffs == 9)
@@ -763,7 +775,7 @@ static int amiga_check_track (FDI *fdi)
 	}
 	for (i = 0; i < drvsec; i++) {
 		if (!sectable[i]) {
-			outlog ("sector %d missing\n", i);
+			fdi2raw_log("sector %d missing\n", i);
 			ok = 0;
 		}
 	}
@@ -884,7 +896,7 @@ static void amiga_sector_header	(FDI *fdi, uae_u8 *header, uae_u8 *data, int sec
 static void s20(FDI *fdi)
 {
 	bit_drop_next (fdi);
-	debuglog ("s20:header=%s,data=%s", datalog(fdi->track_src, 4), datalog(fdi->track_src + 4, 16));
+	fdi2raw_log("s20:header=%s,data=%s", datalog(fdi->track_src, 4), datalog(fdi->track_src + 4, 16));
 	amiga_sector_header (fdi, fdi->track_src, fdi->track_src + 4, 0, 0);
 	fdi->track_src += 4 + 16;
 }
@@ -892,7 +904,7 @@ static void s20(FDI *fdi)
 static void s21(FDI *fdi)
 {
 	bit_drop_next (fdi);
-	debuglog ("s21:header=%s", datalog(fdi->track_src, 4));
+	fdi2raw_log("s21:header=%s", datalog(fdi->track_src, 4));
 	amiga_sector_header (fdi, fdi->track_src, 0, 0, 0);
 	fdi->track_src += 4;
 }
@@ -900,14 +912,14 @@ static void s21(FDI *fdi)
 static void s22(FDI *fdi)
 {
 	bit_drop_next (fdi);
-	debuglog("s22:sector=%d,untilgap=%d", fdi->track_src[0], fdi->track_src[1]);
+	fdi2raw_log("s22:sector=%d,untilgap=%d", fdi->track_src[0], fdi->track_src[1]);
 	amiga_sector_header (fdi, 0, 0, fdi->track_src[0], fdi->track_src[1]);
 	fdi->track_src += 2;
 }
 /* standard 512-byte, CRC-correct Amiga data */
 static void s23(FDI *fdi)
 {
-	debuglog("s23:data=%s", datalog (fdi->track_src, 512));
+	fdi2raw_log("s23:data=%s", datalog (fdi->track_src, 512));
 	amiga_data (fdi, fdi->track_src);
 	fdi->track_src += 512;
 }
@@ -915,7 +927,7 @@ static void s23(FDI *fdi)
 static void s24(FDI *fdi)
 {
 	int shift = *fdi->track_src++;
-	debuglog("s24:shift=%d,data=%s", shift, datalog (fdi->track_src, 128 << shift));
+	fdi2raw_log("s24:shift=%d,data=%s", shift, datalog (fdi->track_src, 128 << shift));
 	amiga_data_raw (fdi, fdi->track_src, 0, 128 << shift);
 	fdi->track_src += 128 << shift;
 }
@@ -923,7 +935,7 @@ static void s24(FDI *fdi)
 static void s25(FDI *fdi)
 {
 	int shift = *fdi->track_src++;
-	debuglog("s25:shift=%d,crc=%s,data=%s", shift, datalog (fdi->track_src, 4), datalog (fdi->track_src + 4, 128 << shift));
+	fdi2raw_log("s25:shift=%d,crc=%s,data=%s", shift, datalog (fdi->track_src, 4), datalog (fdi->track_src + 4, 128 << shift));
 	amiga_data_raw (fdi, fdi->track_src + 4, fdi->track_src, 128 << shift);
 	fdi->track_src += 4 + (128 << shift);
 }
@@ -931,7 +943,7 @@ static void s25(FDI *fdi)
 static void s26(FDI *fdi)
 {
 	s21 (fdi);
-	debuglog("s26:data=%s", datalog (fdi->track_src, 512));
+	fdi2raw_log("s26:data=%s", datalog (fdi->track_src, 512));
 	amiga_data (fdi, fdi->track_src);
 	fdi->track_src += 512;
 }
@@ -939,7 +951,7 @@ static void s26(FDI *fdi)
 static void s27(FDI *fdi)
 {
 	s22 (fdi);
-	debuglog("s27:data=%s", datalog (fdi->track_src, 512));
+	fdi2raw_log("s27:data=%s", datalog (fdi->track_src, 512));
 	amiga_data (fdi, fdi->track_src);
 	fdi->track_src += 512;
 }
@@ -1060,14 +1072,14 @@ static void s12(FDI *fdi)
 static void s13(FDI *fdi)
 {
 	bit_drop_next (fdi);
-	debuglog ("s13:header=%s", datalog (fdi->track_src, 4));
+	fdi2raw_log("s13:header=%s", datalog (fdi->track_src, 4));
 	ibm_sector_header (fdi, fdi->track_src, 0, -1, 1);
 	fdi->track_src += 4;
 }
 /* standard mini-extended IBM sector header */
 static void s14(FDI *fdi)
 {
-	debuglog ("s14:header=%s", datalog (fdi->track_src, 4));
+	fdi2raw_log("s14:header=%s", datalog (fdi->track_src, 4));
 	ibm_sector_header (fdi, fdi->track_src, 0, -1, 0);
 	fdi->track_src += 4;
 }
@@ -1075,33 +1087,33 @@ static void s14(FDI *fdi)
 static void s15(FDI *fdi)
 {
 	bit_drop_next (fdi);
-	debuglog ("s15:sector=%d", *fdi->track_src);
+	fdi2raw_log("s15:sector=%d", *fdi->track_src);
 	ibm_sector_header (fdi, 0, 0, *fdi->track_src++, 1);
 }
 /* standard mini-short IBM sector header */
 static void s16(FDI *fdi)
 {
-	debuglog ("s16:track=%d", *fdi->track_src);
+	fdi2raw_log("s16:track=%d", *fdi->track_src);
 	ibm_sector_header (fdi, 0, 0, *fdi->track_src++, 0);
 }
 /* standard CRC-incorrect mini-extended IBM sector header */
 static void s17(FDI *fdi)
 {
-	debuglog ("s17:header=%s,crc=%s", datalog (fdi->track_src, 4), datalog (fdi->track_src + 4, 2));
+	fdi2raw_log("s17:header=%s,crc=%s", datalog (fdi->track_src, 4), datalog (fdi->track_src + 4, 2));
 	ibm_sector_header (fdi, fdi->track_src, fdi->track_src + 4, -1, 0);
 	fdi->track_src += 4 + 2;
 }
 /* standard CRC-incorrect mini-short IBM sector header */
 static void s18(FDI *fdi)
 {
-	debuglog ("s18:sector=%d,header=%s", *fdi->track_src, datalog (fdi->track_src + 1, 4));
+	fdi2raw_log("s18:sector=%d,header=%s", *fdi->track_src, datalog (fdi->track_src + 1, 4));
 	ibm_sector_header (fdi, 0, fdi->track_src + 1, *fdi->track_src, 0);
 	fdi->track_src += 1 + 4;
 }
 /* standard 512-byte CRC-correct IBM data */
 static void s19(FDI *fdi)
 {
-	debuglog ("s19:data=%s", datalog (fdi->track_src , 512));
+	fdi2raw_log("s19:data=%s", datalog (fdi->track_src , 512));
 	ibm_data (fdi, fdi->track_src, 0, 512);
 	fdi->track_src += 512;
 }
@@ -1109,7 +1121,7 @@ static void s19(FDI *fdi)
 static void s1a(FDI *fdi)
 {
 	int shift = *fdi->track_src++;
-	debuglog ("s1a:shift=%d,data=%s", shift, datalog (fdi->track_src , 128 << shift));
+	fdi2raw_log("s1a:shift=%d,data=%s", shift, datalog (fdi->track_src , 128 << shift));
 	ibm_data (fdi, fdi->track_src, 0, 128 << shift);
 	fdi->track_src += 128 << shift;
 }
@@ -1117,7 +1129,7 @@ static void s1a(FDI *fdi)
 static void s1b(FDI *fdi)
 {
 	int shift = *fdi->track_src++;
-	debuglog ("s1b:shift=%d,crc=%s,data=%s", shift, datalog (fdi->track_src + (128 << shift), 2), datalog (fdi->track_src , 128 << shift));
+	fdi2raw_log("s1b:shift=%d,crc=%s,data=%s", shift, datalog (fdi->track_src + (128 << shift), 2), datalog (fdi->track_src , 128 << shift));
 	ibm_data (fdi, fdi->track_src, fdi->track_src + (128 << shift), 128 << shift);
 	fdi->track_src += (128 << shift) + 2;
 }
@@ -1323,25 +1335,25 @@ static int handle_sectors_described_track (FDI *fdi)
 	fdi->index_offset = get_u32(fdi->track_src);
 	fdi->index_offset >>= 8;
 	fdi->track_src += 3;
-	outlog ("sectors_described, index offset: %d\n",fdi->index_offset);
+	fdi2raw_log("sectors_described, index offset: %d\n",fdi->index_offset);

 	do {
 		fdi->track_type = *fdi->track_src++;
-		outlog ("%06.6X %06.6X %02.2X:",fdi->track_src - start_src + 0x200, fdi->out/8, fdi->track_type);
+		fdi2raw_log("%06.6X %06.6X %02.2X:",fdi->track_src - start_src + 0x200, fdi->out/8, fdi->track_type);
 		oldout = fdi->out;
 		decode_sectors_described_track[fdi->track_type](fdi);
-		outlog(" %d\n", fdi->out - oldout);
+		fdi2raw_log(" %d\n", fdi->out - oldout);
 		oldout = fdi->out;
 		if (fdi->out < 0 || fdi->err) {
-			outlog ("\nin %d bytes, out %d bits\n", fdi->track_src - fdi->track_src_buffer, fdi->out);
+			fdi2raw_log("\nin %d bytes, out %d bits\n", fdi->track_src - fdi->track_src_buffer, fdi->out);
 			return -1;
 		}
 		if (fdi->track_src - fdi->track_src_buffer >= fdi->track_src_len) {
-			outlog ("source buffer overrun, previous type: %02.2X\n", fdi->track_type);
+			fdi2raw_log("source buffer overrun, previous type: %02.2X\n", fdi->track_type);
 			return -1;
 		}
 	} while (fdi->track_type != 0xff);
-	outlog("\n");
+	fdi2raw_log("\n");
 	fix_mfm_sync (fdi);
 	return fdi->out;
 }
@@ -1445,7 +1457,7 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
 		|| (avgp[i] < (standard_MFM_2_bit_cell_size - (standard_MFM_2_bit_cell_size / 4))) ) )
 			i++;
 	if (i == pulses)  {
-		outlog ("No stable and long-enough pulse in track.\n");
+		fdi2raw_log("No stable and long-enough pulse in track.\n");
 		return;
 	}
 	i--;
@@ -1572,7 +1584,7 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
 		|| (minp[i] < (standard_MFM_2_bit_cell_size - (standard_MFM_2_bit_cell_size / 4))) ) )
 			i++;
 	if (i == pulses)  {
-		outlog ("FDI: No stable and long-enough pulse in track.\n");
+		fdi2raw_log("FDI: No stable and long-enough pulse in track.\n");
 		return;
 	}
 	nexti = i;
@@ -1649,12 +1661,12 @@ static void fdi2_decode (FDI *fdi, uint32_t totalavg, uae_u32 *avgp, uae_u32 *mi
 				}
 				avg_pulse += jitter;
 				if ((avg_pulse < min_pulse) || (avg_pulse > max_pulse)) {
-					outlog ("FDI: avg_pulse outside bounds! avg=%u min=%u max=%u\n", avg_pulse, min_pulse, max_pulse);
-					outlog ("FDI: avgp=%u (%u) minp=%u (%u) maxp=%u (%u) jitter=%d i=%d ni=%d\n",
+					fdi2raw_log("FDI: avg_pulse outside bounds! avg=%u min=%u max=%u\n", avg_pulse, min_pulse, max_pulse);
+					fdi2raw_log("FDI: avgp=%u (%u) minp=%u (%u) maxp=%u (%u) jitter=%d i=%d ni=%d\n",
 						avgp[i], avgp[nexti], minp[i], minp[nexti], maxp[i], maxp[nexti], jitter, i, nexti);
 				}
 				if (avg_pulse < ref_pulse)
-					outlog ("FDI: avg_pulse < ref_pulse! (%u < %u)\n", avg_pulse, ref_pulse);
+					fdi2raw_log("FDI: avg_pulse < ref_pulse! (%u < %u)\n", avg_pulse, ref_pulse);
 				pulse += avg_pulse - ref_pulse;
 				ref_pulse = 0;
 				if (i == eodat)
@@ -1927,7 +1939,7 @@ static int decode_lowlevel_track (FDI *fdi, int track, struct fdi_cache *cache)
 		idxp[i] = sum;
 	}
 	len = totalavg / 100000;
-	/* outlog("totalavg=%u index=%d (%d) maxidx=%d weakbits=%d len=%d\n",
+	/* fdi2raw_log("totalavg=%u index=%d (%d) maxidx=%d weakbits=%d len=%d\n",
 		totalavg, indexoffset, maxidx, weakbits, len); */
 	cache->avgp = avgp;
 	cache->idxp = idxp;
@@ -1970,7 +1982,7 @@ void fdi2raw_header_free (FDI *fdi)
 			fdi_free (c->maxp);
 	}
 	fdi_free (fdi);
-	debuglog ("FREE: memory allocated %d\n", fdi_allocated);
+	fdi2raw_log("FREE: memory allocated %d\n", fdi_allocated);
 }

 int fdi2raw_get_last_track (FDI *fdi)
@@ -2021,7 +2033,7 @@ FDI *fdi2raw_header(FILE *f)
 	uae_u8 type, size;
 	FDI *fdi;

-	debuglog ("ALLOC: memory allocated %d\n", fdi_allocated);
+	fdi2raw_log("ALLOC: memory allocated %d\n", fdi_allocated);
 	fdi = fdi_malloc(sizeof(FDI));
 	memset (fdi, 0, sizeof (FDI));
 	fdi->file = f;
@@ -2051,8 +2063,8 @@ FDI *fdi2raw_header(FILE *f)
 	fdi->disk_type = fdi->header[145];
 	fdi->rotation_speed = fdi->header[146] + 128;
 	fdi->write_protect = fdi->header[147] & 1;
-	outlog ("FDI version %d.%d\n", fdi->header[140], fdi->header[141]);
-	outlog ("last_track=%d rotation_speed=%d\n",fdi->last_track,fdi->rotation_speed);
+	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);

 	offset = 512;
 	i = fdi->last_track;
@@ -2091,7 +2103,7 @@ int fdi2raw_loadrevolution_2 (FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, i
 	fdi2_decode (fdi, cache->totalavg,
 		cache->avgp, cache->minp, cache->maxp, cache->idxp,
 		cache->maxidx, &idx, cache->pulses, mfm);
-	/* outlog("track %d: nbits=%d avg len=%.2f weakbits=%d idx=%d\n",
+	/* fdi2raw_log("track %d: nbits=%d avg len=%.2f weakbits=%d idx=%d\n",
 		track, bitoffset, (double)cache->totalavg / bitoffset, cache->weakbits, cache->indexoffset); */
 	len = fdi->out;
 	if (cache->weakbits >= 10 && multirev)
@@ -2144,7 +2156,7 @@ int fdi2raw_loadtrack (FDI *fdi, uae_u16 *mfmbuf, uae_u16 *tracktiming, int trac
 	else
 		fdi->bit_rate = 250;

-	/* outlog ("track %d: srclen: %d track_type: %02.2X, bitrate: %d\n",
+	/* fdi2raw_log("track %d: srclen: %d track_type: %02.2X, bitrate: %d\n",
 		fdi->current_track, fdi->track_src_len, fdi->track_type, fdi->bit_rate); */

 	if ((fdi->track_type & 0xc0) == 0x80) {