ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/TASVideos/BizHawk

This commit is contained in:
adelikat 2016-02-17 20:53:17 -05:00
parent cacfb615c4 96fc7c9ec1
commit 5732362543
15 changed files with 585 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BizHawk.Client.EmuHawk/tools/Watch/RamWatch.cs
View File

@ -407,7 +407,7 @@ namespace BizHawk.Client.EmuHawk
we.SetWatch(SelectedWatches.First().Domain, SelectedWatches, duplicate ? WatchEditor.Mode.Duplicate : WatchEditor.Mode.Edit);
var result = we.ShowHawkDialog();
var result = we.ShowHawkDialog(this);
if (result == DialogResult.OK)
{
Changes();
@ -777,7 +777,7 @@ namespace BizHawk.Client.EmuHawk
poke.SetWatch(SelectedWatches);
if (poke.ShowHawkDialog() == DialogResult.OK)
if (poke.ShowHawkDialog(this) == DialogResult.OK)
{
UpdateValues();
}

3
BizHawk.Emulation.Common/BizHawk.Emulation.Common.csproj
View File

@ -64,6 +64,9 @@
<Compile Include="Base Implementations\NullSound.cs" />
<Compile Include="Base Implementations\TraceBuffer.cs" />
<Compile Include="BinaryQuickSerializer.cs" />
<Compile Include="BizInvoke\BizInvoker.cs" />
<Compile Include="BizInvoke\IImportResolver.cs" />
<Compile Include="BizInvoke\Win32LibraryImportResolver.cs" />
<Compile Include="CodeDataLog.cs" />
<Compile Include="CoreAttributes.cs" />
<Compile Include="CoreComms.cs" />

209
BizHawk.Emulation.Common/BizInvoke/BizInvoker.cs Normal file
View File

@ -0,0 +1,209 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;
namespace BizHawk.Emulation.Common.BizInvoke
{
public static class BizInvoker
{
public static T GetInvoker<T>(IImportResolver dll)
where T : class
{
var baseType = typeof(T);
if (baseType.IsSealed)
throw new InvalidOperationException("Can't proxy a sealed type");
if (!baseType.IsPublic)
// the proxy type will be in a new assembly, so public is required here
throw new InvalidOperationException("Type must be public");
var baseConstructor = baseType.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
if (baseConstructor == null)
throw new InvalidOperationException("Base type must have a zero arg constructor");
var baseMethods = baseType.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Select(m => new
{
Info = m,
Attr = m.GetCustomAttributes(true).OfType<BizImportAttribute>().FirstOrDefault()
})
.Where(a => a.Attr != null)
.ToList();
if (baseMethods.Count == 0)
throw new InvalidOperationException("Couldn't find any [BizImport] methods to proxy");
{
var uo = baseMethods.FirstOrDefault(a => !a.Info.IsVirtual || a.Info.IsFinal);
if (uo != null)
throw new InvalidOperationException("Method " + uo.Info.Name + " cannot be overriden!");
// there's no technical reason to disallow this, but we wouldn't be doing anything
// with the base implementation, so it's probably a user error
var na = baseMethods.FirstOrDefault(a => !a.Info.IsAbstract);
if (na != null)
throw new InvalidOperationException("Method " + na.Info.Name + " is not abstract!");
}
var aname = new AssemblyName(baseType.Name + Guid.NewGuid().ToString("N"));
var assy = AppDomain.CurrentDomain.DefineDynamicAssembly(aname, AssemblyBuilderAccess.Run);
var module = assy.DefineDynamicModule("BizInvoker");
var type = module.DefineType("Bizhawk.BizInvokeProxy", TypeAttributes.Class | TypeAttributes.Public, baseType);
foreach (var mi in baseMethods)
{
var paramInfos = mi.Info.GetParameters();
var paramTypes = paramInfos.Select(p => p.ParameterType).ToArray();
var nativeParamTypes = new List<Type>();
var returnType = mi.Info.ReturnType;
var method = type.DefineMethod(mi.Info.Name, MethodAttributes.Virtual | MethodAttributes.Public,
CallingConventions.HasThis, returnType, paramTypes);
var entryPointName = mi.Attr.EntryPoint ?? mi.Info.Name;
var entryPtr = dll.Resolve(entryPointName);
if (entryPtr == IntPtr.Zero)
throw new InvalidOperationException("Resolver returned NULL for entry point " + entryPointName);
if (returnType != typeof(void) && !returnType.IsPrimitive)
throw new InvalidOperationException("Only primitive return types are supported");
var il = method.GetILGenerator();
for (int i = 0; i < paramTypes.Length; i++)
{
// arg 0 is this, so + 1
nativeParamTypes.Add(EmitParamterLoad(il, i + 1, paramTypes[i]));
}
LoadConstant(il, entryPtr);
il.EmitCalli(OpCodes.Calli, mi.Attr.CallingConvention, returnType, nativeParamTypes.ToArray());
// either there's a primitive on the stack and we're expected to return that primitive,
// or there's nothing on the stack and we're expected to return nothing
il.Emit(OpCodes.Ret);
type.DefineMethodOverride(method, mi.Info);
}
return (T)Activator.CreateInstance(type.CreateType());
}
private static void LoadConstant(ILGenerator il, IntPtr p)
{
if (p == IntPtr.Zero)
il.Emit(OpCodes.Ldc_I4_0);
else if (IntPtr.Size == 4)
il.Emit(OpCodes.Ldc_I4, (int)p);
else
il.Emit(OpCodes.Ldc_I8, (long)p);
il.Emit(OpCodes.Conv_I);
}
private static void LoadConstant(ILGenerator il, UIntPtr p)
{
if (p == UIntPtr.Zero)
il.Emit(OpCodes.Ldc_I4_0);
else if (UIntPtr.Size == 4)
il.Emit(OpCodes.Ldc_I4, (int)p);
else
il.Emit(OpCodes.Ldc_I8, (long)p);
il.Emit(OpCodes.Conv_U);
}
private static Type EmitParamterLoad(ILGenerator il, int idx, Type type)
{
if (type.IsGenericType)
throw new InvalidOperationException("Generic types not supported");
if (type.IsByRef)
{
var et = type.GetElementType();
if (!et.IsPrimitive)
throw new InvalidOperationException("Only refs of primitive types are supported!");
var loc = il.DeclareLocal(type, true);
il.Emit(OpCodes.Ldarg, (short)idx);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, loc);
il.Emit(OpCodes.Conv_I);
return typeof(IntPtr);
}
else if (type.IsArray)
{
var et = type.GetElementType();
if (!et.IsPrimitive)
throw new InvalidOperationException("Only arrays of primitive types are supported!");
// these two cases aren't too hard to add
if (type.GetArrayRank() > 1)
throw new InvalidOperationException("Multidimensional arrays are not supported!");
if (type.Name.Contains('*'))
throw new InvalidOperationException("Only 0-based 1-dimensional arrays are supported!");
var loc = il.DeclareLocal(type, true);
var end = il.DefineLabel();
var isNull = il.DefineLabel();
il.Emit(OpCodes.Ldarg, (short)idx);
il.Emit(OpCodes.Brfalse, isNull);
il.Emit(OpCodes.Ldarg, (short)idx);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Stloc, loc);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldelema, et);
il.Emit(OpCodes.Conv_I);
il.Emit(OpCodes.Br, end);
il.MarkLabel(isNull);
LoadConstant(il, IntPtr.Zero);
il.MarkLabel(end);
return typeof(IntPtr);
}
else if (typeof(Delegate).IsAssignableFrom(type))
{
var mi = typeof(Marshal).GetMethod("GetFunctionPointerForDelegate", new[] { typeof(Delegate) });
var end = il.DefineLabel();
var isNull = il.DefineLabel();
il.Emit(OpCodes.Ldarg, (short)idx);
il.Emit(OpCodes.Brfalse, isNull);
il.Emit(OpCodes.Ldarg, (short)idx);
il.Emit(OpCodes.Call, mi);
il.Emit(OpCodes.Br, end);
il.MarkLabel(isNull);
LoadConstant(il, IntPtr.Zero);
il.MarkLabel(end);
return typeof(IntPtr);
}
else if (type.IsPrimitive)
{
il.Emit(OpCodes.Ldarg, (short)idx);
return type;
}
else
{
throw new InvalidOperationException("Unrecognized parameter type!");
}
}
}
[AttributeUsage(AttributeTargets.Method)]
public class BizImportAttribute : Attribute
{
public CallingConvention CallingConvention
{
get { return _callingConvention; }
}
private readonly CallingConvention _callingConvention;
public string EntryPoint { get; set; }
public BizImportAttribute(CallingConvention c)
{
_callingConvention = c;
}
}
}

12
BizHawk.Emulation.Common/BizInvoke/IImportResolver.cs Normal file
View File

@ -0,0 +1,12 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BizHawk.Emulation.Common.BizInvoke
{
public interface IImportResolver
{
IntPtr Resolve(string entryPoint);
}
}

55
BizHawk.Emulation.Common/BizInvoke/Win32LibraryImportResolver.cs Normal file
View File

@ -0,0 +1,55 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace BizHawk.Emulation.Common.BizInvoke
{
public class Win32LibraryImportResolver : IImportResolver, IDisposable
{
private IntPtr _p;
public Win32LibraryImportResolver(string dllName)
{
_p = Win32.LoadLibrary(dllName);
if (_p == IntPtr.Zero)
throw new InvalidOperationException("LoadLibrary returned NULL");
}
public IntPtr Resolve(string entryPoint)
{
return Win32.GetProcAddress(_p, entryPoint);
}
private void Free()
{
if (_p != IntPtr.Zero)
{
Win32.FreeLibrary(_p);
_p = IntPtr.Zero;
}
}
public void Dispose()
{
Free();
GC.SuppressFinalize(this);
}
~Win32LibraryImportResolver()
{
Free();
}
private static class Win32
{
[DllImport("kernel32.dll")]
public static extern IntPtr LoadLibrary(string dllToLoad);
[DllImport("kernel32.dll")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
[DllImport("kernel32.dll")]
public static extern bool FreeLibrary(IntPtr hModule);
}
}
}

256
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/LibQuickNES.cs
View File

@ -3,10 +3,11 @@ using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using BizHawk.Emulation.Common.BizInvoke;
namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
{
public static class LibQuickNES
public static class LibQuickNESOld
{
public const string dllname = "libquicknes.dll";
@ -258,4 +259,257 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
}
}
}
public abstract class LibQuickNES
{
public const string dllname = "libquicknes.dll";
/// <summary>
/// setup extra mappers. should be done before anything else
/// </summary>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_setup_mappers();
/// <summary>
/// create a new quicknes context
/// </summary>
/// <returns>NULL on failure</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_new();
/// <summary>
/// destroy a quicknes context
/// </summary>
/// <param name="e">context previously returned from qn_new()</param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_delete(IntPtr e);
/// <summary>
/// load an ines file
/// </summary>
/// <param name="e">context</param>
/// <param name="data">file</param>
/// <param name="length">length of file</param>
/// <returns></returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_loadines(IntPtr e, byte[] data, int length);
/// <summary>
/// set audio sample rate
/// </summary>
/// <param name="e">context</param>
/// <param name="rate">hz</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_set_sample_rate(IntPtr e, int rate);
/// <summary>
/// emulate a single frame
/// </summary>
/// <param name="e">context</param>
/// <param name="pad1">pad 1 input</param>
/// <param name="pad2">pad 2 input</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_emulate_frame(IntPtr e, int pad1, int pad2);
/// <summary>
/// blit to rgb32
/// </summary>
/// <param name="e">Context</param>
/// <param name="dest">rgb32 256x240 packed</param>
/// <param name="colors">rgb32 colors, 512 of them</param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_blit(IntPtr e, int[] dest, int[] colors, int cropleft, int croptop, int cropright, int cropbottom);
/// <summary>
/// get quicknes's default palette
/// </summary>
/// <returns>1536 bytes suitable for qn_blit</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_get_default_colors();
/// <summary>
/// get number of times joypad was read in most recent frame
/// </summary>
/// <param name="e">context</param>
/// <returns>0 means lag</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract int qn_get_joypad_read_count(IntPtr e);
/// <summary>
/// get audio info for most recent frame
/// </summary>
/// <param name="e">context</param>
/// <param name="sample_count">number of samples actually created</param>
/// <param name="chan_count">1 for mono, 2 for stereo</param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_get_audio_info(IntPtr e, ref int sample_count, ref int chan_count);
/// <summary>
/// get audio for most recent frame. must not be called more than once per frame!
/// </summary>
/// <param name="e">context</param>
/// <param name="dest">sample buffer</param>
/// <param name="max_samples">length to read into sample buffer</param>
/// <returns>length actually read</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract int qn_read_audio(IntPtr e, short[] dest, int max_samples);
/// <summary>
/// reset the console
/// </summary>
/// <param name="e">context</param>
/// <param name="hard">true for powercycle, false for reset button</param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_reset(IntPtr e, bool hard);
/// <summary>
/// get the required byte size of a savestate
/// </summary>
/// <param name="e">context</param>
/// <param name="size">size is returned</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_state_size(IntPtr e, ref int size);
/// <summary>
/// save state to buffer
/// </summary>
/// <param name="e">context</param>
/// <param name="dest">buffer</param>
/// <param name="size">length of buffer</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_state_save(IntPtr e, byte[] dest, int size);
/// <summary>
/// load state from buffer
/// </summary>
/// <param name="e">context</param>
/// <param name="src">buffer</param>
/// <param name="size">length of buffer</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_state_load(IntPtr e, byte[] src, int size);
/// <summary>
/// query battery ram state
/// </summary>
/// <param name="e">context</param>
/// <returns>true if battery backup sram exists</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract bool qn_has_battery_ram(IntPtr e);
/// <summary>
/// query battery ram size
/// </summary>
/// <param name="e">context</param>
/// <param name="size">size is returned</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_battery_ram_size(IntPtr e, ref int size);
/// <summary>
/// save battery ram to buffer
/// </summary>
/// <param name="e">context</param>
/// <param name="dest">buffer</param>
/// <param name="size">size</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_battery_ram_save(IntPtr e, byte[] dest, int size);
/// <summary>
/// load battery ram from buffer
/// </summary>
/// <param name="e">context</param>
/// <param name="src">buffer</param>
/// <param name="size">size</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_battery_ram_load(IntPtr e, byte[] src, int size);
/// <summary>
/// clear battery ram
/// </summary>
/// <param name="e">context</param>
/// <returns>string error</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_battery_ram_clear(IntPtr e);
/// <summary>
/// set sprite limit; does not affect emulation
/// </summary>
/// <param name="e">context</param>
/// <param name="n">0 to hide, 8 for normal, 64 for all</param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_set_sprite_limit(IntPtr e, int n);
/// <summary>
/// get memory area for debugging
/// </summary>
/// <param name="e">Context</param>
/// <param name="which"></param>
/// <param name="data"></param>
/// <param name="size"></param>
/// <param name="writable"></param>
/// <param name="name"></param>
/// <returns></returns>
[BizImport(CallingConvention.Cdecl)]
public abstract bool qn_get_memory_area(IntPtr e, int which, ref IntPtr data, ref int size, ref bool writable, ref IntPtr name);
/// <summary>
/// peek the system bus
/// </summary>
/// <param name="e">Context</param>
/// <param name="addr">0000:ffff, but non-ram/rom addresses won't work</param>
/// <returns></returns>
[BizImport(CallingConvention.Cdecl)]
public abstract byte qn_peek_prgbus(IntPtr e, int addr);
/// <summary>
/// poke the system bus
/// </summary>
/// <param name="e">Context</param>
/// <param name="addr">0000:ffff, but non-ram/rom addresses won't work</param>
/// <param name="val"></param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_poke_prgbus(IntPtr e, int addr, byte val);
/// <summary>
/// get internal registers
/// </summary>
/// <param name="e">Context</param>
/// <param name="dest">a, x, y, sp, pc, p</param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_get_cpuregs(IntPtr e, [Out] int[] dest);
/// <summary>
/// get the mapper that's loaded
/// </summary>
/// <param name="e">Context</param>
/// <param name="number">recieves mapper number</param>
/// <returns>mapper name</returns>
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_get_mapper(IntPtr e, ref int number);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void TraceCallback(IntPtr data);
/// <summary>
/// set a trace callback to be run on each cycle
/// </summary>
/// <param name="e">Context</param>
/// <param name="cb"></param>
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_set_tracecb(IntPtr e, TraceCallback cb);
[BizImport(CallingConvention.Cdecl)]
public abstract byte qn_get_reg2000(IntPtr e);
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_get_palmem(IntPtr e);
[BizImport(CallingConvention.Cdecl)]
public abstract IntPtr qn_get_oammem(IntPtr e);
[BizImport(CallingConvention.Cdecl)]
public abstract byte qn_peek_ppu(IntPtr e, int addr);
[BizImport(CallingConvention.Cdecl)]
public abstract void qn_peek_ppubus(IntPtr e, byte[] dest);
/// <summary>
/// handle "string error" as returned by some quicknes functions
/// </summary>
/// <param name="p"></param>
public static void ThrowStringError(IntPtr p)
{
if (p == IntPtr.Zero)
return;
string s = Marshal.PtrToStringAnsi(p);
if (s == "Unsupported mapper" || s == "Not an iNES file") // Not worth making a new exception for the iNES error, they ultimately are the same problem
{
throw new Emulation.Common.UnsupportedGameException("Quicknes unsupported mapper");
}
else
{
throw new InvalidOperationException("LibQuickNES error: " + s);
}
}
}
}

2
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.IDebuggable.cs
View File

@ -11,7 +11,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
{
int[] regs = new int[6];
var ret = new Dictionary<string, RegisterValue>();
LibQuickNES.qn_get_cpuregs(Context, regs);
QN.qn_get_cpuregs(Context, regs);
ret["A"] = (byte)regs[0];
ret["X"] = (byte)regs[1];
ret["Y"] = (byte)regs[2];

6
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.IMemoryDomains.cs
View File

@ -18,7 +18,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
bool writable = false;
IntPtr name = IntPtr.Zero;
if (!LibQuickNES.qn_get_memory_area(Context, i, ref data, ref size, ref writable, ref name))
if (!QN.qn_get_memory_area(Context, i, ref data, ref size, ref writable, ref name))
break;
if (data != IntPtr.Zero && size > 0 && name != IntPtr.Zero)
@ -39,7 +39,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
throw new ArgumentOutOfRangeException();
}
return LibQuickNES.qn_peek_prgbus(Context, (int)addr);
return QN.qn_peek_prgbus(Context, (int)addr);
},
delegate(long addr, byte val)
{
@ -48,7 +48,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
throw new ArgumentOutOfRangeException();
}
LibQuickNES.qn_poke_prgbus(Context, (int)addr, val);
QN.qn_poke_prgbus(Context, (int)addr, val);
}
));

10
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.INESPPUViewable.cs
View File

@ -19,7 +19,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
return VideoPalette;
}
private byte R2000 { get { return LibQuickNES.qn_get_reg2000(Context); } }
private byte R2000 { get { return QN.qn_get_reg2000(Context); } }
public bool BGBaseHigh
{
@ -39,27 +39,27 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
private byte[] ppubusbuf = new byte[0x3000];
public byte[] GetPPUBus()
{
LibQuickNES.qn_peek_ppubus(Context, ppubusbuf);
QN.qn_peek_ppubus(Context, ppubusbuf);
return ppubusbuf;
}
private byte[] palrambuf = new byte[0x20];
public byte[] GetPalRam()
{
Marshal.Copy(LibQuickNES.qn_get_palmem(Context), palrambuf, 0, 0x20);
Marshal.Copy(QN.qn_get_palmem(Context), palrambuf, 0, 0x20);
return palrambuf;
}
byte[] oambuf = new byte[0x100];
public byte[] GetOam()
{
Marshal.Copy(LibQuickNES.qn_get_oammem(Context), oambuf, 0, 0x100);
Marshal.Copy(QN.qn_get_oammem(Context), oambuf, 0, 0x100);
return oambuf;
}
public byte PeekPPU(int addr)
{
return LibQuickNES.qn_peek_ppu(Context, addr);
return QN.qn_peek_ppu(Context, addr);
}
// we don't use quicknes's MMC5 at all, so these three methods are just stubs

8
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.ISaveRam.cs
View File

@ -6,20 +6,20 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
{
public byte[] CloneSaveRam()
{
LibQuickNES.ThrowStringError(LibQuickNES.qn_battery_ram_save(Context, SaveRamBuff, SaveRamBuff.Length));
LibQuickNES.ThrowStringError(QN.qn_battery_ram_save(Context, SaveRamBuff, SaveRamBuff.Length));
return (byte[])SaveRamBuff.Clone();
}
public void StoreSaveRam(byte[] data)
{
LibQuickNES.ThrowStringError(LibQuickNES.qn_battery_ram_load(Context, data, data.Length));
LibQuickNES.ThrowStringError(QN.qn_battery_ram_load(Context, data, data.Length));
}
public bool SaveRamModified
{
get
{
return LibQuickNES.qn_has_battery_ram(Context);
return QN.qn_has_battery_ram(Context);
}
}
@ -28,7 +28,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
private void InitSaveRamBuff()
{
int size = 0;
LibQuickNES.ThrowStringError(LibQuickNES.qn_battery_ram_size(Context, ref size));
LibQuickNES.ThrowStringError(QN.qn_battery_ram_size(Context, ref size));
SaveRamBuff = new byte[size];
}
}

4
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.ISettable.cs
View File

@ -24,7 +24,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
public bool PutSettings(QuickNESSettings o)
{
_settings = o;
LibQuickNES.qn_set_sprite_limit(Context, _settings.NumSprites);
QN.qn_set_sprite_limit(Context, _settings.NumSprites);
RecalculateCrops();
CalculatePalette();
@ -146,7 +146,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
private static byte[] GetDefaultColors()
{
IntPtr src = LibQuickNES.qn_get_default_colors();
IntPtr src = QN.qn_get_default_colors();
byte[] ret = new byte[1536];
Marshal.Copy(src, ret, 0, 1536);
return ret;

6
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.IStatable.cs
View File

@ -31,7 +31,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
public void SaveStateBinary(System.IO.BinaryWriter writer)
{
CheckDisposed();
LibQuickNES.ThrowStringError(LibQuickNES.qn_state_save(Context, SaveStateBuff, SaveStateBuff.Length));
LibQuickNES.ThrowStringError(QN.qn_state_save(Context, SaveStateBuff, SaveStateBuff.Length));
writer.Write(SaveStateBuff.Length);
writer.Write(SaveStateBuff);
// other variables
@ -47,7 +47,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
if (len != SaveStateBuff.Length)
throw new InvalidOperationException("Unexpected savestate buffer length!");
reader.Read(SaveStateBuff, 0, SaveStateBuff.Length);
LibQuickNES.ThrowStringError(LibQuickNES.qn_state_load(Context, SaveStateBuff, SaveStateBuff.Length));
LibQuickNES.ThrowStringError(QN.qn_state_load(Context, SaveStateBuff, SaveStateBuff.Length));
// other variables
IsLagFrame = reader.ReadBoolean();
LagCount = reader.ReadInt32();
@ -73,7 +73,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
private void InitSaveStateBuff()
{
int size = 0;
LibQuickNES.ThrowStringError(LibQuickNES.qn_state_size(Context, ref size));
LibQuickNES.ThrowStringError(QN.qn_state_size(Context, ref size));
SaveStateBuff = new byte[size];
SaveStateBuff2 = new byte[size + 13];
}

2
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.IVideoProvider.cs
View File

@ -53,7 +53,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
private void Blit()
{
LibQuickNES.qn_blit(Context, VideoOutput, VideoPalette, cropleft, croptop, cropright, cropbottom);
QN.qn_blit(Context, VideoOutput, VideoPalette, cropleft, croptop, cropright, cropbottom);
}
}
}

40
BizHawk.Emulation.Cores/Consoles/Nintendo/QuickNES/QuickNES.cs
View File

@ -11,6 +11,7 @@ using BizHawk.Common.BufferExtensions;
using BizHawk.Emulation.Common;
using BizHawk.Common;
using BizHawk.Common.CollectionExtensions;
using BizHawk.Emulation.Common.BizInvoke;
namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
{
@ -26,9 +27,14 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
public partial class QuickNES : IEmulator, IVideoProvider, ISyncSoundProvider, ISaveRam, IInputPollable,
IStatable, IDebuggable, ISettable<QuickNES.QuickNESSettings, QuickNES.QuickNESSyncSettings>, Cores.Nintendo.NES.INESPPUViewable
{
static readonly LibQuickNES QN;
static readonly Win32LibraryImportResolver Resolver;
static QuickNES()
{
LibQuickNES.qn_setup_mappers();
Resolver = new Win32LibraryImportResolver(LibQuickNES.dllname);
QN = BizInvoker.GetInvoker<LibQuickNES>(Resolver);
}
[CoreConstructor("NES")]
@ -39,12 +45,19 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
ServiceProvider = new BasicServiceProvider(this);
CoreComm = comm;
Context = LibQuickNES.qn_new();
Context = QN.qn_new();
if (Context == IntPtr.Zero)
throw new InvalidOperationException("qn_new() returned NULL");
try
{
LibQuickNES.ThrowStringError(LibQuickNES.qn_loadines(Context, file, file.Length));
unsafe
{
fixed (byte* p = file)
{
Console.WriteLine((IntPtr)p);
LibQuickNES.ThrowStringError(QN.qn_loadines(Context, file, file.Length));
}
}
InitSaveRamBuff();
InitSaveStateBuff();
@ -52,7 +65,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
InitMemoryDomains();
int mapper = 0;
string mappername = Marshal.PtrToStringAnsi(LibQuickNES.qn_get_mapper(Context, ref mapper));
string mappername = Marshal.PtrToStringAnsi(QN.qn_get_mapper(Context, ref mapper));
Console.WriteLine("QuickNES: Booted with Mapper #{0} \"{1}\"", mapper, mappername);
BoardName = mappername;
CoreComm.VsyncNum = 39375000;
@ -185,21 +198,21 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
using (FP.Save())
{
if (Controller["Power"])
LibQuickNES.qn_reset(Context, true);
QN.qn_reset(Context, true);
if (Controller["Reset"])
LibQuickNES.qn_reset(Context, false);
QN.qn_reset(Context, false);
int j1, j2;
SetPads(out j1, out j2);
if (Tracer.Enabled)
LibQuickNES.qn_set_tracecb(Context, _tracecb);
QN.qn_set_tracecb(Context, _tracecb);
else
LibQuickNES.qn_set_tracecb(Context, null);
QN.qn_set_tracecb(Context, null);
Frame++;
LibQuickNES.ThrowStringError(LibQuickNES.qn_emulate_frame(Context, j1, j2));
IsLagFrame = LibQuickNES.qn_get_joypad_read_count(Context) == 0;
LibQuickNES.ThrowStringError(QN.qn_emulate_frame(Context, j1, j2));
IsLagFrame = QN.qn_get_joypad_read_count(Context) == 0;
if (IsLagFrame)
LagCount++;
@ -214,7 +227,6 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
}
IntPtr Context;
public int Frame { get; private set; }
public string SystemId { get { return "NES"; } }
@ -304,7 +316,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
{
if (Context != IntPtr.Zero)
{
LibQuickNES.qn_delete(Context);
QN.qn_delete(Context);
Context = IntPtr.Zero;
}
}
@ -324,12 +336,12 @@ namespace BizHawk.Emulation.Cores.Consoles.Nintendo.QuickNES
void InitAudio()
{
LibQuickNES.ThrowStringError(LibQuickNES.qn_set_sample_rate(Context, 44100));
LibQuickNES.ThrowStringError(QN.qn_set_sample_rate(Context, 44100));
}
void DrainAudio()
{
NumSamples = LibQuickNES.qn_read_audio(Context, MonoBuff, MonoBuff.Length);
NumSamples = QN.qn_read_audio(Context, MonoBuff, MonoBuff.Length);
unsafe
{
fixed (short* _src = &MonoBuff[0], _dst = &StereoBuff[0])

4
quicknes/bizinterface.cpp
View File

@ -31,7 +31,11 @@ void operator delete(void *p)
std::free(p);
}
#ifdef _MSC_VER
#define EXPORT extern "C" __declspec(dllexport)
#else
#define EXPORT extern "C" __declspec(dllexport) __attribute__((force_align_arg_pointer))
#endif
EXPORT void qn_setup_mappers()
{