/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1994, Silicon Graphics, Inc.               *
 *                                                                        *
 *  These coded instructions, statements, and computer programs  contain  *
 *  unpublished  proprietary  information of Silicon Graphics, Inc., and  *
 *  are protected by Federal copyright  law.  They  may not be disclosed  *
 *  to  third  parties  or copied or duplicated in any form, in whole or  *
 *  in part, without the prior written consent of Silicon Graphics, Inc.  *
 *                                                                        *
 *************************************************************************/

/*
 * File:      rdp2read.c
 *
 * This program reads in a RDP command stream and prints out a 'readable' 
 * version of it.  Also checks for common errors in the display list.
 *
 *  Error Checks:
 *              o  Alignment of pointers
 *              o  Syncs missing
 *              o  Illegal Triangle coefficients
 *              o  Unscissored rectangles
 *
 *  Options:
 *              o  print info about triangle area
 *              o  accumulate span size histogram
 *              o  print only command decode
 */

#include <stdio.h>
#include <unistd.h>
#ifdef __sgi__
#include <bstring.h>
#endif
#include <string.h>
#include "mbi.h"

#define UsageString	"<rdp binfile> [<ramfile>]"

#ifndef TRUE
#define TRUE		1
#endif

#ifndef FALSE
#define FALSE	0
#endif

#ifndef ABS
#define ABS(x)			((x) > 0 ? (x) : (-(x)))
#endif

#ifndef MAX
#define MAX(x, y)		((x) > (y) ? (x) : (y))
#endif

#define MAX_HISTORY		45

#define STL_PREC		(1 << 21)
#define W_PREC			((unsigned)(1 << 31))
#define Z_PREC			(1 << 16)
#define RGBA_PREC		(1 << 16)
#define MAX_COORD_X		((float) (1 << 11) - 1)
#define MIN_COORD_X		(- (float) (1 << 11))
#define MAX_COORD_Y		((float) (1 << 11) - 1)
#define MIN_COORD_Y		(- (float) (1 << 11))

#define D_COMBINE		"combine"
#define D_TEX0			"tex0"
#define D_TEX1			"tex1"
#define D_PRIM			"prim"
#define D_SHADE			"shade"
#define D_ENV			"env"
#define D_CENTER		"center"
#define D_SCALE			"scale"
#define D_COMB_ALPHA		"combined_alpha"
#define D_TEX0_ALPHA		"tex0_alpha"
#define D_TEX1_ALPHA		"tex1_alpha"
#define D_PRIM_ALPHA		"prim_alpha"
#define D_SHADE_ALPHA		"shade_alpha"
#define D_ENV_ALPHA		"env_alpha"
#define D_LOD_FRAC		"lod_frac"
#define D_PRIM_LOD_FRAC		"prim_lod_frac"
#define D_NOISE			"noise"
#define D_CONV_K4		"k4"
#define D_CONV_K5		"k5"
#define D_ONE_PT_OH		"1.0"
#define D_ZERO			"0.0"

/*
 * blender inputs 
 */
#define BL_PIXEL_CLR		"pixel clr"
#define BL_BLENDED_CLR		"blended clr"
#define BL_MEMORY_CLR		"memory clr"
#define BL_BLEND_CLR		"blend reg clr"
#define BL_FOG_CLR		"fog reg clr"
#define BL_PIXEL_ALPHA		"pixel alpha"
#define BL_FOG_ALPHA		"fog alpha"
#define BL_SHADE_ALPHA		"shade alpha"
#define BL_ZERO			"0.0"

/*
 * texture formats 
 */
#define TEX_FORMAT_RGBA		"RGBA"
#define TEX_FORMAT_YUV		"YUV"
#define TEX_FORMAT_CI		"CI"
#define TEX_FORMAT_IA		"IA"
#define TEX_FORMAT_I		"I"
#define TEX_FORMAT_INV		"Invalid"

/*
 * texture sizes 
 */
#define TEX_SIZE_4b		"4b"
#define TEX_SIZE_8b		"8b"
#define TEX_SIZE_16b		"16b"
#define TEX_SIZE_32b		"32b"
#define TEX_SIZE_INV		"Invalid"

typedef int     		bool;
typedef char    		i8;
typedef short int 		i16;
typedef long int 		i32;

typedef struct {
	struct {
		unsigned int    cmd:8;	/*
								 * * command 
								 */
		unsigned int    tile:3;	/*
								 * * tile number 
								 */
		unsigned int    npa:1;	/*
								 * * non-primitive attribute command 
								 */
		unsigned int    prim:1;	/*
								 * * primitive command 
								 */
		unsigned int    lbt:1;	/*
								 * * load block/tile command 
								 */
		unsigned int    sts:1;	/*
								 * * set tile/tile size command 
								 */
	} pc[MAX_HISTORY];			/*
								 * * previous commands, circular buffer 
								 */
	int             curr_cmd;	/*
								 * * index of current command 
								 */
	int             n_cmd;		/*
								 * * number of commands processed so far 
								 */
} SyncWarnings;

/*
 *   G l o b a l s
 */

static SyncWarnings SyncW;
static u8       DRAM[2048 * 1024];
static bool     do_verbose = FALSE;
static u32      NumPrimitives = 0;
static int      nWarnings = 0;
static int      nErrors = 0;
static int      nClocks = 0;
static int      nPrimClocks = 0;
static int      nAttClocks = 0;
static int      nLoadClocks = 0;
static int      nSyncClocks = 0;

/*
 *   F u n c t i o n s
 */

static char    *
decode_tex_fmt(int fmt)
{
	switch (fmt) {
		case 0:
			return (TEX_FORMAT_RGBA);
		case 1:
			return (TEX_FORMAT_YUV);
		case 2:
			return (TEX_FORMAT_CI);
		case 3:
			return (TEX_FORMAT_IA);
		case 4:
			return (TEX_FORMAT_I);
		default:
			return (TEX_FORMAT_INV);
	}
}

static char    *
decode_tex_size(int size)
{
	switch (size) {
		case 0:
			return (TEX_SIZE_4b);
		case 1:
			return (TEX_SIZE_8b);
		case 2:
			return (TEX_SIZE_16b);
		case 3:
			return (TEX_SIZE_32b);
		default:
			return (TEX_SIZE_INV);
	}
}

/*
 *  Classify command as non-primitive attribute, which are
 *  not buffered and so must be explicitly synced.
 */
static int
is_npa_cmd(int cmd)
{
	switch (cmd) {
		case G_SETCIMG:
		case G_SETZIMG:
		case G_SETTIMG:
		case G_SETCOMBINE:
		case G_SETENVCOLOR:
		case G_SETBLENDCOLOR:
		case G_SETFOGCOLOR:
		case G_SETFILLCOLOR:
		case G_RDPSETOTHERMODE:
			/*
			 * case G_SETSCISSOR: 
			 */
		case G_SETCONVERT:
		case G_SETKEYR:
		case G_SETKEYGB:
			return (1);
		default:
			return (0);
	}
}

/*
 *  Classify as triangle command 
 */
static int
is_tri_cmd(int cmd)
{
	switch (cmd) {
		case G_TRI_FILL:
		case G_TRI_SHADE:
		case G_TRI_TXTR:
		case G_TRI_SHADE_TXTR:
		case G_TRI_FILL_ZBUFF:
		case G_TRI_SHADE_ZBUFF:
		case G_TRI_TXTR_ZBUFF:
		case G_TRI_SHADE_TXTR_ZBUFF:
			return (1);
		default:
			return (0);
	}
}

/*
 *  classify as texture rectangle command
 */
static int
is_tex_rect_cmd(int cmd)
{
	switch (cmd) {
		case G_TEXRECTFLIP:
		case G_TEXRECT:
			return (1);
		default:
			return (0);
	}
}

/*
 *  Classify as rectangle command
 */
static int
is_rect_cmd(int cmd)
{
	if (is_tex_rect_cmd(cmd) || cmd == G_FILLRECT)
		return (1);
	else
		return (0);
}

/*
 *  Classify command as load block or load tile 
 */
static int
is_lbt_cmd(int cmd)
{
	switch (cmd) {
		case G_LOADTILE:
		case G_LOADBLOCK:
		case G_LOADTLUT:
			return (1);
		default:
			return (0);
	}
}

/*
 * classify comand as primitive
 */
static int
is_prim_cmd(int cmd)
{
	if (is_rect_cmd(cmd) || is_tri_cmd(cmd) || is_lbt_cmd(cmd))
		return (1);
	else
		return (0);
}

/*
 *  Classify command as set_tile or set_tile_size
 */
static int
is_sts_cmd(int cmd)
{
	switch (cmd) {
		case G_SETTILE:
		case G_SETTILESIZE:
			return (1);
		default:
			return (0);
	}
}

/*
 *  Search through last MAX_HISTORY commands, looking for primitive
 *  command and noting if pipe or full sync command was found first.
 */
static int
no_sync_since_prim(void)
{
	int             indx,
	                i,
	                sync_found = 0,
	                prim_found = 0;

	if (SyncW.n_cmd < 1)
		return (0);

	indx = SyncW.curr_cmd - 1;
	if (indx < 0)
		indx = MAX_HISTORY - 1;

	for (i = 0; i < SyncW.n_cmd; i++) {
		/*
		 * printf("SyncW.pc[%d].cmd = %d\n", indx, SyncW.pc[indx].cmd); 
		 */
		if (SyncW.pc[indx].cmd == G_RDPFULLSYNC ||
			SyncW.pc[indx].cmd == G_RDPPIPESYNC)
			++sync_found;
		else if (SyncW.pc[indx].prim) {
			++prim_found;
			break;
		}
		--indx;
		if (indx < 0)
			indx = MAX_HISTORY - 1;
	}
	/*
	 * printf("sync_found = %d\n", sync_found); 
	 */
	return (!sync_found && prim_found);
}

/*
 *  Search through last MAX_HISTORY commands, looking for primitive
 *  command and noting if load sync command was found first.
 */
static int
no_load_sync_since_prim(void)
{
	int             indx,
	                i,
	                sync_found = 0,
	                prim_found = 0;

	if (SyncW.n_cmd < 1)
		return (0);

	indx = SyncW.curr_cmd - 1;
	if (indx < 0)
		indx = MAX_HISTORY - 1;

	for (i = 0; i < SyncW.n_cmd; i++) {
		/*
		 * printf("SyncW.pc[%d].cmd = %d\n", indx, SyncW.pc[indx].cmd); 
		 */
		if (SyncW.pc[indx].cmd == G_RDPLOADSYNC ||
			SyncW.pc[indx].cmd == G_RDPFULLSYNC ||
			SyncW.pc[indx].cmd == G_RDPPIPESYNC)
			++sync_found;
		else if (SyncW.pc[indx].prim) {
			++prim_found;
			break;
		}
		--indx;
		if (indx < 0)
			indx = MAX_HISTORY - 1;
	}
	/*
	 * printf("sync_found = %d\n", sync_found); 
	 */
	return (!sync_found && prim_found);
}

/*
 *  Search through last MAX_HISTORY commands, looking for primitive
 *  command and noting if tile sync command was found before primitive
 *  referencing given tile number.
 */
static int
no_tile_sync_since_prim(int tile)
{
	int             indx,
	                i,
	                sync_found = 0,
	                prim_found = 0;

	if (SyncW.n_cmd < 1)
		return (0);

	indx = SyncW.curr_cmd - 1;
	if (indx < 0)
		indx = MAX_HISTORY - 1;

	for (i = 0; i < SyncW.n_cmd; i++) {
		/*
		 * printf("SyncW.pc[%d].cmd = %d\n", indx, SyncW.pc[indx].cmd); 
		 */
		if (SyncW.pc[indx].cmd == G_RDPTILESYNC ||
			SyncW.pc[indx].cmd == G_RDPFULLSYNC ||
			SyncW.pc[indx].cmd == G_RDPPIPESYNC ||
			SyncW.pc[indx].cmd == G_RDPLOADSYNC)
			++sync_found;
		else if (SyncW.pc[indx].prim && (SyncW.pc[indx].tile == tile)) {
			++prim_found;
			break;
		}
		--indx;
		if (indx < 0)
			indx = MAX_HISTORY - 1;
	}
	/*
	 * printf("sync_found = %d\n", sync_found); 
	 */
	return (!sync_found && prim_found);
}

/*
 *  check_for_syncs:
 *
 *  Check current command against recent history of commands
 */
static void
check_for_syncs(void)
{
	int             cur_cmd;
	int             tile;

	cur_cmd = SyncW.pc[SyncW.curr_cmd].cmd;
	tile = SyncW.pc[SyncW.curr_cmd].tile;

	/*
	 * if current command is non-prim attribute, and no pipe/full sync
	 * since last primitive, print warning. 
	 */
	if (is_npa_cmd(cur_cmd) && no_sync_since_prim()) {
		printf("******* WARNING: no pipe or full sync between last primitive and current\n");
		printf("*******          attribute change.\n\n");
		++nWarnings;
	}
	/*
	 * if current command is load block/tile, and no load sync between last 
	 * primitive and current command, print warning. 
	 */
	if (is_lbt_cmd(cur_cmd) && no_load_sync_since_prim()) {
		printf("******* WARNING: no load sync between last primitive and current\n");
		printf("*******          load.\n\n");
		++nWarnings;
	}
	/*
	 * if current command is set tile/tile_size, and previous primitive
	 * used that tile, and no tile sync before current command, print
	 * warning. 
	 */
	if (is_sts_cmd(cur_cmd) && no_tile_sync_since_prim(tile)) {
		printf("******* WARNING: no tile sync between last primitive that used this tile(%d)\n", tile);
		printf("*******          and current tile setting.\n\n");
		++nWarnings;
	}
}

float           _yh,
                _ym,
                _yl,
                _delxm;

static void
dump_edge_coef(FILE * in, u32 gfx0, u32 gfx1)
{
	i8              dir,
	                level,
	                tile;
	i16             YL,
	                YM,
	                YH;
	float           yl,
	                ym,
	                yh;
	i32             XL,
	                XH,
	                XM;
	float           xl,
	                xh,
	                xm;
	i32             DxLDy,
	                DxHDy,
	                DxMDy;
	float           dxhdy,
	                dxldy,
	                dxmdy;
	u32             buffer[8];
	float           x[3],
	                y[3],
	                area,
	                real_area,
	                x1,
	                x2,
	                dxmid;
	float           span,
	                span0,
	                span1,
	                span2,
	                span3;
	int             i,
	                worst_clks,
	                small_spans;

	dir = (gfx0 & 0x00800000) >> 23;
	level = (gfx0 & 0x00380000) >> 19;
	tile = (gfx0 & 0x00070000) >> 16;

	YL = (gfx0 & 0x0000ffff);
	YM = ((gfx1 & 0xffff0000) >> 16);
	YH = (gfx1 & 0x0000ffff);

	fread(buffer, sizeof(u32), 6, in);	/*

										 * * we already have gfx0, gfx1... 
										 */

for(i = 0; i < 6; i++) buffer[i] = ntohl(buffer[i]);
	XL = *((i32 *) & (buffer[0]));
	DxLDy = *((i32 *) & (buffer[1]));
	XH = *((i32 *) & (buffer[2]));
	DxHDy = *((i32 *) & (buffer[3]));
	XM = *((i32 *) & (buffer[4]));
	DxMDy = *((i32 *) & (buffer[5]));

	_yl = yl = (float) YL / 4.0;
	_ym = ym = (float) YM / 4.0;
	_yh = yh = (float) YH / 4.0;

	xl = (float) XL / 65536.0;
	xm = (float) XM / 65536.0;
	xh = (float) XH / 65536.0;

	dxhdy = (float) DxHDy / 65536.0;
	dxldy = (float) DxLDy / 65536.0;
	dxmdy = (float) DxMDy / 65536.0;

	_delxm = xl - (xh + (ym - yh) * dxhdy);

	fprintf(stdout, "\n\t    Edge coefficients:\n");
	fprintf(stdout, "\t\tdir = %d level = %d tile = %d\n",
			dir, level, tile);
	fprintf(stdout, "\t\tYL =     %04hx\tYM =        %04hx\tYH =        %04hx\n",
			YL, YM, YH);
	fprintf(stdout, "\t\t     %8.3f\t       %8.3f\t        %8.3f\n", yl, ym, yh);
	fprintf(stdout, "\t\tXL = %08x\tDxLDy = %08x\n", XL, DxLDy);
	fprintf(stdout, "\t\t     %8.3f\t       %8.3f\n", xl, dxldy);
	fprintf(stdout, "\t\tXH = %08x\tDxHDy = %08x\n", XH, DxHDy);
	fprintf(stdout, "\t\t     %8.3f\t       %8.3f\n", xh, dxhdy);
	fprintf(stdout, "\t\tXM = %08x\tDxMDy = %08x\n", XM, DxMDy);
	fprintf(stdout, "\t\t     %8.3f\t       %8.3f\n", xm, dxmdy);

	y[0] = yh;
	y[1] = ym;
	y[2] = yl;

	x[0] = xh + (yh - (int) yh) * dxhdy;
	x[1] = xl;
	x[2] = x[0] + dxhdy * (yl - yh);

	for (area = i = 0; i < 3; i++)
		area += x[i] * y[(i + 1) % 3] - y[i] * x[(i + 1) % 3];
	area /= 2.0;

	area = ABS(area);

	/*
	 *  find area one line at a time, figure out which spans are
	 *  nine clock minimum 
	 */

	real_area = 0;
	x1 = xh;
	x2 = xm;
	dxmid = dxmdy;
	small_spans = 0;

	for (i = (int) yh; i < (int) yl; i++) {
		if (i == (int) ym)
			dxmid = dxldy;

		span0 = ABS(x1 - x2);
		span1 = ABS(x1 - x2 + 0.75 * dxmid);
		span2 = ABS(x1 + 0.75 * dxhdy - x2);
		span3 = ABS(x1 + 0.75 * dxhdy - x2 + 0.75 * dxmid);

		span = MAX(span0, MAX(span1, MAX(span2, span3)));

		if (span < 9.0) {
			span = 9.0;
			small_spans++;
		}
		real_area += span;

		x2 += dxmid;
		x1 += dxhdy;
	}

	worst_clks = 22 + real_area;
	nPrimClocks += worst_clks;

	fprintf(stdout, "\n");
	fprintf(stdout, "\t\t     x0 (%f) y0 (%f)\n", x[0], y[0]);
	fprintf(stdout, "\t\t     x1 (%f) y1 (%f)\n", x[1], y[1]);
	fprintf(stdout, "\t\t     x2 (%f) y2 (%f)\n", x[2], y[2]);

	fprintf(stdout, "\t\t     number of spans.............  %d\n", (int) yl - (int) yh);
	fprintf(stdout, "\t\t     number of spans @ 9 clks....  %d\n", small_spans);
	fprintf(stdout, "\t\t     area........................  %f\n", area);
	fprintf(stdout, "\t\t     appx. num clocks............  %d\n", worst_clks);
	fprintf(stdout, "\t\t     %% overhead..................  %f\n",
			(float) (worst_clks - area) / (float) worst_clks * 100.0);

	/*
	 *   check for illegal X/Y magnitude
	 */
	if (xl > MAX_COORD_X || xl < MIN_COORD_X) {
		fprintf(stdout, "\n\t\t ****** ERROR, xl(%f) out of range (%f,%f)\n",
				xl, MIN_COORD_X, MAX_COORD_X);
		nErrors++;
	}
	if (xh > MAX_COORD_X || xh < MIN_COORD_X) {
		fprintf(stdout, "\n\t\t ****** ERROR, xh(%f) out of range (%f,%f)\n",
				xh, MIN_COORD_X, MAX_COORD_X);
		nErrors++;
	}
	if (xm > MAX_COORD_X || xm < MIN_COORD_X) {
		fprintf(stdout, "\n\t\t ****** ERROR, xm(%f) out of range (%f,%f)\n",
				xm, MIN_COORD_X, MAX_COORD_X);
		nErrors++;
	}
	if (yl > MAX_COORD_Y || yl < MIN_COORD_Y) {
		fprintf(stdout, "\n\t\t ****** ERROR, yl(%f) out of range (%f,%f)\n",
				yl, MIN_COORD_Y, MAX_COORD_Y);
		nErrors++;
	}
	if (yh > MAX_COORD_Y || yh < MIN_COORD_Y) {
		fprintf(stdout, "\n\t\t ****** ERROR, yh(%f) out of range (%f,%f)\n",
				yh, MIN_COORD_Y, MAX_COORD_Y);
		nErrors++;
	}
	if (ym > MAX_COORD_Y || ym < MIN_COORD_Y) {
		fprintf(stdout, "\n\t\t ****** ERROR, ym(%f) out of range (%f,%f)\n",
				ym, MIN_COORD_Y, MAX_COORD_Y);
		nErrors++;
	}
	/*
	 *   check for illegal slope/yh combinations
	 */

	if (dir == 1) {				/*
								 * * * left major  
								 */
		if ((dxmdy < dxhdy) && (YH != YM)) {
			fprintf(stdout, "\n\t\t ****** WARNING, dxmdy < dxhdy for left major triangle\n");
			++nWarnings;
		}
		if ((dxldy > dxmdy) && (YH != YM)) {
			fprintf(stdout, "\n\t\t ****** WARNING, dxldy > dxmdy for left major triangle\n");
			++nWarnings;
		}
	} else
		/*
		 * right major 
		 */
	{
		if ((dxhdy < dxmdy) && (YH != YM)) {
			fprintf(stdout, "\n\t\t ****** WARNING, dxhdy < dxmdy for right major triangle\n");
			++nWarnings;
		}
		if ((dxmdy > dxldy) && (YH != YM)) {
			fprintf(stdout, "\n\t\t ****** WARNING, dxmdy > dxldy for right major triangle\n");
			++nWarnings;
		}
	}

	if (YM < YH) {
		fprintf(stdout, "\n\t\t ****** WARNING, YM < YH\n");
		++nWarnings;
	}
	if (YL < YH) {
		fprintf(stdout, "\n\t\t ****** WARNING, YL < YH\n");
		++nWarnings;
	}
	if (YL < YM) {
		fprintf(stdout, "\n\t\t ****** WARNING, YL < YM\n");
		++nWarnings;
	}
}

static void
dump_shade_coef(FILE * in)
{
	u16             buffer[32];
	i32             red,
	                green,
	                blue,
	                alpha;
	i32             DrDx,
	                DgDx,
	                DbDx,
	                DaDx;
	i32             DrDe,
	                DgDe,
	                DbDe,
	                DaDe;
	i32             DrDy,
	                DgDy,
	                DbDy,
	                DaDy;

	fread(buffer, sizeof(u16), 32, in);
for(red = 0; red < 32; red++) buffer[red] = ntohs(buffer[red]);

	red = buffer[0] << 16;
	red |= buffer[8];
	green = buffer[1] << 16;
	green |= buffer[9];
	blue = buffer[2] << 16;
	blue |= buffer[10];
	alpha = buffer[3] << 16;
	alpha |= buffer[11];

	DrDx = buffer[4] << 16;
	DrDx |= buffer[12];
	DgDx = buffer[5] << 16;
	DgDx |= buffer[13];
	DbDx = buffer[6] << 16;
	DbDx |= buffer[14];
	DaDx = buffer[7] << 16;
	DaDx |= buffer[15];

	DrDe = buffer[16] << 16;
	DrDe |= buffer[24];
	DgDe = buffer[17] << 16;
	DgDe |= buffer[25];
	DbDe = buffer[18] << 16;
	DbDe |= buffer[26];
	DaDe = buffer[19] << 16;
	DaDe |= buffer[27];

	DrDy = buffer[20] << 16;
	DrDy |= buffer[28];
	DgDy = buffer[21] << 16;
	DgDy |= buffer[29];
	DbDy = buffer[22] << 16;
	DbDy |= buffer[30];
	DaDy = buffer[23] << 16;
	DaDy |= buffer[31];

	fprintf(stdout, "\n\t    Shade coefficients:\n");
	fprintf(stdout, "\t\t  red %08x green %08x  blue %08x alpha %08x\n",
			red, green, blue, alpha);
	fprintf(stdout, "\t\t     R  %8.6f\t        G  %8.6f\n",
			(float) red / RGBA_PREC, (float) green / RGBA_PREC);
	fprintf(stdout, "\t\t     B  %8.6f\t        A  %8.6f\n",
			(float) blue / RGBA_PREC, (float) alpha / RGBA_PREC);
	fprintf(stdout, "\n");

	fprintf(stdout, "\t\t DrDx %08x  DgDx %08x  DbDx %08x  DaDx %08x\n",
			DrDx, DgDx, DbDx, DaDx);
	fprintf(stdout, "\t\t  dRdX  %8.6f\t     dGdX  %8.6f\n",
			(float) DrDx / RGBA_PREC, (float) DgDx / RGBA_PREC);
	fprintf(stdout, "\t\t  dBdX  %8.6f\t     dAdX  %8.6f\n",
			(float) DbDx / RGBA_PREC, (float) DaDx / RGBA_PREC);
	fprintf(stdout, "\n");

	fprintf(stdout, "\t\t DrDe %08x  DgDe %08x  DbDe %08x  DaDe %08x\n",
			DrDe, DgDe, DbDe, DaDe);
	fprintf(stdout, "\t\t  dRdE  %8.6f\t     dGdE  %8.6f\n",
			(float) DrDe / RGBA_PREC, (float) DgDe / RGBA_PREC);
	fprintf(stdout, "\t\t  dBdE  %8.6f\t     dAdE  %8.6f\n",
			(float) DbDe / RGBA_PREC, (float) DaDe / RGBA_PREC);
	fprintf(stdout, "\n");

	fprintf(stdout, "\t\t DrDy %08x  DgDy %08x  DbDy %08x  DaDy %08x\n",
			DrDy, DgDy, DbDy, DaDy);
	fprintf(stdout, "\t\t  dRdY  %8.6f\t     dGdY  %8.6f\n",
			(float) DrDy / RGBA_PREC, (float) DgDy / RGBA_PREC);
	fprintf(stdout, "\t\t  dBdY  %8.6f\t     dAdY  %8.6f\n",
			(float) DbDy / RGBA_PREC, (float) DaDy / RGBA_PREC);
	fprintf(stdout, "\n");

	fprintf(stdout, "\t\tR0 %5.2f\tG0 %5.2f\tB0 %5.2f\tA0 %5.2f\n",
			(float) red / RGBA_PREC,
			(float) green / RGBA_PREC,
			(float) blue / RGBA_PREC,
			(float) alpha / RGBA_PREC);
	fprintf(stdout, "\t\tR1 %5.2f\tG1 %5.2f\tB1 %5.2f\tA1 %5.2f\n",
			(float) red / RGBA_PREC + (float) ((int) _ym - (int) _yh) * DrDe / RGBA_PREC +
			(float) _delxm * DrDx / RGBA_PREC,
			(float) green / RGBA_PREC + (float) ((int) _ym - (int) _yh) * DgDe / RGBA_PREC +
			(float) _delxm * DgDx / RGBA_PREC,
			(float) blue / RGBA_PREC + (float) ((int) _ym - (int) _yh) * DbDe / RGBA_PREC +
			(float) _delxm * DbDx / RGBA_PREC,
			(float) alpha / RGBA_PREC + (float) ((int) _ym - (int) _yh) * DaDe / RGBA_PREC +
			(float) _delxm * DaDx / RGBA_PREC);
	fprintf(stdout, "\t\tR2 %5.2f\tG2 %5.2f\tB2 %5.2f\tA2 %5.2f\n",
			(float) red / RGBA_PREC + (float) ((int) _yl - (int) _yh) * DrDe / RGBA_PREC,
			(float) green / RGBA_PREC + (float) ((int) _yl - (int) _yh) * DgDe / RGBA_PREC,
			(float) blue / RGBA_PREC + (float) ((int) _yl - (int) _yh) * DbDe / RGBA_PREC,
			(float) alpha / RGBA_PREC + (float) ((int) _yl - (int) _yh) * DaDe / RGBA_PREC);
	fprintf(stdout, "\n");
}

static void
dump_txtr_coef(FILE * in)
{
	u16             buffer[32];
	u32             gfx0,
	                gfx1;
	int             s,
	                t,
	                w,
	                l;
	int             dxs,
	                dxt,
	                dxw,
	                dxl;
	int             des,
	                det,
	                dew,
	                del;
	int             dys,
	                dyt,
	                dyw,
	                dyl;

	fread(buffer, sizeof(u16), 32, in);
for(s = 0; s < 32; s++) buffer[s] = ntohs(buffer[s]);

	s = buffer[0] << 16;
	s |= buffer[8];
	t = buffer[1] << 16;
	t |= buffer[9];
	w = buffer[2] << 16;
	w |= buffer[10];

	dxs = buffer[4] << 16;
	dxs |= buffer[12];
	dxt = buffer[5] << 16;
	dxt |= buffer[13];
	dxw = buffer[6] << 16;
	dxw |= buffer[14];

	des = buffer[16] << 16;
	des |= buffer[24];
	det = buffer[17] << 16;
	det |= buffer[25];
	dew = buffer[18] << 16;
	dew |= buffer[26];

	dys = buffer[20] << 16;
	dys |= buffer[28];
	dyt = buffer[21] << 16;
	dyt |= buffer[29];
	dyw = buffer[22] << 16;
	dyw |= buffer[30];

	fprintf(stdout, "\n\t    Texture coefficients:\n");
	fprintf(stdout, "\t\t  S %08x  T %08x  W %08x  L %08x\n", s, t, w, l);
	fprintf(stdout, "\t\t     S  %8.6f\t        T  %8.6f\n", (float) s / STL_PREC, (float) t / STL_PREC);
	fprintf(stdout, "\t\t     W  %8.6f\t\n", (float) w / W_PREC);
	fprintf(stdout, "\n");
	fprintf(stdout, "\t\t  dSdX %08x  dTdX %08x  dWdX %08x  dLdX %08x\n", dxs, dxt, dxw, dxl);
	fprintf(stdout, "\t\t  dSdX  %8.6f\t     dTdX  %8.6f\n", (float) dxs / STL_PREC, (float) dxt / STL_PREC);
	fprintf(stdout, "\t\t  dWdX  %8.6f\t\n", (float) dxw / W_PREC);
	fprintf(stdout, "\n");
	fprintf(stdout, "\t\t  dSdE %08x  dTdE %08x  dWdE %08x\n", des, det, dew);
	fprintf(stdout, "\t\t  dSdE  %8.6f\t     dTdE  %8.6f\n", (float) des / STL_PREC, (float) det / STL_PREC);
	fprintf(stdout, "\t\t  dWdE  %8.6f\t\n", (float) dew / W_PREC);
	fprintf(stdout, "\n");
	fprintf(stdout, "\t\t  dSdY %08x  dTdY %08x  dWdY %08x\n", dys, dyt, dyw);
	fprintf(stdout, "\t\t  dSdY  %8.6f\t     dTdY  %8.6f\n", (float) dys / STL_PREC, (float) dyt / STL_PREC);
	fprintf(stdout, "\t\t  dWdY  %8.6f\t\n", (float) dyw / W_PREC);
	fprintf(stdout, "\n");

	fprintf(stdout, "\t\tS0 %5.2f\tT0 %5.2f\tW0 %9.6f\n",
			(float) s / STL_PREC,
			(float) t / STL_PREC,
			(float) w / W_PREC);
	fprintf(stdout, "\t\tS1 %5.2f\tT1 %5.2f\tW1 %9.6f\n",
	 (float) s / STL_PREC + (float) ((int) _ym - (int) _yh) * des / STL_PREC +
			(float) _delxm * dxs / STL_PREC,
	 (float) t / STL_PREC + (float) ((int) _ym - (int) _yh) * det / STL_PREC +
			(float) _delxm * dxt / STL_PREC,
		 (float) w / W_PREC + (float) ((int) _ym - (int) _yh) * dew / W_PREC +
			(float) _delxm * dxw / W_PREC);
	fprintf(stdout, "\t\tS2 %5.2f\tT2 %5.2f\tW2 %9.6f\n",
	  (float) s / STL_PREC + (float) ((int) _yl - (int) _yh) * des / STL_PREC,
	  (float) t / STL_PREC + (float) ((int) _yl - (int) _yh) * det / STL_PREC,
		 (float) w / W_PREC + (float) ((int) _yl - (int) _yh) * dew / W_PREC);
	fprintf(stdout, "\n");
}

static void
dump_zbuff_coef(FILE * in)
{
	u32             buffer[4];
	int             z,
	                dxz,
	                dez,
	                dyz;

	fread(buffer, sizeof(u32), 4, in);
for(z = 0; z < 4; z++) buffer[z] = ntohl(buffer[z]);

	z = buffer[0];
	dxz = buffer[1];
	dez = buffer[2];
	dyz = buffer[3];

	fprintf(stdout, "\n\t    Z-buffer coefficients:\n");
	fprintf(stdout, "\t\t  Z %08x  dZdX %08x  dZdE %08x  dZdY %08x\n", z, dxz, dez, dyz);
	fprintf(stdout, "\t\t     Z  %8.6f\t     dZdX  %8.6f\n", (float) z / 65536.0, (float) dxz / 65536.0);
	fprintf(stdout, "\t\t  dZdE  %8.6f\t     dZdY  %8.6f\n", (float) dez / 65536.0, (float) dyz / 65536.0);
	fprintf(stdout, "\n");

	fprintf(stdout, "\t\tZ0 %8.6f\n",
			(float) z / 65536.0);
	fprintf(stdout, "\t\tZ1 %8.6f\n",
	   (float) z / 65536.0 + (float) ((int) _ym - (int) _yh) * dez / 65536.0 +
			(float) _delxm * dxz / 65536.0);
	fprintf(stdout, "\t\tZ2 %8.6f\n",
	   (float) z / 65536.0 + (float) ((int) _yl - (int) _yh) * dez / 65536.0);
	fprintf(stdout, "\n");
}

/*
 *  suba_decode: convert select to string
 */
static char    *
suba_decode(int sel)
{
	switch (sel) {
		case 0:
			return (D_COMBINE);
		case 1:
			return (D_TEX0);
		case 2:
			return (D_TEX1);
		case 3:
			return (D_PRIM);
		case 4:
			return (D_SHADE);
		case 5:
			return (D_ENV);
		case 6:
			return (D_ONE_PT_OH);
		case 7:
			return (D_NOISE);
		default:
			return (D_ZERO);
	}
}

/*
 *  subb_decode: convert select to string
 */
static char    *
subb_decode(int sel)
{
	switch (sel) {
		case 0:
			return (D_COMBINE);
		case 1:
			return (D_TEX0);
		case 2:
			return (D_TEX1);
		case 3:
			return (D_PRIM);
		case 4:
			return (D_SHADE);
		case 5:
			return (D_ENV);
		case 6:
			return (D_CENTER);
		case 7:
			return (D_CONV_K4);
		default:
			return (D_ZERO);
	}
}

/*
 *  mul_decode: convert select to string
 */
static char    *
mul_decode(int sel)
{
	switch (sel) {
		case 0:
			return (D_COMBINE);
		case 1:
			return (D_TEX0);
		case 2:
			return (D_TEX1);
		case 3:
			return (D_PRIM);
		case 4:
			return (D_SHADE);
		case 5:
			return (D_ENV);
		case 6:
			return (D_SCALE);
		case 7:
			return (D_COMB_ALPHA);
		case 8:
			return (D_TEX0_ALPHA);
		case 9:
			return (D_TEX1_ALPHA);
		case 10:
			return (D_PRIM_ALPHA);
		case 11:
			return (D_SHADE_ALPHA);
		case 12:
			return (D_ENV_ALPHA);
		case 13:
			return (D_LOD_FRAC);
		case 14:
			return (D_PRIM_LOD_FRAC);
		case 15:
			return (D_CONV_K5);
		default:
			return (D_ZERO);
	}
}

/*
 *  add_decode: convert select to string
 */
static char    *
add_decode(int sel)
{
	switch (sel & 7) {
		case 0:
			return (D_COMBINE);
		case 1:
			return (D_TEX0);
		case 2:
			return (D_TEX1);
		case 3:
			return (D_PRIM);
		case 4:
			return (D_SHADE);
		case 5:
			return (D_ENV);
		case 6:
			return (D_ONE_PT_OH);
		case 7:
			return (D_ZERO);
	}
}

/*
 *  a_subab_decode: convert select to string
 */
static char    *
a_subab_decode(int sel)
{
	switch (sel & 7) {
		case 0:
			return (D_COMB_ALPHA);
		case 1:
			return (D_TEX0_ALPHA);
		case 2:
			return (D_TEX1_ALPHA);
		case 3:
			return (D_PRIM_ALPHA);
		case 4:
			return (D_SHADE_ALPHA);
		case 5:
			return (D_ENV_ALPHA);
		case 6:
			return (D_ONE_PT_OH);
		case 7:
			return (D_ZERO);
	}
}

/*
 *  a_mul_decode: convert select to string
 */
static char    *
a_mul_decode(int sel)
{
	switch (sel & 7) {
		case 0:
			return (D_LOD_FRAC);
		case 1:
			return (D_TEX0_ALPHA);
		case 2:
			return (D_TEX1_ALPHA);
		case 3:
			return (D_PRIM_ALPHA);
		case 4:
			return (D_SHADE_ALPHA);
		case 5:
			return (D_ENV_ALPHA);
		case 6:
			return (D_PRIM_LOD_FRAC);
		case 7:
			return (D_ZERO);
	}
}

/*
 *  a_add_decode: convert select to string
 */
static char    *
a_add_decode(int sel)
{
	switch (sel & 7) {
		case 0:
			return (D_COMB_ALPHA);
		case 1:
			return (D_TEX0_ALPHA);
		case 2:
			return (D_TEX1_ALPHA);
		case 3:
			return (D_PRIM_ALPHA);
		case 4:
			return (D_SHADE_ALPHA);
		case 5:
			return (D_ENV_ALPHA);
		case 6:
			return (D_ONE_PT_OH);
		case 7:
			return (D_ZERO);
	}
}

static void
dump_setcombine(u32 gfx0, u32 gfx1)
{
	union {
		struct {
			unsigned int    pad0:2;
			unsigned int    cmd:6;
			unsigned int    suba_r0:4;
			unsigned int    mult_r0:5;
			unsigned int    suba_a0:3;
			unsigned int    mult_a0:3;
			unsigned int    suba_r1:4;
			unsigned int    mult_r1:5;
		} bf;
		u32             word;
	} w0;

	union {
		struct {
			unsigned int    subb_r0:4;
			unsigned int    subb_r1:4;
			unsigned int    suba_a1:3;
			unsigned int    mult_a1:3;
			unsigned int    adds_r0:3;
			unsigned int    subb_a0:3;
			unsigned int    adds_a0:3;
			unsigned int    adds_r1:3;
			unsigned int    subb_a1:3;
			unsigned int    adds_a1:3;
		} bf;
		u32             word;
	} w1;

	unsigned int    suba,
	                subb,
	                mul,
	                add;
	char           *dsuba,
	               *dsubb,
	               *dmul,
	               *dadd;

	w0.word = gfx0;
	w1.word = gfx1;

	suba = w0.bf.suba_r0;
	subb = w1.bf.subb_r0;
	mul = w0.bf.mult_r0;
	add = w1.bf.adds_r0;

	fprintf(stdout, "\n\t    Red/Green/Blue Controls, Cycle 0:\n");
	dsuba = suba_decode(suba);
	dsubb = subb_decode(subb);
	dmul = mul_decode(mul);
	dadd = add_decode(add);
	fprintf(stdout, "\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

	suba = w0.bf.suba_r1;
	subb = w1.bf.subb_r1;
	mul = w0.bf.mult_r1;
	add = w1.bf.adds_r1;

	fprintf(stdout, "\n\t    Red/Green/Blue Controls, Cycle 1:\n");
	dsuba = suba_decode(suba);
	dsubb = subb_decode(subb);
	dmul = mul_decode(mul);
	dadd = add_decode(add);
	fprintf(stdout, "\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

	suba = w0.bf.suba_a0;
	subb = w1.bf.subb_a0;
	mul = w0.bf.mult_a0;
	add = w1.bf.adds_a0;

	fprintf(stdout, "\n\t    Alpha Controls, Cycle 0:\n");
	dsuba = a_subab_decode(suba);
	dsubb = a_subab_decode(subb);
	dmul = a_mul_decode(mul);
	dadd = a_add_decode(add);
	fprintf(stdout, "\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

	suba = w1.bf.suba_a1;
	subb = w1.bf.subb_a1;
	mul = w1.bf.mult_a1;
	add = w1.bf.adds_a1;

	fprintf(stdout, "\n\t    Alpha Controls, Cycle 1:\n");
	dsuba = a_subab_decode(suba);
	dsubb = a_subab_decode(subb);
	dmul = a_mul_decode(mul);
	dadd = a_add_decode(add);
	fprintf(stdout, "\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);
}

static char    *
blender_p_decode(int sel, int two_cycle, int mux)
{
	switch (sel) {
		case 0:
			if (two_cycle && mux)
				return (BL_BLENDED_CLR);
			else
				return (BL_PIXEL_CLR);
			break;
		case 1:
			return (BL_MEMORY_CLR);
			break;
		case 2:
			return (BL_BLEND_CLR);
			break;
		case 3:
			return (BL_FOG_CLR);
			break;
	}
}

static char    *
blender_a_decode(int sel)
{
	switch (sel) {
		case 0:
			return (BL_PIXEL_ALPHA);
			break;
		case 1:
			return (BL_FOG_ALPHA);
			break;
		case 2:
			return (BL_SHADE_ALPHA);
			break;
		case 3:
			return (BL_ZERO);
			break;
	}
}

static char    *
decode_rgb_dither_select(int sel)
{
	switch (sel) {
		case 0:
			return ("magic square");
		case 1:
			return ("bayer");
		case 2:
			return ("noise");
		case 3:
			return ("no dither");
	}
}

static char    *
decode_alpha_dither_select(int sel)
{
	switch (sel) {
		case 0:
			return ("pattern");
		case 1:
			return ("~pattern");
		case 2:
			return ("noise");
		case 3:
			return ("no dither");
	}
}

/*
 *  Dump other modes
 */
static void
dump_setother(u32 gfx0, u32 gfx1)
{
	union {
		struct {
			unsigned int    pad0:2;
			unsigned int    cmd:6;
			unsigned int    atomic:1;
			unsigned int    reserved0:1;
			unsigned int    cycle_type:2;
			unsigned int    persp_tex_en:1;
			unsigned int    detail_tex_en:1;
			unsigned int    sharpen_tex_en:1;
			unsigned int    tex_lod_en:1;
			unsigned int    en_tlut:1;
			unsigned int    tlut_type:1;
			unsigned int    sample_type:1;
			unsigned int    mid_texel:1;
			unsigned int    bi_lerp_0:1;
			unsigned int    bi_lerp_1:1;
			unsigned int    convert_one:1;
			unsigned int    key_en:1;
			unsigned int    rgb_dither_select:2;
			unsigned int    alpha_dither_select:2;
			unsigned int    reserved1:4;
		} bf;
		u32             word;
	} w0;

	union {
		struct {
			unsigned int    b_m1a_0:2;
			unsigned int    b_m1a_1:2;
			unsigned int    b_m1b_0:2;
			unsigned int    b_m1b_1:2;
			unsigned int    b_m2a_0:2;
			unsigned int    b_m2a_1:2;
			unsigned int    b_m2b_0:2;
			unsigned int    b_m2b_1:2;
			unsigned int    reserved0:1;
			unsigned int    force_blend:1;
			unsigned int    alpha_cvg_select:1;
			unsigned int    cvg_times_alpha:1;
			unsigned int    z_mode:2;
			unsigned int    cvg_dest:2;
			unsigned int    color_on_cvg:1;
			unsigned int    image_read_en:1;
			unsigned int    z_update_en:1;
			unsigned int    z_compare_en:1;
			unsigned int    antialias_en:1;
			unsigned int    z_source_sel:1;
			unsigned int    dither_alpha_en:1;
			unsigned int    alpha_compare_en:1;
		} bf;
		u32             word;
	} w1;

	w0.word = gfx0;
	w1.word = gfx1;

	fprintf(stdout, "\t\t    atomic primitive .....  %d\n", w0.bf.atomic);
	fprintf(stdout, "\t\t    cycle_type............  %d ", w0.bf.cycle_type);

	if (w0.bf.cycle_type == 0)
		fprintf(stdout, "(one cycle)\n");
	else if (w0.bf.cycle_type == 1)
		fprintf(stdout, "(two cycle)\n");
	else if (w0.bf.cycle_type == 2)
		fprintf(stdout, "(copy)\n");
	else
		fprintf(stdout, "(fill)\n");

	fprintf(stdout, "\t\t    persp_tex_en..........  %d\n", w0.bf.persp_tex_en);
	fprintf(stdout, "\t\t    detail_tex_en.........  %d\n", w0.bf.detail_tex_en);
	fprintf(stdout, "\t\t    sharpen_tex_en........  %d\n", w0.bf.sharpen_tex_en);
	fprintf(stdout, "\t\t    tex_lod_en............  %d\n", w0.bf.tex_lod_en);
	fprintf(stdout, "\t\t    en_tlut...............  %d\n", w0.bf.en_tlut);
	fprintf(stdout, "\t\t    tlut_type.............  %d\n", w0.bf.tlut_type);
	fprintf(stdout, "\t\t    sample_type...........  %d\n", w0.bf.sample_type);
	fprintf(stdout, "\t\t    mid_texel.............  %d\n", w0.bf.mid_texel);
	fprintf(stdout, "\t\t    bi_lerp_0.............  %d\n", w0.bf.bi_lerp_0);
	fprintf(stdout, "\t\t    bi_lerp_1.............  %d\n", w0.bf.bi_lerp_1);
	fprintf(stdout, "\t\t    convert_one...........  %d\n", w0.bf.convert_one);
	fprintf(stdout, "\t\t    key_en................  %d\n", w0.bf.key_en);
	fprintf(stdout, "\t\t    rgb dither select.....  %d, %s\n", w0.bf.rgb_dither_select,
			decode_rgb_dither_select(w0.bf.rgb_dither_select));
	fprintf(stdout, "\t\t    alpha dither select...  %d, %s\n", w0.bf.alpha_dither_select,
			decode_alpha_dither_select(w0.bf.alpha_dither_select));

	fprintf(stdout, "\n\t    Blender Equation: (1a*1b + 2a*2b) / (1b + 2b)\n");

	fprintf(stdout, "\n\t    Blend Mux Controls, Cycle 0: ");
	fprintf(stdout, "(%d, %d, %d, %d)\n", w1.bf.b_m1a_0, w1.bf.b_m1b_0, w1.bf.b_m2a_0,
			w1.bf.b_m2b_0);

	fprintf(stdout, "\t\t    blend mult 1a.........  ");
	fprintf(stdout, "%s\n", blender_p_decode(w1.bf.b_m1a_0, w0.bf.cycle_type & 1, 0));

	fprintf(stdout, "\t\t    blend mult 1b.........  ");
	fprintf(stdout, "%s\n", blender_a_decode(w1.bf.b_m1b_0));

	fprintf(stdout, "\t\t    blend mult 2a.........  ");
	fprintf(stdout, "%s\n", blender_p_decode(w1.bf.b_m2a_0, w0.bf.cycle_type & 1, 0));

	fprintf(stdout, "\t\t    blend mult 2b.........  ");

	switch (w1.bf.b_m2b_0) {
		case 0:
			fprintf(stdout, "1.0 - %s\n", blender_a_decode(w1.bf.b_m1b_0));
			break;
		case 1:
			fprintf(stdout, "memory alpha\n");
			break;
		case 2:
			fprintf(stdout, "1.0\n");
			break;
		case 3:
			fprintf(stdout, "0.0\n");
			break;
	}

	fprintf(stdout, "\n\t    Blend Mux Controls, Cycle 1: ");
	fprintf(stdout, "(%d, %d, %d, %d)\n", w1.bf.b_m1a_1, w1.bf.b_m1b_1, w1.bf.b_m2a_1,
			w1.bf.b_m2b_1);

	fprintf(stdout, "\t\t    blend mult 1a.........  ");
	fprintf(stdout, "%s\n", blender_p_decode(w1.bf.b_m1a_1, w0.bf.cycle_type & 1, 1));

	fprintf(stdout, "\t\t    blend mult 1b.........  ");
	fprintf(stdout, "%s\n", blender_a_decode(w1.bf.b_m1b_1));

	fprintf(stdout, "\t\t    blend mult 2a.........  ");
	fprintf(stdout, "%s\n", blender_p_decode(w1.bf.b_m2a_1, w0.bf.cycle_type & 1, 0));

	fprintf(stdout, "\t\t    blend mult 2b.........  ");

	switch (w1.bf.b_m2b_1) {
		case 0:
			fprintf(stdout, "1.0 - %s\n", blender_a_decode(w1.bf.b_m1b_1));
			break;
		case 1:
			fprintf(stdout, "memory alpha\n");
			break;
		case 2:
			fprintf(stdout, "1.0\n");
			break;
		case 3:
			fprintf(stdout, "0.0\n");
			break;
	}

	fprintf(stdout, "\n");

	fprintf(stdout, "\t\t    force_blend...........  %d\n", w1.bf.force_blend);
	fprintf(stdout, "\t\t    alpha_cvg_select......  %d\n", w1.bf.alpha_cvg_select);
	fprintf(stdout, "\t\t    cvg_times_alpha.......  %d\n", w1.bf.cvg_times_alpha);

	fprintf(stdout, "\t\t    z_mode................  ");
	switch (w1.bf.z_mode) {
		case 0:
			fprintf(stdout, "opaque\n");
			break;
		case 1:
			fprintf(stdout, "interpenetrating\n");
			break;
		case 2:
			fprintf(stdout, "transparent\n");
			break;
		case 3:
			fprintf(stdout, "decal\n");
			break;
	}

	fprintf(stdout, "\t\t    cvg_dest..............  ");
	switch (w1.bf.cvg_dest) {
		case 0:
			fprintf(stdout, "clamp(normal)\n");
			break;
		case 1:
			fprintf(stdout, "wrap\n");
			break;
		case 2:
			fprintf(stdout, "zap(force to full cvg)\n");
			break;
		case 3:
			fprintf(stdout, "save(don't overwrite mem cvg)\n");
			break;
	}

	fprintf(stdout, "\t\t    color_on_cvg..........  %d\n", w1.bf.color_on_cvg);
	fprintf(stdout, "\t\t    image_read_en.........  %d\n", w1.bf.image_read_en);
	fprintf(stdout, "\t\t    z_update_en...........  %d\n", w1.bf.z_update_en);
	fprintf(stdout, "\t\t    z_compare_en..........  %d\n", w1.bf.z_compare_en);
	fprintf(stdout, "\t\t    antialias_en..........  %d\n", w1.bf.antialias_en);
	fprintf(stdout, "\t\t    z_source_sel..........  %s\n",
			w1.bf.z_source_sel ? "prim z" : "pixel z");
	fprintf(stdout, "\t\t    dither_alpha_en.......  %d\n", w1.bf.dither_alpha_en);
	fprintf(stdout, "\t\t    alpha_compare_en......  %d\n", w1.bf.alpha_compare_en);
}

static void
dump_texrect(FILE * in, u32 gfx0, u32 gfx1)
{
	u32             buffer[4];
	Gtexrect       *texrp;
	float           xl,
	                yl,
	                xh,
	                yh;
	float           area;

	buffer[0] = gfx0;
	buffer[1] = gfx1;
	fread(&gfx0, sizeof(u32), 1, in);
	fread(&gfx1, sizeof(u32), 1, in);
gfx0 = ntohl(gfx0);
gfx1 = ntohl(gfx1);

	buffer[2] = gfx0;
	buffer[3] = gfx1;
	fprintf(stdout, "\t\t\t\t\t%08x %08x\n", buffer[2], buffer[3]);
	texrp = (Gtexrect *) & (buffer[0]);
	xl = (float) texrp->xl / 4.0;
	xh = (float) texrp->xh / 4.0;
	yl = (float) texrp->yl / 4.0;
	yh = (float) texrp->yh / 4.0;

	fprintf(stdout, "\t\tile = %d\n", texrp->tile);
	fprintf(stdout, "\t\txl = %f yl = %f xh = %f yh = %f\n",
			xl, yl, xh, yh);
	fprintf(stdout, "\t\ts = %f t = %f dsdx = %f dtdy = %f\n",
			(float) texrp->s / 32.0, (float) texrp->t / 32.0,
			(float) texrp->dsdx / 1024.0, (float) texrp->dtdy / 1024.0);

	area = (xl - xh) * (yl - yh);
	fprintf(stdout, "\t\t     area........................  %f\n", area);

	nPrimClocks += area;
}

/*
 * Parse and dump a RDP-type display list command.
 */
static void
read_rdp(u32 gfx0, u32 gfx1, FILE * in)
{
	u32             addr,
	                buffer[20];
	int             i0,
	                i1,
	                i2,
	                i3;
	char            op,
	                b0,
	                tstring[32];
	float           area;
	Gsetimg        *imgp;
	Gsetcombine    *combp;
	Gsetcolor      *scolp;
	Gfillrect      *fillrp;
	Gsettile       *stilep;
	Gloadtile      *ltilep;
	Gloadtlut      *ltlutp;

	/*
	 * every command has at least 64-bits... 
	 */
	buffer[0] = gfx0;
	buffer[1] = gfx1;

	op = (char) ((gfx0 & 0xff000000) >> 24);

	/*
	 *  Classify command for next sync check
	 */
	SyncW.pc[SyncW.curr_cmd].cmd = op;
	SyncW.pc[SyncW.curr_cmd].npa = is_npa_cmd(op);
	SyncW.pc[SyncW.curr_cmd].prim = is_prim_cmd(op);
	SyncW.pc[SyncW.curr_cmd].sts = is_sts_cmd(op);
	SyncW.pc[SyncW.curr_cmd].lbt = is_lbt_cmd(op);

	/*
	 * save tile number 
	 */
	if (is_tex_rect_cmd(op) || is_lbt_cmd(op) || is_sts_cmd(op))
		SyncW.pc[SyncW.curr_cmd].tile = ((gfx1 & 0x07000000) >> 24);
	else if (is_tri_cmd(op))
		SyncW.pc[SyncW.curr_cmd].tile = ((gfx0 & 0x00070000) >> 16);
	else
		SyncW.pc[SyncW.curr_cmd].tile = 0;

	check_for_syncs();

	/*
	 * increment/clamp indexes 
	 */
	++SyncW.curr_cmd;
	if (SyncW.curr_cmd > (MAX_HISTORY - 1))
		SyncW.curr_cmd = 0;

	++SyncW.n_cmd;
	if (SyncW.n_cmd > MAX_HISTORY)
		SyncW.n_cmd = MAX_HISTORY;

	/*
	 *  Formatted Dump of each command
	 */
	switch (op) {

		case (char) G_SETCIMG:
			fprintf(stdout, "\tSETCIMG ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			imgp = (Gsetimg *) & (buffer[0]);
			fprintf(stdout, "\t\tfmt = %d siz = %d wd = %d ptr = %08x\n",
					imgp->fmt, imgp->siz, imgp->wd, gfx1);
			++nAttClocks;
			break;

		case (char) G_SETZIMG:
			fprintf(stdout, "\tSETZIMG ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			imgp = (Gsetimg *) & (buffer[0]);
			fprintf(stdout, "\t\tfmt = %d siz = %d wd = %d ptr = %08x\n",
					imgp->fmt, imgp->siz, imgp->wd, gfx1);
			++nAttClocks;
			break;

		case (char) G_SETTIMG:
			fprintf(stdout, "\tSETTIMG ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			imgp = (Gsetimg *) & (buffer[0]);
			fprintf(stdout, "\t\tfmt = %d siz = %d wd = %d ptr = %08x\n",
					imgp->fmt, imgp->siz, imgp->wd, gfx1);
			++nAttClocks;
			break;

		case (char) G_SETCOMBINE:
			fprintf(stdout, "\tSETCOMBINE ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			dump_setcombine(gfx0, gfx1);
			++nAttClocks;
			break;

		case (char) G_SETENVCOLOR:
			fprintf(stdout, "\tSETENVCOLOR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			scolp = (Gsetcolor *) & (buffer[0]);
			fprintf(stdout, "\t\tc = %08x\n", scolp->color);
			++nAttClocks;
			break;

		case (char) G_SETPRIMCOLOR:
			fprintf(stdout, "\tSETPRIMCOLOR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			scolp = (Gsetcolor *) & (buffer[0]);
			fprintf(stdout, "\t\tprim_min_lev = %d prim_lev = %d c = %08x\n",
					scolp->prim_min_level, scolp->prim_level, scolp->color);
			++nAttClocks;
			break;

		case (char) G_SETBLENDCOLOR:
			fprintf(stdout, "\tSETBLENDCOLOR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			scolp = (Gsetcolor *) & (buffer[0]);
			fprintf(stdout, "\t\tc = %08x\n", scolp->color);
			++nAttClocks;
			break;

		case (char) G_SETFOGCOLOR:
			fprintf(stdout, "\tSETFOGCOLOR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			scolp = (Gsetcolor *) & (buffer[0]);
			fprintf(stdout, "\t\tc = %08x\n", scolp->color);
			++nAttClocks;
			break;

		case (char) G_SETFILLCOLOR:
			fprintf(stdout, "\tSETFILLCOLOR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			scolp = (Gsetcolor *) & (buffer[0]);
			fprintf(stdout, "\t\tc = %08x\n", scolp->color);
			++nAttClocks;
			break;

		case (char) G_FILLRECT:
			fprintf(stdout, "\tFILLRECT ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			fillrp = (Gfillrect *) & (buffer[0]);
			fprintf(stdout, "\t\tulx = %d uly = %d lrx = %d lry = %d\n",
					fillrp->x1, fillrp->y1, fillrp->x0, fillrp->y0);

			area = MAX((fillrp->x0 - fillrp->x1) * (fillrp->y0 - fillrp->y1),
					   9 * (fillrp->y0 - fillrp->y1));
			nPrimClocks += (int) area;
			break;

		case (char) G_SETTILE:
			fprintf(stdout, "\tSETTILE ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			stilep = (Gsettile *) & (buffer[0]);
			fprintf(stdout, "\t\tfmt = %s (%d) siz = %s (%d) line = %d tmem = %08x\n",
					decode_tex_fmt(stilep->fmt), stilep->fmt, decode_tex_size(stilep->siz),
					stilep->siz, stilep->line, stilep->tmem);
			fprintf(stdout, "\t\ttile = %d pal = %d ct = %d mt = %d\n",
					stilep->tile, stilep->palette, stilep->ct, stilep->mt);
			fprintf(stdout, "\t\tmaskt = %d shiftt = %d cs = %d ms = %d masks = %d shifts = %d\n",
					stilep->maskt, stilep->shiftt, stilep->cs, stilep->ms,
					stilep->masks, stilep->shifts);
			++nAttClocks;
			break;

		case (char) G_LOADTILE:
			fprintf(stdout, "\tLOADTILE ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			ltilep = (Gloadtile *) & (buffer[0]);
			fprintf(stdout, "\t\tsl = %f tl = %f tile = %d sh = %f th = %f\n",
			 (float) ltilep->sl / 4.0, (float) ltilep->tl / 4.0, ltilep->tile,
					(float) ltilep->sh / 4.0, (float) ltilep->th / 4.0);
			break;

		case (char) G_LOADBLOCK:
			fprintf(stdout, "\tLOADBLOCK ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			/*
			 * same as load tile... 
			 */
			ltilep = (Gloadblock *) & (buffer[0]);
			fprintf(stdout, "\t\tsl = %f tl = %f tile = %d sh = %f dxt = %f\n",
					(float) ltilep->sl, (float) ltilep->tl, ltilep->tile,
				  (float) ltilep->sh, (float) ltilep->th / (float) (1 << 11));
			break;

		case (char) G_SETTILESIZE:
			fprintf(stdout, "\tSETTILESIZE ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * same as load tile... 
			 */
			ltilep = (Gsettilesize *) & (buffer[0]);
			fprintf(stdout, "\t\tsl = %f tl = %f tile = %d sh = %f th = %f\n",
			 (float) ltilep->sl / 4.0, (float) ltilep->tl / 4.0, ltilep->tile,
					(float) ltilep->sh / 4.0, (float) ltilep->th / 4.0);
			++nAttClocks;
			break;

		case (char) G_LOADTLUT:
			fprintf(stdout, "\tLOADTLUT ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			ltlutp = (Gloadtlut *) & (buffer[0]);
			fprintf(stdout, "\t\tsl = %f tl = %f tile = %d sh = %f th = %f\n",
			 (float) ltlutp->sl / 4.0, (float) ltlutp->tl / 4.0, ltlutp->tile,
					(float) ltlutp->sh / 4.0, (float) ltlutp->th / 4.0);
			break;

		case (char) G_RDPSETOTHERMODE:
			fprintf(stdout, "\tRDPSETOTHERMODE ");
			fprintf(stdout, "\t\t%08x %08x\n", gfx0, gfx1);
			dump_setother(gfx0, gfx1);
			++nAttClocks;
			break;

		case (char) G_SETPRIMDEPTH:
			fprintf(stdout, "\tSETPRIMDEPTH ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			i0 = gfx1 >> 16;
			i1 = (gfx1 << 16) >> 16;
			fprintf(stdout, "\t\tprimZ = %d primDelZ = %d\n", i0, i1);
			++nAttClocks;
			break;

		case (char) G_SETSCISSOR:
			fprintf(stdout, "\tSETSCISSOR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			i0 = (gfx0 & 0x00fff000) >> 12;
			i1 = (gfx0 & 0x00000fff);
			i2 = (gfx1 & 0x00fff000) >> 12;
			i3 = (gfx1 & 0x00000fff);
			fprintf(stdout, "\t\txH = %.3f yH = %.3f xL = %.3f yL = %.3f\n",
					(float) i0 / 4.0, (float) i1 / 4.0, (float) i2 / 4.0, (float) i3 / 4.0);
			fprintf(stdout, "\t\tulx = %.3f uly = %.3f lrx = %.3f lry = %.3f\n",
					(float) i0 / 4.0, (float) i1 / 4.0, (float) i2 / 4.0, (float) i3 / 4.0);
			if (gfx1 & 0x02000000) {
				fprintf(stdout, "\t\tscissor field ON, ");
				if (gfx1 & 0x01000000)
					fprintf(stdout, "keep odd lines\n");
				else
					fprintf(stdout, "keep even lines\n");
			} else {
				fprintf(stdout, "\t\tscissor field OFF\n");
			}
			++nAttClocks;
			break;

		case (char) G_SETCONVERT:
			fprintf(stdout, "\tSETCONVERT ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			++nAttClocks;
			break;

		case (char) G_SETKEYR:
			fprintf(stdout, "\tSETKEYR ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			++nAttClocks;
			break;

		case (char) G_SETKEYGB:
			fprintf(stdout, "\tSETKEYGB ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			++nAttClocks;
			break;

		case (char) G_RDPFULLSYNC:
			fprintf(stdout, "\tRDPFULLSYNC ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			nSyncClocks += 43;
			break;

		case (char) G_RDPTILESYNC:
			fprintf(stdout, "\tRDPTILESYNC ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			nSyncClocks += 28;
			break;

		case (char) G_RDPPIPESYNC:
			fprintf(stdout, "\tRDPPIPESYNC ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			nSyncClocks += 43;
			break;

		case (char) G_RDPLOADSYNC:
			fprintf(stdout, "\tRDPLOADSYNC ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			/*
			 * do something... 
			 */
			nSyncClocks += 18;
			break;

		case (char) G_NOOP:
			fprintf(stdout, "\tNOOP ");
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			nAttClocks++;
			break;

		case (char) G_TEXRECTFLIP:
			fprintf(stdout, "\tTEXRECTFLIP ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_texrect(in, gfx0, gfx1);
			break;

		case (char) G_TEXRECT:
			fprintf(stdout, "\tTEXRECT ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_texrect(in, gfx0, gfx1);
			break;

		case (char) G_TRI_FILL:
			fprintf(stdout, "\tG_TRI_FILL ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			break;

		case (char) G_TRI_SHADE:
			fprintf(stdout, "\tG_TRI_SHADE ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_shade_coef(in);
			break;

		case (char) G_TRI_TXTR:
			fprintf(stdout, "\tG_TRI_TXTR ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_txtr_coef(in);
			break;

		case (char) G_TRI_SHADE_TXTR:
			fprintf(stdout, "\tG_TRI_SHADE_TXTR ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_shade_coef(in);
			dump_txtr_coef(in);
			break;

		case (char) G_TRI_FILL_ZBUFF:
			fprintf(stdout, "\tG_TRI_FILL_ZBUFF ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_zbuff_coef(in);
			break;

		case (char) G_TRI_SHADE_ZBUFF:
			fprintf(stdout, "\tG_TRI_SHADE_ZBUFF ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_shade_coef(in);
			dump_zbuff_coef(in);
			break;

		case (char) G_TRI_TXTR_ZBUFF:
			fprintf(stdout, "\tG_TRI_TXTR_ZBUFF ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_txtr_coef(in);
			dump_zbuff_coef(in);
			break;

		case (char) G_TRI_SHADE_TXTR_ZBUFF:
			fprintf(stdout, "\tG_TRI_SHADE_TXTR_ZBUFF ");
			fprintf(stdout, "\t\t\t%08x %08x    prim #%04d\n", gfx0, gfx1, NumPrimitives++);
			dump_edge_coef(in, gfx0, gfx1);
			dump_shade_coef(in);
			dump_txtr_coef(in);
			dump_zbuff_coef(in);
			break;

		default:
			fprintf(stdout, "\tUNKNOWN %02x ", op);
			fprintf(stdout, "\t\t\t%08x %08x\n", gfx0, gfx1);
			fprintf(stdout, "\n\t\t ****** ERROR, unknown command\n");
			nErrors++;
			nAttClocks++;
			break;
	}

	fprintf(stdout, "\n");
}

/*
 * main routine.
 */
int
main(int argc, char *argv[])
{
	FILE           *dram_file,
	               *bin_file;
	u32             gfx0,
	                gfx1,
	               *gfxp;
	int             i;
	bool            do_stdin = FALSE;

	while ((argc > 1) && (argv[1][0] == '-')) {
		switch (argv[1][1]) {

			case 'v':
				do_verbose = FALSE;
				break;

			case '-':
				do_stdin = TRUE;
				break;

			default:
				fprintf(stderr, "%s : unknown argument [%s].\n", argv[0], argv[1]);
				break;
		}
		argc--;
		argv++;
	}

	if (argc < 2 && !do_stdin) {
		fprintf(stderr, "usage: %s %s.\n", argv[0], UsageString);
		exit(-1);
	}
	if (do_stdin) {
		bin_file = stdin;
	} else {
		if ((bin_file = fopen(argv[1], "r")) == NULL) {
			fprintf(stderr, "can't open bin file [%s].\n", argv[1]);
			exit(-1);
		}
	}

	if (argc > 2) {
		if ((dram_file = fopen(argv[2], "r")) == NULL) {
			fprintf(stderr, "can't open DRAM file [%s].\n", argv[2]);
			exit(-1);
		}
		fprintf(stderr, "loading DRAM data.");
		gfxp = (u32 *) &(DRAM[0]);
		i = 0;
		while (!feof(dram_file)) {
			if ((i % 1048576) == 0)
				fprintf(stderr, ".");
			fread(gfxp, sizeof(u32), 1, dram_file);

			gfxp++;
			i += 4;
		}
		fprintf(stderr, "done.\n");
		fclose(dram_file);
	}
	fprintf(stdout, "\n\t\tReadable dump of RDP file [%s]:\n\n", argv[1]);
	fprintf(stdout,
			"------------------------------------------------------------------------------\n");

	fread(&gfx0, sizeof(u32), 1, bin_file);
	fread(&gfx1, sizeof(u32), 1, bin_file);

	while (!feof(bin_file)) {

		gfx0 = ntohl(gfx0);
		gfx1 = ntohl(gfx1);
		read_rdp(gfx0, gfx1, bin_file);

		fread(&gfx0, sizeof(u32), 1, bin_file);
		fread(&gfx1, sizeof(u32), 1, bin_file);
	}

	fprintf(stdout,
			"\n------------------------------------------------------------------------------\n");
	fprintf(stdout, "Number of Warnings: %d\n", nWarnings);
	fprintf(stdout, "Number of Errors: %d\n", nErrors);
	fprintf(stdout, "Number of Sync Clocks (approximate): %d\n", nSyncClocks);
	fprintf(stdout, "Number of Att  Clocks (approximate): %d\n", nAttClocks);
	fprintf(stdout, "Number of Prim Clocks (approximate): %d\n", nPrimClocks);
	fprintf(stdout, "Number of Load Clocks (approximate): Not Implemented\n", nLoadClocks);
	fprintf(stdout, "                                    ------\n");
	fprintf(stdout, "Number of Total Clocks (approximate): %d\n", nSyncClocks +
			nAttClocks + nPrimClocks + nLoadClocks);
}