mirror of https://github.com/PCSX2/pcsx2.git
463 lines
20 KiB
C#
463 lines
20 KiB
C#
/*
|
|
* Copyright (C) 2009-2011 Ferreri Alessio
|
|
* Copyright (C) 2009-2018 PCSX2 Dev Team
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Runtime.InteropServices;
|
|
using System.IO;
|
|
using TCPLibrary.MessageBased.Core;
|
|
using System.Threading;
|
|
|
|
namespace GSDumpGUI
|
|
{
|
|
public delegate void GSgifTransfer(IntPtr data, int size);
|
|
public delegate void GSgifTransfer1(IntPtr data, int size);
|
|
public delegate void GSgifTransfer2(IntPtr data, int size);
|
|
public delegate void GSgifTransfer3(IntPtr data, int size);
|
|
public delegate void GSVSync(byte field);
|
|
public delegate void GSreset();
|
|
public delegate void GSreadFIFO2(IntPtr data, int size);
|
|
public delegate void GSsetGameCRC(int crc, int options);
|
|
public delegate int GSfreeze(int mode, IntPtr data);
|
|
public delegate int GSopen(IntPtr hwnd, String Title, int renderer);
|
|
public delegate void GSclose();
|
|
public delegate void GSshutdown();
|
|
public delegate void GSConfigure();
|
|
public delegate void GSsetBaseMem(IntPtr data);
|
|
public delegate IntPtr PS2EgetLibName();
|
|
public delegate void GSinit();
|
|
public delegate UInt32 GSmakeSnapshot(string path);
|
|
|
|
public class InvalidGSPlugin : Exception
|
|
{
|
|
public InvalidGSPlugin(string reason) : base(reason) {}
|
|
}
|
|
|
|
public class GSDXWrapper
|
|
{
|
|
static public bool DumpTooOld = false;
|
|
|
|
private GSConfigure gsConfigure;
|
|
private PS2EgetLibName Ps2egetLibName;
|
|
private GSgifTransfer GSgifTransfer;
|
|
private GSgifTransfer1 GSgifTransfer1;
|
|
private GSgifTransfer2 GSgifTransfer2;
|
|
private GSgifTransfer3 GSgifTransfer3;
|
|
private GSVSync GSVSync;
|
|
private GSreadFIFO2 GSreadFIFO2;
|
|
private GSsetGameCRC GSsetGameCRC;
|
|
private GSfreeze GSfreeze;
|
|
private GSopen GSopen;
|
|
private GSclose GSclose;
|
|
private GSshutdown GSshutdown;
|
|
private GSsetBaseMem GSsetBaseMem;
|
|
private GSinit GSinit;
|
|
private GSreset GSreset;
|
|
private GSmakeSnapshot GSmakeSnapshot;
|
|
private Boolean Loaded;
|
|
|
|
private String DLL;
|
|
private IntPtr DLLAddr;
|
|
|
|
private Boolean Running;
|
|
|
|
public Queue<TCPMessage> QueueMessage;
|
|
public Boolean DebugMode;
|
|
public GSData CurrentGIFPacket;
|
|
public bool ThereIsWork;
|
|
public AutoResetEvent ExternalEvent;
|
|
public int RunTo;
|
|
|
|
public void Load(String DLL)
|
|
{
|
|
var formerDirectory = Directory.GetCurrentDirectory();
|
|
try
|
|
{
|
|
this.DLL = DLL;
|
|
NativeMethods.SetErrorMode(0x8007);
|
|
|
|
if (Loaded)
|
|
Unload();
|
|
|
|
string dir = DLL;
|
|
dir = Path.GetDirectoryName(dir);
|
|
if (dir == null) return;
|
|
|
|
Directory.SetCurrentDirectory(dir);
|
|
IntPtr hmod = NativeMethods.LoadLibrary(DLL);
|
|
if (hmod != IntPtr.Zero)
|
|
{
|
|
DLLAddr = hmod;
|
|
|
|
IntPtr funcaddrLibName = NativeMethods.GetProcAddress(hmod, "PS2EgetLibName");
|
|
IntPtr funcaddrConfig = NativeMethods.GetProcAddress(hmod, "GSconfigure");
|
|
|
|
IntPtr funcaddrGIF = NativeMethods.GetProcAddress(hmod, "GSgifTransfer");
|
|
IntPtr funcaddrGIF1 = NativeMethods.GetProcAddress(hmod, "GSgifTransfer1");
|
|
IntPtr funcaddrGIF2 = NativeMethods.GetProcAddress(hmod, "GSgifTransfer2");
|
|
IntPtr funcaddrGIF3 = NativeMethods.GetProcAddress(hmod, "GSgifTransfer3");
|
|
IntPtr funcaddrVSync = NativeMethods.GetProcAddress(hmod, "GSvsync");
|
|
IntPtr funcaddrSetBaseMem = NativeMethods.GetProcAddress(hmod, "GSsetBaseMem");
|
|
IntPtr funcaddrGSReset = NativeMethods.GetProcAddress(hmod, "GSreset");
|
|
IntPtr funcaddrOpen = NativeMethods.GetProcAddress(hmod, "GSopen");
|
|
IntPtr funcaddrSetCRC = NativeMethods.GetProcAddress(hmod, "GSsetGameCRC");
|
|
IntPtr funcaddrClose = NativeMethods.GetProcAddress(hmod, "GSclose");
|
|
IntPtr funcaddrShutdown = NativeMethods.GetProcAddress(hmod, "GSshutdown");
|
|
IntPtr funcaddrFreeze = NativeMethods.GetProcAddress(hmod, "GSfreeze");
|
|
IntPtr funcaddrGSreadFIFO2 = NativeMethods.GetProcAddress(hmod, "GSreadFIFO2");
|
|
IntPtr funcaddrinit = NativeMethods.GetProcAddress(hmod, "GSinit");
|
|
IntPtr funcmakeSnapshot = NativeMethods.GetProcAddress(hmod, "GSmakeSnapshot");
|
|
|
|
if (!((funcaddrConfig.ToInt64() > 0) && (funcaddrLibName.ToInt64() > 0) && (funcaddrGIF.ToInt64() > 0)))
|
|
throw new InvalidGSPlugin("");
|
|
|
|
gsConfigure = (GSConfigure) Marshal.GetDelegateForFunctionPointer(funcaddrConfig, typeof(GSConfigure));
|
|
Ps2egetLibName = (PS2EgetLibName) Marshal.GetDelegateForFunctionPointer(funcaddrLibName, typeof(PS2EgetLibName));
|
|
|
|
this.GSgifTransfer = (GSgifTransfer) Marshal.GetDelegateForFunctionPointer(funcaddrGIF, typeof(GSgifTransfer));
|
|
this.GSgifTransfer1 = (GSgifTransfer1) Marshal.GetDelegateForFunctionPointer(funcaddrGIF1, typeof(GSgifTransfer1));
|
|
this.GSgifTransfer2 = (GSgifTransfer2) Marshal.GetDelegateForFunctionPointer(funcaddrGIF2, typeof(GSgifTransfer2));
|
|
this.GSgifTransfer3 = (GSgifTransfer3) Marshal.GetDelegateForFunctionPointer(funcaddrGIF3, typeof(GSgifTransfer3));
|
|
this.GSVSync = (GSVSync) Marshal.GetDelegateForFunctionPointer(funcaddrVSync, typeof(GSVSync));
|
|
this.GSsetBaseMem = (GSsetBaseMem) Marshal.GetDelegateForFunctionPointer(funcaddrSetBaseMem, typeof(GSsetBaseMem));
|
|
this.GSopen = (GSopen) Marshal.GetDelegateForFunctionPointer(funcaddrOpen, typeof(GSopen));
|
|
this.GSsetGameCRC = (GSsetGameCRC) Marshal.GetDelegateForFunctionPointer(funcaddrSetCRC, typeof(GSsetGameCRC));
|
|
this.GSclose = (GSclose) Marshal.GetDelegateForFunctionPointer(funcaddrClose, typeof(GSclose));
|
|
this.GSshutdown = (GSshutdown) Marshal.GetDelegateForFunctionPointer(funcaddrShutdown, typeof(GSshutdown));
|
|
this.GSfreeze = (GSfreeze) Marshal.GetDelegateForFunctionPointer(funcaddrFreeze, typeof(GSfreeze));
|
|
this.GSreset = (GSreset) Marshal.GetDelegateForFunctionPointer(funcaddrGSReset, typeof(GSreset));
|
|
this.GSreadFIFO2 = (GSreadFIFO2) Marshal.GetDelegateForFunctionPointer(funcaddrGSreadFIFO2, typeof(GSreadFIFO2));
|
|
this.GSinit = (GSinit) Marshal.GetDelegateForFunctionPointer(funcaddrinit, typeof(GSinit));
|
|
this.GSmakeSnapshot = (GSmakeSnapshot)Marshal.GetDelegateForFunctionPointer(funcmakeSnapshot, typeof(GSmakeSnapshot));
|
|
|
|
Loaded = true;
|
|
}
|
|
|
|
if (!Loaded)
|
|
{
|
|
Exception lasterror = Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error());
|
|
System.IO.File.AppendAllText(AppDomain.CurrentDomain.BaseDirectory + "log.txt", DLL + " failed to load. Error " + lasterror.ToString() + Environment.NewLine);
|
|
NativeMethods.SetErrorMode(0x0000);
|
|
Unload();
|
|
throw new InvalidGSPlugin(lasterror.ToString());
|
|
}
|
|
|
|
NativeMethods.SetErrorMode(0x0000);
|
|
}
|
|
finally
|
|
{
|
|
Directory.SetCurrentDirectory(formerDirectory);
|
|
}
|
|
}
|
|
|
|
public void Unload()
|
|
{
|
|
NativeMethods.FreeLibrary(DLLAddr);
|
|
Loaded = false;
|
|
}
|
|
|
|
public void GSConfig()
|
|
{
|
|
if (!Loaded)
|
|
throw new Exception("GSdx is not loaded");
|
|
gsConfigure.Invoke();
|
|
}
|
|
|
|
public String PS2EGetLibName()
|
|
{
|
|
if (!Loaded)
|
|
throw new Exception("GSdx is not loaded");
|
|
return Marshal.PtrToStringAnsi(Ps2egetLibName.Invoke());
|
|
}
|
|
|
|
public unsafe void Run(GSDump dump, int rendererOverride)
|
|
{
|
|
QueueMessage = new Queue<TCPMessage>();
|
|
Running = true;
|
|
ExternalEvent = new AutoResetEvent(true);
|
|
|
|
GSinit();
|
|
byte[] tempregisters = new byte[8192];
|
|
Array.Copy(dump.Registers, tempregisters, 8192);
|
|
fixed (byte* pointer = tempregisters)
|
|
{
|
|
GSsetBaseMem(new IntPtr(pointer));
|
|
IntPtr hWnd = IntPtr.Zero;
|
|
|
|
if (GSopen(new IntPtr(&hWnd), "", rendererOverride) != 0)
|
|
return;
|
|
|
|
GSsetGameCRC(dump.CRC, 0);
|
|
|
|
NativeMethods.SetClassLong(hWnd,/*GCL_HICON*/ -14, Program.hMainIcon);
|
|
|
|
fixed (byte* freeze = dump.StateData)
|
|
{
|
|
byte[] GSFreez;
|
|
|
|
if (Environment.Is64BitProcess)
|
|
{
|
|
GSFreez = new byte[16];
|
|
Array.Copy(BitConverter.GetBytes((Int64)dump.StateData.Length), 0, GSFreez, 0, 8);
|
|
Array.Copy(BitConverter.GetBytes(new IntPtr(freeze).ToInt64()), 0, GSFreez, 8, 8);
|
|
}
|
|
else
|
|
{
|
|
GSFreez = new byte[8];
|
|
Array.Copy(BitConverter.GetBytes((Int32)dump.StateData.Length), 0, GSFreez, 0, 4);
|
|
Array.Copy(BitConverter.GetBytes(new IntPtr(freeze).ToInt32()), 0, GSFreez, 4, 4);
|
|
}
|
|
|
|
fixed (byte* fr = GSFreez)
|
|
{
|
|
int ris = GSfreeze(0, new IntPtr(fr));
|
|
if (ris == -1)
|
|
{
|
|
DumpTooOld = true;
|
|
Running = false;
|
|
}
|
|
GSVSync(1);
|
|
|
|
GSreset();
|
|
Marshal.Copy(dump.Registers, 0, new IntPtr(pointer), 8192);
|
|
GSsetBaseMem(new IntPtr(pointer));
|
|
GSfreeze(0, new IntPtr(fr));
|
|
|
|
GSData gsd_vsync = new GSData();
|
|
gsd_vsync.id = GSType.VSync;
|
|
|
|
int gs_idx = 0;
|
|
int debug_idx = 0;
|
|
NativeMessage msg;
|
|
|
|
while (Running)
|
|
{
|
|
while (NativeMethods.PeekMessage(out msg, hWnd, 0, 0, 1)) // PM_REMOVE
|
|
{
|
|
NativeMethods.TranslateMessage(ref msg);
|
|
NativeMethods.DispatchMessage(ref msg);
|
|
|
|
if(msg.msg == 0x0100) // WM_KEYDOWN
|
|
{
|
|
switch(msg.wParam.ToInt32() & 0xFF)
|
|
{
|
|
case 0x1B: Running = false; break; // VK_ESCAPE;
|
|
case 0x77: GSmakeSnapshot(""); break; // VK_F8;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Running || !NativeMethods.IsWindowVisible(hWnd))
|
|
break;
|
|
|
|
if (DebugMode)
|
|
{
|
|
if (QueueMessage.Count > 0)
|
|
{
|
|
TCPMessage Mess = QueueMessage.Dequeue();
|
|
switch (Mess.MessageType)
|
|
{
|
|
case MessageType.Step:
|
|
if (debug_idx >= dump.Data.Count)
|
|
debug_idx = 0;
|
|
RunTo = debug_idx;
|
|
break;
|
|
case MessageType.RunToCursor:
|
|
RunTo = (int)Mess.Parameters[0];
|
|
if(debug_idx > RunTo)
|
|
debug_idx = 0;
|
|
break;
|
|
case MessageType.RunToNextVSync:
|
|
if (debug_idx >= dump.Data.Count)
|
|
debug_idx = 1;
|
|
RunTo = dump.Data.FindIndex(debug_idx, a => a.id == GSType.VSync);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (debug_idx <= RunTo)
|
|
{
|
|
while (debug_idx <= RunTo)
|
|
{
|
|
GSData itm = dump.Data[debug_idx];
|
|
CurrentGIFPacket = itm;
|
|
Step(itm, pointer);
|
|
debug_idx++;
|
|
}
|
|
|
|
int idxnextReg = dump.Data.FindIndex(debug_idx, a => a.id == GSType.Registers);
|
|
if (idxnextReg != -1)
|
|
Step(dump.Data[idxnextReg], pointer);
|
|
|
|
TCPMessage Msg = new TCPMessage();
|
|
Msg.MessageType = MessageType.RunToCursor;
|
|
Msg.Parameters.Add(debug_idx - 1);
|
|
Program.Client.Send(Msg);
|
|
|
|
ExternalEvent.Set();
|
|
}
|
|
|
|
Step(gsd_vsync, pointer);
|
|
}
|
|
else
|
|
{
|
|
while (gs_idx < dump.Data.Count)
|
|
{
|
|
GSData itm = dump.Data[gs_idx++];
|
|
CurrentGIFPacket = itm;
|
|
Step(itm, pointer);
|
|
|
|
if (gs_idx < dump.Data.Count && dump.Data[gs_idx].id == GSType.VSync)
|
|
break;
|
|
}
|
|
|
|
if (gs_idx >= dump.Data.Count) gs_idx = 0;
|
|
}
|
|
}
|
|
|
|
GSclose();
|
|
GSshutdown();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private unsafe void Step(GSData itm, byte* registers)
|
|
{
|
|
/*"C:\Users\Alessio\Desktop\Plugins\Dll\GSdx-SSE4.dll" "C:\Users\Alessio\Desktop\Plugins\Dumps\gsdx_20101222215004.gs" "GSReplay" 0*/
|
|
switch (itm.id)
|
|
{
|
|
case GSType.Transfer:
|
|
switch (((GSTransfer)itm).Path)
|
|
{
|
|
case GSTransferPath.Path1Old:
|
|
byte[] data = new byte[16384];
|
|
int addr = 16384 - itm.data.Length;
|
|
Array.Copy(itm.data, 0, data, addr, itm.data.Length);
|
|
fixed (byte* gifdata = data)
|
|
{
|
|
GSgifTransfer1(new IntPtr(gifdata), addr);
|
|
}
|
|
break;
|
|
case GSTransferPath.Path2:
|
|
fixed (byte* gifdata = itm.data)
|
|
{
|
|
GSgifTransfer2(new IntPtr(gifdata), (itm.data.Length) / 16);
|
|
}
|
|
break;
|
|
case GSTransferPath.Path3:
|
|
fixed (byte* gifdata = itm.data)
|
|
{
|
|
GSgifTransfer3(new IntPtr(gifdata), (itm.data.Length) / 16);
|
|
}
|
|
break;
|
|
case GSTransferPath.Path1New:
|
|
fixed (byte* gifdata = itm.data)
|
|
{
|
|
GSgifTransfer(new IntPtr(gifdata), (itm.data.Length) / 16);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case GSType.VSync:
|
|
GSVSync((*((int*)(registers + 4096)) & 0x2000) > 0 ? (byte)1 : (byte)0);
|
|
break;
|
|
case GSType.ReadFIFO2:
|
|
fixed (byte* FIFO = itm.data)
|
|
{
|
|
byte[] arrnew = new byte[*((int*)FIFO)];
|
|
fixed (byte* arrn = arrnew)
|
|
{
|
|
GSreadFIFO2(new IntPtr(arrn), *((int*)FIFO));
|
|
}
|
|
}
|
|
break;
|
|
case GSType.Registers:
|
|
Marshal.Copy(itm.data, 0, new IntPtr(registers), 8192);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void Stop()
|
|
{
|
|
Running = false;
|
|
}
|
|
|
|
internal List<Object> GetGifPackets(GSDump dump)
|
|
{
|
|
List<Object> Data = new List<Object>();
|
|
for (int i = 0; i < dump.Data.Count; i++)
|
|
{
|
|
String act = i.ToString() + "|";
|
|
act += dump.Data[i].id.ToString() + "|";
|
|
if (dump.Data[i].GetType().IsSubclassOf(typeof(GSData)))
|
|
{
|
|
act += ((GSTransfer)dump.Data[i]).Path.ToString() + "|";
|
|
act += ((GSTransfer)dump.Data[i]).data.Length;
|
|
}
|
|
else
|
|
{
|
|
act += ((GSData)dump.Data[i]).data.Length;
|
|
}
|
|
Data.Add(act);
|
|
}
|
|
return Data;
|
|
}
|
|
|
|
internal object GetGifPacketInfo(GSDump dump, int i)
|
|
{
|
|
if (dump.Data[i].id == GSType.Transfer)
|
|
{
|
|
try
|
|
{
|
|
GIFTag val = GIFTag.ExtractGifTag(dump.Data[i].data, ((GSTransfer)dump.Data[i]).Path);
|
|
return val;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return new GIFTag();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (dump.Data[i].id)
|
|
{
|
|
case GSType.VSync:
|
|
return dump.Data[i].data.Length + "|Field = " + dump.Data[i].data[0].ToString();
|
|
case GSType.ReadFIFO2:
|
|
return dump.Data[i].data.Length + "|ReadFIFO2 : Size = " + BitConverter.ToInt32(dump.Data[i].data, 0).ToString() + " byte";
|
|
case GSType.Registers:
|
|
return dump.Data[i].data.Length + "|Registers";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|