plugins/gpu_neon/psx_gpu/psx_gpu_main.c

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