[pcsx_rearmed.git] / plugins / gpu_neon / psx_gpu / psx_gpu_main.c

/*
 * Copyright (C) 2011 Gilead Kutnick "Exophase" <exophase@gmail.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#include <stdio.h>
#include <stdlib.h>

#include "SDL.h"
#include "common.h"

#include "../../gpulib/gpu.h"
#include "psx_gpu.c"
#include "psx_gpu_parse.c"

#pragma GCC diagnostic ignored "-Wunused-result"

extern u32 span_pixels;
extern u32 span_pixel_blocks;
extern u32 spans;
extern u32 triangles;
extern u32 sprites;
extern u32 sprites_4bpp;
extern u32 sprites_8bpp;
extern u32 sprites_16bpp;
extern u32 sprites_untextured;
extern u32 sprite_blocks;
extern u32 lines;
extern u32 texels_4bpp;
extern u32 texels_8bpp;
extern u32 texels_16bpp;
extern u32 texel_blocks_4bpp;
extern u32 texel_blocks_8bpp;
extern u32 texel_blocks_16bpp;
extern u32 texel_blocks_untextured;
extern u32 blend_blocks;
extern u32 render_buffer_flushes;
extern u32 state_changes;
extern u32 trivial_rejects;
extern u32 left_split_triangles;
extern u32 flat_triangles;
extern u32 clipped_triangles;
extern u32 zero_block_spans;
extern u32 texture_cache_loads;
extern u32 false_modulated_blocks;

static u32 mismatches;

typedef struct
{
	u16 vram[1024 * 512];
	u32 gpu_register[15];
	u32 status;
} gpu_dump_struct;

static gpu_dump_struct state;

psx_gpu_struct __attribute__((aligned(256))) _psx_gpu;
u16 __attribute__((aligned(256))) _vram[(1024 * 512) + 1024];

#define percent_of(numerator, denominator)                                     \
  ((((double)(numerator)) / (denominator)) * 100.0)                            \

void clear_stats(void)
{
  triangles = 0;
  sprites = 0;
  sprites_4bpp = 0;
  sprites_8bpp = 0;
  sprites_16bpp = 0;
  sprites_untextured = 0;
  sprite_blocks = 0;
  lines = 0;
  span_pixels = 0;
  span_pixel_blocks = 0;
  spans = 0;
  texels_4bpp = 0;
  texels_8bpp = 0;
  texels_16bpp = 0;
  texel_blocks_untextured = 0;
  texel_blocks_4bpp = 0;
  texel_blocks_8bpp = 0;
  texel_blocks_16bpp = 0;
  blend_blocks = 0;
  render_buffer_flushes = 0;
  state_changes = 0;
  trivial_rejects = 0;
  left_split_triangles = 0;
  flat_triangles = 0;
  clipped_triangles = 0;
  zero_block_spans = 0;
  texture_cache_loads = 0;
  false_modulated_blocks = 0;
}

void update_screen(psx_gpu_struct *psx_gpu, SDL_Surface *screen)
{
  u32 x, y;

  for(y = 0; y < 512; y++)
  {
    for(x = 0; x < 1024; x++)
    {
      u32 pixel = psx_gpu->vram_ptr[(y * 1024) + x];
      ((u32 *)screen->pixels)[(y * 1024) + x] =
       ((pixel & 0x1F) << (16 + 3)) |
       (((pixel >> 5) & 0x1F) << (8 + 3)) |
       (((pixel >> 10) & 0x1F) << 3);
    }
  }

  SDL_Flip(screen);
}

#ifdef NEON_BUILD

#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
  
#endif

int main(int argc, char *argv[])
{
  psx_gpu_struct *psx_gpu = &_psx_gpu;
  SDL_Surface *screen = NULL;
  SDL_Event event;

  u32 *list;
  int size;
  FILE *state_file;
  FILE *list_file;
  u32 no_display = 0;
  s32 dummy0 = 0;
  s32 dummy1 = 0;
  u32 dummy2 = 0;

  if((argc != 3) && (argc != 4))
  {
    printf("usage:\n%s <state> <list>\n", argv[0]);
    return 1;
  }

  if((argc == 4) && !strcmp(argv[3], "-n"))
    no_display = 1;
  
  state_file = fopen(argv[1], "rb");
  fread(&state, 1, sizeof(gpu_dump_struct), state_file);
  fclose(state_file);
  
  list_file = fopen(argv[2], "rb");
  
  fseek(list_file, 0, SEEK_END);
  size = ftell(list_file);
  fseek(list_file, 0, SEEK_SET);
  //size = 0;

  list = malloc(size);
  fread(list, 1, size, list_file);
  fclose(list_file);
 
  if(no_display == 0) 
  {
    SDL_Init(SDL_INIT_EVERYTHING);
    screen = SDL_SetVideoMode(1024, 512, 32, 0);
    if (screen == 0)
    {
      printf("can't set video mode: %s\n", SDL_GetError());
      return 1;
    }
  }

#ifdef NEON_BUILD
  u16 *vram_ptr;
#if 0
  system("ofbset -fb /dev/fb1 -mem 6291456 -en 0");
  u32 fbdev_handle = open("/dev/fb1", O_RDWR);
  vram_ptr = (mmap((void *)0x50000000, 1024 * 1024 * 2, PROT_READ | PROT_WRITE,
   MAP_SHARED | 0xA0000000, fbdev_handle, 0));
#elif 0
  #ifndef MAP_HUGETLB
  #define MAP_HUGETLB 0x40000 /* arch specific */
  #endif
  vram_ptr = (mmap((void *)0x50000000, 1024 * 1024 * 2, PROT_READ | PROT_WRITE,
   MAP_ANONYMOUS | MAP_PRIVATE | MAP_HUGETLB, -1, 0));
#else
  vram_ptr = (mmap((void *)0x50000000, 1024 * 1024 * 2, PROT_READ | PROT_WRITE,
   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
#endif
  if (vram_ptr == MAP_FAILED)
  {
    perror("mmap");
    return 1;
  }
  vram_ptr += 64;

  initialize_psx_gpu(psx_gpu, vram_ptr);
#else
  initialize_psx_gpu(psx_gpu, _vram + 64);
#endif

#ifdef NEON_BUILD
  //triangle_benchmark(psx_gpu);
  //return 0;
#endif

  memcpy(psx_gpu->vram_ptr, state.vram, 1024 * 512 * 2);

  clear_stats();

#ifdef CYCLE_COUNTER
  init_counter();
#endif

  gpu_parse(psx_gpu, list, size, &dummy0, &dummy1, &dummy2);
  flush_render_block_buffer(psx_gpu);

  clear_stats();

#ifdef CYCLE_COUNTER
  u32 cycles = get_counter();
#endif

  gpu_parse(psx_gpu, list, size, &dummy0, &dummy1, &dummy2);
  flush_render_block_buffer(psx_gpu);

#ifdef CYCLE_COUNTER
  u32 cycles_elapsed = get_counter() - cycles;

  printf("%-64s: %d\n", argv[1], cycles_elapsed);
#else
  printf("%-64s: ", argv[1]);
#endif

#if 1
  u32 i;

  for(i = 0; i < 1024 * 512; i++)
  {
    if((psx_gpu->vram_ptr[i] & 0x7FFF) != (state.vram[i] & 0x7FFF))
    {
      printf("(%d %d %d) vs (%d %d %d) at (%d %d)\n",
       psx_gpu->vram_ptr[i] & 0x1F,
       (psx_gpu->vram_ptr[i] >> 5) & 0x1F,
       (psx_gpu->vram_ptr[i] >> 10) & 0x1F,
       state.vram[i] & 0x1F,
       (state.vram[i] >> 5) & 0x1F,
       (state.vram[i] >> 10) & 0x1F, i % 1024, i / 1024);

      mismatches++;
    }
    else
    {
      psx_gpu->vram_ptr[i] =
       ((psx_gpu->vram_ptr[i] & 0x1F) / 4) |
       ((((psx_gpu->vram_ptr[i] >> 5) & 0x1F) / 4) << 5) |
       ((((psx_gpu->vram_ptr[i] >> 10) & 0x1F) / 4) << 10);
    }
  }
#endif

#if 0
  printf("\n");
  printf("  %d pixels, %d pixel blocks, %d spans\n"
   "   (%lf pixels per block, %lf pixels per span),\n"
   "   %lf blocks per span (%lf per non-zero span), %lf overdraw)\n\n",
   span_pixels, span_pixel_blocks, spans,
   (double)span_pixels / span_pixel_blocks,
   (double)span_pixels / spans,
   (double)span_pixel_blocks / spans, 
   (double)span_pixel_blocks / (spans - zero_block_spans),
   (double)span_pixels / 
   ((psx_gpu->viewport_end_x - psx_gpu->viewport_start_x) * 
   (psx_gpu->viewport_end_y - psx_gpu->viewport_start_y)));

  printf("  %d triangles\n"
   "   (%d trivial rejects, %lf%% flat, %lf%% left split, %lf%% clipped)\n"
   "   (%lf pixels per triangle, %lf rows per triangle)\n\n",
   triangles, trivial_rejects,
   percent_of(flat_triangles, triangles),
   percent_of(left_split_triangles, triangles),
   percent_of(clipped_triangles, triangles),
   (double)span_pixels / triangles,
   (double)spans / triangles);

  printf("  Block data:\n");
  printf("   %7d 4bpp texel blocks  (%lf%%)\n", texel_blocks_4bpp,
   percent_of(texel_blocks_4bpp, span_pixel_blocks));
  printf("   %7d 8bpp texel blocks  (%lf%%)\n", texel_blocks_8bpp,
   percent_of(texel_blocks_8bpp, span_pixel_blocks));
  printf("   %7d 16bpp texel blocks (%lf%%)\n", texel_blocks_16bpp,
   percent_of(texel_blocks_16bpp, span_pixel_blocks));
  printf("   %7d untextured blocks  (%lf%%)\n", texel_blocks_untextured,
   percent_of(texel_blocks_untextured, span_pixel_blocks));
  printf("   %7d sprite blocks      (%lf%%)\n", sprite_blocks,  
   percent_of(sprite_blocks, span_pixel_blocks));
  printf("   %7d blended blocks     (%lf%%)\n", blend_blocks,
   percent_of(blend_blocks, span_pixel_blocks));
  printf("   %7d false-mod blocks   (%lf%%)\n", false_modulated_blocks,
   percent_of(false_modulated_blocks, span_pixel_blocks));
  printf("\n");
  printf("  %lf blocks per render buffer flush\n", (double)span_pixel_blocks /
   render_buffer_flushes);
  printf("  %d zero block spans\n", zero_block_spans);
  printf("  %d state changes, %d texture cache loads\n", state_changes,
   texture_cache_loads);
  if(sprites)
  {
    printf("  %d sprites\n"
     "    4bpp:       %lf%%\n"
     "    8bpp:       %lf%%\n"
     "    16bpp:      %lf%%\n"
     "    untextured: %lf%%\n",
     sprites, percent_of(sprites_4bpp, sprites),
     percent_of(sprites_8bpp, sprites), percent_of(sprites_16bpp, sprites),
     percent_of(sprites_untextured, sprites));
  }
  printf("  %d lines\n", lines);
  printf("\n");
  printf("  %d mismatches\n\n\n", mismatches);
#endif

  fflush(stdout);

  if(no_display == 0)
  {
    while(1)
    {
      update_screen(psx_gpu, screen);
  
      if(SDL_PollEvent(&event))
      {
        if((event.type == SDL_QUIT) ||
         ((event.type == SDL_KEYDOWN) &&
         (event.key.keysym.sym == SDLK_ESCAPE)))
        {
          break;
        }      
      }
  
      SDL_Delay(20);
    }
  }

  return (mismatches != 0);
}
Commit	Line	Data
75e28f62 E	1	/*
	2	* Copyright (C) 2011 Gilead Kutnick "Exophase" <exophase@gmail.com>
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License as
	6	* published by the Free Software Foundation; either version 2 of
	7	* the License, or (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* General Public License for more details.
	13	*/
	14
	15	#include <stdio.h>
	16	#include <stdlib.h>
	17
	18	#include "SDL.h"
	19	#include "common.h"
	20
df05223d	21	#include "../../gpulib/gpu.h"
	22	#include "psx_gpu.c"
	23	#include "psx_gpu_parse.c"
	24
	25	#pragma GCC diagnostic ignored "-Wunused-result"
	26
75e28f62 E	27	extern u32 span_pixels;
75e28f62 E	28	extern u32 span_pixel_blocks;
75e28f62 E	29	extern u32 spans;
	30	extern u32 triangles;
	31	extern u32 sprites;
	32	extern u32 sprites_4bpp;
	33	extern u32 sprites_8bpp;
	34	extern u32 sprites_16bpp;
	35	extern u32 sprites_untextured;
	36	extern u32 sprite_blocks;
	37	extern u32 lines;
	38	extern u32 texels_4bpp;
	39	extern u32 texels_8bpp;
	40	extern u32 texels_16bpp;
	41	extern u32 texel_blocks_4bpp;
	42	extern u32 texel_blocks_8bpp;
	43	extern u32 texel_blocks_16bpp;
	44	extern u32 texel_blocks_untextured;
	45	extern u32 blend_blocks;
75e28f62 E	46	extern u32 render_buffer_flushes;
	47	extern u32 state_changes;
	48	extern u32 trivial_rejects;
	49	extern u32 left_split_triangles;
	50	extern u32 flat_triangles;
	51	extern u32 clipped_triangles;
	52	extern u32 zero_block_spans;
	53	extern u32 texture_cache_loads;
3867c6ef	54	extern u32 false_modulated_blocks;
75e28f62 E	55
	56	static u32 mismatches;
	57
	58	typedef struct
	59	{
	60	u16 vram[1024 * 512];
	61	u32 gpu_register[15];
	62	u32 status;
	63	} gpu_dump_struct;
	64
	65	static gpu_dump_struct state;
	66
	67	psx_gpu_struct __attribute__((aligned(256))) _psx_gpu;
3867c6ef	68	u16 __attribute__((aligned(256))) _vram[(1024 * 512) + 1024];
75e28f62 E	69
	70	#define percent_of(numerator, denominator) \
	71	((((double)(numerator)) / (denominator)) * 100.0) \
	72
	73	void clear_stats(void)
	74	{
	75	triangles = 0;
	76	sprites = 0;
	77	sprites_4bpp = 0;
	78	sprites_8bpp = 0;
	79	sprites_16bpp = 0;
	80	sprites_untextured = 0;
	81	sprite_blocks = 0;
	82	lines = 0;
	83	span_pixels = 0;
	84	span_pixel_blocks = 0;
75e28f62 E	85	spans = 0;
	86	texels_4bpp = 0;
	87	texels_8bpp = 0;
	88	texels_16bpp = 0;
	89	texel_blocks_untextured = 0;
	90	texel_blocks_4bpp = 0;
	91	texel_blocks_8bpp = 0;
	92	texel_blocks_16bpp = 0;
	93	blend_blocks = 0;
75e28f62 E	94	render_buffer_flushes = 0;
	95	state_changes = 0;
	96	trivial_rejects = 0;
	97	left_split_triangles = 0;
	98	flat_triangles = 0;
	99	clipped_triangles = 0;
	100	zero_block_spans = 0;
	101	texture_cache_loads = 0;
3867c6ef	102	false_modulated_blocks = 0;
75e28f62 E	103	}
	104
	105	void update_screen(psx_gpu_struct psx_gpu, SDL_Surface screen)
	106	{
	107	u32 x, y;
	108
	109	for(y = 0; y < 512; y++)
	110	{
	111	for(x = 0; x < 1024; x++)
	112	{
	113	u32 pixel = psx_gpu->vram_ptr[(y * 1024) + x];
	114	((u32 )screen->pixels)[(y 1024) + x] =
	115	((pixel & 0x1F) << (16 + 3)) \|
	116	(((pixel >> 5) & 0x1F) << (8 + 3)) \|
	117	(((pixel >> 10) & 0x1F) << 3);
	118	}
	119	}
	120
	121	SDL_Flip(screen);
	122	}
	123
2bbbb7af	124	#ifdef NEON_BUILD
75e28f62 E	125
	126	#include <fcntl.h>
	127	#include <linux/fb.h>
	128	#include <sys/mman.h>
	129	#include <sys/ioctl.h>
	130
	131	#endif
	132
	133	int main(int argc, char *argv[])
	134	{
	135	psx_gpu_struct *psx_gpu = &_psx_gpu;
f82c6250	136	SDL_Surface *screen = NULL;
75e28f62 E	137	SDL_Event event;
	138
	139	u32 *list;
	140	int size;
	141	FILE *state_file;
	142	FILE *list_file;
	143	u32 no_display = 0;
90ac6fed	144	s32 dummy0 = 0;
52fb8909	145	s32 dummy1 = 0;
52fb8909	146	u32 dummy2 = 0;
75e28f62 E	147
	148	if((argc != 3) && (argc != 4))
	149	{
	150	printf("usage:\n%s <state> <list>\n", argv[0]);
	151	return 1;
	152	}
	153
	154	if((argc == 4) && !strcmp(argv[3], "-n"))
	155	no_display = 1;
	156
	157	state_file = fopen(argv[1], "rb");
	158	fread(&state, 1, sizeof(gpu_dump_struct), state_file);
	159	fclose(state_file);
	160
	161	list_file = fopen(argv[2], "rb");
	162
	163	fseek(list_file, 0, SEEK_END);
	164	size = ftell(list_file);
	165	fseek(list_file, 0, SEEK_SET);
	166	//size = 0;
3867c6ef	167
75e28f62 E	168	list = malloc(size);
	169	fread(list, 1, size, list_file);
	170	fclose(list_file);
	171
	172	if(no_display == 0)
	173	{
	174	SDL_Init(SDL_INIT_EVERYTHING);
	175	screen = SDL_SetVideoMode(1024, 512, 32, 0);
f82c6250	176	if (screen == 0)
	177	{
	178	printf("can't set video mode: %s\n", SDL_GetError());
	179	return 1;
	180	}
75e28f62	181	}
75e28f62	182
2bbbb7af	183	#ifdef NEON_BUILD
f82c6250	184	u16 *vram_ptr;
f82c6250	185	#if 0
75e28f62 E	186	system("ofbset -fb /dev/fb1 -mem 6291456 -en 0");
75e28f62 E	187	u32 fbdev_handle = open("/dev/fb1", O_RDWR);
3867c6ef	188	vram_ptr = (mmap((void )0x50000000, 1024 1024 * 2, PROT_READ \| PROT_WRITE,
75e28f62	189	MAP_SHARED \| 0xA0000000, fbdev_handle, 0));
52fb8909	190	#elif 0
f82c6250	191	#ifndef MAP_HUGETLB
	192	#define MAP_HUGETLB 0x40000 /* arch specific */
	193	#endif
	194	vram_ptr = (mmap((void )0x50000000, 1024 1024 * 2, PROT_READ \| PROT_WRITE,
	195	MAP_ANONYMOUS \| MAP_PRIVATE \| MAP_HUGETLB, -1, 0));
	196	#else
	197	vram_ptr = (mmap((void )0x50000000, 1024 1024 * 2, PROT_READ \| PROT_WRITE,
	198	MAP_ANONYMOUS \| MAP_PRIVATE, -1, 0));
	199	#endif
	200	if (vram_ptr == MAP_FAILED)
	201	{
	202	perror("mmap");
	203	return 1;
	204	}
3867c6ef	205	vram_ptr += 64;
75e28f62	206
87c45ad1	207	initialize_psx_gpu(psx_gpu, vram_ptr);
3867c6ef E	208	#else
	209	initialize_psx_gpu(psx_gpu, _vram + 64);
	210	#endif
75e28f62	211
2bbbb7af	212	#ifdef NEON_BUILD
75e28f62 E	213	//triangle_benchmark(psx_gpu);
	214	//return 0;
	215	#endif
	216
75e28f62	217	memcpy(psx_gpu->vram_ptr, state.vram, 1024 * 512 * 2);
75e28f62 E	218
	219	clear_stats();
	220
52fb8909	221	#ifdef CYCLE_COUNTER
75e28f62 E	222	init_counter();
	223	#endif
	224
52fb8909	225	gpu_parse(psx_gpu, list, size, &dummy0, &dummy1, &dummy2);
75e28f62 E	226	flush_render_block_buffer(psx_gpu);
	227
	228	clear_stats();
	229
52fb8909	230	#ifdef CYCLE_COUNTER
75e28f62 E	231	u32 cycles = get_counter();
	232	#endif
	233
52fb8909	234	gpu_parse(psx_gpu, list, size, &dummy0, &dummy1, &dummy2);
75e28f62 E	235	flush_render_block_buffer(psx_gpu);
75e28f62 E	236
52fb8909	237	#ifdef CYCLE_COUNTER
75e28f62 E	238	u32 cycles_elapsed = get_counter() - cycles;
75e28f62 E	239
87c45ad1 E	240	printf("%-64s: %d\n", argv[1], cycles_elapsed);
	241	#else
	242	printf("%-64s: ", argv[1]);
75e28f62 E	243	#endif
75e28f62 E	244
87c45ad1	245	#if 1
75e28f62 E	246	u32 i;
	247
	248	for(i = 0; i < 1024 * 512; i++)
	249	{
	250	if((psx_gpu->vram_ptr[i] & 0x7FFF) != (state.vram[i] & 0x7FFF))
	251	{
	252	printf("(%d %d %d) vs (%d %d %d) at (%d %d)\n",
	253	psx_gpu->vram_ptr[i] & 0x1F,
	254	(psx_gpu->vram_ptr[i] >> 5) & 0x1F,
	255	(psx_gpu->vram_ptr[i] >> 10) & 0x1F,
	256	state.vram[i] & 0x1F,
	257	(state.vram[i] >> 5) & 0x1F,
	258	(state.vram[i] >> 10) & 0x1F, i % 1024, i / 1024);
	259
	260	mismatches++;
	261	}
	262	else
	263	{
	264	psx_gpu->vram_ptr[i] =
	265	((psx_gpu->vram_ptr[i] & 0x1F) / 4) \|
	266	((((psx_gpu->vram_ptr[i] >> 5) & 0x1F) / 4) << 5) \|
	267	((((psx_gpu->vram_ptr[i] >> 10) & 0x1F) / 4) << 10);
	268	}
	269	}
	270	#endif
75e28f62	271
87c45ad1	272	#if 0
75e28f62	273	printf("\n");
3867c6ef E	274	printf(" %d pixels, %d pixel blocks, %d spans\n"
3867c6ef E	275	" (%lf pixels per block, %lf pixels per span),\n"
75e28f62	276	" %lf blocks per span (%lf per non-zero span), %lf overdraw)\n\n",
3867c6ef	277	span_pixels, span_pixel_blocks, spans,
75e28f62	278	(double)span_pixels / span_pixel_blocks,
75e28f62 E	279	(double)span_pixels / spans,
	280	(double)span_pixel_blocks / spans,
	281	(double)span_pixel_blocks / (spans - zero_block_spans),
	282	(double)span_pixels /
	283	((psx_gpu->viewport_end_x - psx_gpu->viewport_start_x) *
	284	(psx_gpu->viewport_end_y - psx_gpu->viewport_start_y)));
	285
3867c6ef	286	printf(" %d triangles\n"
75e28f62 E	287	" (%d trivial rejects, %lf%% flat, %lf%% left split, %lf%% clipped)\n"
75e28f62 E	288	" (%lf pixels per triangle, %lf rows per triangle)\n\n",
3867c6ef	289	triangles, trivial_rejects,
75e28f62 E	290	percent_of(flat_triangles, triangles),
	291	percent_of(left_split_triangles, triangles),
	292	percent_of(clipped_triangles, triangles),
	293	(double)span_pixels / triangles,
	294	(double)spans / triangles);
	295
	296	printf(" Block data:\n");
	297	printf(" %7d 4bpp texel blocks (%lf%%)\n", texel_blocks_4bpp,
	298	percent_of(texel_blocks_4bpp, span_pixel_blocks));
	299	printf(" %7d 8bpp texel blocks (%lf%%)\n", texel_blocks_8bpp,
	300	percent_of(texel_blocks_8bpp, span_pixel_blocks));
	301	printf(" %7d 16bpp texel blocks (%lf%%)\n", texel_blocks_16bpp,
	302	percent_of(texel_blocks_16bpp, span_pixel_blocks));
	303	printf(" %7d untextured blocks (%lf%%)\n", texel_blocks_untextured,
	304	percent_of(texel_blocks_untextured, span_pixel_blocks));
	305	printf(" %7d sprite blocks (%lf%%)\n", sprite_blocks,
	306	percent_of(sprite_blocks, span_pixel_blocks));
	307	printf(" %7d blended blocks (%lf%%)\n", blend_blocks,
	308	percent_of(blend_blocks, span_pixel_blocks));
3867c6ef E	309	printf(" %7d false-mod blocks (%lf%%)\n", false_modulated_blocks,
3867c6ef E	310	percent_of(false_modulated_blocks, span_pixel_blocks));
75e28f62 E	311	printf("\n");
	312	printf(" %lf blocks per render buffer flush\n", (double)span_pixel_blocks /
	313	render_buffer_flushes);
	314	printf(" %d zero block spans\n", zero_block_spans);
	315	printf(" %d state changes, %d texture cache loads\n", state_changes,
	316	texture_cache_loads);
	317	if(sprites)
	318	{
	319	printf(" %d sprites\n"
	320	" 4bpp: %lf%%\n"
	321	" 8bpp: %lf%%\n"
	322	" 16bpp: %lf%%\n"
	323	" untextured: %lf%%\n",
	324	sprites, percent_of(sprites_4bpp, sprites),
	325	percent_of(sprites_8bpp, sprites), percent_of(sprites_16bpp, sprites),
	326	percent_of(sprites_untextured, sprites));
	327	}
f9248bbf	328	printf(" %d lines\n", lines);
75e28f62 E	329	printf("\n");
	330	printf(" %d mismatches\n\n\n", mismatches);
	331	#endif
	332
	333	fflush(stdout);
	334
	335	if(no_display == 0)
	336	{
	337	while(1)
	338	{
	339	update_screen(psx_gpu, screen);
	340
	341	if(SDL_PollEvent(&event))
	342	{
	343	if((event.type == SDL_QUIT) \|\|
	344	((event.type == SDL_KEYDOWN) &&
	345	(event.key.keysym.sym == SDLK_ESCAPE)))
	346	{
	347	break;
	348	}
	349	}
	350
	351	SDL_Delay(20);
	352	}
	353	}
	354
	355	return (mismatches != 0);
	356	}