siddump.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include "cpu.h"

#define MAX_INSTR 0x400000

typedef struct
{
	unsigned short freq;
	unsigned short pulse;
	unsigned short adsr;
	unsigned char wave;
	int note;
} CHANNEL;

typedef struct
{
	unsigned short cutoff;
	unsigned char ctrl;
	unsigned char type;
} FILTER;

int main(int argc, char **argv);
unsigned char readbyte(FILE *f);
unsigned short readword(FILE *f);

CHANNEL chn[3];
CHANNEL prevchn[3];
CHANNEL prevchn2[3];
FILTER filt;
FILTER prevfilt;

extern unsigned short pc;

const char *notename[] =
 {"C-0", "C#0", "D-0", "D#0", "E-0", "F-0", "F#0", "G-0", "G#0", "A-0", "A#0", "B-0",
	"C-1", "C#1", "D-1", "D#1", "E-1", "F-1", "F#1", "G-1", "G#1", "A-1", "A#1", "B-1",
	"C-2", "C#2", "D-2", "D#2", "E-2", "F-2", "F#2", "G-2", "G#2", "A-2", "A#2", "B-2",
	"C-3", "C#3", "D-3", "D#3", "E-3", "F-3", "F#3", "G-3", "G#3", "A-3", "A#3", "B-3",
	"C-4", "C#4", "D-4", "D#4", "E-4", "F-4", "F#4", "G-4", "G#4", "A-4", "A#4", "B-4",
	"C-5", "C#5", "D-5", "D#5", "E-5", "F-5", "F#5", "G-5", "G#5", "A-5", "A#5", "B-5",
	"C-6", "C#6", "D-6", "D#6", "E-6", "F-6", "F#6", "G-6", "G#6", "A-6", "A#6", "B-6",
	"C-7", "C#7", "D-7", "D#7", "E-7", "F-7", "F#7", "G-7", "G#7", "A-7", "A#7", "B-7"};

const char *filtername[] =
 {"Off", "Low", "Bnd", "L+B", "Hi ", "L+H", "B+H", "LBH"};

unsigned char freqtbllo[] = {
	0x17,0x27,0x39,0x4b,0x5f,0x74,0x8a,0xa1,0xba,0xd4,0xf0,0x0e,
	0x2d,0x4e,0x71,0x96,0xbe,0xe8,0x14,0x43,0x74,0xa9,0xe1,0x1c,
	0x5a,0x9c,0xe2,0x2d,0x7c,0xcf,0x28,0x85,0xe8,0x52,0xc1,0x37,
	0xb4,0x39,0xc5,0x5a,0xf7,0x9e,0x4f,0x0a,0xd1,0xa3,0x82,0x6e,
	0x68,0x71,0x8a,0xb3,0xee,0x3c,0x9e,0x15,0xa2,0x46,0x04,0xdc,
	0xd0,0xe2,0x14,0x67,0xdd,0x79,0x3c,0x29,0x44,0x8d,0x08,0xb8,
	0xa1,0xc5,0x28,0xcd,0xba,0xf1,0x78,0x53,0x87,0x1a,0x10,0x71,
	0x42,0x89,0x4f,0x9b,0x74,0xe2,0xf0,0xa6,0x0e,0x33,0x20,0xff};

unsigned char freqtblhi[] = {
	0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x02,
	0x02,0x02,0x02,0x02,0x02,0x02,0x03,0x03,0x03,0x03,0x03,0x04,
	0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x06,0x06,0x07,0x07,0x08,
	0x08,0x09,0x09,0x0a,0x0a,0x0b,0x0c,0x0d,0x0d,0x0e,0x0f,0x10,
	0x11,0x12,0x13,0x14,0x15,0x17,0x18,0x1a,0x1b,0x1d,0x1f,0x20,
	0x22,0x24,0x27,0x29,0x2b,0x2e,0x31,0x34,0x37,0x3a,0x3e,0x41,
	0x45,0x49,0x4e,0x52,0x57,0x5c,0x62,0x68,0x6e,0x75,0x7c,0x83,
	0x8b,0x93,0x9c,0xa5,0xaf,0xb9,0xc4,0xd0,0xdd,0xea,0xf8,0xff};

int main(int argc, char **argv)
{
	int subtune = 0;
	int seconds = 60;
	int instr = 0;
	int frames = 0;
	int spacing = 0;
	int pattspacing = 0;
	int firstframe = 0;
	int counter = 0;
	int basefreq = 0;
	int basenote = 0xb0;
	int lowres = 0;
	int rows = 0;
	int oldnotefactor = 1;
	int timeseconds = 0;
	int usage = 0;
	int profiling = 0;
	unsigned loadend;
	unsigned loadpos;
	unsigned loadsize;
	unsigned loadaddress;
	unsigned initaddress;
	unsigned playaddress;
	unsigned dataoffset;
	FILE *in = NULL;
	char *sidname = 0;
	int c;

	char outname[64] = { 0 };
	
	int secondSid = 0;
	int toFile = 0;
	
	int displayhex = 0;
	
	FILE* out = NULL;

	// Scan arguments
	for (c = 1; c < argc; c++)
	{
		if (argv[c][0] == '-')
		{
			switch(toupper(argv[c][1]))
			{
				case '?':
				usage = 1;
				break;

				case 'A':
				sscanf(&argv[c][2], "%u", &subtune);
				break;

				case 'C':
				sscanf(&argv[c][2], "%x", &basefreq);
				break;

				case 'D':
				sscanf(&argv[c][2], "%x", &basenote);
				break;

				case 'F':
				sscanf(&argv[c][2], "%u", &firstframe);
				break;

				case 'L':
				lowres = 1;
				break;

				case 'N':
				sscanf(&argv[c][2], "%u", &spacing);
				break;

				case 'O':
				sscanf(&argv[c][2], "%u", &oldnotefactor);
				if (oldnotefactor < 1) oldnotefactor = 1;
				break;

				case 'P':
				sscanf(&argv[c][2], "%u", &pattspacing);
				break;

				case 'S':
				timeseconds = 1;
				break;
				
				case 'H':
				displayhex = 1;
				break;

				case 'T':
				sscanf(&argv[c][2], "%u", &seconds);
				break;
				
				case 'Z':
				profiling = 1;
				break;

				case '2':
				secondSid = 1;
				break;

				case 'X':
				sscanf(&argv[c][2], "%s", outname);
				break;
			}
		}
		else 
		{
			if (!sidname) sidname = argv[c];
		}
	}

	// Usage display
	if ((argc < 2) || (usage))
	{
		printf("Usage: SIDDUMP <sidfile> [options]\n"
				"Warning: CPU emulation may be buggy/inaccurate, illegals support very limited\n\n"
				"Options:\n"
				"-a<value> Accumulator value on init (subtune number) default = 0\n"
				"-c<value> Frequency recalibration. Give note frequency in hex\n"
				"-d<value> Select calibration note (abs.notation 80-DF). Default middle-C (B0)\n"
				"-f<value> First frame to display, default 0\n"
				"-l        Low-resolution mode (only display 1 row per note)\n"
				"-n<value> Note spacing, default 0 (none)\n"
				"-o<value> ""Oldnote-sticky"" factor. Default 1, increase for better vibrato display\n"
				"          (when increased, requires well calibrated frequencies)\n"
				"-p<value> Pattern spacing, default 0 (none)\n"
				"-s        Display time in minutes:seconds:frame format\n"
				"-h        Display frame index in hex format\n"
				"-t<value> Playback time in seconds, default 60\n"
				"-z        Include CPU cycles+rastertime (PAL)+rastertime, badline corrected\n"
				"-x<filename> Output file (dump), will not print to screen\n"
				"-2        Stereo SID, $DE00 (only when output to file)\n");
				
		if(mem)
		{
			free(mem);
		}

		return 1;
	}

	if (strlen(outname) > 0)
	{
		toFile = 1;

		if (strcmp(sidname, outname) == 0)
		{
			printf("Input and output file name must be different !\n");
			
			if(mem)
			{
				free(mem);
			}
			
			return 1;
		}
	}

	// Recalibrate frequencytable
	if (basefreq)
	{
		basenote &= 0x7f;
		if ((basenote < 0) || (basenote > 96))
		{
			printf("Warning: Calibration note out of range. Aborting recalibration.\n");
		}
		
		else
		{
			for (c = 0; c < 96; c++)
			{
				double note = c - basenote;
				double freq = (double)basefreq * pow(2.0, note/12.0);
				int f = freq;
				if (freq > 0xffff) freq = 0xffff;
				freqtbllo[c] = f & 0xff;
				freqtblhi[c] = f >> 8;
			}
		}
	}

	// Check other parameters for correctness
	if ((lowres) && (!spacing)) lowres = 0;

	// Open SID file
	if (!sidname)
	{
		printf("Error: no SID file specified.\n");
		
		if(mem)
		{
			free(mem);
		}
		
		return 1;
	}

	in = fopen(sidname, "rb");
	if (!in)
	{
		printf("Error: couldn't open SID file.\n");
		
		if(mem)
		{
			free(mem);
		}
		
		return 1;
	}

	// Read interesting parts of the SID header
	fseek(in, 6, SEEK_SET);
	dataoffset = readword(in);
	loadaddress = readword(in);
	initaddress = readword(in);
	playaddress = readword(in);
	fseek(in, dataoffset, SEEK_SET);
	if (loadaddress == 0)
		loadaddress = readbyte(in) | (readbyte(in) << 8);

	// Load the C64 data
	loadpos = ftell(in);
	fseek(in, 0, SEEK_END);
	loadend = ftell(in);
	fseek(in, loadpos, SEEK_SET);
	loadsize = loadend - loadpos;
	if (loadsize + loadaddress >= 0x10000)
	{
		printf("Error: SID data continues past end of C64 memory.\n");
		fclose(in);
		
		if(mem)
		{
			free(mem);
		}
		
		return 1;
	}
	
	if(toFile)
	{
		out = fopen(outname, "wb");
		
		if (!out)
		{
			printf("Error: couldn't open output (dump) file. Will print to screen instead.\n");
			fclose(in);
			
			if(mem)
			{
				free(mem);
			}
			
			return 1;
		}
	}
	
	initcpu(initaddress, subtune, 0, 0);

	fread(&mem[loadaddress], loadsize, 1, in);
	fclose(in);

	// Print info & run initroutine
	printf("Load address: $%04X Init address: $%04X Play address: $%04X\n", loadaddress, initaddress, playaddress);
	printf("Calling initroutine with subtune %d\n", subtune);
	mem[0x01] = 0x37;
	//initcpu(initaddress, subtune, 0, 0);
	instr = 0;
	while (runcpu())
	{
		// Allow SID model detection (including $d011 wait) to eventually terminate
		++mem[0xd012];
		if (!mem[0xd012] || ((mem[0xd011] & 0x80) && mem[0xd012] >= 0x38))
		{
				mem[0xd011] ^= 0x80;
				mem[0xd012] = 0x00;
		}
		instr++;
		if (instr > MAX_INSTR)
		{
			printf("Warning: CPU executed a high number of instructions in init, breaking\n");
			break;
		}
	}

	if (playaddress == 0)
	{
		printf("Warning: SID has play address 0, reading from interrupt vector instead\n");
		if ((mem[0x01] & 0x07) == 0x5)
			playaddress = mem[0xfffe] | (mem[0xffff] << 8);
		else
			playaddress = mem[0x314] | (mem[0x315] << 8);
		printf("New play address is $%04X\n", playaddress);
	}

	// Clear channelstructures in preparation & print first time info
	memset(&chn, 0, sizeof chn);
	memset(&filt, 0, sizeof filt);
	memset(&prevchn, 0, sizeof prevchn);
	memset(&prevchn2, 0, sizeof prevchn2);
	memset(&prevfilt, 0, sizeof prevfilt);
	printf("Calling playroutine for %d frames, starting from frame %d\n", seconds*50, firstframe);
	printf("Middle C frequency is $%04X\n\n", freqtbllo[48] | (freqtblhi[48] << 8));
	printf("| Frame | Freq Note/Abs WF ADSR Pul | Freq Note/Abs WF ADSR Pul | Freq Note/Abs WF ADSR Pul | FCut RC Typ V |");
	if (profiling)
	{ // CPU cycles, Raster lines, Raster lines with badlines on every 8th line, first line included
		printf(" Cycl RL RB |");
	}
	printf("\n");
	printf("+-------+---------------------------+---------------------------+---------------------------+---------------+");
	if (profiling)
	{
		printf("------------+");
	}
	printf("\n");

	// Data collection & display loop
	while (frames < firstframe + seconds*50)
	{
		int c;

		// Run the playroutine
		instr = 0;
		initcpu(playaddress, 0, 0, 0);
		while (runcpu())
		{
			instr++;
			if (instr > MAX_INSTR)
			{
				printf("Error: CPU executed abnormally high amount of instructions in playroutine, exiting\n");
				
				if(mem)
				{
					free(mem);
				}
				
				return 1;
			}
			// Test for jump into Kernal interrupt handler exit
			if ((mem[0x01] & 0x07) != 0x5 && (pc == 0xea31 || pc == 0xea81))
				break;
		}

		// Get SID parameters from each channel and the filter
		for (c = 0; c < 3; c++)
		{
			chn[c].freq = mem[0xd400 + 7*c] | (mem[0xd401 + 7*c] << 8);
			chn[c].pulse = (mem[0xd402 + 7*c] | (mem[0xd403 + 7*c] << 8)) & 0xfff;
			chn[c].wave = mem[0xd404 + 7*c];
			chn[c].adsr = mem[0xd406 + 7*c] | (mem[0xd405 + 7*c] << 8);
		}
		
		filt.cutoff = (mem[0xd415] << 5) | (mem[0xd416] << 8);
		filt.ctrl = mem[0xd417];
		filt.type = mem[0xd418];

		// Frame display
		if (frames >= firstframe)
		{
			if (toFile)
			{
				fwrite(&mem[0xD400], 1, 25, out);

				if (secondSid)
				{
					fwrite(&mem[0xDE00], 1, 25, out);
				}
			}
		
			else
			{
				char output[512];
				int time = frames - firstframe;
				output[0] = 0;

				if (!timeseconds)
				{
					if(displayhex)
					{
						sprintf(&output[strlen(output)], "| %5X | ", time);
					}
					
					else
					{
						sprintf(&output[strlen(output)], "| %5d | ", time);
					}
				}
				
				else
					sprintf(&output[strlen(output)], "|%01d:%02d.%02d| ", time / 3000, (time / 50) % 60, time % 50);

				// Loop for each channel
				for (c = 0; c < 3; c++)
				{
					int newnote = 0;

					// Keyoff-keyon sequence detection
					if (chn[c].wave >= 0x10)
					{
						if ((chn[c].wave & 1) && ((!(prevchn2[c].wave & 1)) || (prevchn2[c].wave < 0x10)))
							prevchn[c].note = -1;
					}

					// Frequency
					if ((frames == firstframe) || (prevchn[c].note == -1) || (chn[c].freq != prevchn[c].freq))
					{
						int d;
						int dist = 0x7fffffff;
						int delta = ((int)chn[c].freq) - ((int)prevchn2[c].freq);

						sprintf(&output[strlen(output)], "%04X ", chn[c].freq);

						if (chn[c].wave >= 0x10)
						{
							// Get new note number
							for (d = 0; d < 96; d++)
							{
								int cmpfreq = freqtbllo[d] | (freqtblhi[d] << 8);
								int freq = chn[c].freq;

								if (abs(freq - cmpfreq) < dist)
								{
									dist = abs(freq - cmpfreq);
									// Favor the old note
									if (d == prevchn[c].note) dist /= oldnotefactor;
									chn[c].note = d;
								}
							}

							// Print new note
							if (chn[c].note != prevchn[c].note)
							{
								if (prevchn[c].note == -1)
								{
									if (lowres) newnote = 1;
									sprintf(&output[strlen(output)], " %s %02X  ", notename[chn[c].note], chn[c].note | 0x80);
								}
								else
									sprintf(&output[strlen(output)], "(%s %02X) ", notename[chn[c].note], chn[c].note | 0x80);
							}
							else
							{
								// If same note, print frequency change (slide/vibrato)
								if (delta)
								{
									if (delta > 0)
										sprintf(&output[strlen(output)], "(+ %04X) ", delta);
									else
										sprintf(&output[strlen(output)], "(- %04X) ", -delta);
								}
								else sprintf(&output[strlen(output)], " ... ..  ");
							}
						}
						else sprintf(&output[strlen(output)], " ... ..  ");
					}
					else sprintf(&output[strlen(output)], "....  ... ..  ");

					// Waveform
					if ((frames == firstframe) || (newnote) || (chn[c].wave != prevchn[c].wave))
						sprintf(&output[strlen(output)], "%02X ", chn[c].wave);
					else sprintf(&output[strlen(output)], ".. ");

					// ADSR
					if ((frames == firstframe) || (newnote) || (chn[c].adsr != prevchn[c].adsr)) sprintf(&output[strlen(output)], "%04X ", chn[c].adsr);
					else sprintf(&output[strlen(output)], ".... ");

					// Pulse
					if ((frames == firstframe) || (newnote) || (chn[c].pulse != prevchn[c].pulse)) sprintf(&output[strlen(output)], "%03X ", chn[c].pulse);
					else sprintf(&output[strlen(output)], "... ");

					sprintf(&output[strlen(output)], "| ");
				}

				// Filter cutoff
				if ((frames == firstframe) || (filt.cutoff != prevfilt.cutoff)) sprintf(&output[strlen(output)], "%04X ", filt.cutoff);
				else sprintf(&output[strlen(output)], ".... ");

				// Filter control
				if ((frames == firstframe) || (filt.ctrl != prevfilt.ctrl))
					sprintf(&output[strlen(output)], "%02X ", filt.ctrl);
				else sprintf(&output[strlen(output)], ".. ");

				// Filter passband
				if ((frames == firstframe) || ((filt.type & 0x70) != (prevfilt.type & 0x70)))
					sprintf(&output[strlen(output)], "%s ", filtername[(filt.type >> 4) & 0x7]);
				else sprintf(&output[strlen(output)], "... ");

				// Mastervolume
				if ((frames == firstframe) || ((filt.type & 0xf) != (prevfilt.type & 0xf))) sprintf(&output[strlen(output)], "%01X ", filt.type & 0xf);
				else sprintf(&output[strlen(output)], ". ");

				// Rasterlines / cycle count
				if (profiling)
				{
					int cycles = cpucycles;
					int rasterlines = (cycles + 62) / 63;
					int badlines = ((cycles + 503) / 504);
					int rasterlinesbad = (badlines * 40 + cycles + 62) / 63;
					sprintf(&output[strlen(output)], "| %4d %02X %02X ", cycles, rasterlines, rasterlinesbad);
				}

				// End of frame display, print info so far and copy SID registers to old registers
				sprintf(&output[strlen(output)], "|\n");
				if ((!lowres) || (!((frames - firstframe) % spacing)))
				{
					printf("%s", output);
					for (c = 0; c < 3; c++)
					{
						prevchn[c] = chn[c];
					}
					prevfilt = filt;
				}
				for (c = 0; c < 3; c++) prevchn2[c] = chn[c];

				// Print note/pattern separators
				if (spacing)
				{
					counter++;
					if (counter >= spacing)
					{
						counter = 0;
						if (pattspacing)
						{
							rows++;
							if (rows >= pattspacing)
							{
								rows = 0;
								printf("+=======+===========================+===========================+===========================+===============+\n");
							}
							else
								if (!lowres) printf("+-------+---------------------------+---------------------------+---------------------------+---------------+\n");
						}
						else
							if (!lowres) printf("+-------+---------------------------+---------------------------+---------------------------+---------------+\n");
					}
				}
			}
		}

		// Advance to next frame
		frames++;
	}

	if (out != NULL)
	{
		fclose(out);
	}
	
	if(mem)
	{
		free(mem);
	}
	
	return 0;
}

unsigned char readbyte(FILE *f)
{
	unsigned char res;

	fread(&res, 1, 1, f);
	return res;
}

unsigned short readword(FILE *f)
{
	unsigned char res[2];

	fread(&res, 2, 1, f);
	return (res[0] << 8) | res[1];
}