plugins/gpu_unai/gpu.cpp

   1 /***************************************************************************
   2 *   Copyright (C) 2010 PCSX4ALL Team                                      *
   3 *   Copyright (C) 2010 Unai                                               *
   4 *                                                                         *
   5 *   This program is free software; you can redistribute it and/or modify  *
   6 *   it under the terms of the GNU General Public License as published by  *
   7 *   the Free Software Foundation; either version 2 of the License, or     *
   8 *   (at your option) any later version.                                   *
   9 *                                                                         *
  10 *   This program is distributed in the hope that it will be useful,       *
  11 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13 *   GNU General Public License for more details.                          *
  14 *                                                                         *
  15 *   You should have received a copy of the GNU General Public License     *
  16 *   along with this program; if not, write to the                         *
  17 *   Free Software Foundation, Inc.,                                       *
  18 *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
  19 ***************************************************************************/
  20
  21 #include "port.h"
  22 #include "gpu.h"
  23 #include "profiler.h"
  24 #include "debug.h"
  25
  26 int skipCount = 2; /* frame skip (0,1,2,3...) */
  27 int skCount = 0; /* internal frame skip */
  28 int linesInterlace = 0;  /* internal lines interlace */
  29 int linesInterlace_user = 0; /* Lines interlace */
  30
  31 bool isSkip = false; /* skip frame (info coming from GPU) */
  32 bool wasSkip = false;
  33 bool skipFrame = false; /* skip frame (according to frame skip) */
  34 bool alt_fps = false; /* Alternative FPS algorithm */
  35 bool show_fps = false; /* Show FPS statistics */
  36
  37 bool isPAL = false; /* PAL video timing */
  38 bool progressInterlace_flag = false; /* Progressive interlace flag */
  39 bool progressInterlace = false; /* Progressive interlace option*/
  40 bool frameLimit = false; /* frames to wait */
  41
  42 bool light = true; /* lighting */
  43 bool blend = true; /* blending */
  44 bool FrameToRead = false; /* load image in progress */
  45 bool FrameToWrite = false; /* store image in progress */
  46 bool fb_dirty = false;
  47
  48 bool enableAbbeyHack = false; /* Abe's Odyssey hack */
  49
  50 u8 BLEND_MODE;
  51 u8 TEXT_MODE;
  52 u8 Masking;
  53
  54 u16 PixelMSB;
  55 u16 PixelData;
  56
  57 ///////////////////////////////////////////////////////////////////////////////
  58 //  GPU Global data
  59 ///////////////////////////////////////////////////////////////////////////////
  60
  61 ///////////////////////////////////////////////////////////////////////////////
  62 //  Dma Transfers info
  63 s32             px,py;
  64 s32             x_end,y_end;
  65 u16*  pvram;
  66
  67 u32 GP0;
  68 s32 PacketCount;
  69 s32 PacketIndex;
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72 //  Display status
  73 u32 DisplayArea   [6];
  74
  75 ///////////////////////////////////////////////////////////////////////////////
  76 //  Rasterizer status
  77 u32 TextureWindow [4];
  78 u32 DrawingArea   [4];
  79 u32 DrawingOffset [2];
  80
  81 ///////////////////////////////////////////////////////////////////////////////
  82 //  Rasterizer status
  83
  84 u16* TBA;
  85 u16* CBA;
  86
  87 ///////////////////////////////////////////////////////////////////////////////
  88 //  Inner Loops
  89 s32   u4, du4;
  90 s32   v4, dv4;
  91 s32   r4, dr4;
  92 s32   g4, dg4;
  93 s32   b4, db4;
  94 u32   lInc;
  95 u32   tInc, tMsk;
  96
  97 GPUPacket PacketBuffer;
  98 // FRAME_BUFFER_SIZE is defined in bytes; 512K is guard memory for out of range reads
  99 u16   GPU_FrameBuffer[(FRAME_BUFFER_SIZE+512*1024)/2] __attribute__((aligned(2048)));
 100 u32   GPU_GP1;
 101
 102 ///////////////////////////////////////////////////////////////////////////////
 103 //  Inner loop driver instanciation file
 104 #include "gpu_inner.h"
 105
 106 ///////////////////////////////////////////////////////////////////////////////
 107 //  GPU Raster Macros
 108 #define GPU_RGB16(rgb)        ((((rgb)&0xF80000)>>9)|(((rgb)&0xF800)>>6)|(((rgb)&0xF8)>>3))
 109
 110 #define GPU_EXPANDSIGN_POLY(x)  (((s32)(x)<<20)>>20)
 111 //#define GPU_EXPANDSIGN_POLY(x)  (((s32)(x)<<21)>>21)
 112 #define GPU_EXPANDSIGN_SPRT(x)  (((s32)(x)<<21)>>21)
 113
 114 //#define       GPU_TESTRANGE(x)      { if((u32)(x+1024) > 2047) return; }
 115 #define GPU_TESTRANGE(x)      { if ((x<-1023) || (x>1023)) return; }
 116
 117 #define GPU_SWAP(a,b,t) {(t)=(a);(a)=(b);(b)=(t);}
 118
 119 ///////////////////////////////////////////////////////////////////////////////
 120 // GPU internal image drawing functions
 121 #include "gpu_raster_image.h"
 122
 123 ///////////////////////////////////////////////////////////////////////////////
 124 // GPU internal line drawing functions
 125 #include "gpu_raster_line.h"
 126
 127 ///////////////////////////////////////////////////////////////////////////////
 128 // GPU internal polygon drawing functions
 129 #include "gpu_raster_polygon.h"
 130
 131 ///////////////////////////////////////////////////////////////////////////////
 132 // GPU internal sprite drawing functions
 133 #include "gpu_raster_sprite.h"
 134
 135 ///////////////////////////////////////////////////////////////////////////////
 136 // GPU command buffer execution/store
 137 #include "gpu_command.h"
 138
 139 ///////////////////////////////////////////////////////////////////////////////
 140 INLINE void gpuReset(void)
 141 {
 142         GPU_GP1 = 0x14802000;
 143         TextureWindow[0] = 0;
 144         TextureWindow[1] = 0;
 145         TextureWindow[2] = 255;
 146         TextureWindow[3] = 255;
 147         DrawingArea[2] = 256;
 148         DrawingArea[3] = 240;
 149         DisplayArea[2] = 256;
 150         DisplayArea[3] = 240;
 151         DisplayArea[5] = 240;
 152 }
 153
 154 ///////////////////////////////////////////////////////////////////////////////
 155 bool  GPU_init(void)
 156 {
 157         gpuReset();
 158
 159         // s_invTable
 160         for(int i=1;i<=(1<<TABLE_BITS);++i)
 161         {
 162                 double v = 1.0 / double(i);
 163                 #ifdef GPU_TABLE_10_BITS
 164                 v *= double(0xffffffff>>1);
 165                 #else
 166                 v *= double(0x80000000);
 167                 #endif
 168                 s_invTable[i-1]=s32(v);
 169         }
 170         return (0);
 171 }
 172
 173 ///////////////////////////////////////////////////////////////////////////////
 174 void  GPU_shutdown(void)
 175 {
 176 }
 177
 178 ///////////////////////////////////////////////////////////////////////////////
 179 long  GPU_freeze(unsigned int bWrite, GPUFreeze_t* p2)
 180 {
 181         if (!p2) return (0);
 182         if (p2->Version != 1) return (0);
 183
 184         if (bWrite)
 185         {
 186                 p2->GPU_gp1 = GPU_GP1;
 187                 memset(p2->Control, 0, sizeof(p2->Control));
 188                 // save resolution and registers for P.E.Op.S. compatibility
 189                 p2->Control[3] = (3 << 24) | ((GPU_GP1 >> 23) & 1);
 190                 p2->Control[4] = (4 << 24) | ((GPU_GP1 >> 29) & 3);
 191                 p2->Control[5] = (5 << 24) | (DisplayArea[0] | (DisplayArea[1] << 10));
 192                 p2->Control[6] = (6 << 24) | (2560 << 12);
 193                 p2->Control[7] = (7 << 24) | (DisplayArea[4] | (DisplayArea[5] << 10));
 194                 p2->Control[8] = (8 << 24) | ((GPU_GP1 >> 17) & 0x3f) | ((GPU_GP1 >> 10) & 0x40);
 195                 memcpy(p2->FrameBuffer, (u16*)GPU_FrameBuffer, FRAME_BUFFER_SIZE);
 196                 return (1);
 197         }
 198         else
 199         {
 200                 GPU_GP1 = p2->GPU_gp1;
 201                 memcpy((u16*)GPU_FrameBuffer, p2->FrameBuffer, FRAME_BUFFER_SIZE);
 202                 GPU_writeStatus((5 << 24) | p2->Control[5]);
 203                 GPU_writeStatus((7 << 24) | p2->Control[7]);
 204                 GPU_writeStatus((8 << 24) | p2->Control[8]);
 205                 gpuSetTexture(GPU_GP1);
 206                 return (1);
 207         }
 208         return (0);
 209 }
 210
 211 ///////////////////////////////////////////////////////////////////////////////
 212 //  GPU DMA comunication
 213
 214 ///////////////////////////////////////////////////////////////////////////////
 215 u8 PacketSize[256] =
 216 {
 217         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              0-15
 218         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              16-31
 219         3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, //              32-47
 220         5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11,     //      48-63
 221         2, 2, 2, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, //              64-79
 222         3, 3, 3, 3, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, //              80-95
 223         2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, //              96-111
 224         1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, //              112-127
 225         3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              128-
 226         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              144
 227         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //              160
 228         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
 229         2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
 230         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
 231         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
 232         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  //
 233 };
 234
 235 ///////////////////////////////////////////////////////////////////////////////
 236 INLINE void gpuSendPacket()
 237 {
 238 #ifdef DEBUG_ANALYSIS
 239         dbg_anacnt_GPU_sendPacket++;
 240 #endif
 241         gpuSendPacketFunction(PacketBuffer.U4[0]>>24);
 242 }
 243
 244 ///////////////////////////////////////////////////////////////////////////////
 245 INLINE void gpuCheckPacket(u32 uData)
 246 {
 247         if (PacketCount)
 248         {
 249                 PacketBuffer.U4[PacketIndex++] = uData;
 250                 --PacketCount;
 251         }
 252         else
 253         {
 254                 PacketBuffer.U4[0] = uData;
 255                 PacketCount = PacketSize[uData >> 24];
 256                 PacketIndex = 1;
 257         }
 258         if (!PacketCount) gpuSendPacket();
 259 }
 260
 261 ///////////////////////////////////////////////////////////////////////////////
 262 void  GPU_writeDataMem(u32* dmaAddress, s32 dmaCount)
 263 {
 264 #ifdef DEBUG_ANALYSIS
 265         dbg_anacnt_GPU_writeDataMem++;
 266 #endif
 267         pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
 268         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 269         u32 data;
 270         const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
 271         GPU_GP1 &= ~0x14000000;
 272
 273         while (dmaCount)
 274         {
 275                 if (FrameToWrite)
 276                 {
 277                         while (dmaCount)
 278                         {
 279                                 dmaCount--;
 280                                 data = *dmaAddress++;
 281                                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 282                                 pvram[px] = data;
 283                                 if (++px>=x_end)
 284                                 {
 285                                         px = 0;
 286                                         pvram += 1024;
 287                                         if (++py>=y_end)
 288                                         {
 289                                                 FrameToWrite = false;
 290                                                 GPU_GP1 &= ~0x08000000;
 291                                                 break;
 292                                         }
 293                                 }
 294                                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 295                                 pvram[px] = data>>16;
 296                                 if (++px>=x_end)
 297                                 {
 298                                         px = 0;
 299                                         pvram += 1024;
 300                                         if (++py>=y_end)
 301                                         {
 302                                                 FrameToWrite = false;
 303                                                 GPU_GP1 &= ~0x08000000;
 304                                                 break;
 305                                         }
 306                                 }
 307                         }
 308                 }
 309                 else
 310                 {
 311                         data = *dmaAddress++;
 312                         dmaCount--;
 313                         gpuCheckPacket(data);
 314                 }
 315         }
 316
 317         GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
 318         fb_dirty = true;
 319         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 320         pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
 321 }
 322
 323 u32 *lUsedAddr[3];
 324 INLINE int CheckForEndlessLoop(u32 *laddr)
 325 {
 326         if(laddr==lUsedAddr[1]) return 1;
 327         if(laddr==lUsedAddr[2]) return 1;
 328
 329         if(laddr<lUsedAddr[0]) lUsedAddr[1]=laddr;
 330         else                   lUsedAddr[2]=laddr;
 331         lUsedAddr[0]=laddr;
 332         return 0;
 333 }
 334
 335 ///////////////////////////////////////////////////////////////////////////////
 336 long GPU_dmaChain(u32* baseAddr, u32 dmaVAddr)
 337 {
 338 #ifdef DEBUG_ANALYSIS
 339         dbg_anacnt_GPU_dmaChain++;
 340 #endif
 341         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 342         u32 data, *address, count, offset;
 343         unsigned int DMACommandCounter = 0;
 344         long dma_words = 0;
 345
 346         GPU_GP1 &= ~0x14000000;
 347         lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=(u32*)0x1fffff;
 348         dmaVAddr &= 0x001FFFFF;
 349         while (dmaVAddr != 0x1FFFFF)
 350         {
 351                 address = (baseAddr + (dmaVAddr >> 2));
 352                 if(DMACommandCounter++ > 2000000) break;
 353                 if(CheckForEndlessLoop(address)) break;
 354                 data = *address++;
 355                 count = (data >> 24);
 356                 offset = data & 0x001FFFFF;
 357                 if (dmaVAddr != offset) dmaVAddr = offset;
 358                 else dmaVAddr = 0x1FFFFF;
 359
 360                 if(count>0) GPU_writeDataMem(address,count);
 361                 dma_words += 1 + count;
 362         }
 363         GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
 364         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 365
 366         return dma_words;
 367 }
 368
 369 ///////////////////////////////////////////////////////////////////////////////
 370 void  GPU_writeData(u32 data)
 371 {
 372         const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
 373 #ifdef DEBUG_ANALYSIS
 374         dbg_anacnt_GPU_writeData++;
 375 #endif
 376         pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
 377         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 378         GPU_GP1 &= ~0x14000000;
 379
 380         if (FrameToWrite)
 381         {
 382                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 383                 pvram[px]=(u16)data;
 384                 if (++px>=x_end)
 385                 {
 386                         px = 0;
 387                         pvram += 1024;
 388                         if (++py>=y_end)
 389                         {
 390                                 FrameToWrite = false;
 391                                 GPU_GP1 &= ~0x08000000;
 392                         }
 393                 }
 394                 if (FrameToWrite)
 395                 {
 396                         if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 397                         pvram[px]=data>>16;
 398                         if (++px>=x_end)
 399                         {
 400                                 px = 0;
 401                                 pvram += 1024;
 402                                 if (++py>=y_end)
 403                                 {
 404                                         FrameToWrite = false;
 405                                         GPU_GP1 &= ~0x08000000;
 406                                 }
 407                         }
 408                 }
 409         }
 410         else
 411         {
 412                 gpuCheckPacket(data);
 413         }
 414         GPU_GP1 |= 0x14000000;
 415         fb_dirty = true;
 416         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 417         pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
 418
 419 }
 420
 421
 422 ///////////////////////////////////////////////////////////////////////////////
 423 void  GPU_readDataMem(u32* dmaAddress, s32 dmaCount)
 424 {
 425         const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
 426 #ifdef DEBUG_ANALYSIS
 427         dbg_anacnt_GPU_readDataMem++;
 428 #endif
 429         if(!FrameToRead) return;
 430
 431         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 432         GPU_GP1 &= ~0x14000000;
 433         do
 434         {
 435                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 436                 // lower 16 bit
 437                 u32 data = (unsigned long)pvram[px];
 438
 439                 if (++px>=x_end)
 440                 {
 441                         px = 0;
 442                         pvram += 1024;
 443                 }
 444
 445                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 446                 // higher 16 bit (always, even if it's an odd width)
 447                 data |= (unsigned long)(pvram[px])<<16;
 448
 449                 *dmaAddress++ = data;
 450
 451                 if (++px>=x_end)
 452                 {
 453                         px = 0;
 454                         pvram += 1024;
 455                         if (++py>=y_end)
 456                         {
 457                                 FrameToRead = false;
 458                                 GPU_GP1 &= ~0x08000000;
 459                                 break;
 460                         }
 461                 }
 462         } while (--dmaCount);
 463
 464         GPU_GP1 = (GPU_GP1 | 0x14000000) & ~0x60000000;
 465         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 466 }
 467
 468
 469
 470 ///////////////////////////////////////////////////////////////////////////////
 471 u32  GPU_readData(void)
 472 {
 473         const u16 *VIDEO_END=(GPU_FrameBuffer+(FRAME_BUFFER_SIZE/2)-1);
 474 #ifdef DEBUG_ANALYSIS
 475         dbg_anacnt_GPU_readData++;
 476 #endif
 477         pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
 478         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_READ);
 479         GPU_GP1 &= ~0x14000000;
 480         if (FrameToRead)
 481         {
 482                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 483                 GP0 = pvram[px];
 484                 if (++px>=x_end)
 485                 {
 486                         px = 0;
 487                         pvram += 1024;
 488                         if (++py>=y_end)
 489                         {
 490                                 FrameToRead = false;
 491                                 GPU_GP1 &= ~0x08000000;
 492                         }
 493                 }
 494                 if ((&pvram[px])>(VIDEO_END)) pvram-=512*1024;
 495                 GP0 |= pvram[px]<<16;
 496                 if (++px>=x_end)
 497                 {
 498                         px = 0;
 499                         pvram +=1024;
 500                         if (++py>=y_end)
 501                         {
 502                                 FrameToRead = false;
 503                                 GPU_GP1 &= ~0x08000000;
 504                         }
 505                 }
 506
 507         }
 508         GPU_GP1 |= 0x14000000;
 509
 510         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_READ);
 511         pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
 512         return (GP0);
 513 }
 514
 515 ///////////////////////////////////////////////////////////////////////////////
 516 u32     GPU_readStatus(void)
 517 {
 518 #ifdef DEBUG_ANALYSIS
 519         dbg_anacnt_GPU_readStatus++;
 520 #endif
 521         return GPU_GP1;
 522 }
 523
 524 ///////////////////////////////////////////////////////////////////////////////
 525 void  GPU_writeStatus(u32 data)
 526 {
 527 #ifdef DEBUG_ANALYSIS
 528         dbg_anacnt_GPU_writeStatus++;
 529 #endif
 530         pcsx4all_prof_pause(PCSX4ALL_PROF_CPU);
 531         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 532         switch (data >> 24) {
 533         case 0x00:
 534                 gpuReset();
 535                 break;
 536         case 0x01:
 537                 GPU_GP1 &= ~0x08000000;
 538                 PacketCount = 0; FrameToRead = FrameToWrite = false;
 539                 break;
 540         case 0x02:
 541                 GPU_GP1 &= ~0x08000000;
 542                 PacketCount = 0; FrameToRead = FrameToWrite = false;
 543                 break;
 544         case 0x03:
 545                 GPU_GP1 = (GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
 546                 break;
 547         case 0x04:
 548                 if (data == 0x04000000)
 549                 PacketCount = 0;
 550                 GPU_GP1 = (GPU_GP1 & ~0x60000000) | ((data & 3) << 29);
 551                 break;
 552         case 0x05:
 553                 DisplayArea[0] = (data & 0x000003FF); //(short)(data & 0x3ff);
 554                 DisplayArea[1] = ((data & 0x0007FC00)>>10); //(data & 0x000FFC00) >> 10; //(short)((data>>10)&0x1ff);
 555                 fb_dirty = true;
 556                 wasSkip = isSkip;
 557                 if (isSkip)
 558                         isSkip = false;
 559                 else
 560                         isSkip = skipFrame;
 561                 break;
 562         case 0x07:
 563                 DisplayArea[4] = data & 0x000003FF; //(short)(data & 0x3ff);
 564                 DisplayArea[5] = (data & 0x000FFC00) >> 10; //(short)((data>>10) & 0x3ff);
 565                 fb_dirty = true;
 566                 break;
 567         case 0x08:
 568                 {
 569                         GPU_GP1 = (GPU_GP1 & ~0x007F0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
 570                         static u32 HorizontalResolution[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
 571                         DisplayArea[2] = HorizontalResolution[(GPU_GP1 >> 16) & 7];
 572                         static u32 VerticalResolution[4] = { 240, 480, 256, 480 };
 573                         DisplayArea[3] = VerticalResolution[(GPU_GP1 >> 19) & 3];
 574                         isPAL = (data & 0x08) ? true : false; // if 1 - PAL mode, else NTSC
 575                 }
 576                 fb_dirty = true;
 577                 break;
 578         case 0x10:
 579                 switch (data & 0xffff) {
 580                 case 0:
 581                 case 1:
 582                 case 3:
 583                         GP0 = (DrawingArea[1] << 10) | DrawingArea[0];
 584                         break;
 585                 case 4:
 586                         GP0 = ((DrawingArea[3]-1) << 10) | (DrawingArea[2]-1);
 587                         break;
 588                 case 6:
 589                 case 5:
 590                         GP0 = (DrawingOffset[1] << 11) | DrawingOffset[0];
 591                         break;
 592                 case 7:
 593                         GP0 = 2;
 594                         break;
 595                 default:
 596                         GP0 = 0;
 597                 }
 598                 break;
 599         }
 600         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_HW_WRITE);
 601         pcsx4all_prof_resume(PCSX4ALL_PROF_CPU);
 602 }
 603
 604 #ifndef REARMED
 605
 606 // Blitting functions
 607 #include "gpu_blit.h"
 608
 609 INLINE void gpuVideoOutput(void)
 610 {
 611         static s16 old_res_horz, old_res_vert, old_rgb24;
 612         s16 h0, x0, y0, w0, h1;
 613
 614         x0 = DisplayArea[0];
 615         y0 = DisplayArea[1];
 616
 617         w0 = DisplayArea[2];
 618         h0 = DisplayArea[3];  // video mode
 619
 620         h1 = DisplayArea[5] - DisplayArea[4]; // display needed
 621         if (h0 == 480) h1 = Min2(h1*2,480);
 622
 623         u16* dest_screen16 = SCREEN;
 624         u16* src_screen16  = &((u16*)GPU_FrameBuffer)[FRAME_OFFSET(x0,y0)];
 625         u32 isRGB24 = (GPU_GP1 & 0x00200000 ? 32 : 0);
 626
 627         /* Clear the screen if resolution changed to prevent interlacing and clipping to clash */
 628         if( (w0 != old_res_horz || h1 != old_res_vert || (s16)isRGB24 != old_rgb24) )
 629         {
 630                 // Update old resolution
 631                 old_res_horz = w0;
 632                 old_res_vert = h1;
 633                 old_rgb24 = (s16)isRGB24;
 634                 // Finally, clear the screen for this special case
 635                 video_clear();
 636         }
 637
 638         //  Height centering
 639         int sizeShift = 1;
 640         if(h0==256) h0 = 240; else if(h0==480) sizeShift = 2;
 641         if(h1>h0) { src_screen16 += ((h1-h0)>>sizeShift)*1024; h1 = h0; }
 642         else if(h1<h0) dest_screen16 += ((h0-h1)>>sizeShift)*VIDEO_WIDTH;
 643
 644         /* Main blitter */
 645         int incY = (h0==480) ? 2 : 1;
 646         h0=(h0==480 ? 2048 : 1024);
 647
 648         {
 649                 const int li=linesInterlace;
 650                 bool pi=progressInterlace;
 651                 bool pif=progressInterlace_flag;
 652                 switch ( w0 )
 653                 {
 654                         case 256:
 655                                 for(int y1=y0+h1; y0<y1; y0+=incY)
 656                                 {
 657                                         if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWDWW(    src_screen16,   dest_screen16, isRGB24);
 658                                         dest_screen16 += VIDEO_WIDTH;
 659                                         src_screen16  += h0;
 660                                 }
 661                                 break;
 662                         case 368:
 663                                 for(int y1=y0+h1; y0<y1; y0+=incY)
 664                                 {
 665                                         if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWWWWWWWS(        src_screen16,   dest_screen16, isRGB24, 4);
 666                                         dest_screen16 += VIDEO_WIDTH;
 667                                         src_screen16  += h0;
 668                                 }
 669                                 break;
 670                         case 320:
 671                                 for(int y1=y0+h1; y0<y1; y0+=incY)
 672                                 {
 673                                         if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWW(       src_screen16,   dest_screen16, isRGB24);
 674                                         dest_screen16 += VIDEO_WIDTH;
 675                                         src_screen16  += h0;
 676                                 }
 677                                 break;
 678                         case 384:
 679                                 for(int y1=y0+h1; y0<y1; y0+=incY)
 680                                 {
 681                                         if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWWWWS(   src_screen16,   dest_screen16, isRGB24);
 682                                         dest_screen16 += VIDEO_WIDTH;
 683                                         src_screen16  += h0;
 684                                 }
 685                                 break;
 686                         case 512:
 687                                 for(int y1=y0+h1; y0<y1; y0+=incY)
 688                                 {
 689                                         if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWWSWWSWS( src_screen16, dest_screen16, isRGB24);
 690                                         dest_screen16 += VIDEO_WIDTH;
 691                                         src_screen16  += h0;
 692                                 }
 693                                 break;
 694                         case 640:
 695                                 for(int y1=y0+h1; y0<y1; y0+=incY)
 696                                 {
 697                                         if(( 0 == (y0&li) ) && ((!pi) || (pif=!pif))) GPU_BlitWS(       src_screen16, dest_screen16, isRGB24);
 698                                         dest_screen16 += VIDEO_WIDTH;
 699                                         src_screen16  += h0;
 700                                 }
 701                                 break;
 702                 }
 703                 progressInterlace_flag=!progressInterlace_flag;
 704         }
 705         video_flip();
 706 }
 707
 708 ///////////////////////////////////////////////////////////////////////////////
 709 void  GPU_updateLace(void)
 710 {
 711 #ifdef  ENABLE_GPU_LOG_SUPPORT
 712         fprintf(stdout,"GPU_updateLace()\n");
 713 #endif
 714 #ifdef DEBUG_ANALYSIS
 715         dbg_anacnt_GPU_updateLace++;
 716 #endif
 717         pcsx4all_prof_start_with_pause(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS);
 718 #ifdef PROFILER_PCSX4ALL
 719         pcsx4all_prof_frames++;
 720 #endif
 721 #ifdef DEBUG_FRAME
 722         if(isdbg_frame())
 723         {
 724                 static int passed=0;
 725                 if (!passed) dbg_enable();
 726                 else pcsx4all_exit();
 727                 passed++;
 728         }
 729 #endif
 730
 731         // Frame skip table
 732         static const unsigned char skipTable[12][12] =
 733         {
 734                 { 0,0,0,0,0,0,0,0,0,0,0,0 },
 735                 { 0,0,0,0,0,0,0,0,0,0,0,1 },
 736                 { 0,0,0,0,0,1,0,0,0,0,0,1 },
 737                 { 0,0,0,1,0,0,0,1,0,0,0,1 },
 738                 { 0,0,1,0,0,1,0,0,1,0,0,1 },
 739                 { 0,1,0,0,1,0,1,0,0,1,0,1 },
 740                 { 0,1,0,1,0,1,0,1,0,1,0,1 },
 741                 { 0,1,0,1,1,0,1,0,1,1,0,1 },
 742                 { 0,1,1,0,1,1,0,1,1,0,1,1 },
 743                 { 0,1,1,1,0,1,1,1,0,1,1,1 },
 744                 { 0,1,1,1,1,1,0,1,1,1,1,1 },
 745                 { 0,1,1,1,1,1,1,1,1,1,1,1 }
 746         };
 747
 748         // Interlace bit toggle
 749         GPU_GP1 ^= 0x80000000;
 750
 751         // Update display
 752         if ((!skipFrame) && (!isSkip) && (fb_dirty) && (!(((GPU_GP1&0x08000000))||((GPU_GP1&0x00800000)))))
 753         {
 754                 gpuVideoOutput(); // Display updated
 755
 756                 if (DisplayArea[3] == 480)
 757                 {
 758                         if (linesInterlace_user) linesInterlace = 3; // 1/4 of lines
 759                         else linesInterlace = 1; // if 480 we only need half of lines
 760                 }
 761                 else if (linesInterlace != linesInterlace_user)
 762                 {
 763                         linesInterlace = linesInterlace_user; // resolution changed from 480 to lower one
 764                         video_clear();
 765                 }
 766         }
 767
 768         // Limit FPS
 769         if (frameLimit)
 770         {
 771                 static unsigned next=get_ticks();
 772                 if (!skipFrame)
 773                 {
 774                         unsigned now=get_ticks();
 775                         if (now<next) wait_ticks(next-now);
 776                 }
 777                 next+=(isPAL?(1000000/50):((unsigned)(1000000.0/59.94)));
 778         }
 779
 780         // Show FPS statistics
 781         if (show_fps)
 782         {
 783                 static u32 real_fps=0;
 784                 static u32 prev=get_ticks();
 785                 static char msg[32]="FPS=000/00 SPD=000%";
 786                 u32 now=get_ticks();
 787                 real_fps++;
 788                 if ((now-prev)>=1000000)
 789                 {
 790                         u32 expected_fps=(isPAL?50:60);
 791                         sprintf(msg,"FPS=%3d/%2d SPD=%3d%%",((real_fps*(12-skipCount))/12),((expected_fps*(12-skipCount))/12),((real_fps*100)/expected_fps));
 792                         prev=now;
 793                         real_fps=0;
 794                 }
 795                 port_printf(5,5,msg);
 796         }
 797
 798         // Update frame-skip
 799         if (!alt_fps)
 800         {
 801                 // Video frame-skip
 802                 skipFrame=skipTable[skipCount][skCount];
 803                 skCount--; if (skCount<0) skCount=11;
 804                 isSkip=skipFrame;
 805         }
 806         else
 807         {
 808                 // Game frame-skip
 809                 if (!isSkip)
 810                 {
 811                         skipFrame=skipTable[skipCount][skCount];
 812                         skCount--; if (skCount<0) skCount=11;
 813                         isSkip=true;
 814                 }
 815         }
 816         fb_dirty=false;
 817
 818         pcsx4all_prof_end_with_resume(PCSX4ALL_PROF_GPU,PCSX4ALL_PROF_COUNTERS);
 819 }
 820
 821 #else
 822
 823 #include "../../frontend/plugin_lib.h"
 824 #include "../../frontend/cspace.h"
 825
 826 extern "C" {
 827
 828 static const struct rearmed_cbs *cbs;
 829 static void *screen_buf;
 830 static s16 old_res_horz, old_res_vert, old_rgb24;
 831
 832 static void blit(void)
 833 {
 834         u16 *base = (u16 *)GPU_FrameBuffer;
 835         s16 isRGB24 = (GPU_GP1 & 0x00200000) ? 1 : 0;
 836         s16 h0, x0, y0, w0, h1;
 837         u32 fb_offs;
 838         u8  *dest;
 839
 840         x0 = DisplayArea[0] & ~1; // alignment needed by blitter
 841         y0 = DisplayArea[1];
 842         fb_offs = FRAME_OFFSET(x0, y0);
 843
 844         w0 = DisplayArea[2];
 845         h0 = DisplayArea[3];  // video mode
 846
 847         h1 = DisplayArea[5] - DisplayArea[4]; // display needed
 848         if (h0 == 480) h1 = Min2(h1*2,480);
 849
 850         if (h1 <= 0)
 851                 return;
 852
 853         if (w0 != old_res_horz || h1 != old_res_vert || isRGB24 != old_rgb24)
 854         {
 855                 old_res_horz = w0;
 856                 old_res_vert = h1;
 857                 old_rgb24 = (s16)isRGB24;
 858                 screen_buf = cbs->pl_vout_set_mode(w0, h1, isRGB24 ? 24 : 16);
 859         }
 860         dest = (u8 *)screen_buf;
 861
 862         if (isRGB24)
 863         {
 864 #ifndef MAEMO
 865                 for (; h1-- > 0; dest += w0 * 3, fb_offs += 1024)
 866                 {
 867                         fb_offs &= 1024*512-1;
 868                         bgr888_to_rgb888(dest, base + fb_offs, w0 * 3);
 869                 }
 870 #else
 871                 for (; h1-- > 0; dest += w0 * 2, fb_offs += 1024)
 872                 {
 873                         fb_offs &= 1024*512-1;
 874                         bgr888_to_rgb565(dest, base + fb_offs, w0 * 3);
 875                 }
 876 #endif
 877         }
 878         else
 879         {
 880                 for (; h1-- > 0; dest += w0 * 2, fb_offs += 1024)
 881                 {
 882                         fb_offs &= 1024*512-1;
 883                         bgr555_to_rgb565(dest, base + fb_offs, w0 * 2);
 884                 }
 885         }
 886
 887         screen_buf = cbs->pl_vout_flip();
 888 }
 889
 890 static void blit_raw(void)
 891 {
 892         s16 isRGB24 = (GPU_GP1 & 0x00200000) ? 1 : 0;
 893         s16 h0, w0, h1;
 894
 895         w0 = DisplayArea[2];
 896         h0 = DisplayArea[3];  // video mode
 897         h1 = DisplayArea[5] - DisplayArea[4]; // display needed
 898         if (h0 == 480) h1 = Min2(h1*2,480);
 899
 900         if (h1 <= 0)
 901                 return;
 902
 903         if (w0 != old_res_horz || h1 != old_res_vert || isRGB24 != old_rgb24)
 904         {
 905                 old_res_horz = w0;
 906                 old_res_vert = h1;
 907                 old_rgb24 = (s16)isRGB24;
 908                 screen_buf = cbs->pl_vout_set_mode(w0, h1, isRGB24 ? 24 : 16);
 909         }
 910         cbs->pl_vout_raw_flip(DisplayArea[0], DisplayArea[1]);
 911 }
 912
 913 void GPU_updateLace(void)
 914 {
 915         // Interlace bit toggle
 916         GPU_GP1 ^= 0x80000000;
 917
 918         if (!fb_dirty || (GPU_GP1&0x08800000))
 919                 return;
 920
 921         if (!wasSkip) {
 922                 if (cbs->pl_vout_raw_flip != NULL)
 923                         blit_raw();
 924                 else
 925                         blit();
 926                 fb_dirty = false;
 927                 skCount = 0;
 928         }
 929         else {
 930                 skCount++;
 931                 if (skCount >= 8)
 932                         wasSkip = isSkip = 0;
 933         }
 934
 935         skipFrame = cbs->fskip_advice || cbs->frameskip == 1;
 936 }
 937
 938 long GPUopen(unsigned long *, char *, char *)
 939 {
 940         cbs->pl_vout_open();
 941         screen_buf = cbs->pl_vout_flip();
 942         return 0;
 943 }
 944
 945 long GPUclose(void)
 946 {
 947         cbs->pl_vout_close();
 948         return 0;
 949 }
 950
 951 long GPUfreeze(unsigned int ulGetFreezeData, GPUFreeze_t* p2)
 952 {
 953         if (ulGetFreezeData > 1)
 954                 return 0;
 955
 956         return GPU_freeze(ulGetFreezeData, p2);
 957 }
 958
 959 void GPUrearmedCallbacks(const struct rearmed_cbs *cbs_)
 960 {
 961         enableAbbeyHack = cbs_->gpu_unai.abe_hack;
 962         light = !cbs_->gpu_unai.no_light;
 963         blend = !cbs_->gpu_unai.no_blend;
 964         if (cbs_->pl_vout_set_raw_vram)
 965                 cbs_->pl_vout_set_raw_vram((void *)GPU_FrameBuffer);
 966
 967         cbs = cbs_;
 968 }
 969
 970 } /* extern "C" */
 971
 972 #endif