/**************************************************************************
 *                                                                        *
 *               Copyright (C) 1995, 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:      parser_rdp.c
 *
 * Interpret rdp commands, display them, and check for errors.
 *
 *  Error Checks:
 *              o  Alignment of pointers
 *              o  Color & Z outside first 2 Meg
 *              o  Clr,Tex,Z ot of 3Meg range
 *              o  Syncs missing
 *              o  Illegal Triangle coefficients
 *              o  Unscissored rectangles
 *              o  LoadBlock dxt
 *
 *  Options:
 *              o  print info about triangle area
 *              o  accumulate span size histogram XXX
 *              o  print verbose messages (XXX some)
 *
 *  Bugs:
 *              o  No load clocks estimate
 *              o  Sync clocks
 *              o  Sync checks not fool proof
 *              o  Area calc sometimes bogus
 *              o  Estimated clocks does not take into account RDRAM latency,
 *                  number of cycles, RMW mode, etc.
 */

#include <stdlib.h>
#include <stdio.h>
#include "ultra64.h"
#include "dlprint.h"

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

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

#ifndef INRANGE
#define INRANGE(x, min, max)        (((x) >= (min)) && ((x) <= (max)))
#endif

/*
 *  Color and Z should be in First 2 Megs
 *  Max system memory is 3 Meg
 */
#define MAX_CZ_ADDRESS      ((1 << 21) - 1)
#define MAX_ANY_ADDRESS     (((1 << 20) + (1 << 21)) - 1)
#define MAX_SCREEN_LINES    240

/*
 *  Number of clocks in RDP pipeline
 */
#define MAX_HISTORY         45
#define FULLSYNC_CLOCKS     45  /*
                                 * * XXX 
                                 */
#define PIPESYNC_CLOCKS     45  /*
                                 * * XXX 
                                 */
#define TILESYNC_CLOCKS     25  /*
                                 * * XXX 
                                 */
#define LOADSYNC_CLOCKS     30  /*
                                 * * XXX 
                                 */

/*
 *  Fractional precision of attributes
 */
#define ST_PREC         (1 << 21)
#define W_PREC          ((unsigned)(1 << 31))
#define Z_PREC          (1 << 16)
#define RGBA_PREC       (1 << 16)

#define ST2F32(s)       ((f32)s / (f32)ST_PREC)
#define W2F32(w)        ((f32)w / (f32)W_PREC)
#define Z2F32(z)        ((f32)z / (f32)Z_PREC)
#define RGBA2F32(r)     ((f32)r / (f32)RGBA_PREC)

/*
 *  Edge walker coordinate ranges
 */
#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))

/*
 *  Field decode strings for color combiner
 */
#define PR_SEPARATOR        "----------------------------------------"
#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"

/*
 *    T y p e s
 */

typedef enum {
    RDP_CLR_IMAGE, RDP_Z_IMAGE, RDP_TEX_IMAGE
} RdpImageType;

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

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

static SyncWarn SyncW;
static u8       do_verbose = FALSE;
static u8       do_pr_area = FALSE;
static u8       do_pr_histo = FALSE;
static u32      NumPrimitives = 0;
static u32      nWarnings = 0;
static u32      nErrors = 0;
static u32      nPrimClocks = 0;
static u32      nAttClocks = 0;
static u32      nLoadClocks = 0;
static u32      nSyncClocks = 0;
static u64     *RdpDl;

static f32      Scissorulx,
                Scissoruly,
                Scissorlrx,
                Scissorlry;
static f32      _yh,
                _ym,
                _yl,
                _delxm;

static f32      Trix[3],
                Triy[3];

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

static char    *
decode_tex_fmt(u32 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(u32 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);
    }
}

static u32
decode_size_nibbles(u32 size)
{
    switch (size) {
        case 0:
            return (1);
        case 1:
            return (2);
        case 2:
            return (4);
        case 3:
            return (8);
        default:
            return (0);
    }
}

/*
 *  suba_decode: convert select to string
 */
static char    *
suba_decode(u32 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(u32 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(u32 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(u32 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);
    }
    return "??";
}

/*
 *  a_subab_decode: convert select to string
 */
static char    *
a_subab_decode(u32 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);
    }
    return "??";
}

/*
 *  a_mul_decode: convert select to string
 */
static char    *
a_mul_decode(u32 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);
    }
    return "??";
}

/*
 *  a_add_decode: convert select to string
 */
static char    *
a_add_decode(u32 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);
    }
    return "??";
}

static char    *
blender_p_decode(u32 sel, u32 two_cycle, u32 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;
    }
    return "??";
}

static char    *
blender_a_decode(u32 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;
    }
    return "??";
}

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

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

/*
 *  Classify command as non-primitive attribute, which are
 *  not buffered and so must be explicitly synced.
 */
static int
is_npa_cmd(u32 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_NOOP:
             */
        case G_SETCONVERT:
        case G_SETKEYR:
        case G_SETKEYGB:
            return (1);
        default:
            return (0);
    }
}

/*
 *  Classify as triangle command 
 */
static int
is_tri_cmd(u32 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(u32 cmd)
{
    switch (cmd) {
        case G_TEXRECTFLIP:
        case G_TEXRECT:
            return (1);
        default:
            return (0);
    }
}

/*
 *  Classify as rectangle command
 */
static int
is_rect_cmd(u32 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(u32 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(u32 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++) {
        if (do_verbose)
            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;
    }
    if (do_verbose)
        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++) {
        if (do_verbose)
            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;
    }

    if (do_verbose)
        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(u32 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++) {
        if (do_verbose)
            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;
    }

    if (do_verbose)
        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("vv WARNING: no pipe or full sync between last primitive\n");
        PRINTF("vv          and current 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("vv WARNING: no load sync between last primitive\n");
        PRINTF("vv          and current 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("vv WARNING: no tile sync between last primitive that\n");
        PRINTF("vv used this tile(%d) and current tile setting.\n\n", tile);
        ++nWarnings;
    }
}

static void
dump_command(char *cmd, u64 word0)
{
    PRINTF("\t%s ", cmd);
    PRINTF("\t\t\t%016llx\n", word0);
}

/*
 *  return dram pointer for alignment check 
 */
void
dump_img(u64 word0, RdpImageType type)
{
    Gsetimg        *ip = (Gsetimg *) RdpDl;
    u32             dp,
                    end_address,
                    nbytes_line;

    dp = ip->dram & 0x03ffffff;

    PRINTF("\t\tfmt = %s\n", decode_tex_fmt(ip->fmt));
    PRINTF("\t\tsiz = %s\n", decode_tex_size(ip->siz));
    PRINTF("\t\twid = %d\n", ip->wd);
    PRINTF("\t\tptr = %08x\n", (int)dp);

    if ((type == RDP_CLR_IMAGE || type == RDP_Z_IMAGE)) {
        nbytes_line = decode_size_nibbles(ip->siz) * ip->wd / 2;
        end_address = dp + nbytes_line * MAX_SCREEN_LINES;
        if (end_address > MAX_CZ_ADDRESS) {
            PRINTF("^^ ERROR: Color/Z image should lie in first 0x%x bytes.\n",
                   MAX_CZ_ADDRESS);
            ++nErrors;
        }
    }
    if (dp > MAX_ANY_ADDRESS) {
        PRINTF("^^ ERROR: Image pointer exceeds max memory (0x%x bytes).\n",
               MAX_ANY_ADDRESS);
        ++nErrors;
    }
    if (dp & 0x7) {
        PRINTF("^^ ERROR: Image not aligned to 8 Bytes.\n");
        ++nErrors;
    }
    if ((type == RDP_CLR_IMAGE || type == RDP_Z_IMAGE) && (dp & 0x3f)) {
        PRINTF("^^ WARNING: Image not aligned to 64 Bytes.\n");
        PRINTF("^^          Only necessary if RMW color AND Z.\n");
        ++nWarnings;
    }
    ++nAttClocks;
    ++RdpDl;
}

static void
dump_setcimg(u64 word0)
{
    dump_command("SETCIMG", word0);
    dump_img(word0, RDP_CLR_IMAGE);
}

static void
dump_setzimg(u64 word0)
{
    dump_command("SETZIMG", word0);
    dump_img(word0, RDP_Z_IMAGE);
}

static void
dump_settimg(u64 word0)
{
    dump_command("SETTIMG", word0);
    dump_img(word0, RDP_TEX_IMAGE);
}

static void
dump_setcolor(u64 word0)
{
    Gsetcolor      *sc = (Gsetcolor *) RdpDl;

    PRINTF("\t\tred   = %02x\n", (int)(sc->color >> 24) & 0xff);
    PRINTF("\t\tgreen = %02x\n", (int)(sc->color >> 16) & 0xff);
    PRINTF("\t\tblue  = %02x\n", (int)(sc->color >> 8) & 0xff);
    PRINTF("\t\talpha = %02x\n", (int)sc->color & 0xff);
    ++nAttClocks;
    RdpDl++;
}

static void
dump_setenvcolor(u64 word0)
{
    dump_command("SETENVCOLOR", word0);
    dump_setcolor(word0);
}

static void
dump_setprimcolor(u64 word0)
{
    dump_command("SETPRIMCOLOR", word0);
    dump_setcolor(word0);
    PRINTF("\t\tPrim Min Level = %02x (%f)\n",
           (int)(word0 >> 40) & 0xff, (f32) ((word0 >> 40) & 0xff) / 256.0);
    PRINTF("\t\tPrim Level Frac = %02x (%f)\n",
           (int)(word0 >> 32) & 0xff, (f32) ((word0 >> 32) & 0xff) / 256.0);
}

static void
dump_setprimdepth(u64 word0)
{
    dump_command("SETPRIMDEPTH", word0);
    PRINTF("\t\tprimZ    = %04x\n", (int)(word0 >> 16) & 0xffff);
    PRINTF("\t\tprimDelZ = %04x\n", (int)word0 & 0xffff);
    ++nAttClocks;
    RdpDl++;
}

static void
dump_setblendcolor(u64 word0)
{
    dump_command("SETBLENDCOLOR", word0);
    dump_setcolor(word0);
}

static void
dump_setfogcolor(u64 word0)
{
    dump_command("SETFOGCOLOR", word0);
    dump_setcolor(word0);
}

static void
dump_setfillcolor(u64 word0)
{
    dump_command("SETFILLCOLOR", word0);
    dump_setcolor(word0);
}

static void
dump_fillrect(u64 word0)
{
    Gfillrect      *fp = (Gfillrect *) RdpDl;

    dump_command("FILLRECT", word0);
    PRINTF("\t\tulx = %d\n", fp->x1);
    PRINTF("\t\tuly = %d\n", fp->y1);
    PRINTF("\t\tlrx = %d\n", fp->x0);
    PRINTF("\t\tlry = %d\n", fp->y0);

    nPrimClocks = (int) MAX((fp->x0 - fp->x1) * (fp->y0 - fp->y1),
                            9 * (fp->y0 - fp->y1));
    RdpDl++;
}

static void
dump_settile(u64 word0)
{
    Gsettile       *tp = (Gsettile *) RdpDl;

    dump_command("SETTILE", word0);
    PRINTF("\t\ttile   = %d\n", tp->tile);
    PRINTF("\t\tfmt    = %s (%d)\n", decode_tex_fmt(tp->fmt), tp->fmt);
    PRINTF("\t\tsize   = %s (%d)\n", decode_tex_size(tp->siz), tp->siz);
    PRINTF("\t\tline   = %d\n", tp->line);
    PRINTF("\t\ttmem   = %03x\n", tp->tmem);
    PRINTF("\t\tpal    = %d\n", tp->palette);
    PRINTF("\t\tclmpt  = %d\n", tp->ct);
    PRINTF("\t\tmirrt  = %d\n", tp->mt);
    PRINTF("\t\tmaskt  = %d\n", tp->maskt);
    PRINTF("\t\tshiftt = %d\n", tp->shiftt);
    PRINTF("\t\tclmps  = %d\n", tp->cs);
    PRINTF("\t\tmirrs  = %d\n", tp->ms);
    PRINTF("\t\tmasks  = %d\n", tp->masks);
    PRINTF("\t\tshifts = %d\n", tp->shifts);
    ++nAttClocks;
    ++RdpDl;
}

static void
dump_settilesize(u64 word0)
{
    Gsettilesize   *sp = (Gsettilesize *) RdpDl;

    dump_command("SETTILESIZE", word0);
    PRINTF("\t\ttile = %d\n", sp->tile);
    PRINTF("\t\tsl = %f  tl = %f\n", (f32) sp->sl / 4.0, (f32) sp->tl / 4.0);
    PRINTF("\t\tsh = %f  th = %f\n", (f32) sp->sh / 4.0, (f32) sp->th / 4.0);
    ++nAttClocks;
    ++RdpDl;
}

static void
dump_loadtile(u64 word0)
{
    Gloadtile      *lp = (Gloadtile *) RdpDl;

    dump_command("LOADTILE", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    PRINTF("\t\ttile = %d\n", lp->tile);
    PRINTF("\t\tsl = %f  tl = %f\n", (f32) lp->sl / 4.0, (f32) lp->tl / 4.0);
    PRINTF("\t\tsh = %f  th = %f\n", (f32) lp->sh / 4.0, (f32) lp->th / 4.0);

    RdpDl++;
    /*
     * XXX figure out number of load clocks 
     */
}

static void
dump_loadblock(u64 word0)
{
    Gloadblock     *lp = (Gloadblock *) RdpDl;

    dump_command("LOADBLOCK", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    PRINTF("\t\ttile = %d\n", lp->tile);
    PRINTF("\t\tsl = %f  tl  = %f\n", (f32) lp->sl, (f32) lp->tl);
    PRINTF("\t\tsh = %f  dxt = %f\n", (f32) lp->sh,
           (f32) lp->th / (f32) (1 << 11));

    RdpDl++;
    /*
     * XXX figure out number of load clocks 
     */
}

static void
dump_loadtlut(u64 word0)
{
    Gloadtlut      *lp = (Gloadtlut *) RdpDl;

    dump_command("LOADTLUT", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    PRINTF("\t\ttile = %d\n", lp->tile);
    PRINTF("\t\ttable index  = %d\n", lp->tl);
    PRINTF("\t\tlow index    = %d\n", lp->sl);
    PRINTF("\t\thigh index   = %d\n", lp->sh);
    RdpDl++;
}

static void
dump_setcombine(u64 word0)
{
    union {
        struct {
            u32             pad0:2;
            u32             cmd:6;
            u32             suba_r0:4;
            u32             mult_r0:5;
            u32             suba_a0:3;
            u32             mult_a0:3;
            u32             suba_r1:4;
            u32             mult_r1:5;
            u32             subb_r0:4;
            u32             subb_r1:4;
            u32             suba_a1:3;
            u32             mult_a1:3;
            u32             adds_r0:3;
            u32             subb_a0:3;
            u32             adds_a0:3;
            u32             adds_r1:3;
            u32             subb_a1:3;
            u32             adds_a1:3;
        } bf;
        u64             word;
    } w0;

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

    w0.word = word0;

    dump_command("SETCOMBINE", word0);

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

    PRINTF("\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);
    PRINTF("\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

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

    PRINTF("\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);
    PRINTF("\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

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

    PRINTF("\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);
    PRINTF("\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

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

    PRINTF("\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);
    PRINTF("\t\t    (%s - %s) * %s + %s\n", dsuba, dsubb, dmul, dadd);

    ++nAttClocks;
    RdpDl++;
}

/*
 *  Dump other modes
 */
static void
dump_setothermode(u64 word0)
{
    union {
        struct {
            u32             pad0:2;
            u32             cmd:6;
            u32             atomic:1;
            u32             reserved0:1;
            u32             cycle_type:2;
            u32             persp_tex_en:1;
            u32             detail_tex_en:1;
            u32             sharpen_tex_en:1;
            u32             tex_lod_en:1;
            u32             en_tlut:1;
            u32             tlut_type:1;
            u32             sample_type:1;
            u32             mid_texel:1;
            u32             bi_lerp_0:1;
            u32             bi_lerp_1:1;
            u32             convert_one:1;
            u32             key_en:1;
            u32             rgb_dither_select:2;
            u32             alpha_dither_select:2;
            u32             reserved1:4;
            u32             b_m1a_0:2;
            u32             b_m1a_1:2;
            u32             b_m1b_0:2;
            u32             b_m1b_1:2;
            u32             b_m2a_0:2;
            u32             b_m2a_1:2;
            u32             b_m2b_0:2;
            u32             b_m2b_1:2;
            u32             reserved2:1;
            u32             force_blend:1;
            u32             alpha_cvg_select:1;
            u32             cvg_times_alpha:1;
            u32             z_mode:2;
            u32             cvg_dest:2;
            u32             color_on_cvg:1;
            u32             image_read_en:1;
            u32             z_update_en:1;
            u32             z_compare_en:1;
            u32             antialias_en:1;
            u32             z_source_sel:1;
            u32             dither_alpha_en:1;
            u32             alpha_compare_en:1;
        } bf;
        u64             word;
    } w0;

    w0.word = word0;

    dump_command("RDPSETOTHERMODE", word0);

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

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

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

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

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

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

    PRINTF("\t\t    blend mult 1b.........  ");
    PRINTF("%s\n", blender_a_decode(w0.bf.b_m1b_0));

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

    PRINTF("\t\t    blend mult 2b.........  ");

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

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

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

    PRINTF("\t\t    blend mult 1b.........  ");
    PRINTF("%s\n", blender_a_decode(w0.bf.b_m1b_1));

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

    PRINTF("\t\t    blend mult 2b.........  ");

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

    PRINTF("\n");

    PRINTF("\t\t    force_blend...........  %d\n", w0.bf.force_blend);
    PRINTF("\t\t    alpha_cvg_select......  %d\n", w0.bf.alpha_cvg_select);
    PRINTF("\t\t    cvg_times_alpha.......  %d\n", w0.bf.cvg_times_alpha);

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

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

    PRINTF("\t\t    color_on_cvg..........  %d\n", w0.bf.color_on_cvg);
    PRINTF("\t\t    image_read_en.........  %d\n", w0.bf.image_read_en);
    PRINTF("\t\t    z_update_en...........  %d\n", w0.bf.z_update_en);
    PRINTF("\t\t    z_compare_en..........  %d\n", w0.bf.z_compare_en);
    PRINTF("\t\t    antialias_en..........  %d\n", w0.bf.antialias_en);
    PRINTF("\t\t    z_source_sel..........  %s\n",
           w0.bf.z_source_sel ? "prim z" : "pixel z");
    PRINTF("\t\t    dither_alpha_en.......  %d\n", w0.bf.dither_alpha_en);
    PRINTF("\t\t    alpha_compare_en......  %d\n", w0.bf.alpha_compare_en);
    ++nAttClocks;
    RdpDl++;
}

static void
dump_setscissor(u64 word0)
{

    Scissorulx = (f32) ((word0 >> 44) & 0xfff) / 4.0;
    Scissoruly = (f32) ((word0 >> 32) & 0xfff) / 4.0;
    Scissorlrx = (f32) ((word0 >> 12) & 0xfff) / 4.0;
    Scissorlry = (f32) (word0 & 0xfff) / 4.0;

    dump_command("SETSCISSOR", word0);
    PRINTF("\t\txH (ulx) = %.3f  yH (uly) = %.3f\n", Scissorulx, Scissoruly);
    PRINTF("\t\txL (lrx) = %.3f  yL (lry) = %.3f\n", Scissorlrx, Scissorlry);

    if (word0 & 0x02000000) {
        PRINTF("\t\tscissor field ON, ");
        if (word0 & 0x01000000)
            PRINTF("keep odd lines\n");
        else
            PRINTF("keep even lines\n");
    } else {
        PRINTF("\t\tscissor field OFF\n");
    }
    ++nAttClocks;
    RdpDl++;
}

static void
dump_setconvert(u64 word0)
{
    dump_command("SETCONVERT", word0);
    PRINTF("\t\tK0 = %03x\n", (int)(word0 >> 45) & 0x1ff);
    PRINTF("\t\tK1 = %03x\n", (int)(word0 >> 36) & 0x1ff);
    PRINTF("\t\tK2 = %03x\n", (int)(word0 >> 27) & 0x1ff);
    PRINTF("\t\tK3 = %03x\n", (int)(word0 >> 18) & 0x1ff);
    PRINTF("\t\tK4 = %03x\n", (int)(word0 >> 9) & 0x1ff);
    PRINTF("\t\tK5 = %03x\n", (int)word0 & 0x1ff);
    ++nAttClocks;
    RdpDl++;
}

static void
dump_setkeyr(u64 word0)
{
    dump_command("SETKEYR", word0);
    PRINTF("\t\tRed width  = %03x\n", (int)(word0 >> 16) & 0xfff);
    PRINTF("\t\tRed center = %02x\n", (int)(word0 >> 8) & 0xff);
    PRINTF("\t\tRed scale  = %02x\n", (int)word0 & 0xff);
    ++nAttClocks;
    RdpDl++;
}

static void
dump_setkeygb(u64 word0)
{
    dump_command("SETKEYGB", word0);
    PRINTF("\t\tGrn width  = %03x\n", (int)(word0 >> 44) & 0xfff);
    PRINTF("\t\tGrn center = %02x\n", ((int)word0 >> 24) & 0xff);
    PRINTF("\t\tGrn scale  = %02x\n", (int)(word0 >> 16) & 0xff);
    PRINTF("\t\tBlu width  = %03x\n", (int)(word0 >> 32) & 0xfff);
    PRINTF("\t\tBlu center = %02x\n", (int)(word0 >> 8) & 0xff);
    PRINTF("\t\tBlu scale  = %02x\n", (int)word0 & 0xff);
    ++nAttClocks;
    RdpDl++;
}

static void
dump_fullsync(u64 word0)
{
    dump_command("RDPFULLSYNC", word0);
    nSyncClocks += FULLSYNC_CLOCKS;
    RdpDl++;
}

static void
dump_tilesync(u64 word0)
{
    dump_command("RDPTILESYNC", word0);
    nSyncClocks += TILESYNC_CLOCKS;
    RdpDl++;
}

static void
dump_pipesync(u64 word0)
{
    dump_command("RDPPIPESYNC", word0);
    nSyncClocks += PIPESYNC_CLOCKS;
    RdpDl++;
}

static void
dump_loadsync(u64 word0)
{
    dump_command("RDPLOADSYNC", word0);
    nSyncClocks += LOADSYNC_CLOCKS;
    RdpDl++;
}

static void
dump_noop(u64 word0)
{
    dump_command("NOOP", word0);
    nAttClocks++;
    RdpDl++;
}

static void
dump_trect(u64 word0)
{
    Gtexrect       *tp = (Gtexrect *) RdpDl;

    f32             xl,
                    yl,
                    xh,
                    yh,
                    area;

    xl = (f32) tp->xl / 4.0;
    xh = (f32) tp->xh / 4.0;
    yl = (f32) tp->yl / 4.0;
    yh = (f32) tp->yh / 4.0;

    /*
     *  Check for unscissored rectangles, user is suppossed
     *  to scissor.
     */
    if (!INRANGE(xl, Scissorulx, Scissorlrx) ||
        !INRANGE(xh, Scissorulx, Scissorlrx) ||
        !INRANGE(yl, Scissoruly, Scissorlry) ||
        !INRANGE(yh, Scissoruly, Scissorlry)) {
        PRINTF("\n\t\tvv ERROR, rectangle to scissored\n");
        ++nErrors;
    }
    PRINTF("\t\ttile = %d\n", tp->tile);
    PRINTF("\t\txl = %f  yl = %f\n", xl, yl);
    PRINTF("\t\txh = %f  yh = %f\n", xh, yh);
    PRINTF("\t\ts  = %f  t  = %f\n",
           (f32) tp->s / 32.0, (f32) tp->t / 32.0);
    PRINTF("\t\tdsdx = %f  dtdy = %f\n", (f32) tp->dsdx / 1024.0,
           (f32) tp->dtdy / 1024.0);

    area = (xl - xh) * (yl - yh);

    if (do_pr_area)
        PRINTF("\t\tarea =  %f\n", area);

    nPrimClocks += area;
    RdpDl += 2;
}

static void
dump_texrectflip(u64 word0)
{
    dump_command("TEXRECTFLIP", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_trect(word0);
}

static void
dump_texrect(u64 word0)
{
    dump_command("TEXRECT", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_trect(word0);
}

static void
dump_edge_coef(u64 word0)
{
    u32            *buffer;
    u8              dir,
                    level,
                    tile;
    s16             YL,
                    YM,
                    YH;
    f32             yl,
                    ym,
                    yh;
    s32             XL,
                    XH,
                    XM;
    f32             xl,
                    xh,
                    xm;
    s32             DxLDy,
                    DxHDy,
                    DxMDy;
    f32             dxhdy,
                    dxldy,
                    dxmdy,
                    area,
                    real_area,
                    x1,
                    x2,
                    dxmid;
    f32             span,
                    span0,
                    span1,
                    span2,
                    span3;
    s32             i,
                    worst_clks,
                    small_spans;

    buffer = (u32 *) RdpDl;

    dir = (buffer[0] & 0x00800000) >> 23;
    level = (buffer[0] & 0x00380000) >> 19;
    tile = (buffer[0] & 0x00070000) >> 25;

    YL = buffer[0] & 0x0000ffff;
    YM = (buffer[1] & 0xffff0000) >> 16;
    YH = buffer[1] & 0x0000ffff;

    XL = *((s32 *) &(buffer[2]));
    DxLDy = *((s32 *) &(buffer[3]));
    XH = *((s32 *) &(buffer[4]));
    DxHDy = *((s32 *) &(buffer[5]));
    XM = *((s32 *) &(buffer[6]));
    DxMDy = *((s32 *) &(buffer[7]));

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

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

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

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

    PRINTF("\n\t    Edge coefficients:\n");
    PRINTF("\t\tdir = %d level = %d tile = %d\n\n", dir, level, tile);

    PRINTF("\t\tYH     = %04x (%8.3f)\n", YH, yh);
    PRINTF("\t\tYM     = %04x (%8.3f)\n", YM, ym);
    PRINTF("\t\tYL     = %04x (%8.3f)\n", YL, yl);

    PRINTF("\t\tXH     = %08x (%8.3f)\n", (int)XH, xh);
    PRINTF("\t\tXM     = %08x (%8.3f)\n", (int)XM, xm);
    PRINTF("\t\tXL     = %08x (%8.3f)\n", (int)XL, xl);

    PRINTF("\t\tDxHDy  = %08x (%8.3f)\n", (int)DxHDy, dxhdy);
    PRINTF("\t\tDxMDy  = %08x (%8.3f)\n", (int)DxMDy, dxmdy);
    PRINTF("\t\tDxLDy  = %08x (%8.3f)\n", (int)DxLDy, dxldy);

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

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

    for (area = i = 0; i < 3; i++)
        area += Trix[i] * Triy[(i + 1) % 3] - Triy[i] * Trix[(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;

    if (do_pr_area) {
        PRINTF("\n");
        PRINTF("\t\t     x0 (%f) y0 (%f)\n", Trix[0], Triy[0]);
        PRINTF("\t\t     x1 (%f) y1 (%f)\n", Trix[1], Triy[1]);
        PRINTF("\t\t     x2 (%f) y2 (%f)\n", Trix[2], Triy[2]);

        PRINTF("\t\t     number of spans.............  %d\n", (int) yl - (int) yh);
        PRINTF("\t\t     number of spans @ 9 clks....  %d\n", (int)small_spans);
        PRINTF("\t\t     area........................  %f\n", area);
        PRINTF("\t\t     appx. num clocks............  %d\n", (int)worst_clks);
        PRINTF("\t\t     %% overhead..................  %f\n",
               (f32) (worst_clks - area) / (f32) worst_clks * 100.0);
    }
    /*
     *   check for illegal X/Y magnitude
     */
    if (xl > MAX_COORD_X || xl < MIN_COORD_X) {
        PRINTF("\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) {
        PRINTF("\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) {
        PRINTF("\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) {
        PRINTF("\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) {
        PRINTF("\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) {
        PRINTF("\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)) {
            PRINTF("\n\t\t^^ WARNING, dxmdy < dxhdy for left major triangle\n");
            ++nWarnings;
        }
        if ((dxldy > dxmdy) && (YH != YM)) {
            PRINTF("\n\t\t^^ WARNING, dxldy > dxmdy for left major triangle\n");
            ++nWarnings;
        }
    } else
        /*
         * right major 
         */
    {
        if ((dxhdy < dxmdy) && (YH != YM)) {
            PRINTF("\n\t\t^^ WARNING, dxhdy < dxmdy for right major triangle\n");
            ++nWarnings;
        }
        if ((dxmdy > dxldy) && (YH != YM)) {
            PRINTF("\n\t\t^^ WARNING, dxmdy > dxldy for right major triangle\n");
            ++nWarnings;
        }
    }

    if (YM < YH) {
        PRINTF("\n\t\t^^ WARNING, YM < YH\n");
        ++nWarnings;
    }
    if (YL < YH) {
        PRINTF("\n\t\t^^ WARNING, YL < YH\n");
        ++nWarnings;
    }
    if (YL < YM) {
        PRINTF("\n\t\t^^ WARNING, YL < YM\n");
        ++nWarnings;
    }
    RdpDl += 4;
}

static f32
get_shade_vert1(f32 base, f32 ym, f32 yh, f32 dade, f32 delxm, f32 dadx)
{
    return (RGBA2F32(base) + (f32) ((int) ym - (int) yh) *
            RGBA2F32(dade) + (f32) delxm * RGBA2F32(dadx));
}

static f32
get_shade_vert2(f32 base, f32 yl, f32 yh, f32 dade)
{
    return (RGBA2F32(base) + (f32) ((int) yl - (int) yh) * RGBA2F32(dade));
}

static void
dump_shade_coef(void)
{
    u16            *buffer;
    s32             red,
                    green,
                    blue,
                    alpha;
    s32             DrDx,
                    DgDx,
                    DbDx,
                    DaDx;
    s32             DrDe,
                    DgDe,
                    DbDe,
                    DaDe;
    s32             DrDy,
                    DgDy,
                    DbDy,
                    DaDy;

    buffer = (u16 *) RdpDl;

    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];

    PRINTF("\n\t    Shade coefficients:\n");
    PRINTF("\t\tred  %08x (%8.6f)  green %08x (%8.6f)\n",
           (int)red, RGBA2F32(red), (int)green, RGBA2F32(green));
    PRINTF("\t\tblue %08x (%8.6f)  alpha %08x (%8.6f)\n",
           (int)blue, RGBA2F32(blue), (int)alpha, RGBA2F32(alpha));
    PRINTF("\n");

    PRINTF("\t\tDrDe %08x (%8.6f)  DgDe %08x (%8.6f)\n",
           (int)DrDe, RGBA2F32(DrDe), (int)DgDe, RGBA2F32(DgDe));
    PRINTF("\t\tDbDe %08x (%8.6f)  DaDe %08x (%8.6f)\n",
           (int)DbDe, RGBA2F32(DbDe), (int)DaDe, RGBA2F32(DaDe));
    PRINTF("\n");

    PRINTF("\t\tDrDx %08x (%8.6f)  DgDx %08x (%8.6f)\n",
           (int)DrDx, RGBA2F32(DrDx), (int)DgDx, RGBA2F32(DgDx));
    PRINTF("\t\tDbDx %08x (%8.6f)  DaDx %08x (%8.6f)\n",
           (int)DbDx, RGBA2F32(DbDx), (int)DaDx, RGBA2F32(DaDx));
    PRINTF("\n");

    PRINTF("\t\tDrDy %08x (%8.6f)  DgDy %08x (%8.6f)\n",
           (int)DrDy, RGBA2F32(DrDy), (int)DgDy, RGBA2F32(DgDy));
    PRINTF("\t\tDbDy %08x (%8.6f)  DaDy %08x (%8.6f)\n",
           (int)DbDy, RGBA2F32(DbDy), (int)DaDy, RGBA2F32(DaDy));
    PRINTF("\n");

    PRINTF("\t\tR0 %5.2f\tG0 %5.2f\tB0 %5.2f\tA0 %5.2f\n",
           RGBA2F32(red),
           RGBA2F32(green),
           RGBA2F32(blue),
           RGBA2F32(alpha));
    PRINTF("\t\tR1 %5.2f\tG1 %5.2f\tB1 %5.2f\tA1 %5.2f\n",
           get_shade_vert1(red, _ym, _yh, DrDe, _delxm, DrDx),
           get_shade_vert1(green, _ym, _yh, DgDe, _delxm, DgDx),
           get_shade_vert1(blue, _ym, _yh, DbDe, _delxm, DbDx),
           get_shade_vert1(alpha, _ym, _yh, DaDe, _delxm, DaDx));
    PRINTF("\t\tR2 %5.2f\tG2 %5.2f\tB2 %5.2f\tA2 %5.2f\n",
           get_shade_vert2(red, _yl, _yh, DrDe),
           get_shade_vert2(green, _yl, _yh, DgDe),
           get_shade_vert2(blue, _yl, _yh, DbDe),
           get_shade_vert2(alpha, _yl, _yh, DaDe));
    PRINTF("\n");

    RdpDl += 8;
}

static f32
get_txtr_vert1(f32 base, f32 ym, f32 yh, f32 dade, f32 delxm, f32 dadx)
{
    return (ST2F32(base) + (f32) ((int) ym - (int) yh) *
            ST2F32(dade) + (f32) delxm * ST2F32(dadx));
}

static f32
get_txtr_vert2(f32 base, f32 yl, f32 yh, f32 dade)
{
    return (ST2F32(base) + (f32) ((int) yl - (int) yh) * ST2F32(dade));
}

static f32
get_w_vert1(f32 base, f32 ym, f32 yh, f32 dade, f32 delxm, f32 dadx)
{
    return (W2F32(base) + (f32) ((int) ym - (int) yh) *
            W2F32(dade) + (f32) delxm * W2F32(dadx));
}

static f32
get_w_vert2(f32 base, f32 yl, f32 yh, f32 dade)
{
    return (W2F32(base) + (f32) ((int) yl - (int) yh) * W2F32(dade));
}

static void
dump_txtr_coef(void)
{
    u16            *buffer;
    s32             s,
                    t,
                    w;
    s32             dxs,
                    dxt,
                    dxw;
    s32             des,
                    det,
                    dew;
    s32             dys,
                    dyt,
                    dyw;

    buffer = (u16 *) RdpDl;

    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];

    PRINTF("\n\t    Texture coefficients:\n");
    PRINTF("\t\tS    %08x (%8.6f)  T    %08x (%8.6f)\n",
           (int)s, ST2F32(s), (int)t, ST2F32(t));
    PRINTF("\t\tdSdE %08x (%8.6f)  dTdE %08x (%8.6f)\n",
           (int)des, ST2F32(des), (int)det, ST2F32(det));
    PRINTF("\t\tdSdX %08x (%8.6f)  dTdX %08x (%8.6f)\n",
           (int)dxs, ST2F32(dxs), (int)dxt, ST2F32(dxt));
    PRINTF("\t\tdSdY %08x (%8.6f)  dTdY %08x (%8.6f)\n",
           (int)dys, ST2F32(dys), (int)dyt, ST2F32(dyt));
    PRINTF("\n");

    PRINTF("\t\tW    %08x (%8.6f)\n", (int)w, W2F32(w));
    PRINTF("\t\tdWdE %08x (%8.6f)\n", (int)dew, W2F32(dew));
    PRINTF("\t\tdWdX %08x (%8.6f)\n", (int)dxw, W2F32(dxw));
    PRINTF("\t\tdWdY %08x (%8.6f)\n", (int)dyw, W2F32(dyw));
    PRINTF("\n");

    PRINTF("\t\tS0 %5.2f\tT0 %5.2f\tW0 %9.6f\n",
           ST2F32(s), ST2F32(t), ST2F32(w));
    PRINTF("\t\tS1 %5.2f\tT1 %5.2f\tW1 %9.6f\n",
           get_txtr_vert1(s, _ym, _yh, des, _delxm, dxs),
           get_txtr_vert1(t, _ym, _yh, det, _delxm, dxt),
           get_w_vert1(w, _ym, _yh, dew, _delxm, dxw));
    PRINTF("\t\tS2 %5.2f\tT2 %5.2f\tW2 %9.6f\n",
           get_txtr_vert2(s, _yl, _yh, des),
           get_txtr_vert2(t, _yl, _yh, det),
           get_w_vert2(w, _yl, _yh, dew));
    PRINTF("\n");

    RdpDl += 8;
}

f32
get_z_vert1(f32 base, f32 ym, f32 yh, f32 dade, f32 delxm, f32 dadx)
{
    return (Z2F32(base) + (f32) ((int) ym - (int) yh) *
            Z2F32(dade) + (f32) delxm * Z2F32(dadx));
}

f32
get_z_vert2(f32 base, f32 yl, f32 yh, f32 dade)
{
    return (Z2F32(base) + (f32) ((int) yl - (int) yh) * Z2F32(dade));
}

static void
dump_zbuff_coef(void)
{
    u32            *buffer;
    s32             z,
                    dxz,
                    dez,
                    dyz;

    buffer = (u32 *) RdpDl;

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

    PRINTF("\n\t    Z-buffer coefficients:\n");
    PRINTF("\t\tZ    %08x (%8.6f)\n", (int)z, Z2F32(z));
    PRINTF("\t\tdZdE %08x (%8.6f)\n", (int)dez, Z2F32(dez));
    PRINTF("\t\tdZdX %08x (%8.6f)\n", (int)dxz, Z2F32(dxz));
    PRINTF("\t\tdZdY %08x (%8.6f)\n", (int)dyz, Z2F32(dyz));
    PRINTF("\n");

    PRINTF("\t\tZ0 %8.6f\n", Z2F32(z));
    PRINTF("\t\tZ1 %8.6f\n", get_z_vert1(z, _ym, _yh, dez, _delxm, dxz));
    PRINTF("\t\tZ2 %8.6f\n", get_z_vert2(z, _yl, _yh, dez));
    PRINTF("\n");

    RdpDl += 2;
}

static void
dump_tri_fill(u64 word0)
{
    dump_command("G_TRI_FILL", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
}

static void
dump_tri_shade(u64 word0)
{
    dump_command("G_TRI_SHADE", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_shade_coef();
}

static void
dump_tri_txtr(u64 word0)
{
    dump_command("G_TRI_TXTR", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_txtr_coef();
}

static void
dump_tri_shade_txtr(u64 word0)
{
    dump_command("G_TRI_SHADE_TXTR", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_shade_coef();
    dump_txtr_coef();
}

static void
dump_tri_fill_zbuff(u64 word0)
{
    dump_command("G_TRI_FILL_ZBUFF", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_zbuff_coef();
}

static void
dump_tri_shade_zbuff(u64 word0)
{
    dump_command("G_TRI_SHADE_ZBUFF", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_shade_coef();
    dump_zbuff_coef();
}

static void
dump_tri_txtr_zbuff(u64 word0)
{
    dump_command("G_TRI_TXTR_ZBUFF", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_txtr_coef();
    dump_zbuff_coef();
}

static void
dump_tri_shade_txtr_zbuff(u64 word0)
{
    dump_command("G_TRI_SHADE_TXTR_ZBUFF", word0);
    PRINTF("\t\tprim #%04d\n", (int)NumPrimitives++);
    dump_edge_coef(word0);
    dump_shade_coef();
    dump_txtr_coef();
    dump_zbuff_coef();
}

/*
 * Parse and dump a RDP-type display list command.
 */
void
read_rdp(u64 word0)
{
    u8              op;

    /*
     *  Command ID
     */
    op = (u8) ((word0 & 0xff00000000000000LLU) >> 56);

    /*
     *  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 = ((word0 & 0x0000000007000000LLU) >> 24);
    else if (is_tri_cmd(op))
        SyncW.pc[SyncW.curr_cmd].tile = ((word0 & 0x0007000000000000LLU) >> 48);
    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, error checking of each command
     */
    switch (op) {

        case G_SETCIMG:
            dump_setcimg(word0);
            break;

        case G_SETZIMG:
            dump_setzimg(word0);
            break;

        case G_SETTIMG:
            dump_settimg(word0);
            break;

        case G_SETCOMBINE:
            dump_setcombine(word0);
            break;

        case G_SETENVCOLOR:
            dump_setenvcolor(word0);
            break;

        case G_SETPRIMCOLOR:
            dump_setprimcolor(word0);
            break;

        case G_SETBLENDCOLOR:
            dump_setblendcolor(word0);
            break;

        case G_SETFOGCOLOR:
            dump_setfogcolor(word0);
            break;

        case G_SETFILLCOLOR:
            dump_setfillcolor(word0);
            break;

        case G_FILLRECT:
            dump_fillrect(word0);
            break;

        case G_SETTILE:
            dump_settile(word0);
            break;

        case G_LOADTILE:
            dump_loadtile(word0);
            break;

        case G_LOADBLOCK:
            dump_loadblock(word0);
            break;

        case G_SETTILESIZE:
            dump_settilesize(word0);
            break;

        case G_LOADTLUT:
            dump_loadtlut(word0);
            break;

        case G_RDPSETOTHERMODE:
            dump_setothermode(word0);
            break;

        case G_SETPRIMDEPTH:
            dump_setprimdepth(word0);
            break;

        case G_SETSCISSOR:
            dump_setscissor(word0);
            break;

        case G_SETCONVERT:
            dump_setconvert(word0);
            break;

        case G_SETKEYR:
            dump_setkeyr(word0);
            break;

        case G_SETKEYGB:
            dump_setkeygb(word0);
            break;

        case G_RDPFULLSYNC:
            dump_fullsync(word0);
            break;

        case G_RDPTILESYNC:
            dump_tilesync(word0);
            break;

        case G_RDPPIPESYNC:
            dump_pipesync(word0);
            break;

        case G_RDPLOADSYNC:
            dump_loadsync(word0);
            break;

        case G_NOOP:
            dump_noop(word0);
            break;

        case G_TEXRECTFLIP:
            dump_texrectflip(word0);
            break;

        case G_TEXRECT:
            dump_texrect(word0);
            break;

        case G_TRI_FILL:
            dump_tri_fill(word0);
            break;

        case G_TRI_SHADE:
            dump_tri_shade(word0);
            break;

        case G_TRI_TXTR:
            dump_tri_txtr(word0);
            break;

        case G_TRI_SHADE_TXTR:
            dump_tri_shade_txtr(word0);
            break;

        case G_TRI_FILL_ZBUFF:
            dump_tri_fill_zbuff(word0);
            break;

        case G_TRI_SHADE_ZBUFF:
            dump_tri_shade_zbuff(word0);
            break;

        case G_TRI_TXTR_ZBUFF:
            dump_tri_txtr_zbuff(word0);
            break;

        case G_TRI_SHADE_TXTR_ZBUFF:
            dump_tri_shade_txtr_zbuff(word0);
            break;

        default:
            PRINTF("\tUNKNOWN %02x ", op);
            PRINTF("\t\t\t%016llx\n", word0);
            PRINTF("\n\t\t** ERROR, unknown command\n");
            nErrors++;
            nAttClocks++;
            RdpDl++;
            break;
    }

    PRINTF("\n");
}

void DumpRdpDL(u32* rdp_dl, u32 nbytes)
{
    u32   curInts = 0;
    u32   numInts = nbytes >> 2;

    while(curInts < numInts)
    {
      PRINTF("%05d: 0x",(int)curInts >> 1);   
      PRINTF("%08x", (int)rdp_dl[curInts]);
      PRINTF("%08x \n", (int)rdp_dl[curInts+1]);
      curInts += 2;
    }
}

/*
 * external interface to rdp display list dump
 */
void ParseRdpDL(u64 *rdp_dl, u32 nbytes, u8 flags)
{
    f32             total_clks;
    u32             ncommands,
                    nwords;

    ncommands = 0;
    nwords = nbytes / sizeof(u64);

    do_verbose = flags & GU_PARSERDP_VERBOSE;
    do_pr_area = flags & GU_PARSERDP_PRAREA;
    do_pr_histo = flags & GU_PARSERDP_PRHISTO;
    if(flags & GU_PARSERDP_DUMPONLY)
    {
        DumpRdpDL((u32*)rdp_dl,nbytes);
        return;
    }
    /*
     *  Global pointer, updated by function that parse commands
     */
    RdpDl = rdp_dl;

    PRINTF("%s\n", PR_SEPARATOR);

    while (RdpDl != (rdp_dl + nwords)) {
        read_rdp(*RdpDl);
        ++ncommands;
    }

    PRINTF("%s\n\n", PR_SEPARATOR);

    total_clks = nSyncClocks + nAttClocks + nPrimClocks + nLoadClocks;

    if (total_clks == 0)
        return;

    PRINTF("Number of Words in Display List:     %d\n", (int)nwords);
    PRINTF("Number of Commands in Display List:  %d\n", (int)ncommands);
    PRINTF("Number of Warnings:                  %d\n", (int)nWarnings);
    PRINTF("Number of Errors:                    %d\n\n", (int)nErrors);

    PRINTF("Number of Load Clocks (approx): Not Implemented\n");
    PRINTF("Number of Sync Clocks (approx):  %8d (%%%f)\n",
           (int)nSyncClocks, (f32) nSyncClocks / total_clks * 100.0);
    PRINTF("Number of Att  Clocks (approx):  %8d (%%%f)\n",
           (int)nAttClocks, (f32) nAttClocks / total_clks * 100.0);
    PRINTF("Number of Prim Clocks (approx):  %8d (%%%f)\n",
           (int)nPrimClocks, (f32) nPrimClocks / total_clks * 100.0);
    PRINTF("                                ----------\n");
    PRINTF("Number of Total Clocks (approx): %8d\n", (int) total_clks);

}