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