--- /dev/null
+/***************************************************************************
+* Copyright (C) 2010 PCSX4ALL Team *
+* Copyright (C) 2010 Unai *
+* Copyright (C) 2016 Senquack (dansilsby <AT> gmail <DOT> com) *
+* *
+* This program is free software; you can redistribute it and/or modify *
+* it under the terms of the GNU General Public License as published by *
+* the Free Software Foundation; either version 2 of the License, or *
+* (at your option) any later version. *
+* *
+* This program is distributed in the hope that it will be useful, *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
+* GNU General Public License for more details. *
+* *
+* You should have received a copy of the GNU General Public License *
+* along with this program; if not, write to the *
+* Free Software Foundation, Inc., *
+* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
+***************************************************************************/
+
+#include <stddef.h>
+#include "plugins.h"
+#include "psxcommon.h"
+//#include "port.h"
+#include "gpu_senquack.h"
+
+#define VIDEO_WIDTH 320
+
+#ifdef TIME_IN_MSEC
+#define TPS 1000
+#else
+#define TPS 1000000
+#endif
+
+#define IS_PAL (gpu_senquack.GPU_GP1&(0x08<<17))
+
+//senquack - Original 512KB of guard space seems not to be enough, as Xenogears
+// accesses outside this range and crashes in town intro fight sequence.
+// Increased to 2MB total (double PSX VRAM) and Xenogears no longer
+// crashes, but some textures are still messed up. Also note that alignment min
+// is 16 bytes, needed for pixel-skipping rendering/blitting in high horiz res.
+// Extra 4KB is for guard room at beginning.
+// TODO: Determine cause of out-of-bounds write/reads. <-- Note: this is largely
+// solved by adoption of PCSX Rearmed's 'gpulib' in gpulib_if.cpp, which
+// replaces this file (gpu.cpp)
+//u16 GPU_FrameBuffer[(FRAME_BUFFER_SIZE+512*1024)/2] __attribute__((aligned(32)));
+static u16 GPU_FrameBuffer[(FRAME_BUFFER_SIZE*2 + 4096)/2] __attribute__((aligned(32)));
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU fixed point math
+#include "gpu_fixedpoint.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Inner loop driver instantiation file
+#include "gpu_inner.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal image drawing functions
+#include "gpu_raster_image.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal line drawing functions
+#include "gpu_raster_line.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal polygon drawing functions
+#include "gpu_raster_polygon.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU internal sprite drawing functions
+#include "gpu_raster_sprite.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU command buffer execution/store
+#include "gpu_command.h"
+
+///////////////////////////////////////////////////////////////////////////////
+static void gpuReset(void)
+{
+ memset((void*)&gpu_senquack, 0, sizeof(gpu_senquack));
+ gpu_senquack.vram = (u16*)GPU_FrameBuffer + (4096/2); //4kb guard room in front
+ gpu_senquack.GPU_GP1 = 0x14802000;
+ gpu_senquack.DrawingArea[2] = 256;
+ gpu_senquack.DrawingArea[3] = 240;
+ gpu_senquack.DisplayArea[2] = 256;
+ gpu_senquack.DisplayArea[3] = 240;
+ gpu_senquack.DisplayArea[5] = 240;
+ gpu_senquack.TextureWindow[0] = 0;
+ gpu_senquack.TextureWindow[1] = 0;
+ gpu_senquack.TextureWindow[2] = 255;
+ gpu_senquack.TextureWindow[3] = 255;
+ //senquack - new vars must be updated whenever texture window is changed:
+ // (used for polygon-drawing in gpu_inner.h, gpu_raster_polygon.h)
+ const u32 fb = FIXED_BITS; // # of fractional fixed-pt bits of u4/v4
+ gpu_senquack.u_msk = (((u32)gpu_senquack.TextureWindow[2]) << fb) | ((1 << fb) - 1);
+ gpu_senquack.v_msk = (((u32)gpu_senquack.TextureWindow[3]) << fb) | ((1 << fb) - 1);
+
+ // Configuration options
+ gpu_senquack.config = gpu_senquack_config_ext;
+ gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
+ gpu_senquack.frameskip.skipCount = gpu_senquack.config.frameskip_count;
+
+ SetupLightLUT();
+ SetupDitheringConstants();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+long GPU_init(void)
+{
+ gpuReset();
+
+#ifdef GPU_UNAI_USE_INT_DIV_MULTINV
+ // s_invTable
+ for(unsigned int i=1;i<=(1<<TABLE_BITS);++i)
+ {
+ s_invTable[i-1]=0x7fffffff/i;
+ }
+#endif
+
+ gpu_senquack.fb_dirty = true;
+ gpu_senquack.dma.last_dma = NULL;
+ return (0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+long GPU_shutdown(void)
+{
+ return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+long GPU_freeze(u32 bWrite, GPUFreeze_t* p2)
+{
+ if (!p2) return (0);
+ if (p2->ulFreezeVersion != 1) return (0);
+
+ if (bWrite)
+ {
+ p2->ulStatus = gpu_senquack.GPU_GP1;
+ memset(p2->ulControl, 0, sizeof(p2->ulControl));
+ // save resolution and registers for P.E.Op.S. compatibility
+ p2->ulControl[3] = (3 << 24) | ((gpu_senquack.GPU_GP1 >> 23) & 1);
+ p2->ulControl[4] = (4 << 24) | ((gpu_senquack.GPU_GP1 >> 29) & 3);
+ p2->ulControl[5] = (5 << 24) | (gpu_senquack.DisplayArea[0] | (gpu_senquack.DisplayArea[1] << 10));
+ p2->ulControl[6] = (6 << 24) | (2560 << 12);
+ p2->ulControl[7] = (7 << 24) | (gpu_senquack.DisplayArea[4] | (gpu_senquack.DisplayArea[5] << 10));
+ p2->ulControl[8] = (8 << 24) | ((gpu_senquack.GPU_GP1 >> 17) & 0x3f) | ((gpu_senquack.GPU_GP1 >> 10) & 0x40);
+ memcpy((void*)p2->psxVRam, (void*)gpu_senquack.vram, FRAME_BUFFER_SIZE);
+ return (1);
+ }
+ else
+ {
+ extern void GPU_writeStatus(u32 data);
+ gpu_senquack.GPU_GP1 = p2->ulStatus;
+ memcpy((void*)gpu_senquack.vram, (void*)p2->psxVRam, FRAME_BUFFER_SIZE);
+ GPU_writeStatus((5 << 24) | p2->ulControl[5]);
+ GPU_writeStatus((7 << 24) | p2->ulControl[7]);
+ GPU_writeStatus((8 << 24) | p2->ulControl[8]);
+ gpuSetTexture(gpu_senquack.GPU_GP1);
+ return (1);
+ }
+ return (0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU DMA comunication
+
+///////////////////////////////////////////////////////////////////////////////
+u8 PacketSize[256] =
+{
+ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0-15
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16-31
+ 3, 3, 3, 3, 6, 6, 6, 6, 4, 4, 4, 4, 8, 8, 8, 8, // 32-47
+ 5, 5, 5, 5, 8, 8, 8, 8, 7, 7, 7, 7, 11, 11, 11, 11, // 48-63
+ 2, 2, 2, 2, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, // 64-79
+ 3, 3, 3, 3, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, // 80-95
+ 2, 2, 2, 2, 3, 3, 3, 3, 1, 1, 1, 1, 2, 2, 2, 2, // 96-111
+ 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, // 112-127
+ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 128-
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 144
+ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 160
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 //
+};
+
+///////////////////////////////////////////////////////////////////////////////
+INLINE void gpuSendPacket()
+{
+ gpuSendPacketFunction(gpu_senquack.PacketBuffer.U4[0]>>24);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+INLINE void gpuCheckPacket(u32 uData)
+{
+ if (gpu_senquack.PacketCount)
+ {
+ gpu_senquack.PacketBuffer.U4[gpu_senquack.PacketIndex++] = uData;
+ --gpu_senquack.PacketCount;
+ }
+ else
+ {
+ gpu_senquack.PacketBuffer.U4[0] = uData;
+ gpu_senquack.PacketCount = PacketSize[uData >> 24];
+ gpu_senquack.PacketIndex = 1;
+ }
+ if (!gpu_senquack.PacketCount) gpuSendPacket();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void GPU_writeDataMem(u32* dmaAddress, int dmaCount)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeDataMem(%d)\n",dmaCount);
+ #endif
+ u32 data;
+ const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ gpu_senquack.GPU_GP1 &= ~0x14000000;
+
+ while (dmaCount)
+ {
+ if (gpu_senquack.dma.FrameToWrite)
+ {
+ while (dmaCount)
+ {
+ dmaCount--;
+ data = *dmaAddress++;
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ gpu_senquack.dma.pvram[gpu_senquack.dma.px] = data;
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToWrite = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_senquack.fb_dirty = true;
+ break;
+ }
+ }
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ gpu_senquack.dma.pvram[gpu_senquack.dma.px] = data>>16;
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToWrite = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_senquack.fb_dirty = true;
+ break;
+ }
+ }
+ }
+ }
+ else
+ {
+ data = *dmaAddress++;
+ dmaCount--;
+ gpuCheckPacket(data);
+ }
+ }
+
+ gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 | 0x14000000) & ~0x60000000;
+}
+
+long GPU_dmaChain(u32 *rambase, u32 start_addr)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_dmaChain(0x%x)\n",start_addr);
+ #endif
+
+ u32 addr, *list;
+ u32 len, count;
+ long dma_words = 0;
+
+ if (gpu_senquack.dma.last_dma) *gpu_senquack.dma.last_dma |= 0x800000;
+
+ gpu_senquack.GPU_GP1 &= ~0x14000000;
+
+ addr = start_addr & 0xffffff;
+ for (count = 0; addr != 0xffffff; count++)
+ {
+ list = rambase + (addr & 0x1fffff) / 4;
+ len = list[0] >> 24;
+ addr = list[0] & 0xffffff;
+
+ dma_words += 1 + len;
+
+ // add loop detection marker
+ list[0] |= 0x800000;
+
+ if (len) GPU_writeDataMem(list + 1, len);
+
+ if (addr & 0x800000)
+ {
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_dmaChain(LOOP)\n");
+ #endif
+ break;
+ }
+ }
+
+ // remove loop detection markers
+ addr = start_addr & 0x1fffff;
+ while (count-- > 0)
+ {
+ list = rambase + addr / 4;
+ addr = list[0] & 0x1fffff;
+ list[0] &= ~0x800000;
+ }
+
+ if (gpu_senquack.dma.last_dma) *gpu_senquack.dma.last_dma &= ~0x800000;
+ gpu_senquack.dma.last_dma = rambase + (start_addr & 0x1fffff) / 4;
+
+ gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 | 0x14000000) & ~0x60000000;
+
+ return dma_words;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void GPU_writeData(u32 data)
+{
+ const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeData()\n");
+ #endif
+ gpu_senquack.GPU_GP1 &= ~0x14000000;
+
+ if (gpu_senquack.dma.FrameToWrite)
+ {
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ gpu_senquack.dma.pvram[gpu_senquack.dma.px]=(u16)data;
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToWrite = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_senquack.fb_dirty = true;
+ }
+ }
+ if (gpu_senquack.dma.FrameToWrite)
+ {
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ gpu_senquack.dma.pvram[gpu_senquack.dma.px]=data>>16;
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToWrite = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_senquack.fb_dirty = true;
+ }
+ }
+ }
+ }
+ else
+ {
+ gpuCheckPacket(data);
+ }
+ gpu_senquack.GPU_GP1 |= 0x14000000;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+void GPU_readDataMem(u32* dmaAddress, int dmaCount)
+{
+ const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_readDataMem(%d)\n",dmaCount);
+ #endif
+ if(!gpu_senquack.dma.FrameToRead) return;
+
+ gpu_senquack.GPU_GP1 &= ~0x14000000;
+ do
+ {
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ // lower 16 bit
+ //senquack - 64-bit fix (from notaz)
+ //u32 data = (unsigned long)gpu_senquack.dma.pvram[gpu_senquack.dma.px];
+ u32 data = (u32)gpu_senquack.dma.pvram[gpu_senquack.dma.px];
+
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ }
+
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ // higher 16 bit (always, even if it's an odd width)
+ //senquack - 64-bit fix (from notaz)
+ //data |= (unsigned long)(gpu_senquack.dma.pvram[gpu_senquack.dma.px])<<16;
+ data |= (u32)(gpu_senquack.dma.pvram[gpu_senquack.dma.px])<<16;
+
+ *dmaAddress++ = data;
+
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToRead = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ break;
+ }
+ }
+ } while (--dmaCount);
+
+ gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 | 0x14000000) & ~0x60000000;
+}
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+u32 GPU_readData(void)
+{
+ const u16 *VIDEO_END = (u16*)gpu_senquack.vram+(FRAME_BUFFER_SIZE/2)-1;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_readData()\n");
+ #endif
+ gpu_senquack.GPU_GP1 &= ~0x14000000;
+ if (gpu_senquack.dma.FrameToRead)
+ {
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ gpu_senquack.GPU_GP0 = gpu_senquack.dma.pvram[gpu_senquack.dma.px];
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToRead = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ }
+ }
+ if ((&gpu_senquack.dma.pvram[gpu_senquack.dma.px])>(VIDEO_END)) gpu_senquack.dma.pvram-=512*1024;
+ gpu_senquack.GPU_GP0 |= gpu_senquack.dma.pvram[gpu_senquack.dma.px]<<16;
+ if (++gpu_senquack.dma.px >= gpu_senquack.dma.x_end)
+ {
+ gpu_senquack.dma.px = 0;
+ gpu_senquack.dma.pvram += 1024;
+ if (++gpu_senquack.dma.py >= gpu_senquack.dma.y_end)
+ {
+ gpu_senquack.dma.FrameToRead = false;
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ }
+ }
+
+ }
+ gpu_senquack.GPU_GP1 |= 0x14000000;
+
+ return (gpu_senquack.GPU_GP0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+u32 GPU_readStatus(void)
+{
+ return gpu_senquack.GPU_GP1;
+}
+
+INLINE void GPU_NoSkip(void)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_NoSkip()\n");
+ #endif
+ gpu_senquack.frameskip.wasSkip = gpu_senquack.frameskip.isSkip;
+ if (gpu_senquack.frameskip.isSkip)
+ {
+ gpu_senquack.frameskip.isSkip = false;
+ gpu_senquack.frameskip.skipGPU = false;
+ }
+ else
+ {
+ gpu_senquack.frameskip.isSkip = gpu_senquack.frameskip.skipFrame;
+ gpu_senquack.frameskip.skipGPU = gpu_senquack.frameskip.skipFrame;
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void GPU_writeStatus(u32 data)
+{
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeStatus(%d,%d)\n",data>>24,data & 0xff);
+ #endif
+ switch (data >> 24) {
+ case 0x00:
+ gpuReset();
+ break;
+ case 0x01:
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_senquack.PacketCount = 0;
+ gpu_senquack.dma.FrameToRead = gpu_senquack.dma.FrameToWrite = false;
+ break;
+ case 0x02:
+ gpu_senquack.GPU_GP1 &= ~0x08000000;
+ gpu_senquack.PacketCount = 0;
+ gpu_senquack.dma.FrameToRead = gpu_senquack.dma.FrameToWrite = false;
+ break;
+ case 0x03:
+ gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x00800000) | ((data & 1) << 23);
+ break;
+ case 0x04:
+ if (data == 0x04000000) gpu_senquack.PacketCount = 0;
+ gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x60000000) | ((data & 3) << 29);
+ break;
+ case 0x05:
+ // Start of Display Area in VRAM
+ gpu_senquack.DisplayArea[0] = data & 0x3ff; // X (0..1023)
+ gpu_senquack.DisplayArea[1] = (data >> 10) & 0x1ff; // Y (0..511)
+ GPU_NoSkip();
+ break;
+ case 0x06:
+ // GP1(06h) - Horizontal Display range (on Screen)
+ // 0-11 X1 (260h+0) ;12bit ;\counted in 53.222400MHz units,
+ // 12-23 X2 (260h+320*8) ;12bit ;/relative to HSYNC
+
+ // senquack - gpu_senquack completely ignores GP1(0x06) command and
+ // lacks even a place in DisplayArea[] array to store the values.
+ // It seems to have been concerned only with vertical display range
+ // and centering top/bottom. I will not add support here, and
+ // focus instead on the gpulib version (gpulib_if.cpp) which uses
+ // gpulib for its PS1->host framebuffer blitting.
+ break;
+ case 0x07:
+ // GP1(07h) - Vertical Display range (on Screen)
+ // 0-9 Y1 (NTSC=88h-(224/2), (PAL=A3h-(264/2)) ;\scanline numbers on screen,
+ // 10-19 Y2 (NTSC=88h+(224/2), (PAL=A3h+(264/2)) ;/relative to VSYNC
+ // 20-23 Not used (zero)
+ {
+ u32 v1=data & 0x000003FF; //(short)(data & 0x3ff);
+ u32 v2=(data & 0x000FFC00) >> 10; //(short)((data>>10) & 0x3ff);
+ if ((gpu_senquack.DisplayArea[4]!=v1)||(gpu_senquack.DisplayArea[5]!=v2))
+ {
+ gpu_senquack.DisplayArea[4] = v1;
+ gpu_senquack.DisplayArea[5] = v2;
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"video_clear(CHANGE_Y)\n");
+ #endif
+ video_clear();
+ }
+ }
+ break;
+ case 0x08:
+ {
+ static const u32 HorizontalResolution[8] = { 256, 368, 320, 384, 512, 512, 640, 640 };
+ static const u32 VerticalResolution[4] = { 240, 480, 256, 480 };
+ gpu_senquack.GPU_GP1 = (gpu_senquack.GPU_GP1 & ~0x007F0000) | ((data & 0x3F) << 17) | ((data & 0x40) << 10);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_writeStatus(RES=%dx%d,BITS=%d,PAL=%d)\n",HorizontalResolution[(gpu_senquack.GPU_GP1 >> 16) & 7],
+ VerticalResolution[(gpu_senquack.GPU_GP1 >> 19) & 3],(gpu_senquack.GPU_GP1&0x00200000?24:15),(IS_PAL?1:0));
+ #endif
+ // Video mode change
+ u32 new_width = HorizontalResolution[(gpu_senquack.GPU_GP1 >> 16) & 7];
+ u32 new_height = VerticalResolution[(gpu_senquack.GPU_GP1 >> 19) & 3];
+
+ if (gpu_senquack.DisplayArea[2] != new_width || gpu_senquack.DisplayArea[3] != new_height)
+ {
+ // Update width
+ gpu_senquack.DisplayArea[2] = new_width;
+
+ if (PixelSkipEnabled()) {
+ // Set blit_mask for high horizontal resolutions. This allows skipping
+ // rendering pixels that would never get displayed on low-resolution
+ // platforms that use simple pixel-dropping scaler.
+ switch (gpu_senquack.DisplayArea[2])
+ {
+ case 512: gpu_senquack.blit_mask = 0xa4; break; // GPU_BlitWWSWWSWS
+ case 640: gpu_senquack.blit_mask = 0xaa; break; // GPU_BlitWS
+ default: gpu_senquack.blit_mask = 0; break;
+ }
+ } else {
+ gpu_senquack.blit_mask = 0;
+ }
+
+ // Update height
+ gpu_senquack.DisplayArea[3] = new_height;
+
+ if (LineSkipEnabled()) {
+ // Set rendering line-skip (only render every other line in high-res
+ // 480 vertical mode, or, optionally, force it for all video modes)
+
+ if (gpu_senquack.DisplayArea[3] == 480) {
+ if (gpu_senquack.config.ilace_force) {
+ gpu_senquack.ilace_mask = 3; // Only need 1/4 of lines
+ } else {
+ gpu_senquack.ilace_mask = 1; // Only need 1/2 of lines
+ }
+ } else {
+ // Vert resolution changed from 480 to lower one
+ gpu_senquack.ilace_mask = gpu_senquack.config.ilace_force;
+ }
+ } else {
+ gpu_senquack.ilace_mask = 0;
+ }
+
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"video_clear(CHANGE_RES)\n");
+ #endif
+ video_clear();
+ }
+
+ }
+ break;
+ case 0x10:
+ switch (data & 0xff) {
+ case 2: gpu_senquack.GPU_GP0 = gpu_senquack.tex_window; break;
+ case 3: gpu_senquack.GPU_GP0 = (gpu_senquack.DrawingArea[1] << 10) | gpu_senquack.DrawingArea[0]; break;
+ case 4: gpu_senquack.GPU_GP0 = ((gpu_senquack.DrawingArea[3]-1) << 10) | (gpu_senquack.DrawingArea[2]-1); break;
+ case 5: case 6: gpu_senquack.GPU_GP0 = (((u32)gpu_senquack.DrawingOffset[1] & 0x7ff) << 11) | ((u32)gpu_senquack.DrawingOffset[0] & 0x7ff); break;
+ case 7: gpu_senquack.GPU_GP0 = 2; break;
+ case 8: case 15: gpu_senquack.GPU_GP0 = 0xBFC03720; break;
+ }
+ break;
+ }
+}
+
+// Blitting functions
+#include "gpu_blit.h"
+
+static void gpuVideoOutput(void)
+{
+ int h0, x0, y0, w0, h1;
+
+ x0 = gpu_senquack.DisplayArea[0];
+ y0 = gpu_senquack.DisplayArea[1];
+
+ w0 = gpu_senquack.DisplayArea[2];
+ h0 = gpu_senquack.DisplayArea[3]; // video mode
+
+ h1 = gpu_senquack.DisplayArea[5] - gpu_senquack.DisplayArea[4]; // display needed
+ if (h0 == 480) h1 = Min2(h1*2,480);
+
+ bool isRGB24 = (gpu_senquack.GPU_GP1 & 0x00200000 ? true : false);
+ u16* dst16 = SCREEN;
+ u16* src16 = (u16*)gpu_senquack.vram;
+
+ // PS1 fb read wraps around (fixes black screen in 'Tobal no. 1')
+ unsigned int src16_offs_msk = 1024*512-1;
+ unsigned int src16_offs = (x0 + y0*1024) & src16_offs_msk;
+
+ // Height centering
+ int sizeShift = 1;
+ if (h0 == 256) {
+ h0 = 240;
+ } else if (h0 == 480) {
+ sizeShift = 2;
+ }
+ if (h1 > h0) {
+ src16_offs = (src16_offs + (((h1-h0) / 2) * 1024)) & src16_offs_msk;
+ h1 = h0;
+ } else if (h1<h0) {
+ dst16 += ((h0-h1) >> sizeShift) * VIDEO_WIDTH;
+ }
+
+
+ /* Main blitter */
+ int incY = (h0==480) ? 2 : 1;
+ h0=(h0==480 ? 2048 : 1024);
+
+ {
+ const int li=gpu_senquack.ilace_mask;
+ bool pi = ProgressiveInterlaceEnabled();
+ bool pif = gpu_senquack.prog_ilace_flag;
+ switch ( w0 )
+ {
+ case 256:
+ for(int y1=y0+h1; y0<y1; y0+=incY)
+ {
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWDWW(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
+ }
+ break;
+ case 368:
+ for(int y1=y0+h1; y0<y1; y0+=incY)
+ {
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWWWWWWWS(src16 + src16_offs, dst16, isRGB24, 4);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
+ }
+ break;
+ case 320:
+ // Ensure 32-bit alignment for GPU_BlitWW() blitter:
+ src16_offs &= ~1;
+ for(int y1=y0+h1; y0<y1; y0+=incY)
+ {
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWW(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
+ }
+ break;
+ case 384:
+ for(int y1=y0+h1; y0<y1; y0+=incY)
+ {
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWWWWS(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
+ }
+ break;
+ case 512:
+ for(int y1=y0+h1; y0<y1; y0+=incY)
+ {
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWWSWWSWS(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
+ }
+ break;
+ case 640:
+ for(int y1=y0+h1; y0<y1; y0+=incY)
+ {
+ if (( 0 == (y0&li) ) && ((!pi) || (pif=!pif)))
+ GPU_BlitWS(src16 + src16_offs, dst16, isRGB24);
+ dst16 += VIDEO_WIDTH;
+ src16_offs = (src16_offs + h0) & src16_offs_msk;
+ }
+ break;
+ }
+ gpu_senquack.prog_ilace_flag = !gpu_senquack.prog_ilace_flag;
+ }
+ video_flip();
+}
+
+// Update frames-skip each second>>3 (8 times per second)
+#define GPU_FRAMESKIP_UPDATE 3
+
+static void GPU_frameskip (bool show)
+{
+ u32 now=get_ticks(); // current frame
+
+ // Update frameskip
+ if (gpu_senquack.frameskip.skipCount==0) gpu_senquack.frameskip.skipFrame=false; // frameskip off
+ else if (gpu_senquack.frameskip.skipCount==7) { if (show) gpu_senquack.frameskip.skipFrame=!gpu_senquack.frameskip.skipFrame; } // frameskip medium
+ else if (gpu_senquack.frameskip.skipCount==8) gpu_senquack.frameskip.skipFrame=true; // frameskip maximum
+ else
+ {
+ static u32 spd=100; // speed %
+ static u32 frames=0; // frames counter
+ static u32 prev=now; // previous fps calculation
+ frames++;
+ if ((now-prev)>=(TPS>>GPU_FRAMESKIP_UPDATE))
+ {
+ if (IS_PAL) spd=(frames<<1);
+ else spd=((frames*1001)/600);
+ spd<<=GPU_FRAMESKIP_UPDATE;
+ frames=0;
+ prev=now;
+ }
+ switch(gpu_senquack.frameskip.skipCount)
+ {
+ case 1: if (spd<50) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<50%)
+ case 2: if (spd<60) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<60%)
+ case 3: if (spd<70) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<70%)
+ case 4: if (spd<80) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<80%)
+ case 5: if (spd<90) gpu_senquack.frameskip.skipFrame=true; else gpu_senquack.frameskip.skipFrame=false; break; // frameskip on (spd<90%)
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+void GPU_updateLace(void)
+{
+ // Interlace bit toggle
+ gpu_senquack.GPU_GP1 ^= 0x80000000;
+
+ // Update display?
+ if ((gpu_senquack.fb_dirty) && (!gpu_senquack.frameskip.wasSkip) && (!(gpu_senquack.GPU_GP1&0x00800000)))
+ {
+ // Display updated
+ gpuVideoOutput();
+ GPU_frameskip(true);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_updateLace(UPDATE)\n");
+ #endif
+ } else {
+ GPU_frameskip(false);
+ #ifdef ENABLE_GPU_LOG_SUPPORT
+ fprintf(stdout,"GPU_updateLace(SKIP)\n");
+ #endif
+ }
+
+ if ((!gpu_senquack.frameskip.skipCount) && (gpu_senquack.DisplayArea[3] == 480)) gpu_senquack.frameskip.skipGPU=true; // Tekken 3 hack
+
+ gpu_senquack.fb_dirty=false;
+ gpu_senquack.dma.last_dma = NULL;
+}
+
+// Allows frontend to signal plugin to redraw screen after returning to emu
+void GPU_requestScreenRedraw()
+{
+ gpu_senquack.fb_dirty = true;
+}
+
+void GPU_getScreenInfo(GPUScreenInfo_t *sinfo)
+{
+ bool depth24 = (gpu_senquack.GPU_GP1 & 0x00200000 ? true : false);
+ int16_t hres = (uint16_t)gpu_senquack.DisplayArea[2];
+ int16_t vres = (uint16_t)gpu_senquack.DisplayArea[3];
+ int16_t w = hres; // Original gpu_senquack doesn't support width < 100%
+ int16_t h = gpu_senquack.DisplayArea[5] - gpu_senquack.DisplayArea[4];
+ if (vres == 480)
+ h *= 2;
+ if (h <= 0 || h > vres)
+ h = vres;
+
+ sinfo->vram = (uint8_t*)gpu_senquack.vram;
+ sinfo->x = (uint16_t)gpu_senquack.DisplayArea[0];
+ sinfo->y = (uint16_t)gpu_senquack.DisplayArea[1];
+ sinfo->w = w;
+ sinfo->h = h;
+ sinfo->hres = hres;
+ sinfo->vres = vres;
+ sinfo->depth24 = depth24;
+ sinfo->pal = IS_PAL;
+}
notaz.gp2x.de / pcsx_rearmed.git / blobdiff