plugins/dfxvideo/gpu.c

   1 /***************************************************************************
   2                           gpu.c  -  description
   3                              -------------------
   4     begin                : Sun Oct 28 2001
   5     copyright            : (C) 2001 by Pete Bernert
   6     email                : BlackDove@addcom.de
   7  ***************************************************************************/
   8 /***************************************************************************
   9  *                                                                         *
  10  *   This program is free software; you can redistribute it and/or modify  *
  11  *   it under the terms of the GNU General Public License as published by  *
  12  *   the Free Software Foundation; either version 2 of the License, or     *
  13  *   (at your option) any later version. See also the license.txt file for *
  14  *   additional informations.                                              *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "gpu.h"
  19 #include "stdint.h"
  20 #include "psemu_plugin_defs.h"
  21
  22 ////////////////////////////////////////////////////////////////////////
  23 // memory image of the PSX vram
  24 ////////////////////////////////////////////////////////////////////////
  25
  26 unsigned char  *psxVub;
  27 signed   char  *psxVsb;
  28 unsigned short *psxVuw;
  29 unsigned short *psxVuw_eom;
  30 signed   short *psxVsw;
  31 uint32_t *psxVul;
  32 int32_t  *psxVsl;
  33
  34 ////////////////////////////////////////////////////////////////////////
  35 // GPU globals
  36 ////////////////////////////////////////////////////////////////////////
  37
  38 static long       lGPUdataRet;
  39 long              lGPUstatusRet;
  40 uint32_t          ulStatusControl[256];
  41
  42 static uint32_t gpuDataM[256];
  43 static unsigned   char gpuCommand = 0;
  44 static long       gpuDataC = 0;
  45 static long       gpuDataP = 0;
  46
  47 VRAMLoad_t        VRAMWrite;
  48 VRAMLoad_t        VRAMRead;
  49 DATAREGISTERMODES DataWriteMode;
  50 DATAREGISTERMODES DataReadMode;
  51
  52 BOOL              bSkipNextFrame = FALSE;
  53 BOOL              fskip_frameReady;
  54 DWORD             lace_count_since_flip;
  55 DWORD             dwLaceCnt=0;
  56 short             sDispWidths[8] = {256,320,512,640,368,384,512,640};
  57 PSXDisplay_t      PSXDisplay;
  58 PSXDisplay_t      PreviousPSXDisplay;
  59 long              lSelectedSlot=0;
  60 BOOL              bDoLazyUpdate=FALSE;
  61 uint32_t          lGPUInfoVals[16];
  62 static int        iFakePrimBusy=0;
  63 static const int  *skip_advice;
  64
  65 ////////////////////////////////////////////////////////////////////////
  66 // some misc external display funcs
  67 ////////////////////////////////////////////////////////////////////////
  68
  69 #include <time.h>
  70
  71 // FPS library
  72 #include "fps.c"
  73
  74
  75 ////////////////////////////////////////////////////////////////////////
  76 // sets all kind of act fixes
  77 ////////////////////////////////////////////////////////////////////////
  78
  79 static void SetFixes(void)
  80  {
  81   if(dwActFixes&0x02) sDispWidths[4]=384;
  82   else                sDispWidths[4]=368;
  83  }
  84
  85 ////////////////////////////////////////////////////////////////////////
  86 // INIT, will be called after lib load... well, just do some var init...
  87 ////////////////////////////////////////////////////////////////////////
  88
  89 // one extra MB for soft drawing funcs security
  90 static unsigned char vram[1024*512*2 + 1024*1024] __attribute__((aligned(2048)));
  91
  92 long CALLBACK GPUinit(void)                                // GPU INIT
  93 {
  94  memset(ulStatusControl,0,256*sizeof(uint32_t));  // init save state scontrol field
  95
  96  //!!! ATTENTION !!!
  97  psxVub=vram + 512 * 1024;                           // security offset into double sized psx vram!
  98
  99  psxVsb=(signed char *)psxVub;                         // different ways of accessing PSX VRAM
 100  psxVsw=(signed short *)psxVub;
 101  psxVsl=(int32_t *)psxVub;
 102  psxVuw=(unsigned short *)psxVub;
 103  psxVul=(uint32_t *)psxVub;
 104
 105  psxVuw_eom=psxVuw+1024*512;                    // pre-calc of end of vram
 106
 107  memset(vram,0x00,(512*2)*1024 + (1024*1024));
 108  memset(lGPUInfoVals,0x00,16*sizeof(uint32_t));
 109
 110  PSXDisplay.RGB24        = FALSE;                      // init some stuff
 111  PSXDisplay.Interlaced   = FALSE;
 112  PSXDisplay.DrawOffset.x = 0;
 113  PSXDisplay.DrawOffset.y = 0;
 114  PSXDisplay.DisplayMode.x= 320;
 115  PSXDisplay.DisplayMode.y= 240;
 116  PreviousPSXDisplay.DisplayMode.x= 320;
 117  PreviousPSXDisplay.DisplayMode.y= 240;
 118  PSXDisplay.Disabled     = FALSE;
 119  PreviousPSXDisplay.Range.x0 =0;
 120  PreviousPSXDisplay.Range.y0 =0;
 121  PSXDisplay.Range.x0=0;
 122  PSXDisplay.Range.x1=0;
 123  PreviousPSXDisplay.DisplayModeNew.y=0;
 124  PSXDisplay.Double = 1;
 125  lGPUdataRet = 0x400;
 126
 127  DataWriteMode = DR_NORMAL;
 128
 129  // Reset transfer values, to prevent mis-transfer of data
 130  memset(&VRAMWrite, 0, sizeof(VRAMLoad_t));
 131  memset(&VRAMRead, 0, sizeof(VRAMLoad_t));
 132
 133  // device initialised already !
 134  lGPUstatusRet = 0x14802000;
 135  GPUIsIdle;
 136  GPUIsReadyForCommands;
 137  bDoVSyncUpdate = TRUE;
 138
 139  return 0;
 140 }
 141
 142 ////////////////////////////////////////////////////////////////////////
 143 // Here starts all...
 144 ////////////////////////////////////////////////////////////////////////
 145
 146
 147 long GPUopen(unsigned long * disp,char * CapText,char * CfgFile)
 148 {
 149  unsigned long d;
 150
 151  SetFixes();
 152
 153  InitFPS();
 154
 155  bDoVSyncUpdate = TRUE;
 156
 157  d=ulInitDisplay();                                    // setup x
 158
 159  if(disp)
 160         *disp=d;                                     // wanna x pointer? ok
 161
 162  if(d) return 0;
 163  return -1;
 164 }
 165
 166
 167 ////////////////////////////////////////////////////////////////////////
 168 // time to leave...
 169 ////////////////////////////////////////////////////////////////////////
 170
 171 long CALLBACK GPUclose()                               // GPU CLOSE
 172 {
 173  CloseDisplay();                                       // shutdown direct draw
 174
 175  return 0;
 176 }
 177
 178 ////////////////////////////////////////////////////////////////////////
 179 // I shot the sheriff
 180 ////////////////////////////////////////////////////////////////////////
 181
 182 long CALLBACK GPUshutdown(void)                            // GPU SHUTDOWN
 183 {
 184  CloseDisplay();                                       // shutdown direct draw
 185  return 0;                                             // nothinh to do
 186 }
 187
 188 ////////////////////////////////////////////////////////////////////////
 189 // Update display (swap buffers)
 190 ////////////////////////////////////////////////////////////////////////
 191
 192 static void updateDisplay(void)                               // UPDATE DISPLAY
 193 {
 194  if(PSXDisplay.Disabled)                               // disable?
 195   {
 196    return;                                             // -> and bye
 197   }
 198
 199  if(dwActFixes&32)                                     // pc fps calculation fix
 200   {
 201    if(UseFrameLimit) PCFrameCap();                     // -> brake
 202    if(UseFrameSkip) PCcalcfps();
 203   }
 204
 205  if(UseFrameSkip)                                      // skip ?
 206   {
 207    if(fskip_frameReady)
 208     {
 209      DoBufferSwap();                                   // -> to skip or not to skip
 210      fskip_frameReady=FALSE;
 211      bDoVSyncUpdate=FALSE;                             // vsync done
 212     }
 213   }
 214  else                                                  // no skip ?
 215   {
 216    bSkipNextFrame = FALSE;
 217    DoBufferSwap();                                     // -> swap
 218    bDoVSyncUpdate=FALSE;                               // vsync done
 219   }
 220 }
 221
 222 static void decideSkip(void)
 223 {
 224  if(!bDoVSyncUpdate)
 225    return;
 226
 227  lace_count_since_flip=0;
 228  fskip_frameReady=!bSkipNextFrame;
 229
 230  if(dwActFixes&0xa0)                                   // -> pc fps calculation fix/old skipping fix
 231   {
 232    int skip = (skip_advice && *skip_advice) || UseFrameSkip == 1 || fps_skip < fFrameRateHz;
 233    if(skip && !bSkipNextFrame)                         // -> skip max one in a row
 234        {bSkipNextFrame = TRUE; fps_skip=fFrameRateHz;}
 235    else bSkipNextFrame = FALSE;
 236   }
 237  else FrameSkip();
 238 }
 239
 240 ////////////////////////////////////////////////////////////////////////
 241 // roughly emulated screen centering bits... not complete !!!
 242 ////////////////////////////////////////////////////////////////////////
 243
 244 void ChangeDispOffsetsX(void)                          // X CENTER
 245 {
 246  long lx,l;
 247
 248  if(!PSXDisplay.Range.x1) return;
 249
 250  l=PreviousPSXDisplay.DisplayMode.x;
 251
 252  l*=(long)PSXDisplay.Range.x1;
 253  l/=2560;lx=l;l&=0xfffffff8;
 254
 255  if(l==PreviousPSXDisplay.Range.y1) return;            // abusing range.y1 for
 256  PreviousPSXDisplay.Range.y1=(short)l;                 // storing last x range and test
 257
 258  if(lx>=PreviousPSXDisplay.DisplayMode.x)
 259   {
 260    PreviousPSXDisplay.Range.x1=
 261     (short)PreviousPSXDisplay.DisplayMode.x;
 262    PreviousPSXDisplay.Range.x0=0;
 263   }
 264  else
 265   {
 266    PreviousPSXDisplay.Range.x1=(short)l;
 267
 268    PreviousPSXDisplay.Range.x0=
 269     (PSXDisplay.Range.x0-500)/8;
 270
 271    if(PreviousPSXDisplay.Range.x0<0)
 272     PreviousPSXDisplay.Range.x0=0;
 273
 274    if((PreviousPSXDisplay.Range.x0+lx)>
 275       PreviousPSXDisplay.DisplayMode.x)
 276     {
 277      PreviousPSXDisplay.Range.x0=
 278       (short)(PreviousPSXDisplay.DisplayMode.x-lx);
 279      PreviousPSXDisplay.Range.x0+=2; //???
 280
 281      PreviousPSXDisplay.Range.x1+=(short)(lx-l);
 282
 283      PreviousPSXDisplay.Range.x1-=2; // makes linux stretching easier
 284
 285     }
 286
 287    // some linux alignment security
 288    PreviousPSXDisplay.Range.x0=PreviousPSXDisplay.Range.x0>>1;
 289    PreviousPSXDisplay.Range.x0=PreviousPSXDisplay.Range.x0<<1;
 290    PreviousPSXDisplay.Range.x1=PreviousPSXDisplay.Range.x1>>1;
 291    PreviousPSXDisplay.Range.x1=PreviousPSXDisplay.Range.x1<<1;
 292
 293    DoClearScreenBuffer();
 294   }
 295
 296  bDoVSyncUpdate=TRUE;
 297 }
 298
 299 ////////////////////////////////////////////////////////////////////////
 300
 301 void ChangeDispOffsetsY(void)                          // Y CENTER
 302 {
 303  int iT,iO=PreviousPSXDisplay.Range.y0;
 304  int iOldYOffset=PreviousPSXDisplay.DisplayModeNew.y;
 305
 306 // new
 307
 308  if((PreviousPSXDisplay.DisplayModeNew.x+PSXDisplay.DisplayModeNew.y)>512)
 309   {
 310    int dy1=512-PreviousPSXDisplay.DisplayModeNew.x;
 311    int dy2=(PreviousPSXDisplay.DisplayModeNew.x+PSXDisplay.DisplayModeNew.y)-512;
 312
 313    if(dy1>=dy2)
 314     {
 315      PreviousPSXDisplay.DisplayModeNew.y=-dy2;
 316     }
 317    else
 318     {
 319      PSXDisplay.DisplayPosition.y=0;
 320      PreviousPSXDisplay.DisplayModeNew.y=-dy1;
 321     }
 322   }
 323  else PreviousPSXDisplay.DisplayModeNew.y=0;
 324
 325 // eon
 326
 327  if(PreviousPSXDisplay.DisplayModeNew.y!=iOldYOffset) // if old offset!=new offset: recalc height
 328   {
 329    PSXDisplay.Height = PSXDisplay.Range.y1 -
 330                        PSXDisplay.Range.y0 +
 331                        PreviousPSXDisplay.DisplayModeNew.y;
 332    PSXDisplay.DisplayModeNew.y=PSXDisplay.Height*PSXDisplay.Double;
 333   }
 334
 335 //
 336
 337  if(PSXDisplay.PAL) iT=48; else iT=28;
 338
 339  if(PSXDisplay.Range.y0>=iT)
 340   {
 341    PreviousPSXDisplay.Range.y0=
 342     (short)((PSXDisplay.Range.y0-iT-4)*PSXDisplay.Double);
 343    if(PreviousPSXDisplay.Range.y0<0)
 344     PreviousPSXDisplay.Range.y0=0;
 345    PSXDisplay.DisplayModeNew.y+=
 346     PreviousPSXDisplay.Range.y0;
 347   }
 348  else
 349   PreviousPSXDisplay.Range.y0=0;
 350
 351  if(iO!=PreviousPSXDisplay.Range.y0)
 352   {
 353    DoClearScreenBuffer();
 354  }
 355 }
 356
 357 ////////////////////////////////////////////////////////////////////////
 358 // check if update needed
 359 ////////////////////////////////////////////////////////////////////////
 360
 361 static void updateDisplayIfChanged(void)                      // UPDATE DISPLAY IF CHANGED
 362 {
 363  if ((PSXDisplay.DisplayMode.y == PSXDisplay.DisplayModeNew.y) &&
 364      (PSXDisplay.DisplayMode.x == PSXDisplay.DisplayModeNew.x))
 365   {
 366    if((PSXDisplay.RGB24      == PSXDisplay.RGB24New) &&
 367       (PSXDisplay.Interlaced == PSXDisplay.InterlacedNew)) return;
 368   }
 369
 370  PSXDisplay.RGB24         = PSXDisplay.RGB24New;       // get new infos
 371
 372  PSXDisplay.DisplayMode.y = PSXDisplay.DisplayModeNew.y;
 373  PSXDisplay.DisplayMode.x = PSXDisplay.DisplayModeNew.x;
 374  PreviousPSXDisplay.DisplayMode.x=                     // previous will hold
 375   min(640,PSXDisplay.DisplayMode.x);                   // max 640x512... that's
 376  PreviousPSXDisplay.DisplayMode.y=                     // the size of my
 377   min(512,PSXDisplay.DisplayMode.y);                   // back buffer surface
 378  PSXDisplay.Interlaced    = PSXDisplay.InterlacedNew;
 379
 380  PSXDisplay.DisplayEnd.x=                              // calc end of display
 381   PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 382  PSXDisplay.DisplayEnd.y=
 383   PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;
 384  PreviousPSXDisplay.DisplayEnd.x=
 385   PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 386  PreviousPSXDisplay.DisplayEnd.y=
 387   PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y+PreviousPSXDisplay.DisplayModeNew.y;
 388
 389  ChangeDispOffsetsX();
 390
 391  if(iFrameLimit==2) SetAutoFrameCap();                 // -> set it
 392
 393  if(UseFrameSkip) decideSkip();                        // stupid stuff when frame skipping enabled
 394 }
 395
 396 ////////////////////////////////////////////////////////////////////////
 397 // update lace is called evry VSync
 398 ////////////////////////////////////////////////////////////////////////
 399
 400 void CALLBACK GPUupdateLace(void)                      // VSYNC
 401 {
 402  //if(!(dwActFixes&1))
 403  // lGPUstatusRet^=0x80000000;                           // odd/even bit
 404
 405  //pcsx-rearmed: removed, this is handled by core
 406  //if(!(dwActFixes&32))                                  // std fps limitation?
 407  // CheckFrameRate();
 408
 409  if(PSXDisplay.Interlaced)                             // interlaced mode?
 410   {
 411    lGPUstatusRet^=0x80000000;                          // odd/even bit?
 412
 413    if(bDoVSyncUpdate && PSXDisplay.DisplayMode.x>0 && PSXDisplay.DisplayMode.y>0)
 414     {
 415      updateDisplay();
 416     }
 417   }
 418  else                                                  // non-interlaced?
 419   {
 420    if(dwActFixes&64)                                   // lazy screen update fix
 421     {
 422      if(bDoLazyUpdate)
 423       updateDisplay();
 424      bDoLazyUpdate=FALSE;
 425     }
 426    else
 427     {
 428      if(bDoVSyncUpdate)                                // some primitives drawn?
 429        updateDisplay();                                // -> update display
 430     }
 431   }
 432
 433  if(UseFrameSkip) {                                    // frame over-skip guard
 434   lace_count_since_flip++;
 435   if(lace_count_since_flip > 8) {
 436    bSkipNextFrame=FALSE;
 437    fskip_frameReady=TRUE;
 438   }
 439  }
 440 }
 441
 442 ////////////////////////////////////////////////////////////////////////
 443 // process read request from GPU status register
 444 ////////////////////////////////////////////////////////////////////////
 445
 446
 447 uint32_t CALLBACK GPUreadStatus(void)             // READ STATUS
 448 {
 449  if(dwActFixes&1)
 450   {
 451    static int iNumRead=0;                         // odd/even hack
 452    if((iNumRead++)==2)
 453     {
 454      iNumRead=0;
 455      lGPUstatusRet^=0x80000000;                   // interlaced bit toggle... we do it on every 3 read status... needed by some games (like ChronoCross) with old epsxe versions (1.5.2 and older)
 456     }
 457   }
 458
 459  if(iFakePrimBusy)                                // 27.10.2007 - PETE : emulating some 'busy' while drawing... pfff
 460   {
 461    iFakePrimBusy--;
 462
 463    if(iFakePrimBusy&1)                            // we do a busy-idle-busy-idle sequence after/while drawing prims
 464     {
 465      GPUIsBusy;
 466      GPUIsNotReadyForCommands;
 467     }
 468    else
 469     {
 470      GPUIsIdle;
 471      GPUIsReadyForCommands;
 472     }
 473   }
 474  return lGPUstatusRet;
 475 }
 476
 477 ////////////////////////////////////////////////////////////////////////
 478 // processes data send to GPU status register
 479 // these are always single packet commands.
 480 ////////////////////////////////////////////////////////////////////////
 481
 482 void CALLBACK GPUwriteStatus(uint32_t gdata)      // WRITE STATUS
 483 {
 484  uint32_t lCommand=(gdata>>24)&0xff;
 485
 486  ulStatusControl[lCommand]=gdata;                      // store command for freezing
 487
 488  switch(lCommand)
 489   {
 490    //--------------------------------------------------//
 491    // reset gpu
 492    case 0x00:
 493     memset(lGPUInfoVals,0x00,16*sizeof(uint32_t));
 494     lGPUstatusRet=0x14802000;
 495     PSXDisplay.Disabled=1;
 496     DataWriteMode=DataReadMode=DR_NORMAL;
 497     PSXDisplay.DrawOffset.x=PSXDisplay.DrawOffset.y=0;
 498     drawX=drawY=0;drawW=drawH=0;
 499     sSetMask=0;lSetMask=0;bCheckMask=FALSE;
 500     usMirror=0;
 501     GlobalTextAddrX=0;GlobalTextAddrY=0;
 502     GlobalTextTP=0;GlobalTextABR=0;
 503     PSXDisplay.RGB24=FALSE;
 504     PSXDisplay.Interlaced=FALSE;
 505     bUsingTWin = FALSE;
 506     return;
 507    //--------------------------------------------------//
 508    // dis/enable display
 509    case 0x03:
 510
 511     PreviousPSXDisplay.Disabled = PSXDisplay.Disabled;
 512     PSXDisplay.Disabled = (gdata & 1);
 513
 514     if(PSXDisplay.Disabled)
 515          lGPUstatusRet|=GPUSTATUS_DISPLAYDISABLED;
 516     else lGPUstatusRet&=~GPUSTATUS_DISPLAYDISABLED;
 517     return;
 518
 519    //--------------------------------------------------//
 520    // setting transfer mode
 521    case 0x04:
 522     gdata &= 0x03;                                     // Only want the lower two bits
 523
 524     DataWriteMode=DataReadMode=DR_NORMAL;
 525     if(gdata==0x02) DataWriteMode=DR_VRAMTRANSFER;
 526     if(gdata==0x03) DataReadMode =DR_VRAMTRANSFER;
 527     lGPUstatusRet&=~GPUSTATUS_DMABITS;                 // Clear the current settings of the DMA bits
 528     lGPUstatusRet|=(gdata << 29);                      // Set the DMA bits according to the received data
 529
 530     return;
 531    //--------------------------------------------------//
 532    // setting display position
 533    case 0x05:
 534     {
 535      PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;
 536      PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;
 537
 538 // new
 539      PSXDisplay.DisplayPosition.y = (short)((gdata>>10)&0x1ff);
 540
 541      // store the same val in some helper var, we need it on later compares
 542      PreviousPSXDisplay.DisplayModeNew.x=PSXDisplay.DisplayPosition.y;
 543
 544      if((PSXDisplay.DisplayPosition.y+PSXDisplay.DisplayMode.y)>512)
 545       {
 546        int dy1=512-PSXDisplay.DisplayPosition.y;
 547        int dy2=(PSXDisplay.DisplayPosition.y+PSXDisplay.DisplayMode.y)-512;
 548
 549        if(dy1>=dy2)
 550         {
 551          PreviousPSXDisplay.DisplayModeNew.y=-dy2;
 552         }
 553        else
 554         {
 555          PSXDisplay.DisplayPosition.y=0;
 556          PreviousPSXDisplay.DisplayModeNew.y=-dy1;
 557         }
 558       }
 559      else PreviousPSXDisplay.DisplayModeNew.y=0;
 560 // eon
 561
 562      PSXDisplay.DisplayPosition.x = (short)(gdata & 0x3ff);
 563      PSXDisplay.DisplayEnd.x=
 564       PSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 565      PSXDisplay.DisplayEnd.y=
 566       PSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y + PreviousPSXDisplay.DisplayModeNew.y;
 567      PreviousPSXDisplay.DisplayEnd.x=
 568       PreviousPSXDisplay.DisplayPosition.x+ PSXDisplay.DisplayMode.x;
 569      PreviousPSXDisplay.DisplayEnd.y=
 570       PreviousPSXDisplay.DisplayPosition.y+ PSXDisplay.DisplayMode.y + PreviousPSXDisplay.DisplayModeNew.y;
 571
 572      bDoVSyncUpdate=TRUE;
 573
 574      if (!(PSXDisplay.Interlaced))                      // stupid frame skipping option
 575       {
 576        if(dwActFixes&64) bDoLazyUpdate=TRUE;
 577       }
 578      if(UseFrameSkip)  decideSkip();
 579     }return;
 580    //--------------------------------------------------//
 581    // setting width
 582    case 0x06:
 583
 584     PSXDisplay.Range.x0=(short)(gdata & 0x7ff);
 585     PSXDisplay.Range.x1=(short)((gdata>>12) & 0xfff);
 586
 587     PSXDisplay.Range.x1-=PSXDisplay.Range.x0;
 588
 589     ChangeDispOffsetsX();
 590
 591     return;
 592    //--------------------------------------------------//
 593    // setting height
 594    case 0x07:
 595     {
 596
 597      PSXDisplay.Range.y0=(short)(gdata & 0x3ff);
 598      PSXDisplay.Range.y1=(short)((gdata>>10) & 0x3ff);
 599
 600      PreviousPSXDisplay.Height = PSXDisplay.Height;
 601
 602      PSXDisplay.Height = PSXDisplay.Range.y1 -
 603                          PSXDisplay.Range.y0 +
 604                          PreviousPSXDisplay.DisplayModeNew.y;
 605
 606      if(PreviousPSXDisplay.Height!=PSXDisplay.Height)
 607       {
 608        PSXDisplay.DisplayModeNew.y=PSXDisplay.Height*PSXDisplay.Double;
 609
 610        ChangeDispOffsetsY();
 611
 612        updateDisplayIfChanged();
 613       }
 614      return;
 615     }
 616    //--------------------------------------------------//
 617    // setting display infos
 618    case 0x08:
 619
 620     PSXDisplay.DisplayModeNew.x =
 621      sDispWidths[(gdata & 0x03) | ((gdata & 0x40) >> 4)];
 622
 623     if (gdata&0x04) PSXDisplay.Double=2;
 624     else            PSXDisplay.Double=1;
 625
 626     PSXDisplay.DisplayModeNew.y = PSXDisplay.Height*PSXDisplay.Double;
 627
 628     ChangeDispOffsetsY();
 629
 630     PSXDisplay.PAL           = (gdata & 0x08)?TRUE:FALSE; // if 1 - PAL mode, else NTSC
 631     PSXDisplay.RGB24New      = (gdata & 0x10)?TRUE:FALSE; // if 1 - TrueColor
 632     PSXDisplay.InterlacedNew = (gdata & 0x20)?TRUE:FALSE; // if 1 - Interlace
 633
 634     lGPUstatusRet&=~GPUSTATUS_WIDTHBITS;                   // Clear the width bits
 635     lGPUstatusRet|=
 636                (((gdata & 0x03) << 17) |
 637                ((gdata & 0x40) << 10));                // Set the width bits
 638
 639     if(PSXDisplay.InterlacedNew)
 640      {
 641       if(!PSXDisplay.Interlaced)
 642        {
 643         PreviousPSXDisplay.DisplayPosition.x = PSXDisplay.DisplayPosition.x;
 644         PreviousPSXDisplay.DisplayPosition.y = PSXDisplay.DisplayPosition.y;
 645        }
 646       lGPUstatusRet|=GPUSTATUS_INTERLACED;
 647      }
 648     else lGPUstatusRet&=~(GPUSTATUS_INTERLACED|0x80000000);
 649
 650     if (PSXDisplay.PAL)
 651          lGPUstatusRet|=GPUSTATUS_PAL;
 652     else lGPUstatusRet&=~GPUSTATUS_PAL;
 653
 654     if (PSXDisplay.Double==2)
 655          lGPUstatusRet|=GPUSTATUS_DOUBLEHEIGHT;
 656     else lGPUstatusRet&=~GPUSTATUS_DOUBLEHEIGHT;
 657
 658     if (PSXDisplay.RGB24New)
 659          lGPUstatusRet|=GPUSTATUS_RGB24;
 660     else lGPUstatusRet&=~GPUSTATUS_RGB24;
 661
 662     updateDisplayIfChanged();
 663
 664     return;
 665    //--------------------------------------------------//
 666    // ask about GPU version and other stuff
 667    case 0x10:
 668
 669     gdata&=0xff;
 670
 671     switch(gdata)
 672      {
 673       case 0x02:
 674        lGPUdataRet=lGPUInfoVals[INFO_TW];              // tw infos
 675        return;
 676       case 0x03:
 677        lGPUdataRet=lGPUInfoVals[INFO_DRAWSTART];       // draw start
 678        return;
 679       case 0x04:
 680        lGPUdataRet=lGPUInfoVals[INFO_DRAWEND];         // draw end
 681        return;
 682       case 0x05:
 683       case 0x06:
 684        lGPUdataRet=lGPUInfoVals[INFO_DRAWOFF];         // draw offset
 685        return;
 686       case 0x07:
 687        lGPUdataRet=0x02;                               // gpu type
 688        return;
 689       case 0x08:
 690       case 0x0F:                                       // some bios addr?
 691        lGPUdataRet=0xBFC03720;
 692        return;
 693      }
 694     return;
 695    //--------------------------------------------------//
 696   }
 697 }
 698
 699 ////////////////////////////////////////////////////////////////////////
 700 // vram read/write helpers, needed by LEWPY's optimized vram read/write :)
 701 ////////////////////////////////////////////////////////////////////////
 702
 703 static inline void FinishedVRAMWrite(void)
 704 {
 705  // Set register to NORMAL operation
 706  DataWriteMode = DR_NORMAL;
 707  // Reset transfer values, to prevent mis-transfer of data
 708  VRAMWrite.x = 0;
 709  VRAMWrite.y = 0;
 710  VRAMWrite.Width = 0;
 711  VRAMWrite.Height = 0;
 712  VRAMWrite.ColsRemaining = 0;
 713  VRAMWrite.RowsRemaining = 0;
 714 }
 715
 716 static inline void FinishedVRAMRead(void)
 717 {
 718  // Set register to NORMAL operation
 719  DataReadMode = DR_NORMAL;
 720  // Reset transfer values, to prevent mis-transfer of data
 721  VRAMRead.x = 0;
 722  VRAMRead.y = 0;
 723  VRAMRead.Width = 0;
 724  VRAMRead.Height = 0;
 725  VRAMRead.ColsRemaining = 0;
 726  VRAMRead.RowsRemaining = 0;
 727
 728  // Indicate GPU is no longer ready for VRAM data in the STATUS REGISTER
 729  lGPUstatusRet&=~GPUSTATUS_READYFORVRAM;
 730 }
 731
 732 ////////////////////////////////////////////////////////////////////////
 733 // core read from vram
 734 ////////////////////////////////////////////////////////////////////////
 735
 736 void CALLBACK GPUreadDataMem(uint32_t * pMem, int iSize)
 737 {
 738  int i;
 739
 740  if(DataReadMode!=DR_VRAMTRANSFER) return;
 741
 742  GPUIsBusy;
 743
 744  // adjust read ptr, if necessary
 745  while(VRAMRead.ImagePtr>=psxVuw_eom)
 746   VRAMRead.ImagePtr-=512*1024;
 747  while(VRAMRead.ImagePtr<psxVuw)
 748   VRAMRead.ImagePtr+=512*1024;
 749
 750  for(i=0;i<iSize;i++)
 751   {
 752    // do 2 seperate 16bit reads for compatibility (wrap issues)
 753    if ((VRAMRead.ColsRemaining > 0) && (VRAMRead.RowsRemaining > 0))
 754     {
 755      // lower 16 bit
 756      lGPUdataRet=(uint32_t)GETLE16(VRAMRead.ImagePtr);
 757
 758      VRAMRead.ImagePtr++;
 759      if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=512*1024;
 760      VRAMRead.RowsRemaining --;
 761
 762      if(VRAMRead.RowsRemaining<=0)
 763       {
 764        VRAMRead.RowsRemaining = VRAMRead.Width;
 765        VRAMRead.ColsRemaining--;
 766        VRAMRead.ImagePtr += 1024 - VRAMRead.Width;
 767        if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=512*1024;
 768       }
 769
 770      // higher 16 bit (always, even if it's an odd width)
 771      lGPUdataRet|=(uint32_t)GETLE16(VRAMRead.ImagePtr)<<16;
 772      PUTLE32(pMem, lGPUdataRet); pMem++;
 773
 774      if(VRAMRead.ColsRemaining <= 0)
 775       {FinishedVRAMRead();goto ENDREAD;}
 776
 777      VRAMRead.ImagePtr++;
 778      if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=512*1024;
 779      VRAMRead.RowsRemaining--;
 780      if(VRAMRead.RowsRemaining<=0)
 781       {
 782        VRAMRead.RowsRemaining = VRAMRead.Width;
 783        VRAMRead.ColsRemaining--;
 784        VRAMRead.ImagePtr += 1024 - VRAMRead.Width;
 785        if(VRAMRead.ImagePtr>=psxVuw_eom) VRAMRead.ImagePtr-=512*1024;
 786       }
 787      if(VRAMRead.ColsRemaining <= 0)
 788       {FinishedVRAMRead();goto ENDREAD;}
 789     }
 790    else {FinishedVRAMRead();goto ENDREAD;}
 791   }
 792
 793 ENDREAD:
 794  GPUIsIdle;
 795 }
 796
 797
 798 ////////////////////////////////////////////////////////////////////////
 799
 800 uint32_t CALLBACK GPUreadData(void)
 801 {
 802  uint32_t l;
 803  GPUreadDataMem(&l,1);
 804  return lGPUdataRet;
 805 }
 806
 807 // Software drawing function
 808 #include "soft.c"
 809
 810 // PSX drawing primitives
 811 #include "prim.c"
 812
 813 ////////////////////////////////////////////////////////////////////////
 814 // processes data send to GPU data register
 815 // extra table entries for fixing polyline troubles
 816 ////////////////////////////////////////////////////////////////////////
 817
 818 static const unsigned char primTableCX[256] =
 819 {
 820     // 00
 821     0,0,3,0,0,0,0,0,
 822     // 08
 823     0,0,0,0,0,0,0,0,
 824     // 10
 825     0,0,0,0,0,0,0,0,
 826     // 18
 827     0,0,0,0,0,0,0,0,
 828     // 20
 829     4,4,4,4,7,7,7,7,
 830     // 28
 831     5,5,5,5,9,9,9,9,
 832     // 30
 833     6,6,6,6,9,9,9,9,
 834     // 38
 835     8,8,8,8,12,12,12,12,
 836     // 40
 837     3,3,3,3,0,0,0,0,
 838     // 48
 839 //  5,5,5,5,6,6,6,6,    // FLINE
 840     254,254,254,254,254,254,254,254,
 841     // 50
 842     4,4,4,4,0,0,0,0,
 843     // 58
 844 //  7,7,7,7,9,9,9,9,    // GLINE
 845     255,255,255,255,255,255,255,255,
 846     // 60
 847     3,3,3,3,4,4,4,4,
 848     // 68
 849     2,2,2,2,3,3,3,3,    // 3=SPRITE1???
 850     // 70
 851     2,2,2,2,3,3,3,3,
 852     // 78
 853     2,2,2,2,3,3,3,3,
 854     // 80
 855     4,0,0,0,0,0,0,0,
 856     // 88
 857     0,0,0,0,0,0,0,0,
 858     // 90
 859     0,0,0,0,0,0,0,0,
 860     // 98
 861     0,0,0,0,0,0,0,0,
 862     // a0
 863     3,0,0,0,0,0,0,0,
 864     // a8
 865     0,0,0,0,0,0,0,0,
 866     // b0
 867     0,0,0,0,0,0,0,0,
 868     // b8
 869     0,0,0,0,0,0,0,0,
 870     // c0
 871     3,0,0,0,0,0,0,0,
 872     // c8
 873     0,0,0,0,0,0,0,0,
 874     // d0
 875     0,0,0,0,0,0,0,0,
 876     // d8
 877     0,0,0,0,0,0,0,0,
 878     // e0
 879     0,1,1,1,1,1,1,0,
 880     // e8
 881     0,0,0,0,0,0,0,0,
 882     // f0
 883     0,0,0,0,0,0,0,0,
 884     // f8
 885     0,0,0,0,0,0,0,0
 886 };
 887
 888 void CALLBACK GPUwriteDataMem(uint32_t * pMem, int iSize)
 889 {
 890  unsigned char command;
 891  uint32_t gdata=0;
 892  int i=0;
 893  GPUIsBusy;
 894  GPUIsNotReadyForCommands;
 895
 896 STARTVRAM:
 897
 898  if(DataWriteMode==DR_VRAMTRANSFER)
 899   {
 900    BOOL bFinished=FALSE;
 901
 902    // make sure we are in vram
 903    while(VRAMWrite.ImagePtr>=psxVuw_eom)
 904     VRAMWrite.ImagePtr-=512*1024;
 905    while(VRAMWrite.ImagePtr<psxVuw)
 906     VRAMWrite.ImagePtr+=512*1024;
 907
 908    // now do the loop
 909    while(VRAMWrite.ColsRemaining>0)
 910     {
 911      while(VRAMWrite.RowsRemaining>0)
 912       {
 913        if(i>=iSize) {goto ENDVRAM;}
 914        i++;
 915
 916        gdata=GETLE32(pMem); pMem++;
 917
 918        PUTLE16(VRAMWrite.ImagePtr, (unsigned short)gdata); VRAMWrite.ImagePtr++;
 919        if(VRAMWrite.ImagePtr>=psxVuw_eom) VRAMWrite.ImagePtr-=512*1024;
 920        VRAMWrite.RowsRemaining --;
 921
 922        if(VRAMWrite.RowsRemaining <= 0)
 923         {
 924          VRAMWrite.ColsRemaining--;
 925          if (VRAMWrite.ColsRemaining <= 0)             // last pixel is odd width
 926           {
 927            gdata=(gdata&0xFFFF)|(((uint32_t)GETLE16(VRAMWrite.ImagePtr))<<16);
 928            FinishedVRAMWrite();
 929            bDoVSyncUpdate=TRUE;
 930            goto ENDVRAM;
 931           }
 932          VRAMWrite.RowsRemaining = VRAMWrite.Width;
 933          VRAMWrite.ImagePtr += 1024 - VRAMWrite.Width;
 934         }
 935
 936        PUTLE16(VRAMWrite.ImagePtr, (unsigned short)(gdata>>16)); VRAMWrite.ImagePtr++;
 937        if(VRAMWrite.ImagePtr>=psxVuw_eom) VRAMWrite.ImagePtr-=512*1024;
 938        VRAMWrite.RowsRemaining --;
 939       }
 940
 941      VRAMWrite.RowsRemaining = VRAMWrite.Width;
 942      VRAMWrite.ColsRemaining--;
 943      VRAMWrite.ImagePtr += 1024 - VRAMWrite.Width;
 944      bFinished=TRUE;
 945     }
 946
 947    FinishedVRAMWrite();
 948    if(bFinished) bDoVSyncUpdate=TRUE;
 949   }
 950
 951 ENDVRAM:
 952
 953  if(DataWriteMode==DR_NORMAL)
 954   {
 955    void (* *primFunc)(unsigned char *);
 956    if(bSkipNextFrame) primFunc=primTableSkip;
 957    else               primFunc=primTableJ;
 958
 959    for(;i<iSize;)
 960     {
 961      if(DataWriteMode==DR_VRAMTRANSFER) goto STARTVRAM;
 962
 963      gdata=GETLE32(pMem); pMem++; i++;
 964
 965      if(gpuDataC == 0)
 966       {
 967        command = (unsigned char)((gdata>>24) & 0xff);
 968
 969 //if(command>=0xb0 && command<0xc0) auxprintf("b0 %x!!!!!!!!!\n",command);
 970
 971        if(primTableCX[command])
 972         {
 973          gpuDataC = primTableCX[command];
 974          gpuCommand = command;
 975          PUTLE32_(&gpuDataM[0], gdata);
 976          gpuDataP = 1;
 977         }
 978        else continue;
 979       }
 980      else
 981       {
 982        PUTLE32_(&gpuDataM[gpuDataP], gdata);
 983        if(gpuDataC>128)
 984         {
 985          if((gpuDataC==254 && gpuDataP>=3) ||
 986             (gpuDataC==255 && gpuDataP>=4 && !(gpuDataP&1)))
 987           {
 988            if((gpuDataM[gpuDataP] & 0xF000F000) == 0x50005000)
 989             gpuDataP=gpuDataC-1;
 990           }
 991         }
 992        gpuDataP++;
 993       }
 994
 995      if(gpuDataP == gpuDataC)
 996       {
 997        gpuDataC=gpuDataP=0;
 998        primFunc[gpuCommand]((unsigned char *)gpuDataM);
 999        if(dwActFixes&0x0400)      // hack for emulating "gpu busy" in some games
1000         iFakePrimBusy=4;
1001       }
1002     }
1003   }
1004
1005  lGPUdataRet=gdata;
1006
1007  GPUIsReadyForCommands;
1008  GPUIsIdle;
1009 }
1010
1011 ////////////////////////////////////////////////////////////////////////
1012
1013 void CALLBACK GPUwriteData(uint32_t gdata)
1014 {
1015  PUTLE32_(&gdata, gdata);
1016  GPUwriteDataMem(&gdata,1);
1017 }
1018
1019 ////////////////////////////////////////////////////////////////////////
1020 // process gpu commands
1021 ////////////////////////////////////////////////////////////////////////
1022
1023 unsigned long lUsedAddr[3];
1024
1025 static inline BOOL CheckForEndlessLoop(unsigned long laddr)
1026 {
1027  if(laddr==lUsedAddr[1]) return TRUE;
1028  if(laddr==lUsedAddr[2]) return TRUE;
1029
1030  if(laddr<lUsedAddr[0]) lUsedAddr[1]=laddr;
1031  else                   lUsedAddr[2]=laddr;
1032  lUsedAddr[0]=laddr;
1033  return FALSE;
1034 }
1035
1036 long CALLBACK GPUdmaChain(uint32_t * baseAddrL, uint32_t addr)
1037 {
1038  uint32_t dmaMem;
1039  unsigned char * baseAddrB;
1040  short count;unsigned int DMACommandCounter = 0;
1041  long dmaWords = 0;
1042
1043  GPUIsBusy;
1044
1045  lUsedAddr[0]=lUsedAddr[1]=lUsedAddr[2]=0xffffff;
1046
1047  baseAddrB = (unsigned char*) baseAddrL;
1048
1049  do
1050   {
1051    addr&=0x1FFFFC;
1052    if(DMACommandCounter++ > 2000000) break;
1053    if(CheckForEndlessLoop(addr)) break;
1054
1055    count = baseAddrB[addr+3];
1056    dmaWords += 1 + count;
1057
1058    dmaMem=addr+4;
1059
1060    if(count>0) GPUwriteDataMem(&baseAddrL[dmaMem>>2],count);
1061
1062    addr = GETLE32(&baseAddrL[addr>>2])&0xffffff;
1063    } while (!(addr & 0x800000)); // contrary to some documentation, the end-of-linked-list marker is not actually 0xFF'FFFF
1064                                   // any pointer with bit 23 set will do.
1065
1066  GPUIsIdle;
1067
1068  return dmaWords;
1069 }
1070
1071 ////////////////////////////////////////////////////////////////////////
1072 // Freeze
1073 ////////////////////////////////////////////////////////////////////////
1074
1075 typedef struct GPUFREEZETAG
1076 {
1077  uint32_t ulFreezeVersion;      // should be always 1 for now (set by main emu)
1078  uint32_t ulStatus;             // current gpu status
1079  uint32_t ulControl[256];       // latest control register values
1080  unsigned char psxVRam[1024*1024*2]; // current VRam image (full 2 MB for ZN)
1081 } GPUFreeze_t;
1082
1083 ////////////////////////////////////////////////////////////////////////
1084
1085 long CALLBACK GPUfreeze(uint32_t ulGetFreezeData,GPUFreeze_t * pF)
1086 {
1087  //----------------------------------------------------//
1088  if(ulGetFreezeData==2)                                // 2: info, which save slot is selected? (just for display)
1089   {
1090    long lSlotNum=*((long *)pF);
1091    if(lSlotNum<0) return 0;
1092    if(lSlotNum>8) return 0;
1093    lSelectedSlot=lSlotNum+1;
1094    return 1;
1095   }
1096  //----------------------------------------------------//
1097  if(!pF)                    return 0;                  // some checks
1098  if(pF->ulFreezeVersion!=1) return 0;
1099
1100  if(ulGetFreezeData==1)                                // 1: get data
1101   {
1102    pF->ulStatus=lGPUstatusRet;
1103    memcpy(pF->ulControl,ulStatusControl,256*sizeof(uint32_t));
1104    memcpy(pF->psxVRam,  psxVub,         1024*512*2);
1105
1106    return 1;
1107   }
1108
1109  if(ulGetFreezeData!=0) return 0;                      // 0: set data
1110
1111  lGPUstatusRet=pF->ulStatus;
1112  memcpy(ulStatusControl,pF->ulControl,256*sizeof(uint32_t));
1113  memcpy(psxVub,         pF->psxVRam,  1024*512*2);
1114
1115 // RESET TEXTURE STORE HERE, IF YOU USE SOMETHING LIKE THAT
1116
1117  PreviousPSXDisplay.Height = 0;
1118  GPUwriteStatus(ulStatusControl[0]);
1119  GPUwriteStatus(ulStatusControl[1]);
1120  GPUwriteStatus(ulStatusControl[2]);
1121  GPUwriteStatus(ulStatusControl[3]);
1122  GPUwriteStatus(ulStatusControl[8]);                   // try to repair things
1123  GPUwriteStatus(ulStatusControl[6]);
1124  GPUwriteStatus(ulStatusControl[7]);
1125  GPUwriteStatus(ulStatusControl[5]);
1126  GPUwriteStatus(ulStatusControl[4]);
1127
1128  return 1;
1129 }
1130
1131 // rearmed thing
1132 #include "../../frontend/plugin_lib.h"
1133
1134 const struct rearmed_cbs *rcbs;
1135
1136 void GPUrearmedCallbacks(const struct rearmed_cbs *cbs)
1137 {
1138  // sync config
1139  UseFrameSkip = cbs->frameskip;
1140  iUseDither = cbs->gpu_peops.iUseDither;
1141  dwActFixes = cbs->gpu_peops.dwActFixes;
1142  fFrameRateHz = cbs->gpu_peops.fFrameRateHz;
1143  dwFrameRateTicks = cbs->gpu_peops.dwFrameRateTicks;
1144  if (cbs->pl_vout_set_raw_vram)
1145   cbs->pl_vout_set_raw_vram(psxVub);
1146  if (cbs->pl_set_gpu_caps)
1147   cbs->pl_set_gpu_caps(0);
1148
1149  skip_advice = &cbs->fskip_advice;
1150  fps_skip = 100.0f;
1151  rcbs = cbs;
1152 }