path: root/dla2csv.c

/* dla2csv.c - convert dla.xex save files to CSV.
	Rather bloated and slow by Atari standards. */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <dirent.h>

#ifdef __CC65__
	#ifndef __ATARI__
		#error Unsupported cc65 machine type: only "-t atari" is supported.
	#endif
#endif

#include "dlaver.h"

#define HEIGHT 170
#define WIDTH 176

/* cc65 doesn't fold constants, it won't let us do this:
	#define INBUF_SIZE (WIDTH * HEIGHT)
	...it has to be a *constant*. */
#define INBUF_SIZE 3740

#define STRINGBUF_SIZE 256

void print_id(void) {
	printf("DLA to CSV converter v" VERSION ".\n");
}

#ifdef __ATARI__
	#include <atari.h>

/* cc65 doesn't "localize" \b to the Atari backspace character, so: */
	#define BS CH_DEL

/* I like these colors. Also they match dla.xex. */
#define TEXT_COLOR 0x0e
#define TEXT_BG_COLOR 0x90

/* On the Atari, we should show Atari-style error messages, including
	the familiar error number.
	Another reason to do this: on the Atari, perror() says "Bad file number"
	instead of "No space left on device", if the disk fills up due
	to fprintf().
	On modern platforms, just use perror().  */
	#define PERROR(x) atari_perror(x)
void atari_perror(char *msg) {
	printf("%s: Error %d: %s\n", msg, _oserror, _stroserror(_oserror));
}

/* cc65 doesn't play nice with the Break key on the Atari. It
	works as expected during disk I/O, but if you press it while
	printing to stdout or reading from stdin, the program freezes.
	so call disable_break() at startup, then wrap disk I/O in
	enable_break() and disable_break(). */
void enable_break() {
	OS.pokmsk = POKEY_WRITE.irqen = (OS.pokmsk | 0x80);
}

void disable_break() {
	OS.pokmsk = POKEY_WRITE.irqen = (OS.pokmsk & 0x7f);
}

char old_color1, old_color2;

void restore_colors(void) {
	OS.color1 = old_color1;
	OS.color2 = old_color2;
}

void init_console(void) {
	/* cc65's startup code turns off caps lock. turn it back on,
		since we're typing DOS filenames. in BASIC this would be:
		POKE 702,64 */
	OS.shflok = 0x40;

	/* also, cc65 sets APPMHI to $bc1f (last byte before the GR.0
		display list). which causes the atari to lock up when Reset
		is pressed. I can't believe this is useful behaviour... */
	OS.appmhi = 0;

	/* clear the screen */
	putchar(CH_CLR);

	/* save the old text & background colors */
	old_color1 = OS.color1;
	old_color2 = OS.color2;

	/* Use my glorious and eye-catching color scheme :) */
	OS.color1 = TEXT_COLOR;
	OS.color2 = TEXT_BG_COLOR;

	/* Put things back the way they were, when we exit. */
	atexit(restore_colors);
	atexit(enable_break);
}

void print_banner(void) {
	int i;

	print_id();

	printf("\n"
	       "At any filename prompt, you may:\n" );
	printf(
	       "- Press Return, to exit this program.\n");
	printf(
			 "- Enter a number, to get a directory of\n"
			 "  that drive.");

	/* be nice to emulator users. */
	for(i = 0; i < 12; i++) {
		if(OS.hatabs[i].id == 'H') {
			printf(" Use 0 for \"H:\".");
			break;
		}
	}
	printf("\n");
}

/* Show disk directory, in a 3-column layout.
	drive is an ASCII digit, e.g. 0x31 is drive 1. */
void show_dir(char drive) {
	static char dirspec[16];
	char device = 'D';
	DIR *dir;
	struct dirent *ent;
	int column = 0;

	if(drive == '0') {
		drive++;
		device = 'H';
	}

	sprintf(dirspec, "%c%c:*.*", device, drive);

	if(!(dir = opendir(dirspec))) {
		dirspec[2] = '\0';
		PERROR(dirspec);
		return;
	}

	while((ent = readdir(dir))) {
		printf("%-13s", ent->d_name);
		if(++column == 3) {
			column = 0;
			putchar('\n');
		}
	}

	closedir(dir);
	if(column) putchar('\n');
}
#else
	/* non-Atari is assumed to be POSIX (and not something like
		Commodore or Apple II). */
	#define BS '\b'
	#define PERROR(x) perror(x)
	#define print_banner() print_id()
	#define noop()
	#define enable_break() noop()
	#define disable_break() noop()
	#define init_console() noop()
#endif

char inbuf[INBUF_SIZE];
char stringbuf[STRINGBUF_SIZE];
FILE *inf, *outf;

/* We can't use string literal syntax, cc65 "helpfully" turns "\x0a"
	into an Atari 0x9b EOL character. Numeric constants are left alone. */
char a8eol[] = { 0x9b, 0x00, 0x00 };
char uxeol[] = { 0x0a, 0x00, 0x00 };
char mseol[] = { 0x0d, 0x0a, 0x00 };
char *eoltypes[][2] = {
	{ "Atari ($9B)", a8eol },
	{ "Unix (\\n)",  uxeol },
	{ "MS (\\r\\n)", mseol },
	{ NULL, NULL }
};

/* Read a string from stdin (E: on the Atari).
	Exit on EOF (or Break key on the Atari, except we disable it).
	On Linux, EOF is the ^D character, and this works.
	On the Atari, EOF is ^3... On DOS 2.0S, we end up back at the DUP
	menu... but SpartaDOS 3.2d locks up with a black screen. So don't
	document ctrl-3 as a way to exit the program (too bad), and just
	hope the user never presses it.
 */
void readstring(void) {
	char *result;
	memset(stringbuf, 0, STRINGBUF_SIZE);
	result = fgets(stringbuf, STRINGBUF_SIZE - 1, stdin);
	if(result == NULL) {
		exit(1);
	}
}

int prompt_yn(char *prompt, int default_y) {
	char *yn = "y/N";
	if(default_y) yn = "Y/n";

	printf("%s[%s]? ", prompt, yn);
	fflush(stdout);
	readstring();

	switch(stringbuf[0]) {
		case 'y':
		case 'Y':
			return 1;
			break;
		case 'n':
		case 'N':
			return 0;
			break;
		default:
			break;
	}
	return default_y;
}

/* Prompt for a filename, try to open it. If there's an error,
	show error message and retry. Will not return until it
	opens the file. */
FILE *prompt_filename(const char *name, const char *mode) {
	FILE *f = NULL;

	putchar('\n');
	while(f == NULL) {
		printf("%s file: ", name);
		fflush(stdout);
		readstring();
		stringbuf[strlen(stringbuf) - 1] = '\0'; /* kill trailing \n */
		if(strlen(stringbuf) == 0) {
			if(prompt_yn("Exit program", 0)) {
				exit(0);
			}
			continue;
		}

#ifdef __ATARI__
		/* if the user enters a single digit, show directory of that drive. */
		if(isdigit(stringbuf[0])) {
			show_dir(stringbuf[0]);
			continue;
		}

		/* if user entered a filename with no device spec (D: or D1: etc),
			prepend D: */
		if(!strchr(stringbuf, ':')) {
			memmove(stringbuf+2, stringbuf, strlen(stringbuf) + 1);
			stringbuf[0] = 'D';
			stringbuf[1] = ':';
		}
#endif

		enable_break();
		f = fopen(stringbuf, mode);
		disable_break();

		if(!f) PERROR(stringbuf);
	}
	return f;
}

/* Prompt for and read EOL type, retry if needed. Will not return
	until a valid number was entered. */
char *prompt_eol(void) {
	static int default_eoltype = 0;
	int i;

	putchar('\n');
	for(i = 0; eoltypes[i][0] != NULL; i++) {
		printf("%d:%s  ", i + 1, eoltypes[i][0]);
	}
	putchar('\n');

	i = -1;
	while(i == -1) {
		printf("Line ending type[%d]? ", default_eoltype + 1);
		fflush(stdout);
		readstring();
		if(stringbuf[0] == '\n') {
			i = default_eoltype;
		} else {
			i = stringbuf[0] - 49; /* ASCII 1-3 => 0-2 */
			if(i < 0 || i > 2)
				i = -1;
		}
	}
	default_eoltype = i;
	return eoltypes[i][1];
}

void backspace3(void) {
	putchar(BS);
	putchar(BS);
	putchar(BS);
}

/* check_dla() returns 1 if all is well, 0 if there's a problem. */
int check_dla(int bytes) {
	int i, ok = 1;

	/* warn if the file size is wrong... */
	if(bytes < INBUF_SIZE) {
		printf("Warning: File too short!\n");
		ok = 0;
	} else if(fgetc(inf) != EOF) {
		printf("Warning: File too long!\n");
		ok = 0;
	} else {
		printf("File size is OK.\n");
	}
	fclose(inf);

	/* a DLA file never has non-zero pixels in the first 3 columns */
	for(i = 0; i < INBUF_SIZE; i += (WIDTH / 8)) {
		if(inbuf[i] & 0xe0) {
			printf("Warning: File doesn't look like a DLA!\n");
			ok = 0;
			break;
		}
	}


	return ok;
}

int read_file(void) {
	int bytes;

	/* in case of short read on 2nd or later conversion: */
	memset(inbuf, 0, INBUF_SIZE);

	/* read whole input file into memory */
	inf = prompt_filename("Input DLA", "rb");
	printf("Reading...");
	fflush(stdout);
	enable_break();
	bytes = fread(inbuf, 1, INBUF_SIZE, inf);
	disable_break();
	if(bytes <= 0) {
		PERROR(stringbuf);
	}

	return bytes;
}

/* convert() returns the number of particles on success, 0 on failure. */
int convert(char *eol) {
	char *inp;
	int x, y, xmask, particles;

	outf = prompt_filename("Output CSV", "wb");

#ifdef __ATARI__
	printf("Press Ctrl-C to abort conversion.\n");
#endif
	printf("\nConverting...   ");
	fflush(stdout);

	/* CSV file header row (column names) */
	fprintf(outf, "x,y%s", eol);

	inp = inbuf;
	xmask = 0x80;
	particles = 0;

	/* write output file one line at a time */
	/* loop over all the pixels, by row, then column. this
		loop is rather slow. */
	for(y = 0; y < HEIGHT; y++) {
#ifdef __ATARI__
		/* check for ^C */
		if(OS.ch == (KEY_C | KEY_CTRL)) {
			printf("\nUser abort!\n");
			fclose(outf);
			remove(stringbuf);
			OS.ch = KEY_NONE;
			return 0;
		}
#endif
		backspace3();
		printf("%02d%%", y * 100 / HEIGHT); /* percentage */
		fflush(stdout);
		for(x = 0; x < WIDTH; x++) {
			/* slight optimization, saves ~12 sec (30% speedup) on Atari */
			if(!*inp) {
				inp++;
				x += 7;
				continue;
			}
			if(*inp & xmask) {
				if(fprintf(outf, "%d,%d%s", x, y, eol) < 0) {
					putchar('\n');
					PERROR(stringbuf);
					fclose(outf);
					remove(stringbuf);
					return 0;
				}
				particles++;
			}
			xmask >>= 1;
			if(!xmask) {
				xmask = 0x80;
				inp++;
			}
		}
	}
	fclose(outf);

	return particles;
}

int main(int argc, char **argv) {
	char *eol;
	int done, result = 0;

	init_console();
	print_banner();

	while(1) {
		disable_break();

		result = read_file();
		if(result <= 0) continue;
		printf("Read %d bytes.\n", result);

		/* if anything looks wrong, we shouldn't proceed... but the user
			is boss, so give him the choice to shoot himself in the foot. */
		if(!check_dla(result)) {
			if(!prompt_yn("Try to convert anyway", 0))
				continue;
		}

		eol = prompt_eol();

		/* convert in a loop. in case of write error, this allows retry
			without re-reading the input file. */
		done = 0;
		while(!done) {
			result = convert(eol);
			if(result) {
				done = 1;
				backspace3();
				printf("100%%\n%d particles.\n", result);
			} else {
				if(!prompt_yn("Conversion failed, try again", 1))
					done = 1;
			}
		}

		if(!prompt_yn("\nConvert another file", 1))
			break;
	}
	exit(0);
}