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

ahh, yahbooze, we hardly knew you...

This commit is contained in:
nattthebear 2017-06-11 14:44:47 -04:00
parent 9f19e00668
commit e73157bb49
46 changed files with 0 additions and 8343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BizHawk.Client.EmuHawk/Extensions/CoreExtensions.cs
View File

@ -36,10 +36,6 @@ namespace BizHawk.Client.EmuHawk.CoreExtensions
{
return Properties.Resources.bsnes;
}
else if (core is Yabause)
{
return Properties.Resources.yabause;
}
else if (core is Atari7800)
{
return Properties.Resources.emu7800;

20
BizHawk.Client.EmuHawk/config/ProfileConfig.cs
View File

@ -94,11 +94,6 @@ namespace BizHawk.Client.EmuHawk
// SNES
Global.Config.SNES_InSnes9x = true;
// Saturn
var saturnSettings = GetSyncSettings<Yabause, Yabause.SaturnSyncSettings>();
saturnSettings.SkipBios = false;
PutSyncSettings<Yabause>(saturnSettings);
// Genesis
var genesisSettings = GetSyncSettings<GPGX, GPGX.GPGXSyncSettings>();
genesisSettings.Region = LibGPGX.Region.Autodetect;
@ -151,11 +146,6 @@ namespace BizHawk.Client.EmuHawk
snesSettings.Profile = "Compatibility";
PutSyncSettings<LibsnesCore>(snesSettings);
// Saturn
var saturnSettings = GetSyncSettings<Yabause, Yabause.SaturnSyncSettings>();
saturnSettings.SkipBios = false;
PutSyncSettings<Yabause>(saturnSettings);
// Genesis
var genesisSettings = GetSyncSettings<GPGX, GPGX.GPGXSyncSettings>();
genesisSettings.Region = LibGPGX.Region.Autodetect;
@ -211,11 +201,6 @@ namespace BizHawk.Client.EmuHawk
snesSettings.Profile = "Compatibility";
PutSyncSettings<LibsnesCore>(snesSettings);
// Saturn
var saturnSettings = GetSyncSettings<Yabause, Yabause.SaturnSyncSettings>();
saturnSettings.SkipBios = true;
PutSyncSettings<Yabause>(saturnSettings);
// Genesis
var genesisSettings = GetSyncSettings<GPGX, GPGX.GPGXSyncSettings>();
genesisSettings.Region = LibGPGX.Region.Autodetect;
@ -271,11 +256,6 @@ namespace BizHawk.Client.EmuHawk
snesSettings.Profile = "Compatibility";
PutSyncSettings<LibsnesCore>(snesSettings);
// Saturn
var saturnSettings = GetSyncSettings<Yabause, Yabause.SaturnSyncSettings>();
saturnSettings.SkipBios = true;
PutSyncSettings<Yabause>(saturnSettings);
// Genesis
var genesisSettings = GetSyncSettings<GPGX, GPGX.GPGXSyncSettings>();
genesisSettings.Region = LibGPGX.Region.Autodetect;

23
BizHawk.Emulation.Cores/BizHawk.Emulation.Cores.csproj
View File

@ -1148,31 +1148,8 @@
<Compile Include="Consoles\Sega\gpgx64\LibGPGX.cs" />
<Compile Include="Consoles\Sega\Saturn\FilePiping.cs" />
<Compile Include="Consoles\Sega\Saturn\LibSaturnus.cs" />
<Compile Include="Consoles\Sega\Saturn\LibYabause.cs" />
<Compile Include="Consoles\Sega\Saturn\Saturnus.cs" />
<Compile Include="Consoles\Sega\Saturn\SaturnusControllerDeck.cs" />
<Compile Include="Consoles\Sega\Saturn\Yabause.cs" />
<Compile Include="Consoles\Sega\Saturn\Yabause.IDriveLight.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\Saturn\Yabause.IInputPollable.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\Saturn\Yabause.IMemoryDomains.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\Saturn\Yabause.ISaveram.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\Saturn\Yabause.ISettable.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\Saturn\Yabause.IStatable.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\Saturn\Yabause.ITraceable.cs">
<DependentUpon>Yabause.cs</DependentUpon>
</Compile>
<Compile Include="Consoles\Sega\SMS\SMS.cs" />
<Compile Include="Consoles\Sega\SMS\SMS.ICodeDataLogger.cs">
<DependentUpon>SMS.cs</DependentUpon>

252
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/LibYabause.cs
View File

@ -1,252 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public static class LibYabause
{
/// <summary>
/// A,B,C,Start,DPad
/// </summary>
public enum Buttons1 : byte
{
B = 0x01,
C = 0x02,
A = 0x04,
S = 0x08,
U = 0x10,
D = 0x20,
L = 0x40,
R = 0x80
}
/// <summary>
/// X,Y,Z,Shoulders
/// </summary>
public enum Buttons2 : byte
{
L = 0x08,
Z = 0x10,
Y = 0x20,
X = 0x40,
R = 0x80
}
/// <summary>
///
/// </summary>
/// <param name="p11">player1</param>
/// <param name="p12">player1</param>
/// <param name="p21">player2</param>
/// <param name="p22">player2</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_setpads(Buttons1 p11, Buttons2 p12, Buttons1 p21, Buttons2 p22);
/// <summary>
/// set video buffer
/// </summary>
/// <param name="buff">32 bit color, should persist over time. must hold at least 704*512px in software mode, or (704*n*512*n)px
/// in hardware mode with native factor size, or w*hpx in gl mode with explicit size</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_setvidbuff(IntPtr buff);
/// <summary>
///
/// </summary>
/// <param name="buff">persistent location of s16 interleaved</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_setsndbuff(IntPtr buff);
/// <summary>
/// soft reset, or something like that
/// </summary>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_softreset();
/// <summary>
/// hard reset, or something like that
/// </summary>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_hardreset();
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void InputCallback();
/// <summary>
/// set a fcn to call every time input is read
/// </summary>
/// <param name="cb">execxutes right before the input read. null to clear</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_setinputcallback(InputCallback cb);
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void TraceCallback(string dis, string regs);
/// <summary>
/// set a fcn to call every time input is read
/// </summary>
/// <param name="cb">execxutes right before the input read. null to clear</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_settracecallback(TraceCallback cb);
/// <summary>
///
/// </summary>
/// <param name="fn"></param>
/// <returns>success</returns>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_loadstate(string fn);
/// <summary>
///
/// </summary>
/// <param name="fn"></param>
/// <returns>success</returns>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_savestate(string fn);
/// <summary>
///
/// </summary>
/// <param name="w">width of framebuffer</param>
/// <param name="h">height of framebuffer</param>
/// <param name="nsamp">number of sample pairs produced</param>
/// <returns>true if lagged</returns>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_frameadvance(out int w, out int h, out int nsamp);
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_deinit();
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_savesaveram(string fn);
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_loadsaveram(string fn);
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_clearsaveram();
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_saveramodified();
public struct NativeMemoryDomain
{
public IntPtr data;
public string name;
public int length;
}
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr libyabause_getmemoryareas();
public static IEnumerable<NativeMemoryDomain> libyabause_getmemoryareas_ex()
{
var ret = new List<NativeMemoryDomain>();
IntPtr start = libyabause_getmemoryareas();
while (true)
{
var nmd = (NativeMemoryDomain)Marshal.PtrToStructure(start, typeof(NativeMemoryDomain));
if (nmd.data == IntPtr.Zero || nmd.name == null)
return ret.AsReadOnly();
ret.Add(nmd);
start += Marshal.SizeOf(typeof(NativeMemoryDomain));
}
}
/// <summary>
/// set the overall resolution. only works in gl mode and when nativefactor = 0
/// </summary>
/// <param name="w">width</param>
/// <param name="h">height</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_glresize(int w, int h);
/// <summary>
/// cause the overall resolution to automatically switch to a multiple of the original console resolution, as the original console resolution changes.
/// only applies in gl mode.
/// </summary>
/// <param name="n">factor, 1-4, 0 to disable.</param>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void libyabause_glsetnativefactor(int n);
public enum CartType : int
{
NONE = 0,
DRAM8MBIT = 6,
DRAM32MBIT = 7
}
/// <summary>
///
/// </summary>
/// <param name="intf">cd interface. struct need not persist after call, but the function pointers better</param>
/// <param name="biosfn">path to bios, pass null to use built in bios emulation</param>
/// <param name="usegl">true for opengl</param>
/// <param name="quickload">if true, skip bios opening</param>
/// <param name="clocksync">if true, sync RTC to actual emulated time; if false, use real real time</param>
/// <param name="clockbase">if non-zero, initial emulation time in unix format</param>
/// <returns></returns>
[DllImport("libyabause.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool libyabause_init(ref CDInterface intf, string biosfn, bool usegl, CartType carttype, bool quickload, bool clocksync, int clockbase);
public struct CDInterface
{
public int DontTouch;
public IntPtr DontTouch2;
/// <summary>
/// init cd functions
/// </summary>
/// <param name="unused"></param>
/// <returns>0 on success, -1 on failure</returns>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int Init(string unused);
public Init InitFunc;
/// <summary>
/// deinit cd functions
/// </summary>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void DeInit();
public DeInit DeInitFunc;
/// <summary>
/// 0 = cd present, spinning
/// 1 = cd present, not spinning
/// 2 = no cd
/// 3 = tray open
/// </summary>
/// <returns></returns>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int GetStatus();
public GetStatus GetStatusFunc;
/// <summary>
/// read all TOC entries
/// </summary>
/// <param name="dest">place to copy to</param>
/// <returns>number of bytes written. should be 408</returns>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int ReadTOC(IntPtr dest);
public ReadTOC ReadTOCFunc;
/// <summary>
/// read a sector, should be 2352 bytes
/// </summary>
/// <param name="FAD"></param>
/// <param name="dest"></param>
/// <returns></returns>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int ReadSectorFAD(int FAD, IntPtr dest);
public ReadSectorFAD ReadSectorFADFunc;
/// <summary>
/// hint the next sector, for async loading
/// </summary>
/// <param name="FAD"></param>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void ReadAheadFAD(int FAD);
public ReadAheadFAD ReadAheadFADFunc;
}
}
}

14
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.IDriveLight.cs
View File

@ -1,14 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause : IDriveLight
{
public bool DriveLightEnabled { get; private set; }
public bool DriveLightOn { get; private set; }
}
}

23
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.IInputPollable.cs
View File

@ -1,23 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause : IInputPollable
{
public int LagCount { get; set; }
public bool IsLagFrame { get; set; }
// TODO: optimize managed to unmanaged using the ActiveChanged event
public IInputCallbackSystem InputCallbacks
{
[FeatureNotImplemented]get { return _inputCallbacks; }
}
private readonly InputCallbackSystem _inputCallbacks = new InputCallbackSystem();
}
}

26
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.IMemoryDomains.cs
View File

@ -1,26 +0,0 @@
using System.Collections.Generic;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause
{
private IMemoryDomains _memoryDomains;
private void InitMemoryDomains()
{
var ret = new List<MemoryDomain>();
var nmds = LibYabause.libyabause_getmemoryareas_ex();
foreach (var nmd in nmds)
{
ret.Add(new MemoryDomainIntPtr(nmd.name, MemoryDomain.Endian.Little, nmd.data, nmd.length, true, 4));
}
// main memory is in position 2
_memoryDomains = new MemoryDomainList(ret);
_memoryDomains.MainMemory = _memoryDomains["Work Ram Low"];
(ServiceProvider as BasicServiceProvider).Register<IMemoryDomains>(_memoryDomains);
}
}
}

74
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.ISaveram.cs
View File

@ -1,74 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause : ISaveRam
{
public byte[] CloneSaveRam()
{
if (Disposed)
{
if (DisposedSaveRam != null)
{
return (byte[])DisposedSaveRam.Clone();
}
else
{
return new byte[0];
}
}
else
{
var ms = new MemoryStream();
var fp = new FilePiping();
fp.Get(ms);
bool success = LibYabause.libyabause_savesaveram(fp.GetPipeNameNative());
fp.Finish();
if (!success)
throw new Exception("libyabause_savesaveram() failed!");
var ret = ms.ToArray();
ms.Dispose();
return ret;
}
}
public void StoreSaveRam(byte[] data)
{
if (Disposed)
{
throw new Exception("It's a bit late for that");
}
else
{
var fp = new FilePiping();
fp.Offer(data);
bool success = LibYabause.libyabause_loadsaveram(fp.GetPipeNameNative());
fp.Finish();
if (!success)
{
throw new Exception("libyabause_loadsaveram() failed!");
}
}
}
public bool SaveRamModified
{
get
{
if (Disposed)
{
return DisposedSaveRam != null;
}
else
{
return LibYabause.libyabause_saveramodified();
}
}
}
}
}

135
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.ISettable.cs
View File

@ -1,135 +0,0 @@
using System;
using System.ComponentModel;
using Newtonsoft.Json;
using BizHawk.Common;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause : ISettable<object, Yabause.SaturnSyncSettings>
{
public object GetSettings()
{
return null;
}
public SaturnSyncSettings GetSyncSettings()
{
return SyncSettings.Clone();
}
public bool PutSettings(object o)
{
return false;
}
public bool PutSyncSettings(SaturnSyncSettings o)
{
bool ret = SaturnSyncSettings.NeedsReboot(SyncSettings, o);
SyncSettings = o;
if (GLMode && SyncSettings.UseGL)
{
if (SyncSettings.DispFree)
{
SetGLRes(0, SyncSettings.GLW, SyncSettings.GLH);
}
else
{
SetGLRes(SyncSettings.DispFactor, 0, 0);
}
}
return ret;
}
private SaturnSyncSettings SyncSettings;
public class SaturnSyncSettings
{
[DisplayName("Open GL Mode")]
[Description("Use OpenGL mode for rendering instead of software.")]
[DefaultValue(false)]
public bool UseGL { get; set; }
[DisplayName("Display Factor")]
[Description("In OpenGL mode, the internal resolution as a multiple of the normal internal resolution (1x, 2x, 3x, 4x). Ignored in software mode or when a custom resolution is used.")]
[DefaultValue(1)]
public int DispFactor
{
get { return _DispFactor; }
set { _DispFactor = Math.Max(1, Math.Min(value, 4)); }
}
[JsonIgnore]
[DeepEqualsIgnore]
private int _DispFactor;
[DisplayName("Display Free")]
[Description("In OpenGL mode, set to true to use a custom resolution and ignore DispFactor.")]
[DefaultValue(false)]
public bool DispFree { get { return _DispFree; } set { _DispFree = value; } }
[JsonIgnore]
[DeepEqualsIgnore]
private bool _DispFree;
[DisplayName("DispFree Final Width")]
[Description("In OpenGL mode and when DispFree is true, the width of the final resolution.")]
[DefaultValue(640)]
public int GLW { get { return _GLW; } set { _GLW = Math.Max(320, Math.Min(value, 2048)); } }
[JsonIgnore]
[DeepEqualsIgnore]
private int _GLW;
[DisplayName("DispFree Final Height")]
[Description("In OpenGL mode and when DispFree is true, the height of the final resolution.")]
[DefaultValue(480)]
public int GLH
{
get { return _GLH; }
set { _GLH = Math.Max(224, Math.Min(value, 1024)); }
}
[JsonIgnore]
[DeepEqualsIgnore]
private int _GLH;
[DisplayName("Ram Cart Type")]
[Description("The type of the attached RAM cart. Most games will not use this.")]
[DefaultValue(LibYabause.CartType.NONE)]
public LibYabause.CartType CartType { get; set; }
[DisplayName("Skip BIOS")]
[Description("Skip the Bios Intro screen.")]
[DefaultValue(false)]
public bool SkipBios { get; set; }
[DisplayName("Use RealTime RTC")]
[Description("If true, the real time clock will reflect real time, instead of emulated time. Ignored (forced to false) when a movie is recording.")]
[DefaultValue(false)]
public bool RealTimeRTC { get; set; }
[DisplayName("RTC intiial time")]
[Description("Set the initial RTC time. Only used when RealTimeRTC is false.")]
[DefaultValue(typeof(DateTime), "2010-01-01")]
public DateTime RTCInitialTime { get; set; }
public static bool NeedsReboot(SaturnSyncSettings x, SaturnSyncSettings y)
{
return !DeepEquality.DeepEquals(x, y);
}
public SaturnSyncSettings Clone()
{
return (SaturnSyncSettings)MemberwiseClone();
}
public SaturnSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
}
}
}

125
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.IStatable.cs
View File

@ -1,125 +0,0 @@
using System;
using System.IO;
using BizHawk.Common.BufferExtensions;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause : IStatable
{
public bool BinarySaveStatesPreferred { get { return true; } }
// these next 5 functions are all exact copy paste from gambatte.
// if something's wrong here, it's probably wrong there too
public void SaveStateText(TextWriter writer)
{
var temp = SaveStateBinary();
temp.SaveAsHexFast(writer);
// write extra copy of stuff we don't use
writer.WriteLine("Frame {0}", Frame);
}
public void LoadStateText(TextReader reader)
{
string hex = reader.ReadLine();
byte[] state = new byte[hex.Length / 2];
state.ReadFromHexFast(hex);
LoadStateBinary(new BinaryReader(new MemoryStream(state)));
}
public void SaveStateBinary(BinaryWriter writer)
{
byte[] data = SaveCoreBinary();
writer.Write(data.Length);
writer.Write(data);
// other variables
writer.Write(IsLagFrame);
writer.Write(LagCount);
writer.Write(Frame);
}
public void LoadStateBinary(BinaryReader reader)
{
int length = reader.ReadInt32();
byte[] data = reader.ReadBytes(length);
LoadCoreBinary(data);
// other variables
IsLagFrame = reader.ReadBoolean();
LagCount = reader.ReadInt32();
Frame = reader.ReadInt32();
}
public byte[] SaveStateBinary()
{
MemoryStream ms = new MemoryStream();
BinaryWriter bw = new BinaryWriter(ms);
SaveStateBinary(bw);
bw.Flush();
return ms.ToArray();
}
/// <summary>
/// does a save, load, save combo, and checks the two saves for identicalness.
/// </summary>
private void CheckStates()
{
byte[] s1 = SaveStateBinary();
LoadStateBinary(new BinaryReader(new MemoryStream(s1, false)));
byte[] s2 = SaveStateBinary();
if (s1.Length != s2.Length)
throw new Exception(string.Format("CheckStates: Length {0} != {1}", s1.Length, s2.Length));
unsafe
{
fixed (byte* b1 = &s1[0], b2 = &s2[0])
{
for (int i = 0; i < s1.Length; i++)
{
if (b1[i] != b2[i])
{
File.WriteAllBytes("save1.raw", s1);
File.WriteAllBytes("save2.raw", s2);
throw new Exception(string.Format("CheckStates s1[{0}] = {1}, s2[{0}] = {2}", i, b1[i], b2[i]));
}
}
}
}
}
private void LoadCoreBinary(byte[] data)
{
var fp = new FilePiping();
fp.Offer(data);
//loadstate can trigger GL work
ActivateGL();
bool succeed = LibYabause.libyabause_loadstate(fp.GetPipeNameNative());
DeactivateGL();
fp.Finish();
if (!succeed)
throw new Exception("libyabause_loadstate() failed");
}
private byte[] SaveCoreBinary()
{
var ms = new MemoryStream();
var fp = new FilePiping();
fp.Get(ms);
bool succeed = LibYabause.libyabause_savestate(fp.GetPipeNameNative());
fp.Finish();
var ret = ms.ToArray();
ms.Close();
if (!succeed)
throw new Exception("libyabause_savestate() failed");
return ret;
}
}
}

35
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.ITraceable.cs
View File

@ -1,35 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
public partial class Yabause
{
public TraceBuffer Tracer { get; private set; }
public static string TraceHeader = "SH2: core, PC, machine code, mnemonic, operands, registers (GPRs, PR, SR, MAC, GBR, VBR)";
LibYabause.TraceCallback trace_cb;
public void YabauseTraceCallback(string dis, string regs)
{
Tracer.Put(new TraceInfo
{
Disassembly = dis,
RegisterInfo = regs
});
}
private void ConnectTracer()
{
trace_cb = new LibYabause.TraceCallback(YabauseTraceCallback);
Tracer = new TraceBuffer() { Header = TraceHeader };
ServiceProvider = new BasicServiceProvider(this);
(ServiceProvider as BasicServiceProvider).Register<ITraceable>(Tracer);
}
}
}

504
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.cs
View File

@ -1,504 +0,0 @@
using System;
using System.Runtime.InteropServices;
using BizHawk.Emulation.Common;
using BizHawk.Emulation.DiscSystem;
namespace BizHawk.Emulation.Cores.Sega.Saturn
{
[CoreAttributes(
"Yabause",
"",
isPorted: true,
isReleased: true,
portedVersion: "9.12",
portedUrl: "http://yabause.org",
singleInstance: true)]
public partial class Yabause : IEmulator, IVideoProvider, ISoundProvider, ISaveRam, IStatable, IInputPollable,
ISettable<object, Yabause.SaturnSyncSettings>, IDriveLight
{
public Yabause(CoreComm coreComm, Disc cd, object syncSettings)
{
ServiceProvider = new BasicServiceProvider(this);
byte[] bios = coreComm.CoreFileProvider.GetFirmware("SAT", "J", true, "Saturn BIOS is required.");
coreComm.RomStatusDetails = string.Format("Disk partial hash:{0}", new DiscHasher(cd).OldHash());
CoreComm = coreComm;
CD = cd;
DiscSectorReader = new DiscSectorReader(cd);
SyncSettings = (SaturnSyncSettings)syncSettings ?? new SaturnSyncSettings();
if (SyncSettings.UseGL && glContext == null)
{
glContext = coreComm.RequestGLContext(2,0,false);
}
ResetCounters();
ActivateGL();
Init(bios);
InputCallbackH = new LibYabause.InputCallback(() => InputCallbacks.Call());
LibYabause.libyabause_setinputcallback(InputCallbackH);
ConnectTracer();
DriveLightEnabled = true;
DeactivateGL();
}
public static ControllerDefinition SaturnController = new ControllerDefinition
{
Name = "Saturn Controller",
BoolButtons =
{
"Power", "Reset",
"P1 Up", "P1 Down", "P1 Left", "P1 Right", "P1 Start", "P1 A", "P1 B", "P1 C", "P1 X", "P1 Y", "P1 Z", "P1 L", "P1 R",
"P2 Up", "P2 Down", "P2 Left", "P2 Right", "P2 Start", "P2 A", "P2 B", "P2 C", "P2 X", "P2 Y", "P2 Z", "P2 L", "P2 R",
}
};
static Yabause AttachedCore = null;
GCHandle VideoHandle;
Disc CD;
DiscSectorReader DiscSectorReader;
GCHandle SoundHandle;
bool Disposed = false;
byte[] DisposedSaveRam;
LibYabause.CDInterface.Init InitH;
LibYabause.CDInterface.DeInit DeInitH;
LibYabause.CDInterface.GetStatus GetStatusH;
LibYabause.CDInterface.ReadTOC ReadTOCH;
LibYabause.CDInterface.ReadSectorFAD ReadSectorFADH;
LibYabause.CDInterface.ReadAheadFAD ReadAheadFADH;
LibYabause.InputCallback InputCallbackH;
public IEmulatorServiceProvider ServiceProvider { get; private set; }
object glContext;
void ActivateGL()
{
//if (!SyncSettings.UseGL) return; //not safe
if (glContext == null) return;
CoreComm.ActivateGLContext(glContext);
}
void DeactivateGL()
{
//if (!SyncSettings.UseGL) return; //not safe
if (glContext == null) return;
CoreComm.DeactivateGLContext();
}
void Init(byte[] bios)
{
bool GL = SyncSettings.UseGL;
if (AttachedCore != null)
{
AttachedCore.Dispose();
AttachedCore = null;
}
VideoHandle = GCHandle.Alloc(VideoBuffer, GCHandleType.Pinned);
SoundHandle = GCHandle.Alloc(SoundBuffer, GCHandleType.Pinned);
LibYabause.CDInterface CDInt = new LibYabause.CDInterface();
CDInt.InitFunc = InitH = new LibYabause.CDInterface.Init(CD_Init);
CDInt.DeInitFunc = DeInitH = new LibYabause.CDInterface.DeInit(CD_DeInit);
CDInt.GetStatusFunc = GetStatusH = new LibYabause.CDInterface.GetStatus(CD_GetStatus);
CDInt.ReadTOCFunc = ReadTOCH = new LibYabause.CDInterface.ReadTOC(CD_ReadTOC);
CDInt.ReadSectorFADFunc = ReadSectorFADH = new LibYabause.CDInterface.ReadSectorFAD(CD_ReadSectorFAD);
CDInt.ReadAheadFADFunc = ReadAheadFADH = new LibYabause.CDInterface.ReadAheadFAD(CD_ReadAheadFAD);
var fp = new FilePiping();
string BiosPipe = fp.GetPipeNameNative();
fp.Offer(bios);
int basetime;
if (SyncSettings.RealTimeRTC)
basetime = 0;
else
basetime = (int)((SyncSettings.RTCInitialTime - new DateTime(1970, 1, 1).ToLocalTime()).TotalSeconds);
if (!LibYabause.libyabause_init
(
ref CDInt,
BiosPipe,
GL,
SyncSettings.CartType,
SyncSettings.SkipBios,
!SyncSettings.RealTimeRTC,
basetime
))
throw new Exception("libyabause_init() failed!");
fp.Finish();
LibYabause.libyabause_setvidbuff(VideoHandle.AddrOfPinnedObject());
LibYabause.libyabause_setsndbuff(SoundHandle.AddrOfPinnedObject());
AttachedCore = this;
// with or without GL, this is the guaranteed frame -1 size; (unless you do a gl resize)
BufferWidth = 320;
BufferHeight = 224;
InitMemoryDomains();
GLMode = GL;
// if in GL mode, this will trigger the initial GL resize
PutSyncSettings(this.SyncSettings);
}
public ControllerDefinition ControllerDefinition
{
get { return SaturnController; }
}
public bool GLMode { get; private set; }
public void SetGLRes(int factor, int width, int height)
{
if (!GLMode)
return;
if (factor < 0) factor = 0;
if (factor > 4) factor = 4;
int maxwidth, maxheight;
if (factor == 0)
{
maxwidth = width;
maxheight = height;
}
else
{
maxwidth = 704 * factor;
maxheight = 512 * factor;
}
if (maxwidth * maxheight > VideoBuffer.Length)
{
VideoHandle.Free();
VideoBuffer = new int[maxwidth * maxheight];
VideoHandle = GCHandle.Alloc(VideoBuffer, GCHandleType.Pinned);
LibYabause.libyabause_setvidbuff(VideoHandle.AddrOfPinnedObject());
}
LibYabause.libyabause_glsetnativefactor(factor);
if (factor == 0)
LibYabause.libyabause_glresize(width, height);
}
public void FrameAdvance(IController controller, bool render, bool rendersound = true)
{
int w, h, nsamp;
ActivateGL();
LibYabause.Buttons1 p11 = (LibYabause.Buttons1)0xff;
LibYabause.Buttons2 p12 = (LibYabause.Buttons2)0xff;
LibYabause.Buttons1 p21 = (LibYabause.Buttons1)0xff;
LibYabause.Buttons2 p22 = (LibYabause.Buttons2)0xff;
if (controller.IsPressed("P1 A"))
p11 &= ~LibYabause.Buttons1.A;
if (controller.IsPressed("P1 B"))
p11 &= ~LibYabause.Buttons1.B;
if (controller.IsPressed("P1 C"))
p11 &= ~LibYabause.Buttons1.C;
if (controller.IsPressed("P1 Start"))
p11 &= ~LibYabause.Buttons1.S;
if (controller.IsPressed("P1 Left"))
p11 &= ~LibYabause.Buttons1.L;
if (controller.IsPressed("P1 Right"))
p11 &= ~LibYabause.Buttons1.R;
if (controller.IsPressed("P1 Up"))
p11 &= ~LibYabause.Buttons1.U;
if (controller.IsPressed("P1 Down"))
p11 &= ~LibYabause.Buttons1.D;
if (controller.IsPressed("P1 L"))
p12 &= ~LibYabause.Buttons2.L;
if (controller.IsPressed("P1 R"))
p12 &= ~LibYabause.Buttons2.R;
if (controller.IsPressed("P1 X"))
p12 &= ~LibYabause.Buttons2.X;
if (controller.IsPressed("P1 Y"))
p12 &= ~LibYabause.Buttons2.Y;
if (controller.IsPressed("P1 Z"))
p12 &= ~LibYabause.Buttons2.Z;
if (controller.IsPressed("P2 A"))
p21 &= ~LibYabause.Buttons1.A;
if (controller.IsPressed("P2 B"))
p21 &= ~LibYabause.Buttons1.B;
if (controller.IsPressed("P2 C"))
p21 &= ~LibYabause.Buttons1.C;
if (controller.IsPressed("P2 Start"))
p21 &= ~LibYabause.Buttons1.S;
if (controller.IsPressed("P2 Left"))
p21 &= ~LibYabause.Buttons1.L;
if (controller.IsPressed("P2 Right"))
p21 &= ~LibYabause.Buttons1.R;
if (controller.IsPressed("P2 Up"))
p21 &= ~LibYabause.Buttons1.U;
if (controller.IsPressed("P2 Down"))
p21 &= ~LibYabause.Buttons1.D;
if (controller.IsPressed("P2 L"))
p22 &= ~LibYabause.Buttons2.L;
if (controller.IsPressed("P2 R"))
p22 &= ~LibYabause.Buttons2.R;
if (controller.IsPressed("P2 X"))
p22 &= ~LibYabause.Buttons2.X;
if (controller.IsPressed("P2 Y"))
p22 &= ~LibYabause.Buttons2.Y;
if (controller.IsPressed("P2 Z"))
p22 &= ~LibYabause.Buttons2.Z;
if (controller.IsPressed("Reset"))
LibYabause.libyabause_softreset();
if (controller.IsPressed("Power"))
LibYabause.libyabause_hardreset();
LibYabause.libyabause_setpads(p11, p12, p21, p22);
DriveLightOn = false;
if (Tracer.Enabled)
LibYabause.libyabause_settracecallback(trace_cb);
else
LibYabause.libyabause_settracecallback(null);
IsLagFrame = LibYabause.libyabause_frameadvance(out w, out h, out nsamp);
BufferWidth = w;
BufferHeight = h;
SoundNSamp = nsamp;
Frame++;
if (IsLagFrame)
LagCount++;
//Console.WriteLine(nsamp);
//CheckStates();
DeactivateGL();
}
public int Frame { get; private set; }
public string SystemId { get { return "SAT"; } }
public bool DeterministicEmulation { get { return true; } }
public void ResetCounters()
{
Frame = 0;
LagCount = 0;
IsLagFrame = false;
}
public CoreComm CoreComm { get; private set; }
public void Dispose()
{
if (!Disposed)
{
ActivateGL();
if (SaveRamModified)
DisposedSaveRam = CloneSaveRam();
LibYabause.libyabause_setvidbuff(IntPtr.Zero);
LibYabause.libyabause_setsndbuff(IntPtr.Zero);
LibYabause.libyabause_deinit();
VideoHandle.Free();
SoundHandle.Free();
CD.Dispose();
Disposed = true;
DeactivateGL();
if (glContext != null)
CoreComm.ReleaseGLContext(glContext);
}
}
#region IVideoProvider
int[] VideoBuffer = new int[704 * 512];
int[] TextureIdBuffer = new int[1]; //todo
public int[] GetVideoBuffer() {
//doesn't work yet
//if (SyncSettings.UseGL)
// return new[] { VideoBuffer[0] };
//else
return VideoBuffer;
}
public int VirtualWidth { get { return BufferWidth; } }
public int VirtualHeight { get { return BufferHeight; } }
public int BufferWidth { get; private set; }
public int BufferHeight { get; private set; }
public int BackgroundColor { get { return unchecked((int)0xff000000); } }
public int VsyncNumerator
{
[FeatureNotImplemented]
get
{
return NullVideo.DefaultVsyncNum;
}
}
public int VsyncDenominator
{
[FeatureNotImplemented]
get
{
return NullVideo.DefaultVsyncDen;
}
}
#endregion
#region ISyncSoundProvider
private short[] SoundBuffer = new short[44100 * 2];
private int SoundNSamp = 0;
public void GetSamplesSync(out short[] samples, out int nsamp)
{
nsamp = SoundNSamp;
samples = SoundBuffer;
}
public void DiscardSamples() { }
public bool CanProvideAsync
{
get { return false; }
}
public void SetSyncMode(SyncSoundMode mode)
{
if (mode == SyncSoundMode.Async)
{
throw new NotSupportedException("Async mode is not supported.");
}
}
public SyncSoundMode SyncMode
{
get { return SyncSoundMode.Sync; }
}
public void GetSamplesAsync(short[] samples)
{
throw new InvalidOperationException("Async mode is not supported.");
}
#endregion
#region CD
/// <summary>
/// init cd functions
/// </summary>
/// <param name="unused"></param>
/// <returns>0 on success, -1 on failure</returns>
int CD_Init(string unused)
{
return 0;
}
/// <summary>
/// deinit cd functions
/// </summary>
void CD_DeInit()
{
}
/// <summary>
/// 0 = cd present, spinning
/// 1 = cd present, not spinning
/// 2 = no cd
/// 3 = tray open
/// </summary>
/// <returns></returns>
int CD_GetStatus()
{
return 0;
}
/// <summary>
/// read all TOC entries
/// </summary>
/// <param name="dest">place to copy to</param>
/// <returns>number of bytes written. should be 408 (99 tracks, 3 specials)</returns>
int CD_ReadTOC(IntPtr dest)
{
// this stuff from yabause's cdbase.c. don't ask me to explain it
//TODO - we could just get this out of the actual TOC, it's the same thing
int[] rTOC = new int[102];
var ses = CD.Session1;
int ntrk = ses.InformationTrackCount;
for (int i = 0; i < 99; i++)
{
int tnum = i + 1;
if (tnum <= ntrk)
{
var trk = ses.Tracks[tnum];
uint t = (uint)trk.LBA + 150;
if(trk.IsAudio)
t |= 0x01000000;
else
t |= 0x41000000;
rTOC[i] = (int)t;
}
else
{
rTOC[i] = unchecked((int)0xffffffff);
}
}
rTOC[99] = (int)(rTOC[0] & 0xff000000 | 0x010000);
rTOC[100] = (int)(rTOC[ntrk - 1] & 0xff000000 | (uint)(ntrk << 16));
rTOC[101] = (int)(rTOC[ntrk - 1] & 0xff000000 | (uint)(CD.TOC.LeadoutLBA)); //zero 03-jul-2014 - maybe off by 150
Marshal.Copy(rTOC, 0, dest, 102);
return 408;
}
/// <summary>
/// read a sector, should be 2352 bytes
/// </summary>
/// <param name="FAD"></param>
/// <param name="dest"></param>
/// <returns></returns>
int CD_ReadSectorFAD(int FAD, IntPtr dest)
{
byte[] data = new byte[2352];
try
{
//CD.ReadABA_2352(FAD, data, 0);
DiscSectorReader.ReadLBA_2352(FAD - 150, data, 0); //zero 21-jun-2015 - did I adapt this right?
}
catch (Exception e)
{
Console.WriteLine("CD_ReadSectorFAD: Managed Exception:\n" + e.ToString());
return 0; // failure
}
Marshal.Copy(data, 0, dest, 2352);
DriveLightOn = true;
return 1; // success
}
/// <summary>
/// hint the next sector, for async loading
/// </summary>
/// <param name="FAD"></param>
void CD_ReadAheadFAD(int FAD)
{
// ignored for now
}
#endregion
}
}

BIN
output/dll/libyabause.dll
View File

Binary file not shown.

36
yabause/AUTHORS
View File

@ -1,36 +0,0 @@
Current team
------------
Theo Berkau
Guillaume Duhamel
Filipe Azevedo (pasnox)
Lawrence Sebald (BlueCrab)
Contributors
------------
Anders Montonen (antime)
Andrew Church
Ari64
Michele Balistreri
Richard Dolinsky (menace690)
Lucas Newman (Adam Green)
Joost Peters
Jerome Vernet
Takashi Kiyohara
Weston Yager
Ex-Cyber
Romulo Fernandes (nightz)
pa__
Fabien Coulon
trap15
devmiyax
Translators
-----------
Benjamin Siskoo
Felipe2
(people we grabbed code from)
------------
Stephane Dallongeville - c68k and scsp
Patrick Kooman - profiler
Bart Trzynadlowski - sh2 disassembler

35
yabause/CMakeLists.txt
View File

@ -1,35 +0,0 @@
project(yabause)
cmake_minimum_required(VERSION 2.8)
set(YAB_PACKAGE yabause)
set(YAB_VERSION_MAJOR 0)
set(YAB_VERSION_MINOR 9)
set(YAB_VERSION_PATCH 12)
set(YAB_VERSION "${YAB_VERSION_MAJOR}.${YAB_VERSION_MINOR}.${YAB_VERSION_PATCH}")
set(CPACK_SOURCE_GENERATOR TGZ)
set(CPACK_PACKAGE_VERSION_MAJOR ${YAB_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${YAB_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${YAB_VERSION_PATCH})
set(CPACK_PACKAGE_VENDOR "Yabause team")
set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/COPYING")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "yabause-${YAB_VERSION}")
if (APPLE)
set(CPACK_GENERATOR DragNDrop)
set(CPACK_PACKAGE_FILE_NAME yabause-${YAB_VERSION}-mac)
endif ()
if (WIN32)
SET(CPACK_NSIS_INSTALLED_ICON_NAME yabause.exe)
set(CPACK_NSIS_MENU_LINKS yabause.exe;Yabause)
set(CPACK_NSIS_URL_INFO_ABOUT "http://yabause.org")
set(CPACK_NSIS_COMPRESSOR "/SOLID lzma")
endif ()
include(CPack)
add_subdirectory(doc)
add_subdirectory(l10n)
add_subdirectory(src)

340
yabause/COPYING
View File

@ -1,340 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
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 02110-1301 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

924
yabause/ChangeLog
View File

@ -1,924 +0,0 @@
0.9.11 -> 0.9.12
general:
- Fixes to the dynamic recompiler (Ari64)
- Added ARMv5 support to the dynarec (Ari64)
- New OSD system (Guillaume)
- Added "built-in" DDK to make it easier to compile on Windows (Guillaume)
sound:
- Improvements / Fixes in both SCSP and SCSP2 (Cwiiis)
video:
- Major improvements to the OpenGL renderer (Devmiyax)
- Major improvements to the software renderer (Guillaume)
- Some fixes to register emulation (Guillaume)
- Improvements to line drawing functions in the software renderer (Cwiiis)
- Fixed endianess bugs (Guillaume)
cocoa port:
- Added "load image" feature (BlueCrab)
- Fixed the resize bug (BlueCrab)
qt port:
- Added shortcuts to toggle vdp2 layers (Benjamin Siskoo)
- Fixed the "mute sound" feature (Guillaume)
- It's now possible to compile the Qt port in "full software" mode (Guillaume)
- Added an autostart option, disabled by default (Guillaume)
- Now using a XDG compliant location for config file (Guillaume)
- Added a debugger to the Qt port (CyberWarriorX)
- DirectX cores can now be used in Qt port (CyberWarriorX)
- Cheat search function (CyberWarriorX)
- Option to show/hide menu and toolbar (Guillaume)
- Close button in pad settings (guillaume)
0.9.10 -> 0.9.11
general:
- Now using CMake as the default build system.
For now, autotools based build and "custom" build systems are still supported.
- New Cocoa port
- Added a dynamic recompiling SH2 core for x86 and ARM
- New SCSP implementation
- Major update of the software renderer from the yabause-rr team
- Added an option to allow to execute from the cache
- Improvements to the OpenGL renderer
carbon port:
- Improvements
gtk port:
- Added command line option to enable/disable frame skipping / limiting.
- Added frame skipping/limiting configuration in settings.
- Added --autoload command line option
- Vdp2 layers can be toggled from the Vdp2 debug window
psp port:
- Added support for Media Engine CPU
- Improvements to the PSP port
qt port:
- Added command line support
wii port:
- Merged some stuff from the wiibrew fork, mostly related to SH2 emulation
windows port:
- Fixed the XBox controller driver
- Fixed the "open iso then cancel bug"
0.9.9 -> 0.9.10
scsp/68k:
- Added code to make SCSP emulation frame-accurate (optional,
enabled with --enable-scsp-frame-accurate configure switch).
- Added a new 68000 emulation core.
software video core:
- Added line scroll emulation.
- Improved user clipping.
- Added some basic vertical scroll emulation, enough to get
Sonic Jam working.
gtk port
- Gtk port is now compiling on Mac OS X.
- Fixed full software screenshots.
- Fixed store function in transfer dialog.
windows port:
- Added 12 player support.
- Fixed a bug that was causing the memory transfer dialog
to register the wrong filename after pressing "Browse".
- Fixed bugs in Goto Address dialog.
- Fixed a bug that was causing the vdp2 viewer dialog
to register the wrong filename after pressing "Browse".
- Added MD saving in SCU DSP debug dialog.
- Added new Ram Watch dialog.
- Added video recording feature.
- Added move recording feature.
general:
- Added Lithuanian translation.
- New sound core using OpenAL.
- Added joystick core for Mac OS X.
- Added a joystick core for Linux.
- Added a PSP port.
- Added support for loading ELF binaries.
- Now using gettimeofday when available for better resolution.
- Fixed save states.
0.9.8 -> 0.9.9
opengl video core:
- Fixed a bug that was causing some games to
crash (albert odyssey, dragon ball, etc.)
gtk port:
- Automatic detection of current locale.
qt port:
- Added support of DESTDIR and --program-prefix
- Automatic detection of current locale.
- Added support for multiple players.
windows port:
- Fixed crash when going into settings.
- Fixed mouse wheel usage in disassembler.
- Rewrote as an unicode application.
- Fixed the key configuration problem.
- Fixed joypad support.
- Partial fix for mouse wheel and slider problem.
- Fixed fullscreen bug.
general:
- Hooks for renaming .desktop on installation.
- .yts file are now installed.
- Fixed parallel builds.
- SDL peripheral core now handles all connected
joysticks.
0.9.7 -> 0.9.8
vdp2:
- Fixed a bug in software renderer with rotating
backgrounds.
opengl video core:
- Added gouraud shading and mesh processing.
This is not enabled by default.
software video core:
- Fixed user clipping.
gtk port:
- Added mouse support.
- Configuration dialog now displays key names instead
of values. Also made it so each different configuration
is saved. This broke compatibility with old .ini files.
windows port:
- Support for spaces in filenames when using CLI.
- Added mouse support.
- Added cheat search.
general:
- Added mouse emulation.
- Added de, es, it, pt-br and sv translations
- Support for "out of src" build.
- Fixed compilation for non supported platforms.
For instance this should fix compilation on dragonfly bsd.
Fixed compilation on GNU/Hurd too.
0.9.6 -> 0.9.7
vdp1:
- Added clipping for line-based drawing to software renderer.
vdp2:
- Toggling a screen is now core independent.
- Added per-character priority to software renderer.
gtk port:
- Fixed fullscreen setting and added a keep ratio one.
- Fixed a bug in the vdp2 debugger that was causing the emu to crash.
- Full software mode can be compiled again.
- Fixed segfault when taking screenshots in full software mode.
- Fixed default value for region.
- Window position is now saved and restored when re-opening the emu.
- Fixed a problem when changing input cores.
qt port:
- Improved compilation process: make (un)install now works.
- Fix crash when configuring input while using translated version.
windows port:
- Changed resolution list generation so it adds the resolution to the list,
regardless of whether it supports 60 hz or not.
- Fixed error when trying to add blank cheat code.
- Fixed all code that allowed the user to choose filename for saving so it
automatically places a default extension.
- Save and Clear buttons are now enabled when loading a cheat file.
- Fixed a bug with AR code adding where it was tracking the wrong edit
window.
- Fixed a bug when adding raw cheat codes.
- Fixed bugs in vdp1 debugger.
- Fixed a bug where saving/loading a save state and an error occured would
cause sound looping.
- Scroll bar in memory editor now works properly when you move the thumb
control.
- Added support for x64 builds in Visual Studio.
general:
- Fixed a bug that was causing older save states to fail.
0.9.5 -> 0.9.6
sdl joystick core:
- Fixed it...
software video core:
- Improvements and bug fixes.
carbon port:
- Added detection of sdk in the build process.
- Changed the cd core so that the first device found is used.
Users shouldn't have anything to set up when using cd device now.
gtk port:
- Tagged more strings to be translatable.
- Fixed bugs when setting a resolution in settings.
- Fixed controller settings so keys can now be configured even if
emulation is not started.
qt port:
- Removed libsjw core.
wii port:
- Updated to use the last devkitppc.
- Added support for classic controller and for wiimote, disabled
keyboard support.
windows port:
- Added command line support.
general:
- Updated copyright for some files where it was missing or
inaccurate.
- Fixes and improvements to the build process: fixed cross compilation
of Qt port, added Wii port support, found a better way to "trigger"
compilation of gen68k, fixed a bug when calling the sub-configure,
.inc files are now cleaned, added MINI18N variable support, forwarded
distclean rule to qt makefiles, configure now make sure the compiler
is a cross compiler when cross compiling
- Added a workaround for the "limits.h" problem... now distros should
fix their headers...
- Fixed the .desktop files for linux (gtk + qt ports)
- Added translation files for fr and pt in the repository.
0.9.4 -> 0.9.5
68k:
- Added 1010 and 1111 line emulator support.
cd block:
- Reworked bin/cue support. Reading should be a lot more accurate
now on tracks 2 and greater.
emulated bios:
- Fixed a bug in BupGetDate year calculation.
- Fixed a bug where interrupt mask wasn't being set correctly when
using emulated bios.
smpc:
- Added support for SMPC NMIREQ command.
- Added reset button emulation.
software video core:
- Improved software renderer: window, line scroll, mosaic are now
available and color offset and scroll screen has been fixed.
gtk port:
- Tagged most of gtk port strings to be translatable.
qt port:
- Added ability to specify address where binaries are loaded when
using command line.
- Other bug fixes.
wii port:
- Added support for bios and game loading from sd card.
- Added sound support.
- Added usb keyboard support.
windows port:
- Added pause emulation function.
- Other bug fixes.
dreamcast port:
- Rewrote all of the Dreamcast CD Interface in hand-optimized
assembly.
- Enabled use of the emulated bios if there is no saturn.bin on
the CD.
general:
- Updated peripheral interface so both ports can now be used and
multiple pads can now be connected to each port.
- Added translation support through mini18n library.
0.9.3 -> 0.9.4
scsp:
- Fixed a timer bug.
- Fixed a bug with mcire word writes.
- Added wave file output core to available sound cores.
- Fixed a bug in total level attenuation.
- Fixed a bug in EG.
gtk port:
- Redesigned memory dump window.
- Redesigned SH2 debug window.
- Other bug fixes.
qt port:
- Added initial support. It should be pretty much on par with the gtk port.
wii port:
- Added initial support.
windows port:
- Fixed a bug where emulation wasn't paused when save/load state as was
selected from the menu.
- Changed disassembler so it can scroll up and down.
- Tweaked error messages so it doesn't report invalid opcode errors when
running the fast interpreter.
- Added SCSP common control register debug info to SCSP debug dialog
- Other bug fixes.
general:
- Added a few internal tweaks that should yield some performance gains.
- Added support for saving and loading cheats.
0.9.2 -> 0.9.3
cart:
- Fixed a couple of bugs with Netlink emulation.
cd block:
- Tweaked error handling for cue files so it's more helpful to the user.
scu:
- Fixed a bug in DSP MVI instruction.
- Fixed a bug with DSP Program Ram Address.
- Fixed ALU behaviour on NOP.
- Other bug fixes.
vdp2:
- Fixed a bug where coefficient reading wasn't making sure reads weren't
going out of bounds.
- Tweaked frame-skipping so it only skips if frame time is faster/slower
than a 1/2 a frame. The results are much better now.
- Added general VDP2 debug info functionality.
- Added partial end code support to VDP1 texture debugging.
opengl video core:
- Fixed a bug in 16 BPP sprites where pixels 0x0001-0x7FFF weren't
transparent when transparency was enabled.
gtk port:
- Redesigned the window so each part can now be resized.
- Added a toolbar and removed the buttons.
- The sprite list now displays texture thumbnails.
- Added tooltips to "run" and "pause" buttons.
- Redesigned VDP2 debug window.
windows port:
- Fixed a bug that was causing Yabause to crash when run for the first time.
- Added screen capture.
- Reworked Input dialog so it'll allow for more than one peripheral(in the
future).
- Added a bunch of tools tips for basic and input settings.
- Fixed a bug that was causing wrong VDP1 command information to sometimes
be displayed.
- Other bug fixes.
- Fixed a bug that was causing the wrong breakpoint to be removed from the
breakpoint list.
- Text length is now limited correctly in breakpoint edit text controls.
general:
- Tweaked memory breakpoints so that regardless of whether you're using
cached or cache-through addresses variations of an address, it'll still
detect and break when the memory is accessed.
- Other bug fixes.
0.9.1 -> 0.9.2
cd block:
- Fixed a bug in periodic timing. Most movies should play correctly now.
- Other bug fixes
scsp:
- Fixed a bug that was causing reversed panning.
- Fixed a bug in SCSP slot debug stats.
sh2:
- Fixed a bug that caused Yabause to crash when fetching instructions from
some areas.
vdp2:
- Fixed undocumented plane size setting when debugging vdp2
- Special Color Calculation mode added to vdp2 debugging
opengl video core:
- Added the eight missing sprite types in Vdp1ReadPriority.
software video core:
- Fixed a bug where Polygons that used non-RGB values had the wrong
priority.
- Fixed a bug that was causing some scrolling issues.
gtk port:
- CD, sound, and video cores can now be changed without restarting the
emulator.
- Added basic support for save states.
windows port:
- Fixed compilation with MSYS.
- Changed SCSP debug dialog so it allows for individual slot saving.
- Fixed a bug when using goto address in memory editor.
- Fixed a bug where Yabause crashed when joystick was unplugged.
- Added memory search support.
- Fixed cheat dialog. Codes should show up after re-opening it.
general:
- Fixed some bugs where vdp1/vdp2 layers wouldn't be drawn after switching
video cores.
- Fixed a bug when switching between opengl and software video cores.
- Added memory search function.
0.9.0 -> 0.9.1
scsp:
- Fixed slot pitch LFO. Amplitude LFO is probably more accurate now too.
emulated bios:
- Added Backup RAM manager functions.
opengl video core:
- Fixed a bug with VDP2 2x2 plane size rotation screens.
- Optimized tile mode rotation screens
- Added support for VDP1 polyline.
software video core:
- FPS display now working.
- Added support for VDP2 rotation without coefficient tables.
- Fixed a bug in VDP2 24 BPP bitmap mode.
- Fixed several clipping bugs in Normal and Scaled Sprites.
- Fixed a bug with VDP2 2x2 plane size rotation screens.
- Optimized tile mode rotation screens.
linux port:
- Cursor now disappears after 2 seconds of inactivity in the gtk port.
macos port:
- New high resolution icon.
- Add some missing OS X application property list keys.
windows port:
- Fixed window position bug.
- Other bug fixes.
general:
- Tweaked frame timing code so it's more accurate.
- Re-implemented save states.
- Some internal changes do so that sound, video, and cd cores can be changed
at runtime.
0.8.6 -> 0.9.0
opengl video core:
- Added support for VDP1 line draw.
- Added support for VDP2 Rotation with coefficient tables.
- Other bug fixes.
software video core:
- Added support for VDP1 frame buffer switching.
- Added support for VDP2 Rotation with coefficient tables.
- Fixed a bug in frame buffer erasing.
- Other bug fixes.
linux port:
- Fixed a bug on 64 bits CPU.
- Hanged the location of the ini file to conform to XDG specification.
- Removed some old useless code.
- Added a "subclass" to GtkDrawingArea so sprite textures and screenshots
can now be saved through a popup menu.
macos port:
- Added fullscreen support.
- Added graphics layer toggling.
windows port:
- Fixed a stack corruption bug in DirectInput code.
- Fixed(hopefully this time) the joystick centering bug.
0.8.5 -> 0.8.6
68k:
- Fixed a bug which caused the emulator to crash if 68k execution jumped to
an invalid address.
scsp:
- Fixed a bug where the slot buffer pointers weren't set correctly.
- Added a function for debugging SCSP registers
vdp1:
- MODR returns the correct version number now.
- Fixed a bug that caused Local Coordinates, etc. commands to not get executed
correctly.
software video core:
- Added vdp2 horizontal flip for cell mode.
linux port:
- Improved vdp1 window a bit.
- Updated website url.
- Some cleanups
macos port:
- Added browse buttons for some settings.
- Added universal build support.
- Emulation loop was optimized.
- Fixed bug when "Run" is selected from the menu.
- Audio is now muted when emulator is paused.
- Fixed Backup RAM saving.
- Fixed a bug that was causing filenames to be parsed wrong.
- Other bug fixes and cleanups.
windows port:
- msys compiling is now fixed.
- Windows position is now saved when program exits.
- Fixed sound volume adjustment. Should be more accurate now.
- Fixed centering bug on joysticks.
- Fixed POV hat diagonals.
- Sound is now muted in the about dialog.
- Other bug fixes.
general:
- Added COFF file support.
0.8.0 -> 0.8.5
scsp:
- Added functions for dumping individual slots to wav files.
scu:
- Fixed SCU execution speed
sh2:
- Added DVDNTL/DVDNTH mirrors
- Added overflow interrupt
vdp1:
- Added function for displaying vdp1 textures for debugging
- Other bug fixes
vdp2:
- Added more RBG0 debug info
68k:
- Added a core system for m68k and a c68k core interface.
- Added a dummy m68k core based on old yabause code, working enough
to boot the bios.
emulated bios:
- Registers are now reset correctly
- Fixed bug in BiosSetSh2Interrupt
- Added Read/Write Save support
- Added undocumented CD Authentication function
opengl video core:
- RBG0 bug fixes
- Rotation Screen improvements
software video core:
- Added 32 BPP cell draw mode
bsd port:
- Added support for OpenBSD
linux port:
- Fixed the segfault that occured when opening the preferences dialog.
- Added texture display in vdp1 debug dialog
- Other GUI improvements
macos port:
- Added browse button for bios setting
- Other bug fixes
windows port:
- Fixed a bug that was causing sound to not work on some people's computers.
- Added texture display in vdp1 debug dialog
- Added window/full screen resizing
- Added full screen on startup
- Settings changed to use tabs instead of what was previously used
- Other bug fixes
- Logging now is done to a logging window when DEBUG is defined while
compiling.
- Added cheat dialog
- Added memory editor
- Added Visual C++ project file
general:
- Added Cheat support. Largely untested.
0.7.2 -> 0.8.0
cart:
- Moved Netlink code to its own file: netlink.c
- Improved Netlink AT command handling. Most games using the X-Band software
should work now.
- Fixed a number of bugs that were causing strange behaviour in Netlink
emulation.
- Added Modem states. Online Mode is now handled correctly.
- Added Networking code that allows two Yabause instances to communicate
with each other. Still somewhat buggy.
cd block:
- Fixed an issue where games that didn't specify an index along with the
track when playing cd audio didn't work correctly.
vdp1:
- Code cleanups.
vdp2:
- Code cleanups.
- Adjusted frameskip code so it skips up to a maximum of 9 frames at a time.
direct sound core:
- Fixed a bug that was screwing up the buffer position. Now it's almost
perfect(at the very least there's no clicks or pops anymore).
sdl sound core:
- Fixed a bug that was screwing up the buffer position. Now it's almost
perfect(at the very least there's no clicks or pops anymore).
software video core:
- Polygon drawing improvements
- Removed the silly y-axis clipping technique
- Added a filter for clipping detection
- Added vdp1 "end codes" in textures, but didn't find a game that use it
yet, please report bugs.
- Code Cleanups
- Fixed a potential bug in polygons
- Fixed a bug in polygon clipping
linux port:
- Code cleanups
- Changed a few things in configure script to fix compilation problems when
OpenGL and/or gtkglext were not present.
- Added a log popup window.
- Added a screenshot window on gtk port.
- Fixed Pause/Screenshot bug.
- Removed the "Keep ratio" setting as it can't be done in gtk and
replaced it by a "Fullscreen" setting.
- Added a yabause entry in gnome and KDE application menus
- Changed configure script so it fails on linux if --with-opengl is used
and gtlglext is not installed.
dreamcast port:
- Compiles and runs again.
- Added Normal Sprite support.
- Added Distorted Sprite support.
- Added Scaled Sprite support.
- Added in YabauseGetTicks support.
- Ported VDP2 portion of software renderer.
- Added new cd core.
- Added very simple GUI.
- Other bug fixes.
netbsd port:
- Added patch to get yabause working on netbsd with cd support thanks to
Takashi Kyohara.
windows port:
- Added pad configuration(first pad only).
- Added support for gamepads/joysticks.
- Removed duplicate cd code.
- Added a separate thread for cd access. SPTICDGetStatus is the only
function making use of it for now.
- Fixed fullscreen bug
- Added dialog and settings saving/loading for Netlink stuff(disabled for now).
- Other bug fixes.
general:
- Commited mac port fix by Antime.
- Coordinate Increment Registers are now set to 1 when using the quick load
function. It seems there's at least one game out there that doesn't want
to set it.
- Improved Backup Ram bios emulation functions. The only functions that
still aren't functioning correctly are Bup Write, Bup Read, Bup Verify,
and Bup Set/Get Date. So still no saving, but at least there's no errors
when running games now.
0.7.1 -> 0.7.2
cart:
- A few Netlink changes(still doesn't work).
cd block:
- CD Block play disc command fixes and improvements. Play Modes now handled correctly.
- Added correct Repeat counter support.
- CD audio data is now written to its own buffer, which is then played by the SCSP.
scsp:
- CD audio data is now played by the SCSP. EFSDL and EFPAN support still needs to be added.
opengl video core:
- glutInit is now called before any other glut function(except for on the windows port).
software video core:
- Added normal sprite flipping(copied from scaled sprites).
- Corrected a bug with 8 bpp color calculation in scaled and distorted sprites.
- Fixed a bug that caused duplicated textures in 8 bpp regular sprites.
- Distorted sprites made safer (won't read outside the texture)
- Fixed transparency for distorted sprites.
- Fixed scaled sprites bug in zoom points modes two points mode and C point
upper than A.
- Fixed a bug that was causing sprite priority problems.
linux port:
- Fixed a gtk warning.
- Added Joystick support.
- Added a test in configuration dialog so input tab is displayed only when
emulation is initialized.
- Added NTSC/PAL setting
- Input settings are now disabled when PERCore isn't initialized.
- Added a sound setting tab.
macos port:
- Added code to handle settings (everything should be working now, except
the "browse" buttons).
- Controls are now using the new Per* functions.
- Fixed some bugs in combo boxes.
windows port:
- EC Compatibility list link added to help menu.
- Fixed an issue where default values weren't set correctly when yabause.ini
wasn't present.
- Fixed an issue where Yabause would go into an endless loop if bios path
was incorrect.
- DirectX error messages now return more info when there's an error.
- Fixed an issue where people without hardware sound buffers on their
sound card would have problems trying to run with sound.
- Fixed some inaccurate information in the README.WIN file.
- Fixed cut-off text in Memory Transfer dialog.
- All dialog windows can now be closed using the X icon in the top-right
corner.
general:
- Fixed an issue where in certain cases Yabause would crash when sound
settings were altered.
- Some useless files were removed.
- Moved SDL detection in "global" part of configure script as it may be used
by all ports.
- Fixed a weird issue where a few functions were trying to return a value
when they obviously can't(How come GNU C compilers won't detect this?).
- Fixed a number of things that were causing compilation issues in VC++(VC++
still doesn't completely compile Yabause yet).
- Configure now checks if c99 variadic macros are available.
0.7.0 -> 0.7.1
opengl video core:
- Added polygons that use a palette.
software video core:
- Added scaled sprites with clipping and flipping.
- Full screen mode now working correctly.
- Added correct support for vdp2 resolutions other than 320x224.
- Fixed compilation issue on big endian systems.
- Added function to software renderer for fetching width/height of the display buffer
- Memory leak when clearing VDP1 frame buffer fixed.
linux port:
- Added autostart and fullscreen command line switches.
- Fixed a bug that was causing the emulator to sometimes start in using PAL
timing.
- Added an option to choose the peripheral interface at configure time.
- Started to move the gtk controls code into a proper peripheral core.
- Added code so software renderer can be used without OpenGL.
- Added --without-opengl switch to configure script to prevent OpenGL
detection.
- Resizing is now enabled when using software renderer and opengl.
macos port:
- Fixed a bug that was causing the emulator to sometimes start in using PAL
timing.
- Some fixes to carbon interface (preferences should works now).
windows port:
- Fixed a bug that was causing the emulator to sometimes start in using PAL
timing.
- Added shortcuts to the Yabause website, forum, donation page, and the
submit bug page to the main menu.
- Added About dialog.
general:
- Fixed a potential issue when enabling/disabling auto frameskipping.
0.6.0 -> 0.7.0
cart:
- Added Action Replay flash emulation.
cd block:
- Fixed Read Directory/Change Directory commands. This fixes Duke Nukem 3D
and a few others that have Netlink support.
- Audio data is no longer stored when read by the cd block. This fixes
Guardian Heroes.
- other bug fixes.
scsp:
- Added function that allows developers to get easy to read information on
the requested scsp sound slot.
- Fixed a bug where the phase wasn't getting updated if DISDL was set to 0.
This fixes Falcom Classics, Nadesico, and many other games using ADX.
- Fixed a bug that was causing OCT with a setting of 0x8 to play at the
wrong octave.
- Fixed a bug that was causing King of Fighters 95(and possibly others) to
go into an endless loop.
scu:
- Improved SCU interrupt handling.
sh2:
- Fixed a bug in exts.b opcode.
- Corrected some bugs in sh2idle
- SCI emulation improvements
smpc:
- Added proper DOTSEL reporting.
- Region settings are now properly preserved.
- Changed region autodetection so it defaults to the japanese region if
it can't autodetect.
68k:
- Fixed a few bugs.
vdp2:
- Debug info bug fixes
- Implemented one mode of external HV latching. This fixes King of Fighters
95.
- External latch and sync flags are now cleared on TVSTAT reading.
- Added speed throttle(basically skips 6 frame draws).
- Added long writes for VCSTA, LSTA0, and LSTA1 registers.
software video core:
- Rewrote it so it's no longer dependent on SDL.
- Added NBG2/NBG3 support.
- Added tile mode rendering.
- Added frame buffer emulation.
- Added normal sprite drawing.
- Changed Normal Sprite drawing so that Scaled Sprite and Distorted Sprite
functions can use it too.
- Added some support for Scaled/Distorted Sprites.
- Added VDP1 Polyline and Line drawing to Software renderer.
- Fixed a bunch of bugs.
opengl video core:
- Fixed a few issues with OpenGL initialization.
- Fixed a window/fullscreen bug.
- Added a smart Line Scroll/Vertical Cell Scroll interpreter.
- Changed Color Offset so it uses the same method as the Software renderer.
- Fixed Rotation Table reading.
- Fixed a bug in VIDOGLVdp1PolylineDraw where coordinate reads were writing
to invalid areas.
linux port:
- Removed some useless debug messages and fixed the "quit" menu entry.
- Added vdp1 debug dialog in new gtk interface.
- Added dialog for sh2, video core switching.
- Added reset menu entry.
- Added about dialog.
- Added MSH2 and SSH2 debug dialogs to the GTK interface.
- Added transfer dialog to the new gtk ui.
- Added empty Memory Dump dialog.
- Added the dialog box for scsp
- Added shortcut F7 for command Step
- Added support for memory breakpoints in sh2 debug dialog
- Sound is now muted when emulation is paused (in gtk interface).
- The window data is now saved while emulation is paused.
- Screenshot function added.
macos port:
- Added carbon interface
- Can now build .dmg image from .app directory
- Other improvements
windows port:
- Added SCSP Debug Dialog.
- Added Reset option to menu.
- Now uses DirectInput and DirectSound instead of SDL.
- Added dialog for video, sound and input core switching.
- Fixed window/fullscreen switching.
- Added support for memory breakpoints in sh2 debug dialog.
- Sound volume can now be adjusted in the settings dialog.
- Sound is now muted when dialog window has focus.
- Auto frameskip can be be enabled via video settings menu.
- Other bug fixes.
general:
- Better handling of NULL string when opening a file
- Fixed a few memory leaks
- ISO support fixes
- PAL support added
- Fixed v-blank timing
- Added auto frameskipping(still not working correctly)
- Improved sound buffering
- Fixed handling of invalid SH2 opcodes
- Dummy sound core bug fixes
- Fixed some warnings
- Added experimental bios emulation
- Added memory breakpoints
- Added a function to the sound cores for setting the volume.
0.5.0 -> 0.6.0
cart:
- accesses to Netlink addresses when Netlink was not present was causing
errors, this has been fixed.
scu:
- fixed DSP debugging.
- fixed a Timer 0 bug. Fixes Shining the Holy Ark.
sh2:
- added SH2 idle detection. Speed should be significantly faster.
- separated original core(now the "debug interpreter core") from the core
with idle detection.
- sh2 cores are now selectable.
68k:
- added 68k disassembler.
- fixed some warnings.
vdp1:
- added debugging functions.
- fixed bug that was causing garbage graphics in Albert Odyssey.
- fixed bug that was causing graphics in Legend of Oasis to not get drawn.
- other bug fixes.
vdp2:
- fixed a few priority bugs.
- added initial special priority emulation.
general:
- added fullscreen and fixed resize in Windows. Still needs quite a bit of
work.
- changed event handling a bit. Gained quite a bit of speed from it.
- fixed some Mac OS X port bugs.
- fixed some Dreamcast port bugs.
- added proper Linux gui.
- Fixed YGL initialization.
- fixed some Windows ports bugs
- other bug fixes.
0.0.7 -> 0.5.0
cd block:
- bug fixes.
- improved timing.
cart:
- added Action Replay emulation.
- added 8/32 Mbit dram emulation.
- added 4/8/32 Mbit backup ram emulation.
- added 16 Mbit rom emulation.
- added very early Netlink emulation.
scsp:
- added Stephane Dallongeville's SCSP's core. Thanks again Stef!
- fixed a couple of bugs that were causing movies to lock up.
68k:
- added Stephane Dallongeville's 68k's core. Thanks again Stef!
- fixed a few endian related bugs.
- added debugger(still need disassembler though).
scu:
- added dsp emulation.
- added dsp debugger.
- added indirect dma emulation.
- added timer0 emulation.
- bug fixes.
smpc:
- added very basic SH2 direct peripheral mode.
- added clock change commands.
- added slave sh2 off/on commands.
- fixed intback command timing.
- bug fixes.
sh2:
- added FRT, WDT, and partial UBC emulation.
- fixed a couple of opcode bugs.
- re-added debugger.
- added some early dynarec code.
vdp1:
- added sprite priorities.
- added color offset.
- bug fixes.
vdp2:
- added basic rbg0 emulation(no rotation, etc.).
- added backscreen emulation.
- added caching.
- added color offset.
- added video mode changing.
- added screen scrolling.
- fix caching bug.
- other bug fixes.
- added early software video rendering. It's still pretty much unuseable at this point.
general:
- added binary execution.
- rewrote entire code in C for portability and speed.
- fixed a number of configure bugs, added a few more command-line options.
- fixed code so it's 64-bit friendly.
- added iso and bin/cue files support.
- changed several parts of yabause to allow for multiple implementations of video, sound, and peripheral code..
- added save states(currently broken unfortunately).
0.0.6 -> 0.0.7
cd block:
- added cd interface for porters.
- whole bunch of cd commands were added. Most games should now
start to boot.
- added region auto-detection.
mpeg card:
- added basic emulation.
- added mpeg rom loading support.
scsp:
- bug fixes.
scu:
- bug fixes.
smpc:
- bug fixes.
superh:
- fixed dma.
- lots of other bugfixes.
- opcode optimizations.
vdp1:
- added sprite caching.
- added scaled sprites.
- added sprite color modes 0, 1, 2, 3, 4.
- macosx color bug fixed.
- bug fixes.
vdp2:
- macosx color bug fixed.
- bug fixes.
general:
- added fps counter.
- switched to OpenGL, removed SDL_gfx.
- yui interface added. Now each port should be able to provide
a nice custom ui.
- threads removed, program should be more stable now.
- added save ram loading ability.
0.0.5 -> 0.0.6
scu
- added direct dma.
superh
- added division unit.
- fixed endianess issue.
vdp2
- added NBG3.
- fixed color bug.
0.0.4 -> 0.0.5
vdp2:
- lot of work, the vdp2 is now capable of
displaying the set-clock screen of the
bios.
monitor/debugger:
- added memory dump possibility.
0.0.2 -> 0.0.4
monitor/debugger:
- added debugging possibility, can now pause/resume emulation
and execute instructions step by step;
- opcodes are disassembled interactively.
general:
- early emulations of different cpu/onchip modules: scu, vdp1
and dmac;
- translate most of the code from french to english;
- added synchronisation between processors;
- yabause is now using SDL, remove all fork/ipc code and use
SDL_Thread instead.
0.0.1 -> 0.0.2
sh2:
- "mull" is now decoded;
- changed the way the opcodes are decoded, now using a table with pointers
to function, should be faster.
intc:
- now tests if the interrupt level is correct before accepting one.
vdp2:
- early emulation, just throws an interrupt every half-frame.
general:
- vdp1 and vdp2 are now synchronized with the master sh;
- fixed some memory bug, all the shared memory allocated is de-allocated;
- now using configure/make, should be more portable;
- modified things to be more c++ and less linux/c.

8
yabause/GOALS
View File

@ -1,8 +0,0 @@
Goals for a 1.0.0 release
--------------------------
-Full "stock" saturn emulation. At the very least it should be "feature complete"(most major bugs should be fixed at this point too)
-Any external carts or peripheral do not need to be fully emulated at this point
-Switchable SH2 Dynarec/Interpreter cores
-Full debugging support
-Speed should be high at this point(It's too tough ironing out those bugs with Yabause at its current state)
-Save States

229
yabause/INSTALL
View File

@ -1,229 +0,0 @@
Copyright 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
Foundation, Inc.
This file is free documentation; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, and a
file `config.log' containing compiler output (useful mainly for
debugging `configure').
It can also use an optional file (typically called `config.cache'
and enabled with `--cache-file=config.cache' or simply `-C') that saves
the results of its tests to speed up reconfiguring. (Caching is
disabled by default to prevent problems with accidental use of stale
cache files.)
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If you are using the cache, and at
some point `config.cache' contains results you don't want to keep, you
may remove or edit it.
The file `configure.ac' (or `configure.in') is used to create
`configure' by a program called `autoconf'. You only need
`configure.ac' if you want to change it or regenerate `configure' using
a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes awhile. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. Run `./configure --help'
for details on some of the pertinent environment variables.
You can give `configure' initial values for configuration parameters
by setting variables in the command line or in the environment. Here
is an example:
./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
*Note Defining Variables::, for more details.
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not support the `VPATH'
variable, you have to compile the package for one architecture at a
time in the source code directory. After you have installed the
package for one architecture, use `make distclean' before reconfiguring
for another architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
In addition, if you use an unusual directory layout you can give
options like `--bindir=PATH' to specify different values for particular
kinds of files. Run `configure --help' for a list of the directories
you can set and what kinds of files go in them.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' cannot figure out
automatically, but needs to determine by the type of machine the package
will run on. Usually, assuming the package is built to be run on the
_same_ architectures, `configure' can figure that out, but if it prints
a message saying it cannot guess the machine type, give it the
`--build=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name which has the form:
CPU-COMPANY-SYSTEM
where SYSTEM can have one of these forms:
OS KERNEL-OS
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the machine type.
If you are _building_ compiler tools for cross-compiling, you should
use the `--target=TYPE' option to select the type of system they will
produce code for.
If you want to _use_ a cross compiler, that generates code for a
platform different from the build platform, you should specify the
"host" platform (i.e., that on which the generated programs will
eventually be run) with `--host=TYPE'.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Defining Variables
==================
Variables not defined in a site shell script can be set in the
environment passed to `configure'. However, some packages may run
configure again during the build, and the customized values of these
variables may be lost. In order to avoid this problem, you should set
them in the `configure' command line, using `VAR=value'. For example:
./configure CC=/usr/local2/bin/gcc
will cause the specified gcc to be used as the C compiler (unless it is
overridden in the site shell script).
`configure' Invocation
======================
`configure' recognizes the following options to control how it
operates.
`--help'
`-h'
Print a summary of the options to `configure', and exit.
`--version'
`-V'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`--cache-file=FILE'
Enable the cache: use and save the results of the tests in FILE,
traditionally `config.cache'. FILE defaults to `/dev/null' to
disable caching.
`--config-cache'
`-C'
Alias for `--cache-file=config.cache'.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made. To
suppress all normal output, redirect it to `/dev/null' (any error
messages will still be shown).
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`configure' also accepts some other, not widely useful, options. Run
`configure --help' for more details.

2
yabause/Makefile.am
View File

@ -1,2 +0,0 @@
SUBDIRS = src l10n
EXTRA_DIST = README.DC README.LIN README.MAC README.WIN GOALS README.QT README.WII README.PSP

0
yabause/NEWS
View File

103
yabause/README
View File

@ -1,103 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
____________________________________
Copyright (c) 2002-2011 Yabause team
1) Introduction.............................................20
2) Staff/Thanks.............................................39
3) Contact information......................................75
4) Disclaimer...............................................86
1 Introduction________________________________________________
Yabause is a Sega Saturn emulator under GNU GPL.
Yabause can boot Saturn bios and games, some of those games
are playable.
For installation/how to use information, check the ports
specific README files:
* README.DC for the dreamcast port
* README.LIN for the linux port
* README.MAC for the mac port
* README.PSP for the PSP port
* README.QT for the crossplatform Qt 4 port
* README.WII for the WII port
* README.WIN for the windows port
2 Staff/Thanks________________________________________________
See the AUTHORS file for team members list.
Thanks to:
* Runik (author of Saturnin), for all his help, especially
on the vdp2.
http://saturnin.consollection.com
* Fabien Autrel (author of Satourne),
for letting me browse his sources.
http://satourne.consollection.com
* Chuck Mason (author of semu),
for releasing semu sources and for his handy debugger.
* Romain Vallet
for winning the "Find a name for my emu" contest, for
his contribution to this README and for this nice web
site he did.
http://romanito.free.fr/
* Stefano and all of segadev for their help.
* Josquin Debaz
for writing the man page.
* Bart Trzynadlowski
for his disassembler.
* Charles MacDonald
for his saturn sample programs, docs, and being a major
source for saturn information.
3 Contact information_________________________________________
E-mail: guillaume@yabause.org
Web: http://yabause.org
IRC: irc://irc.freenode.net/yabause
Please don't ask for roms, bios files or any other copyrighted
stuff. Please use the forum when you have any questions if
possible.
4 Disclaimer__________________________________________________
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 02110-1301 USA
See the GNU General Public License details in COPYING.

85
yabause/README.DC
View File

@ -1,85 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
____________________________________
Copyright (c) 2002-2011 Yabause team
1) Introduction.............................................20
2) Compiling instructions...................................31
2) How to use Yabause.......................................48
4) Final Thoughts...........................................71
1 Introduction________________________________________________
This file documents the Dreamcast version only, for general
information check the README file. Note, that if you are just
a casual user, and not a developer, you probably won't have
to worry about the Compiling instructions below. Pick up with
the section "How to use Yabause" to learn how to make a CD
image you can burn to use Yabause (or use a program like
Selfboot).
2 Compiling instructions______________________________________
Yabause is written in C using KallistiOS. So, in order to
compile it, you need a working sh-elf targetted C compiler,
such as gcc and a working KallistiOS environment:
* http://gamedev.allusion.net
Once KallistiOS is set up, you should be ready to build
Yabause.
Uncompress the Yabause source archive, move to the newly
created directory, type "cd src", then "make -f Makefile.dc",
it will generate one binary: "yabause.bin" in the "src"
directory.
3 How to use Yabause__________________________________________
Before using Yabause, you need to build a CD with a few files
in the correct places. In order to build a CD with the
compiled binary, you must first scramble the binary. This can
be done with the scramble utility which can be obtained from
http://mc.pp.se/dc/files/scramble.c . This will have to be
compiled with your native compiler. Once you run the scramble
program on the yabause.bin file created in section 2 above,
you will have a binary file suitable for booting on a real
Dreamcast.
Once you have your scrambled binary, you may choose to include
a Sega Saturn BIOS image on your disc as well. As of 0.9.5,
this is not a requirement for the Dreamcast port, but if you
choose to use an actual BIOS image, it must be put on the
root of the CD and named "saturn.bin".
From this point, follow your favorite guide for how to build
a selfbooting CD out of plain files. I use the one available
at http://mc.pp.se/dc/cdr.html .
4 Final Thoughts______________________________________________
The Dreamcast port of Yabause is quite slow. I have done very
little in the way of optimizing any of the core of Yabause
toward the Dreamcast (there is quite a bit that could be done
when time allows). Do not expect the Dreamcast port of
Yabause to run your favorite Sega Saturn games at any sort of
playable speed for now (or the near future). As Yabause
matures, and I have more time to work on it, hopefully speed
will improve. For now, think of it as a fancy tech demo.
Note that in 0.9.5, a small bit of assembly has appeared in
the Dreamcast port. Hopefully as time goes on more of the
Dreamcast specific code will be rewritten in assembly for at
least some small speed increase.

135
yabause/README.LIN
View File

@ -1,135 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
____________________________________
Copyright (c) 2002-2011 Yabause team
1) Introduction.............................................19
2) Compiling instructions...................................25
3) How to use Yabause......................................102
1 Introduction________________________________________________
This file documents the gtk version only, for general
information check the README file.
2 Compiling instructions______________________________________
The Gtk+ port of Yabause is written in C and depends on the
Gtk+ library (thus the name). The recommended setup of the
Gtk+ port is to link it against OpenGL and gtkglext libraries,
but this is not mandatory; see "Full Software mode" for
further instructions.
Yabause currently provides two build system, a legacy build
process using the autotools and a newer build process using
CMake.
2.1 Recommended setup_________________________________________
You need a working C compiler, such as gcc and the above
libraries runtime and development packages:
* http://www.gtk.org
* http://gtkglext.sourceforge.net
* OpenGL should be included with your compiler, if it isn't,
check on your distribution's website for links.
* http://www.cmake.org, you'll need a CMake version >= 2.8
With those libraries, you'll get a working Yabause, but with
some restrictions:
* No sound
* No translations
* Depending on your OS, keyboard input only
You may want to install some optional dependencies for a
better experience.
2.2 Optional libraries________________________________________
Yabause can use a number of optional libraries:
* SDL: provides sound and joystick support
http://www.libsdl.org/
* OpenAL: provides sound support
* mini18n: provides translation support
2.3 Compiling_________________________________________________
For the build process, we recommend using two directories: one
for the Yabause sources (SOURCES) and one for the build (BUILD)
Uncompress the Yabause source archive into the $SOURCES dir
and create the $BUILD directory.
Move to the build directory and type "cmake $SOURCES" then
"make" it will generate one program: "yabause" in the "src/gtk"
directory.
You can even type "make install" to install that program on
your system (in /usr/local/ by default), but we don't support
desinstalling it.
2.4 Full Software mode________________________________________
The Gtk+ supports building without OpenGL support.
cmake -DYAB_WANT_OPENGL=NO $SOURCES
make
3 How to use Yabause__________________________________________
Before using Yabause, you need to configure a few things in
the Preferences dialog (Yabause>Preferences).
3.1 Configuration_____________________________________________
First, set the BIOS path.
Yabause can run some games without a BIOS, but most of them
needs it. If you want to use the emulated BIOS, just let the
BIOS entry blank.
Next, set the cdrom device.
It can be a cd device, an iso or a cue file. Set the cd type
accordingly.
The last thing you have to configure is the keys.
Once eveything is set, you can start emulation with the
"Yabause>run" entry.
3.2 Command line arguments____________________________________
-b (or --bios=)
Specify bios file.
-c (or --cdrom=)
Specify cd device. You can know which file is used as cd
device by looking in /etc/fstab. It is commonly something
like /dev/hdc or /dev/hdd for IDE devices and /dev/scd0
for SCSI devices.
-i (or --iso=)
Specify iso file.

98
yabause/README.MAC
View File

@ -1,98 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
____________________________________
Copyright (c) 2002-2012 Yabause team
1) Introduction.............................................20
2) Compiling instructions...................................26
3) How to use Yabause.......................................46
4) Known Issues.............................................92
1 Introduction________________________________________________
This file documents the mac version only, for general
information check the README file.
2 Compiling instructions______________________________________
Yabause is written in C and Objective C using the Cocoa,
IOKit, OpenGL, and CoreAudio frameworks. All of these
frameworks should be installed by default on your Mac OS X
system. You must have the Mac OS X 10.6 SDK installed by the
Xcode installer in order to build Yabause. In addition, you
will need at least Xcode 3.2.
Once you have Xcode installed, you should be ready to build
Yabause.
Uncompress the Yabause source archive, and open the
Yabause.xcodeproj in the src/cocoa directory. From there it
should be as easy as hitting the Build or Build and Run
button in Xcode. This should generate a Yabause.app file
that can be run just like any other application bundle on
Mac OS X.
3 How to use Yabause__________________________________________
Before using Yabause, you need to configure a few things in
the Preferences dialog (Yabause > Preferences).
3.1 Configuration_____________________________________________
First, set the BIOS path.
Yabause can run some games without a BIOS, but many of them
need it. If you want to use the emulated BIOS, select the
checkbox for that.
Next, set up the video and sound cores. For the video core,
you have 4 options:
1. OpenGL Hardware Video Core - Potentially the fastest video
core choice, at least with a discrete video card. However,
it is also the least accurate.
2. Software Video Core - The most accurate video core you can
use, but also the slowest.
3. Grand Central Dispatch Software Core - A multithreaded
version of the Software Video Core. On a multi-core system
this should be significantly faster than the Software core
with a similar accuracy level.
4. Disable Video - Does exactly what it sounds like.
For the sound core, you only have two options:
1. Core Audio Sound Core - The default sound core. Select
this one if you want sound.
2. Disable Sound - Does exactly what it sounds like.
Next, set up keys for input. Go to the Input tab, and
configure each button (at least on Controller 1). For the
moment, this is limited to keyboard input only.
There are other options you can configure as well in here,
including BRAM (for saving), a MPEG ROM (for games that use
the VideoCD/MPEG card), and a cartridge for the cartridge
port on the Saturn.
Once eveything is set, you can start emulation with the
"File > Run BIOS", "File > Run CDROM" or "File > Run Image"
menu options. Don't use the Run BIOS entry if you're using
BIOS emulation.
4 Known Issues________________________________________________
When running in GDB, you should not use fullscreen mode. If
Yabause crashes while running under GDB in fullscreen mode,
you will probably get stuck with no way to exit. This should
only affect developers and shouldn't ever be an issue for
normal users.

802
yabause/README.PSP
View File

@ -1,802 +0,0 @@
PSP-Specific Yabause Documentation
==================================
Important notice
----------------
PSP support for Yabause is experimental; please be aware that some things
may not work well (or at all).
Unlike Yabause 0.9.10, this version of Yabause now works on all PSPs,
including the original PSP-1000 ("Phat"). However, some games may run
more slowly on PSP Phats because of the limited amount of memory available
for caching dynamically-translated program code.
Installing from a binary distribution
-------------------------------------
The yabause-X.Y.Z.zip archive contains a "PSP" directory (folder); copy
this into the root directory of your Memory Stick. (On Windows, for
example, your Memory Stick might show up as the drive F: -- in this case,
drag the "PSP" folder from the ZIP archive onto the "F:" drive icon in
Windows Explorer.)
The "PSP" directory contains a directory called "GAME", which in turn
contains a directory called "YABAUSE". Inside the "YABAUSE" directory are
two files named "EBOOT.PBP" and "ME.PRX"; these are the program files used
by Yabause, like .EXE and .DLL files on Windows. You'll also need to copy
your CD image and other data files to this directory on your Memory Stick
(see below).
Once you've copied Yabause to your Memory Stick, skip to "How to use
Yabause" below.
Installing from source
----------------------
To build Yabause for PSP from the source code, you'll need a recent (at
least SVN r2450(*)) copy of the unofficial PSP SDK from http://ps2dev.org,
along with the toolchain from the same site; Gentoo Linux users can also
download a Portage overlay from http://achurch.org/portage-psp.tar.bz2 and
"emerge pspsdk". Ensure that the PSP toolchain (psp-gcc) and tools
(psp-prxgen, etc.) are in your $PATH, then configure Yabause with:
./configure --host=psp [options...]
(*) Note that the PSP SDK headers and libraries are, at least through
r2493, missing some functions required by Yabause. If you get errors
about the functions sceKernelIcacheInvalidateAll or
sceKernelIcacheInvalidateRange, apply the patch found in
src/psp/icache-funcs-2450.patch to the PSP SDK source, recompile and
reinstall it, then rebuild Yabause. This patch is already included if
you build the SDK from the Gentoo Portage overlay.
You can ignore the warning about the --build option that appears when you
start the configure script. You may also see a warning about "using cross
tools not prefixed with host triplet"; you can usually ignore this as well,
but if you get strange build errors related to libraries like SDL or
OpenGL, try disabling the optional libraries with the options
"--without-sdl" and "--without-opengl".
The following additional options can be used when configuring for PSP:
--enable-psp-debug
Enables printing of debug messages to standard error.
--enable-psp-profile
Enables printing of profiling statistics to standard error.
By default, statistics are output every 100 frames; edit
src/psp/main.c to change this. Note that profiling has a
significant impact on emulation speed.
--with-psp-me-test
Builds an additional program, "me-test.prx", which tests the
functionality of the Media Engine access library included with
Yabause. Only useful for debugging or extending the library.
Note that if you build with optimization disabled (-O0) or at too low a
level, you may get compilation errors in src/psp/satopt-sh2.c. -O3 is
recommended; set this flag in the CFLAGS environment variable before
running the "configure" script. For example, if you use the "bash" shell:
CFLAGS=-O3 ./configure --host=psp [options...]
After the configure script completes, run "make" to build Yabause. The
build process will create the EBOOT.PBP and me.prx (note that the latter
is lowercase) files in the src/psp/ subdirectory; create a directory for
Yabause under /PSP/GAME on your memory stick (e.g. /PSP/GAME/YABAUSE) and
copy the files there.
How to use Yabause (PSP-specific notes)
---------------------------------------
All files you intend to use with Yabause (BIOS images, CD images, backup
RAM images) must be stored in the same directory as the EBOOT.PBP and
ME.PRX files mentioned above. The default filenames used by Yabause are
as follows:
BIOS.BIN -- BIOS image
CD.ISO -- CD image (can also be a *.CUE file)
BACKUP.BIN -- Backup RAM image (will be created if it does not exist)
You can choose other files from the Yabause configuration menu, which is
displayed the first time you start Yabause and can also be brought up at
any time by pressing the Select button; see below for details. If you do
not already have a backup RAM image, just leave the backup RAM filename at
its default setting, and the file will be created the first time backup RAM
is saved.
The directional pad and analog stick can both be used to emulate the
Saturn controller's directional pad. The default button controls are as
follows:
Start -- Start
A -- Cross
B -- Circle
C -- (unassigned)
X -- Square
Y -- Triangle
Z -- (unassigned)
L -- L
R -- R
Button controls can be changed via the configuration menu.
The Yabause PSP configuration menu
----------------------------------
When you first run Yabause, the configuration menu will be displayed,
allowing you to choose the CD image you want to run and configure other
Yabause options. You can also press Select while the emulator is running
to bring up the menu; the emulator will remain paused while you have the
menu open.
The main menu contains six options:
* "Configure general options..."
This opens a submenu with the following options:
* "Start emulator immediately"
When enabled, the emulator will start running immediately when
you load Yabause, instead of showing the configuration menu.
* "Select BIOS/CD/backup files..."
This opens a submenu which allows you to select the files
containing the BIOS image, CD image, and backup data you want
to use. Selecting one of the three options will open a file
selector, allowing you to choose any file in the Yabause
directory on your Memory Stick.
Note that changing any of the files will reset the emulator.
* "Auto-save backup RAM"
When enabled, automatically saves the contents of backup RAM to
your Memory Stick whenever you save your game in the emulator.
The emulator will display "Backup RAM saved." on the screen for
a short time when an autosave occurs. Note that the emulator
may pause for a fraction of a second while autosaving. This
option is enabled by default.
Be aware that backup RAM is _not_ saved to the Memory Stick
when you quit Yabause; if you disable this option, you need to
manually save it using the "Save backup RAM now" option when
appropriate.
* "Save backup RAM now"
Immediately saves the contents of backup RAM to your Memory
Stick. If you have auto-save disabled, you should use this
option to save backup RAM before quitting Yabause.
* "Save backup RAM as..."
Allows you to enter a new filename (using the PSP's built-in
on-screen keyboard) for the backup RAM save file. This can be
useful if you want to keep separate backup RAM files for
different games, or if you want to save more slots than a game
normally allows. Yabause will immediately save backup RAM to
the filename you enter, and will also use that filename when
later auto-saving backup RAM (or when you manually use "Save
backup RAM now"). However, the new filename will only be used
until you quit Yabause, unless you select "Save options" on the
main menu.
Note that the emulator will _not_ be reset when you use this
option, so you can feel free to select it while playing a game.
(However, don't select it while the game is in the middle of
loading or saving, as this can corrupt backup RAM -- just as if
you tried to remove the PSP's Memory Stick while saving a game
on your PSP.)
NOTE: For reasons currently unknown, the top part of the
on-screen keyboard display may flicker or appear corrupted.
However, text can be entered as usual.
* "Configure controller buttons..."
This opens a submenu which allows you to configure which PSP button
corresponds to which button on the emulated Saturn controller.
Pressing one of the Circle, Cross, Triangle, or Square buttons on
the PSP will assign that button to the currently selected Saturn
controller button. The PSP's Start, L, and R buttons are always
assigned to the same-named buttons on the Saturn controller, and
cannot be changed.
Since both the Circle and Cross buttons are used for button
assignment, the Start button is used to return to the main menu.
* "Configure video options..."
This opens a submenu with the following options:
* "Use hardware video renderer" / "Use software video renderer"
These options allow you to choose between the PSP-specific
hardware renderer and the default software renderer built into
Yabause for displaying Saturn graphics. The hardware renderer
is significantly faster; for simple 2-D graphics, it can run at
a full 60fps without frame skipping (if the game program itself
can be emulated quickly enough). However, a number of more
complex graphics features are not supported, so if a game does
not display correctly, try using the software renderer instead.
The selected renderer can be changed while the emulator is
running without disturbing your game in progress. However,
changing the renderer may cause the screen to blank out or
display corrupted graphics for a short time.
* "Configure hardware rendering settings..."
This option opens another submenu which allows you to change
certain aspects of the hardware video renderer's behavior:
* "Aggressively cache pixel data"
When enabled, Yabause will try to store a copy of all
graphic data in the PSP's native pixel format, to speed up
drawing. However, Yabause may not always notice when the
data is changed, causing incorrect graphics to appear.
(This can be fixed by disabling the option, exiting the
menu for a moment, then re-enabling the option.) When
disabled, all graphics are redrawn from the Saturn data
every frame. This option is enabled by default.
* "Smooth textures and sprites"
When enabled, smoothing (antialiasing) is applied to all
3-D textures and sprites drawn on the screen. This can
make 3-D environments look smoother than on a real Saturn,
but it will also cause zoomed sprites to look blurry, which
may not be the game's intended behavior.
* "Smooth high-resolution graphics"
When enabled, high-resolution graphics (which ordinarly
would not fit on the PSP's screen) are displayed by
averaging adjacent pixels to give a smoother look to the
display; this can particularly help in reading small text
on a high-resolution screen. However, this smoothing is
significantly slower than the default method of just
skipping every second pixel.
* "Enable rotated/distorted graphics"
Selects whether to display rotated or distorted graphics
at all. Most such graphics cannot be rendered by the
PSP's hardware, so Yabause has to draw them in software,
which can be a major source of slowdown. Disabling this
option will turn such graphics off entirely. This option
is enabled by default.
* "Optimize rotated/distorted graphics"
When enabled, Yabause will try to detect certain types of
rotated or distorted graphics which can be approximated by
PSP hardware operations such as 3D transformations, and use
the PSP's hardware to draw them quickly. However, this
will often result in graphics that look different from the
game as played on an actual Saturn, so this option can be
used to disable the optimizations and draw the graphcs more
accurately (at the expense of speed). This option is
enabled by default.
Note that none of the above options have any effect when the
software video renderer is in use.
* "Configure frame-skip settings..."
This option opens another submenu which allows you to configure
the hardware renderer's frame-skip behavior:
* "Frame-skip mode"
This option is intended to allow you to switch between
manual setting and automatic adjustment of frame-skip
parameters. However, automatic mode is not yet
implemented, so always leave this set on "Manual".
* "Number of frames to skip"
In Manual mode, sets the number of frames to skip for every
frame drawn. 0 means "draw every frame", 1 means "draw
every second frame" (skip 1 frame for every frame drawn),
and so on.
* "Limit to 30fps for interlaced display"
Always skip at least one frame when drawing interlaced
(high-resolution) screens. Has no effect unless the number
of frames to skip is set to zero. This option is enabled
by default.
* "Halve framerate for rotated backgrounds"
Reduce the frame rate by half (in other words, skip every
second frame that would otherwise be drawn) when rotated or
distorted background graphics are displayed. Since rotation
and distortion take a long time to process on the PSP, this
option can help keep games playable even when they make use
of these Saturn hardware features. This option is enabled
by default.
Note that this option does not apply to rotated or
distorted graphics which are displayed using an optimized
algorithm (see the "Optimize rotated/distorted graphics"
option above).
Frame skipping is not supported by the software renderer, so
none of these options will have any effect when the software
renderer is in use.
* "Show FPS"
When enabled, the emulator's current speed in emulated frames per
second (FPS) will be displayed in the upper-right corner of the
screen as "FPS: XX.X (Y/Z)". The number "XX.X" is the average
frame rate, calculated from the last few seconds of emulation;
"Y" shows the number of Saturn frames emulated since the previous
frame was shown, while "Z" is the actual time that passed in
60ths of a second. (Thus, the instantaneous frame rate can be
calculated as (Y/Z)*60.)
This option has no effect when the software renderer is in use.
* "Configure advanced settings..."
This opens a submenu with the following options:
* "Use SH-2 recompiler"
This option allows you to choose between the default SH-2 core,
which recompiles Saturn SH-2 code into native MIPS code for the
PSP, and the SH-2 interpreter built into Yabause. The SH-2
interpreter is much slower, often by an order of magnitude or
more, so there is generally no reason to disable this option
unless you suspect a bug in the recompiler.
Note that changing this option will reset the emulator. As with
"Reset emulator" on the main menu, you must hold L and R while
changing this option to avoid an accidental reset.
* "Select SH-2 optimizations..."
This option opens up another submenu which allows you to turn on
or off certain optimizations used by the SH-2 recompiler. These
are shortcuts taken by the recompiler to allow games to run more
quickly, but in rare cases they can cause games to misbehave or
even crash. If a game doesn't work correctly, turning one or
more of these options off may fix it.
These options can be changed while the emulator is running
without disturbing your game in progress. However, changing them
causes the emulator to clear out any recompiled code it has in
memory, so the game may run slowly for a short time after exiting
the menu as the emulator recompiles SH-2 code using the new
options.
All optimizations are enabled by default.
* "Configure Media Engine options..."
This option opens up another submenu with options for
configuring the Media Engine:
* "Use Media Engine for emulation"
Enables the use of the PSP's Media Engine CPU to handle part
of the emulation in parallel with the main CPU. This can
provide a moderate boost to emulation speed; however, since
the Media Engine is not designed for this sort of parallel
processing, some games may behave incorrectly or even crash.
As such, this option is still considered experimental; use
it at your own risk.
IMPORTANT: It is not currently possible to suspend the PSP
while the Media Engine is in use. If you start Yabause with
the Media Engine enabled, the "suspend" function of the
PSP's power switch will be disabled, so you must save your
game inside the emulator and exit Yabause before putting the
PSP into suspend mode.
This option only takes effect when Yabause is started, so if
you change it, make sure you select "Save options" in the
main menu and then quit and restart Yabause.
* "Cache writeback frequency"
Sets the frequency at which the main CPU and Media Engine
caches are synchronized, relative to the frequency of code
execution on the Media Engine. The default frequency of 1/1
is safest; lower frequencies (1/2, 1/4, and so on) can
increase emulation speed, but are also more likely to cause
sound glitches, crashes, or other incorrect behavior
depending on the particular game. However, adjusting the
size of the write-through region (see below) can mitigate
these problems for some games.
Naturally, this option has no effect if the Media Engine is
not being used for emulation.
* "Sound RAM write-through region"
Sets the size of the region at the beginning of sound RAM
which is written through the PSP's cache. Writing through
the cache is an order of magnitude slower than normal
operation, so setting this to a large value can slow down
games significantly. However, most games only use a small
portion of sound RAM for communication with the sound CPU,
so by tuning this value appropriately, you may be able to
reduce the cache writeback frequency (see above) while still
getting stable operation. From experimentation, a value of
2k seems to work well for some games.
Naturally, this option has no effect if the Media Engine is
not being used for emulation.
* "Use more precise emulation timing"
When enabled, the emulator will keep the various parts of the
emulated Saturn hardware more precisely in sync with each other.
This carries a noticeable speed penalty, but some games may
require this more precise timing to work correctly.
* "Sync audio output to emulation"
When enabled, the emulator will synchronize audio output with
the rest of the emulation. In general, this improves audio/video
synchronization but causes more frequent audio dropouts (or
"popping") when the emulator runs more slowly than real time.
However, the exact effect of this option can vary:
- When disabled, the audio can get ahead of the video if the
emulator is running slowly; this can be seen, for example,
in the Saturn BIOS startup animation. On the other hand,
game code that uses the audio output speed for timing (such
as the movie player in Panzer Dragoon Saga) can actually run
faster with synchronization disabled. MIDI-style background
music will also play more smoothly, though of course the
music tempo will slow down depending on the emulation speed.
- When enabled, the audio output will match the output of a
real Saturn much more closely. In particular, this option
is needed to avoid popping in streamed audio such as Red
Book audio tracks when the emulator runs at full speed
(60fps). On the flip side, the audio will momentarily drop
out (as described above) whenever the emulator takes more
than 1/60th of a second to process an emulated frame.
This option is enabled by default.
* "Sync Saturn clock to emulation"
When enabled, the Saturn's internal clock is synchronized with
the emulation, rather than following real time regardless of
emulation speed. If the emulator is running slow, for example,
this option will slow the Saturn's clock down to match the speed
at which the emulator is running. This option is enabled by
default.
* "Always start from 1998-01-01 12:00"
When enabled, the Saturn's internal clock will always be
initialized to 12:00 noon on January 1, 1998, rather than the
current time when the emulator starts. When used with the clock
sync option above, this is useful in debugging because it ensures
a consistent environment each time the emulator is started.
Outside of debugging, however, there is usually no reason to
enable this option.
* "Save options"
Save the current settings, so Yabause will use them automatically the
next time you start it up.
* "Reset emulator"
Reset the emulator, as though you had pressed the Saturn's RESET
button. To avoid accidentally resetting the emulator, you must hold
the PSP's L and R buttons while selecting this option.
Pressing Select on any menu screen will exit the menu and return to the
Saturn emulation.
Troubleshooting
---------------
Q: "My game runs too slowly!"
A: C'est la vie. The PSP is unfortunately just not powerful enough to
emulate the Saturn at full speed (see "Technical notes" below for the
gory details). Here are some things you can do to improve the speed of
the emulator:
* Make sure you are using the hardware video renderer (in the
"Configure video options" menu) and the SH-2 recompiler (in the
"Configure advanced settings" menu).
* Under "Configure video options" / "Configure hardware rendering"
settings", turn off "Enable rotated/distorted graphics". A single
distorted background can take the equivalent of 2 to 3 frames at
60fps to render on the PSP.
* Under "Configure video options" / "Configure frame-skip settings",
set the frame-skip mode to manual and increase the number of frames
to skip. (Many games only run at 30 frames per second, so using a
frame-skip count of 1 won't actually make a visible difference
compared to a count of 0.)
* Under "Configure advanced emulation options" / "Select SH-2
optimizations", make sure all optimizations are enabled.
* Under "Configure advanced emulation options", if "Use more precise
emulation timing" is disabled, try enabling it. (This may cause
the game to freeze or crash, however.)
* Try turning on the "Use Media Engine for emulation" option in the
"Configure advanced emulation options" menu, but note that this
option is experimental and may cause your game to misbehave or even
crash.
* If the Media Engine is enabled, try lowering the cache writeback
frequency in the "advanced emulation options" menu. Typically,
1/4 to 1/8 will provide a noticeable speed increase over 1/1, while
1/16 and lower are not likely to have much effect.
Q: "My game suddenly froze!"
A: Try pressing Select to open the Yabause menu.
* If the menu doesn't open, then either you've hit a bug in Yabause,
or the SH-2 optimizer has caused the program to misbehave. Restart
Yabause, then go to the "Configure advanced emulation options" /
"Select SH-2 optimizations" and disable all of the options there.
If that fixes the problem, you can then try turning the options on
one by one to find the one that caused the crash (you may need to
repeat whatever actions you performed in the game in order to
determine whether the crash occurs or not), and disable only that
option to keep the emulator running as fast as possible.
* If the menu does open, then one likely cause is a timing issue;
this can be seen, for example, when starting Dead or Alive with the
"Use more precise emulation timing" option disabled. Try enabling
this option under the "Configure advanced emulation options" menu
and resetting the emulator to see if it fixes the problem.
In either of the above cases, it's also possible that the game itself
has a bug. Look in FAQs or other online resources and see if any
similar problems have been reported.
Technical notes
---------------
The Saturn, like the PSOne, is only one step down in power from the PSP
itself, so full-speed emulation is a fairly difficult proposition from the
outset. To make matters worse, the Saturn's architecture is about as
different from the PSP as two modern computer architectures can be:
different primary CPUs (SH-2 versus MIPS Allegrex), big-endian byte order
(Saturn) versus little-endian (PSP), tile-based graphics (Saturn) versus
texture-based graphics (PSP), and so on. As such, Yabause must take a
number of shortcuts to make games even somewhat playable.
<<< SH-2 emulation >>>
Emulation of the Saturn's two SH-2 CPUs in particular is problematic.
These processors run at either 26 or 28 MHz, and they use a RISC-like
instruction set in which most instructions execute in one clock cycle, so
in a worst-case scenario Yabause would need to process 56 million SH-2
instructions per second--on top of sound, video, and other hardware
emulation--to maintain full speed. But the PSP's single(*) Allegrex CPU
runs at a maximum of 333MHz, meaning that the SH-2 emulator must be able to
execute each instruction (including accessing the register file, swapping
byte order in memory accesses, updating the SH-2 clock cycle counter, and
so on) within at most 6 native clock cycles for full-speed emulation. In
fact, the demands of emulating the other Saturn hardware reduce this to
something closer to 4 native clock cycles.
(*) The PSP actually has a second CPU, the Media Engine, but limitations
of the PSP architecture make it unsuitable for use as a full-fledged
second processor. See below for details.
With these limitations, interpreted execution of SH-2 code is out of the
question--merely looking up the instruction handler would exhaust the
instruction's quota of execution time. For this reason, the PSP port uses
a dynamic translator to convert blocks of SH-2 code into blocks of native
MIPS code. When the emulator encounters a block of SH-2 code for the first
time, it scans through the block, generating equivalent native code for the
block which is then executed directly on the native CPU. This naturally
causes the emulator to pause for a short time when it encounters a lot of
new code at once, such as when loading a new part of a game from CD; this
is the price that must be paid for the speed of native code execution.
Even with this dynamic translation, however, there are still a number of
hurdles to fast emulation. For example:
* Every time the end of a code block is reached, the emulator must look up
the next block to execute. This lookup consumes precious cycles which do
not directly correspond to SH-2 instruction emulation (around 35 cycles
per lookup in the current version).
In order to streamline code translation and increase the optimizability
of individual blocks, the dynamic translator tends to choose minimally-
sized blocks for translation. Tests showed that this was an improvement
over an older algorithm that used larger blocks, but the resulting
overhead of block lookups imposes a limit on execution speed for certain
types of code, particularly algorithms which rely heavily on subroutine
calls.
At the other end of the spectrum, one might consider modifying a true
compiler like GCC to accept SH-2 instructions as input, then running
each code block through the compiler itself to generate native code.
This could undoubtedly produce efficient output with larger blocks, but
it would also impose significant additional overhead when translating.
* The SH-2 is unable to load arbitrary constants into registers, instead
using PC-relative accesses to load values outside the range of a MOV #imm
instruction from memory. However, Saturn programs also use PC-relative
accesses for function-local static variables, meaning that there is no
general way to tell whether a given value is actually a constant or
merely a variable that may be modified elsewhere.
This presents a particular problem in optimizing memory accesses, since
if a pointer loaded from a PC-relative address is not known to be
constant, the translated code must incur the overhead of checking the
pointer's value every time the block is executed. The SH-2 core includes
an optional optimization, SH2_OPTIMIZE_LOCAL_POINTERS, which takes the
stance that all such pointers either are constant or will always point
within the same memory region (high system RAM, VDP2 RAM, etc.). This
optimization shows a marked improvement in execution speed in some cases,
but any code which violates the assumption above will cause the emulator
to crash.
* Some games make use of self-modifying code, presumably in an attempt to
increase execution speed; one example can be found in the "light ray"
animation used in Panzer Dragoon Saga when obtaining an item. Naturally,
the use of self-modifying code has a severe impact on execution time in a
dynamic translation environment, as each modification requires every
block containing the modified instruction to be retranslated. (A similar
effect can be seen on modern x86-family CPUs, which internally translate
x86 instructions to native micro-ops for execution; self-modifying code
can slow down the processor by an order of magnitude or more.)
The SH-2 core attempts to detect frequently modified instructions and
pass them directly to the interpreter to avoid the overhead of repeated
translation, but there is unfortunately no true solution to the problem
other than rewriting the relevant part of the game program itself.
* Memory accesses are difficult to implement efficiently; in fact, the SH-2
emulator devotes over 1,000 lines of source code to handling load and
store operations, independently of the memory access handlers in the
Yabause core. The current implementation is able to handle accesses to
true RAM fairly quickly, but any access which falls back to the default
MappedMemory*() handlers incurs a significant access penalty (typically
20-30 cycles plus any handling needed for the specific address).
This is most obvious while loading data from the emulated CD, since the
game program must access a hardware register in a loop while waiting for
the CD data to be loaded, and additionally some games read CD data
directly out of the CD data register rather than using DMA to load the
data into memory. Currently, the only way to speed up such code blocks
is through handwritten translation (see src/psp/satopt-sh2.c).
Patches to either speed up specific games or to improve the translation
algorithm generally are of course welcome.
<<< Use of the Media Engine >>>
Aside from the two SH-2 cores, a third major consumer of CPU time is the
SCSP, the Saturn's sound processor, and particularly the MC68EC000
("68k") CPU used therein. While most games don't run particularly complex
code on the 68k, it is nonetheless a proper CPU in its own right, and
requires a fair amount of time to emulate; multi-channel FM background
music takes time to generate as well. Currently, the PSP port of Yabause
has the ability to make use of the PSP's Media Engine CPU to process 68k
instructions and audio generation in parallel with the rest of the
emulation, but this use of the Media Engine is a considerable departure
from Sony's design and thus a risky endeavor.
The primary difficulty with using the ME as a "second core" in the sense
of the multi-core processors used in PCs is that of cache coherency.
Unlike generic multiprocessor or multi-core systems, the PSP's two CPUs
do not implement cache coherency; this means that neither CPU knows what
the other CPU has in its cache, and one CPU may inadvertently clobber the
other's changes, causing stores to memory to get lost. As an example,
consider these two simple loops, operating in parallel on a two-element
array initialized to {1,1} that resides in a single cache line:
Core 1 Core 2
------ ------
for (;;) { for (;;) {
array[0] += array[1]; array[1] += array[0];
} }
This illustrates two problems caused by the lack of cache coherency:
* On a cache-coherent (or single-core) system, the two array elements
will increase unpredictably as each loop sees the updated value stored
by the other loop. On the PSP, however, both elements will increase
monotonically; once each CPU loads the cache line, it never sees any
stores performed by the other CPU, because accesses to the array always
hit the cache.
* On a cache-coherent system, if the cache line is flushed to memory, it
will always contain the current values of both array elements. On the
PSP, however, the array element _not_ updated by the flushing CPU will
be written with the same value it had when the cache line was loaded
by that CPU. In particular, if the other CPU had already flushed the
cache line, that change will be clobbered--for example (here "SC" is
the main CPU and "ME" is the Media Engine):
Time Operation SC cache ME cache Memory Desired
---- ---------- -------- -------- ------ -------
T1 Initialize {1,1} {1,1} {1,1} {1,1}
T2 SC flush {A,1} {1,B} {A,1} {A,B}
T3 ME flush {C,1} {1,D} {1,D} {C,D}
Note that at no time after initialization are the contents of memory
correct, and in particular, the value "A" written by the SC is lost
when the ME flushes {1,D} from its cache, even though the ME loop
never actually modified that array element.
In order for Yabause to have even a hope of stable operation, therefore,
the use of both CPUs' caches must be carefully controlled to avoid data
loss.
When use of the Media Engine is enabled, the following steps are taken
to avoid data corruption due to the lack of cache coherency:
* SCSP state variables used for inter-thread communication are divided into
separate, 64-byte (cache-line) aligned data sections, based on which
thread (the main Yabause thread, running on the SC, or the SCSP thread,
running on the ME) writes to them.
* SCSP state variables are accessed using uncached (0x4nnnnnnn) addresses
in two cases: when _reading_ data written by the other CPU (to avoid an
old value getting stuck in the cache), and when _writing_ data which is
also written by the other CPU (to avoid the cache line clobbering problem
described above).
* Sound RAM is accessed _with_ caching (except in one case described
below), because forcing every sound RAM access through an uncached
pointer causes significant slowdown. Instead, cached CPU data is written
back to RAM at strategic points.
* The SC's data cache is flushed (written back and invalidated) immediately
before waiting for the SCSP thread to finish processing, e.g. for
ScspReset(). The data cache is written back on every ScspExec() call
(though the writeback frequency may be reduced through the configuration
menu), but it is _not_ flushed for performance reasons; instead, sound
RAM read accesses from the SC are made through uncached addresses, as
with SCSP state variables above.
* The ME's data cache is flushed after each iteration of the SCSP thread
loop. This flushing is not coded directly into scsp.c, but instead
takes place in the YabThreadYield() and YabThreadSleep() implementations.
(These functions are naturally meaningless on the ME, but since the SCSP
thread calls one or the other at the end of each loop, it's a convenient
place to flush the cache.)
* The 68k state block, along with dynamically-generated native code when
dynamic translation is enabled, is stored in a separately allocated pool
and managed with custom memory allocation functions (local_malloc() and
friends in psp-m68k.c), since the standard memory management functions
are not designed to work with the ME and would likely cause a crash due
to cache desynchronization.
In general, using the ME provides a moderate speed improvement (10-15%) to
overall emulation speed. There are, however, some cases in which the lack
of cache coherency could cause games to misbehave or even crash Yabause:
* If a game writes (from the SH-2) to a portion of sound RAM containing 68k
program code while the 68k is executing, the 68k may execute incorrect
code, or the dynamic translation memory pool may be corrupted. Normally,
games should only load code while the 68k is stopped, but there may be
cases when the SH-2 writes to a variable in sound RAM which is located in
the same region as 68k code, thus triggering this issue.
* Games which rely on the precise relative timing of the SH-2 and 68k
processors are likely to fail in any multithreaded emulator, but are more
likely to fail when using the ME due to delays in data being written out
from the data caches.

138
yabause/README.QT
View File

@ -1,138 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
_________________________________________
Copyright (c) 2002-2011 Yabause team
1) Compiling instructions...................................20
2) How to use Yabause.......................................82
3) Contact information.....................................105
4) Disclaimer..............................................121
1 Compiling instructions______________________________________
Yabause is written in C using the OpenGL library, so you need a working C compiler(such as gcc) and
these libraries, runtime and development packages:
* OpenGL should be included with your compiler, if it isn't,
check on your compiler's website for links.
Yabause can also use the SDL library:
* http://www.libsdl.org/
Yabause can also use the GLUT library:
* Check google, I haven't been able to find a good
source for it.
Once these libraries installed, you should be ready to
install Yabause.
Building the Qt 4 port require the Qt 4.3.x libraries too, it's a crossplatform C++ library for various all days crossplatform work ( gui, threads ... ).
I used the version 4.3.4 version for the developement and tests, so please don't report bugs if you are not using at least this version.
* http://www.trolltech.com/products/qt
Compiling for Windows : using mingw/cygwin__________________________________
All you have to do now is now is go into your mingw/cygwin
shell environment, go into the directory where you extracted
yabause, and type: "./configure --enable-newperinterface ---with-port=qt". Once that's done(and there
was no errors), type: "make". It should now take some time to
compile so go grab yourself a sandwich or beer - whatever suits
your fancy and it should be done in a few minutes. Now all you
have to do is type "./src/qt/release/yabause" in order to run it.
Compiling for Mac OS X : using gcc__________________________________________
Uncompress the Yabause source archive, move to the newly
created directory, type "./configure --enable-newperinterface --disable-dependency-tracking --disable-shared --with-port=qt", then "make",
it will generate a bundle: "Yabause.app" in the "src/qt"
directory.
You can then use Yabause by opening the bundle with:
"open Yabause.app" or with the Mac OS X finder.
Compiling for *Nix/Linux/BSD ? : using gcc__________________________________
Uncompress the Yabause source archive, move to the newly
created directory, type "./configure --enable-newperinterface ---with-port=qt", then "make",
it will generate one program: "yabause" in the "src/qt"
directory.
You can also pass the --enable-debug option to the configure script, Yabause
will then print debug messages in a special dock window.
(Use the --help flag for a complete list of options.)
You can even type "make install" to install that program on
your system (in /usr/local/ by default), then uninstalling is
done by typing "make uninstall".
You can try to read other specific README files for more information.
2 How to use Yabause__________________________________________
Before using Yabause, you need to configure a few things in
the Preferences dialog (File>Settings).
2.1 Configuration_____________________________________________
First, set the BIOS path.
Yabause can run some games without a BIOS, but most of them
needs it. If you want to use the emulated BIOS, just let the
BIOS entry blank.
Next, set the cdrom device.
It can be a cd device, an iso or a cue file. Set the cd type
accordingly.
The last thing you have to configure is the keys.
Once eveything is set, you can start emulation with the
"Emulation>Run" entry.
3 Contact information_________________________________________
General inquiries should go to:
E-mail: guillaume.duhamel@gmail.com
E-mail: cwx@cyberwarriorx.com
Qt Port-related inquiries should go to:
E-mail: pasnox@yabause.org
Web: http://yabause.org
Please don't ask for roms, bios files or any other copyrighted
stuff. Please use the forum when you have any questions if
possible.
4 Disclaimer__________________________________________________
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 02110-1301 USA
See the GNU General Public License details in COPYING.

88
yabause/README.WII
View File

@ -1,88 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
_________________________________________
Copyright (c) 2002-2011 Yabause team
1) Special Notice...........................................21
2) Compiling instructions...................................28
3) How to use Yabause.......................................50
4) Contact information......................................55
5) Disclaimer...............................................71
1 Special Notice______________________________________________
Please note that the Wii port is in alpha status, and won't be
officially supported until a later date. If you would like to
contribute, please contact us(see the contact information
section in README).
2 Compiling instructions______________________________________
Yabause is written in C using the devkitPro packages. You can
download it from:
http://www.devkitpro.org
Once this is installed, you should be ready to install Yabause.
To compile, either use the Makefile.wii file in the src
subdirectory to compile it(e.g. make -f Makefile.wii) or you can
use configure in the main directory as follows:
./configure --build=i686-pc-linux-gnu --host=powerpc-gekko
Once that's done, type "make". It should now take some time to
compile so go grab yourself a sandwich or beer - whatever suits
your fancy and it should be done in a few minutes. You should
now have a file called "yabause.elf". Now all you have to do is
load it on your Wii(which is something we won't cover here).
3 How to use Yabause__________________________________________
To be finished later.
4 Contact information_________________________________________
General inquiries should go to:
E-mail: guillaume@yabause.org
E-mail: cwx@cyberwarriorx.com
Windows Port-related inquiries should go to:
E-mail: cwx@cyberwarriorx.com
Web: http://yabause.org
Please don't ask for roms, bios files or any other copyrighted
stuff. Please use the forum when you have any questions if
possible.
5 Disclaimer__________________________________________________
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 02110-1301 USA
See the GNU General Public License details in COPYING.

250
yabause/README.WIN
View File

@ -1,250 +0,0 @@
_ _
/ \_/ \ ___ _ ____
\ /___ ___ / || | __ / \ ____
\ // || \ / || | \ \\ \_// \
/ // || // _ || |__\ \\ \ __/
\_// _ || \\_/ \_||______/ \ \\ \__
\_/ \_||___/ \____/ \____\
Yet Another Buggy And Uncomplete Saturn Emulator
_________________________________________
Copyright (c) 2002-2011 Yabause team
1) Compiling instructions...................................20
2) How to use Yabause.......................................68
3) Contact information.....................................217
4) Disclaimer..............................................233
1 Compiling instructions______________________________________
Yabause is written in C using the DirectX 8.0, OpenGL, GLUT, and
mini18n libraries, so you need a working C compiler(such as gcc)
and these libraries, runtime and development packages:
* You can find DirectX headers and libraries(for mingw) at
http://alleg.sourceforge.net/wip.html as the file
"dx80_mgw.zip". The actual runtime libraries(or
headers/libraries for Visual C++) can be gotten from
http://www.microsoft.com/DirectX
* OpenGL should be included with your compiler, if it isn't,
check on your compiler's website for links.
* Check google for GLUT. I haven't been able to find a good
source for it.
* You can get mini18n from Yabause's sourceforge download page
here: http://sourceforge.net/project/showfiles.php?group_id=89991&package_id=304859
Once these libraries installed, you should be ready to
install Yabause.
Compiling using mingw/cygwin__________________________________
All you have to do now is now is go into your mingw/cygwin
shell environment, go into the directory where you extracted
yabause, and type: "./configure". Once that's done(and there
was no errors), type: "make". It should now take some time to
compile so go grab yourself a sandwich or beer - whatever suits
your fancy and it should be done in a few minutes. Now all you
have to do is type "./src/yabause" in order to run it.
Compiling using Visual C++____________________________________
Make sure you have the latest DirectX SDK and DDK installed. You
can get both of them from Microsoft's website.
Load up IDE that comes with Visual C++/Visual Studio, go into the
file menu, open an existing project. Go into the yabause's
src/windows directory and open yabause.sln. Now all you have
to do is build it like any other Visual C++ project.
You can compile for either x86 or x64(for those using Windows XP
x64 or Vista x64.
2 How to use Yabause__________________________________________
While not necessarily needed, it is recommended you get a Saturn
ROM BIOS image. Please don't ask us where to get one.
Execute "yabause". The program will open a settings window.
Basic Settings________________________________________________
The Disc Type setting allows you to choose whether you'd like to
use a real cdrom or a cdrom image of the game you're trying to
run.
The Cue/Iso File setting allows you to specify the location
of your Saturn game's cdrom image.
The Drive Letter setting is for you to be able to choose which
cdrom drive you want yabause to use when trying to boot a game.
The SH2 Core setting is for you to be able to choose which SH2
Core to use. Unless you're a developer, chances are, you should
leave it as the default: "Fast Interpreter".
The Region setting allows you to choose which region of game
you'll be booting. In most cases, it's best to leave it as
"Auto-detect".
The Bios ROM File setting allows you to specify the location
of your Saturn ROM BIOS image. If you leave it blank, yabause
will try to emulate the bios instead. It's better to specify
a ROM BIOS image if you can since the emulated bios isn't
100% perfect and may not work with your games.
The Backup RAM File setting allows you to specify the location
of the Backup RAM file. This file allows yabause to store and
load save games.
The MPEG ROM File setting allows you to specify the location
of a MPEG Card's ROM image. While not necessary, it does allow
you to test out the saturn's vcd capabilities.
The Cartridge Type setting allows you to choose which type of
external cartridge to emulate. Some carts also require you to
supply a rom filename, or a new filename for the emulator to
write to. You can enter that information in the field below it.
When you're done, just click on the "OK" button. If the bios
location was specified correctly, emulation should start and
you will see a brief animation of the saturn logo being formed.
Special Note: Some settings require a restart of the program.
There's also settings specifically for video, sound, and input.
Video Settings________________________________________________
If you click on the "Video" tab another list of settings is
displayed. You can set the Video Core to either do hardware
rendering using OpenGL, software renderer(uses OpenGL the final
draw though), or disable drawing completely with the "None"
option. You can also "Enable Auto Frame-skipping" which basically
tries to skip rendering video frames if emulation is lagging in
an attempt to speed things up.
The Full Screen on startup setting allows you to set Yabause to
run using the full screen when started. You can also change what
resolution is used while in full screen.
The custom window size setting allows you to set the size of the
video display for yabause.
Sound Settings________________________________________________
If you click on the "Sound" tab another list of settings is
displayed. You can set the Sound Core to either do sound mixing
using DirectX Sound or disable sound completely with the "None"
option. You can also adjust the sound volume using the volume
slider underneath.
Input Settings________________________________________________
If you click on the "Input" tab another list of settings is
displayed. Here you can choose which peripheral(s) emulate. If
you press "Config" another window will pop up. Here can set which
device you'd like to use at the top of the window. Control
settings can be changed by clicking on the equivalent button, and
then when a new window pops up that says "waiting for input..."
press a key/button and that will set the new setting for that
control.
Log Settings__________________________________________________
If you've compiled your own copy of Yabause with the processor
define DEBUG, another tab will be available called "Log". This
allows you to control whether or not the program should be
logging emulation output using the "Enable Logging" setting. Log
Type tells the program whether it should write the output to a
file, or to a separate window so you can monitor the output while
you're running the program.
Here are the default key mappings(they may be subject to change):
Up arrow - Up
Left arrow - Left
Down arrow - Down
right arrow - Right
k - A button
l - B button
m - C button
u - X button
i - Y button
o - Z button
x - Left Trigger
z - Right Trigger
j - Start button
q - Quit program
F1 - Toggle FPS display
Alt-Enter - Toggle fullscreen/window mode
` - Enable Speed Throttle
1 - Toggle VDP2 NBG0 display
2 - Toggle VDP2 NBG1 display
3 - Toggle VDP2 NBG2 display
4 - Toggle VDP2 NBG3 display
5 - Toggle VDP2 RBG0 display
6 - Toggle VDP1 display
F2 - Load State from slot 1
F3 - Load State from slot 2
F4 - Load State from slot 3
F5 - Load State from slot 4
F6 - Load State from slot 5
F7 - Load State from slot 6
F8 - Load State from slot 7
F9 - Load State from slot 8
F10 - Load State from slot 9
Shift-F2 - Save State to slot 1
Shift-F3 - Save State to slot 2
Shift-F4 - Save State to slot 3
Shift-F5 - Save State to slot 4
Shift-F6 - Save State to slot 5
Shift-F7 - Save State to slot 6
Shift-F8 - Save State to slot 7
Shift-F9 - Save State to slot 8
Shift-F10 - Save State to slot 9
Command-line Options__________________________________________
You can also run the program using command-line options. To see a
full list, run "yabause --help" in the command prompt.
3 Contact information_________________________________________
General inquiries should go to:
E-mail: guillaume@yabause.org
E-mail: cwx@cyberwarriorx.com
Windows Port-related inquiries should go to:
E-mail: cwx@cyberwarriorx.com
Web: http://yabause.org
Please don't ask for roms, bios files or any other copyrighted
stuff. Please use the forum when you have any questions if
possible.
4 Disclaimer__________________________________________________
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 02110-1301 USA
See the GNU General Public License details in COPYING.

1
yabause/TODO
View File

@ -1 +0,0 @@
Everything moved to sourceforge trackers.

34
yabause/acinclude.m4
View File

@ -1,34 +0,0 @@
AC_DEFUN([YAB_CHECK_HOST_TOOLS],
[
AC_CHECK_TOOLS([$1], [$2])
if test `expr x$[$1] : x$host_alias` -eq 0 ; then
[$1]=""
fi
])
AC_DEFUN([YAB_DEP_DISABLED],
[
depdisabled=no
for i in $ac_configure_args ; do
if test $i = "'--disable-dependency-tracking'" ; then
depdisabled=yes
fi
done
if test "$depdisabled" = "no" ; then
AC_MSG_ERROR([You must disable dependency tracking
run the configure script again with --disable-dependency-tracking])
fi
])
AC_DEFUN([YAB_LINK_MINI18N],
[
AC_ARG_ENABLE(static-mini18n,
AC_HELP_STRING(--enable-static-mini18n, Use a static dependency on mini18n),
[use_static_mini18n=$enableval])
if test "x$use_static_mini18n" = "xyes" ; then
LIBS="-Wl,-Bstatic -lmini18n -Wl,-Bdynamic $LIBS"
else
LIBS="-lmini18n $LIBS"
fi
AC_DEFINE(HAVE_LIBMINI18N)
])

2
yabause/autogen.sh
View File

@ -1,2 +0,0 @@
aclocal && autoconf && automake --add-missing --copy
cd src/c68k && aclocal && autoconf && automake

57
yabause/autopackage/default.apspec.in
View File

@ -1,57 +0,0 @@
# Copyright 2006 Guillaume Duhamel
# Copyright 2006 Fabien Coulon
#
# This file is part of Yabause.
#
# Yabause 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.
#
# Yabause 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 Yabause; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
# -*-shell-script-*-
[Meta]
RootName: @yabause.org/yabause:$SOFTWAREVERSION
DisplayName: Yabause Sega Saturn Emulator
ShortName: yabause
Maintainer: Guillaume Duhamel <guillaume@yabause.org>
Packager: Guillaume Duhamel <guillaume@yabause.org>
Summary: Yabause is a Sega Saturn emulator.
URL: http://yabause.org/
License: GNU General Public License, Version 2
SoftwareVersion: @VERSION@
AutopackageTarget: 1.0
[Description]
This is a Sega Saturn emulator.
[BuildPrepare]
prepareBuild --enable-static-mini18n CFLAGS='-D_FORTIFY_SOURCE=0'
[BuildUnprepare]
unprepareBuild
[Imports]
echo '*' | import
[Prepare]
# Dependency checking
require @gtk.org/gtk 2.4
[Install]
# Put your installation script here
installExe bin/yabause
installDesktop "Game" share/applications/yabause.desktop
installData share/yabause
[Uninstall]
# Usually just the following line is enough to uninstall everything
uninstallFromLog

616
yabause/configure.in
View File

@ -1,616 +0,0 @@
AC_INIT(yabause, 0.9.10)
if test "x$host_alias" = "xpowerpc-gekko" ; then
config_guess_sucks=$host_alias
host_alias=powerpc
elif test "x$host_alias" = "xpsp" ; then
config_guess_sucks=$host_alias
host_alias=mips
fi
AC_CANONICAL_HOST
AC_CANONICAL_TARGET
if test ! "x$config_guess_sucks" = "x" ; then
host_alias=$config_guess_sucks
fi
# hack to reset host_alias when we're not cross compiling
if test "x$host_alias" = "x$build_alias"; then
host_alias=
fi
AM_INIT_AUTOMAKE([1.8.0])
AC_PROG_RANLIB
# Check for --host=psp now because we need to get the PSP SDK directory and
# set linker flags/libraries
if test "x$host_alias" = "xpsp" ; then
AC_MSG_CHECKING([for PSPSDK])
if test -z "$PSPSDK"; then
saved_IFS=$IFS
IFS=$PATH_SEPARATOR
for dir in $PATH; do
IFS=$saved_IFS
test -z "$dir" && dir=.
if test -x "$dir/psp-config"; then
PSPSDK=`"$dir/psp-config" -p`
test -n "$PSPSDK" && break
fi
done
IFS=$saved_IFS
fi
if test -n "$PSPSDK"; then
AC_MSG_RESULT([$PSPSDK])
else
AC_MSG_RESULT([not found])
AC_MSG_ERROR([Please set the PSPSDK variable])
fi
CFLAGS="-G0 -falign-functions=16 -I$PSPSDK/include -DNO_CLI $CFLAGS"
LDFLAGS="-specs=$PSPSDK/lib/prxspecs -Wl,-q,-T$PSPSDK/lib/linkfile.prx -L$PSPSDK/lib $LDFLAGS"
LIBS="$LIBS -lm -lc -lpspaudio -lpspctrl -lpspdisplay -lpspgu -lpspge -lpsppower -lpsputility -lpspuser"
fi
AC_PROG_CC
if test `expr x$CC : x$host_alias` -eq 0 ; then
AC_MSG_ERROR([$CC is not a cross compiler and we're cross-compiling.])
fi
AC_PROG_CPP
AC_PROG_INSTALL
AC_LANG(C)
AC_LANG(C++)
AC_C_BIGENDIAN
AM_PROG_CC_C_O
AM_PROG_AS
# Check what kind of CPU we're running on
case "$target_cpu" in
x86|i?86) yabause_cpu=x86; AC_DEFINE(CPU_X86);;
x86_64|amd64) yabause_cpu=x64; AC_DEFINE(CPU_X64);;
armv7*) yabause_cpu=arm; AC_DEFINE(CPU_ARM);;
*) if test "$host_alias" = psp; then
yabause_cpu=psp; AC_DEFINE(CPU_PSP)
else
yabause_cpu=unknown
fi;;
esac
#################################################################################
# #
# phase 1, we're checking for things that could be used by Yabause library #
# #
#################################################################################
# checking for gettimeofday
AC_CHECK_HEADERS([sys/time.h])
AC_CHECK_FUNCS([gettimeofday])
# checking for floorf (C99 single-precision math)
OLDLIBS="$LIBS"
LIBS="$LIBS -lm"
AC_CHECK_FUNCS([floorf])
LIBS="$OLDLIBS"
# checking for mini18n
if test ! "x$MINI18N" = "x" ; then
OLDCPPFLAGS="$CPPFLAGS"
OLDLDFLAGS="$LDFLAGS"
CPPFLAGS="$CPPFLAGS -I$MINI18N/include"
LDFLAGS="$LDFLAGS -L$MINI18N/lib"
AC_CHECK_LIB(mini18n, mini18n, [YAB_LINK_MINI18N], [
CPPFLAGS="$OLDCPPFLAGS"
LDFLAGS="$OLDLDFLAGS"
])
else
AC_CHECK_LIB(mini18n, mini18n, [YAB_LINK_MINI18N])
fi
# checking for variadic macros
AC_MSG_CHECKING([[whether the compiled supports c99 variadic macros]])
AC_COMPILE_IFELSE(AC_LANG_PROGRAM([[#define MACRO(...) puts(__VA_ARGS__)]], [[MACRO("foo");]]),
AC_DEFINE(HAVE_C99_VARIADIC_MACROS)
AC_MSG_RESULT(yes), AC_MSG_RESULT(no))
# checking for SDL (can be used for sound and input)
use_sdl=yes
AC_ARG_WITH(sdl, AC_HELP_STRING(--without-sdl, don't use SDL), [use_sdl=$withval])
if test x$use_sdl = xyes ; then
case $host in
*darwin*)
OLDLDFLAGS="$LDFLAGS"
LDFLAGS="$LDFLAGS -framework SDL"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
int t(void) { return 0; }
]],[[
int foo = t();
]])],[AC_DEFINE(HAVE_LIBSDL)
SDL_LIBS="-framework SDL"], [])
LDFLAGS="$OLDLDFLAGS"
;;
*)
YAB_CHECK_HOST_TOOLS(HAVE_LIBSDL, [sdl-config sdl11-config])
if test ! x$HAVE_LIBSDL = x ; then
SDL_CFLAGS=`$HAVE_LIBSDL --cflags`
SDL_LIBS=`$HAVE_LIBSDL --libs`
AC_DEFINE(HAVE_LIBSDL)
fi
;;
esac
CFLAGS="$CFLAGS $SDL_CFLAGS"
LIBS="$LIBS $SDL_LIBS"
fi
# checking for OpenGL (most ports needs it for video)
use_opengl=yes
AC_ARG_WITH(opengl, AC_HELP_STRING(--without-opengl, don't use OpenGL), [use_opengl=$withval])
if test x$use_opengl = xyes ; then
case $host in
*darwin*)
LIBS="$LIBS -framework OpenGL"
AC_DEFINE(HAVE_LIBGL)
;;
*cygwin* | *mingw32*)
YAB_LIBS="$YAB_LIBS -lopengl32 -lglut32"
AC_DEFINE(HAVE_LIBGL)
;;
*linux* | *bsd*)
AC_PATH_XTRA
LIBS="$LIBS $X_LIBS"
CFLAGS="$CFLAGS $X_CFLAGS"
AC_CHECK_LIB(GL, glEnable, [
LIBS="$LIBS -lGL"
AC_DEFINE(HAVE_LIBGL)
],, $LIBS)
AC_CHECK_LIB(glut, glutGetModifiers,[
LIBS="$LIBS -lglut"
AC_DEFINE(HAVE_LIBGLUT)],, $LIBS)
AC_CHECK_FUNC(glXGetProcAddress, AC_DEFINE(HAVE_GLXGETPROCADDRESS))
;;
*)
AC_CHECK_LIB(GL, glEnable, [
LIBS="$LIBS -lGL"
AC_DEFINE(HAVE_LIBGL)
],, $LIBS)
AC_CHECK_LIB(glut, glutGetModifiers,[
LIBS="$LIBS -lglut"
AC_DEFINE(HAVE_LIBGLUT)],, $LIBS)
;;
esac
fi
# checking for OpenAL (can be used for sound)
use_openal=yes
AC_ARG_WITH(openal, AC_HELP_STRING(--without-openal, "don't use OpenAL"), [use_openal=$withval])
if test x$use_openal = xyes ; then
case $host in
*darwin*)
LIBS="$LIBS -framework OpenAL"
AC_DEFINE(HAVE_LIBAL)
;;
*mingw32*)
# The OpenAL sound code uses Pthreads at the moment, so MinGW
# won't work right now.
;;
*)
AC_CHECK_LIB(pthread, main)
AC_CHECK_LIB(openal, alBufferData, [
LIBS="$LIBS -lopenal"
AC_DEFINE(HAVE_LIBAL)
],, $LIBS)
;;
esac
fi
# platform-specific features
case $host in
*darwin*)
yabause_arch=macosx
AC_DEFINE([ARCH_IS_MACOSX])
LIBS="$LIBS -framework CoreFoundation -framework IOKit"
major=`expr $host_os : "darwin\(@<:@^.@:>@*\)"`
if test $major -ge 7 ; then
sdkversion=0
sdkfile=""
for i in /Developer/SDKs/MacOSX10.*.sdk; do
j=`expr $i : "/Developer/SDKs/MacOSX10.\(.\).*.sdk"`
if test $j -gt $sdkversion ; then
sdkversion=$j
sdkfile=$i
fi
done
AC_ARG_WITH([sdk], AC_HELP_STRING(--with-sdk, [choose your sdk (macosx only)]), [sdkfile=$withval])
YAB_DEP_DISABLED
CFLAGS="$CFLAGS -mmacosx-version-min=10.3 -isysroot $sdkfile -arch i386 -arch ppc"
LDFLAGS="$LDFLAGS -Wl,-macosx_version_min,10.3 -arch i386 -arch ppc"
AC_DEFINE(MAC_OS_X_VERSION_MAX_ALLOWED, MAC_OS_X_VERSION_10_3)
fi
;;
*linux*)
yabause_arch=linux
LIBS="$LIBS -lm"
AC_DEFINE([ARCH_IS_LINUX])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <linux/cdrom.h>]], [[int i = CDSL_CURRENT;]])],
[],
[AC_DEFINE(LINUX_CDROM_H_IS_BROKEN)])
;;
*cygwin*)
yabause_arch=windows
AC_DEFINE([ARCH_IS_WINDOWS])
AC_DEFINE(_WIN32_IE, 0x0500)
;;
*mingw32*)
yabause_arch=windows
AC_DEFINE([ARCH_IS_WINDOWS])
AC_CHECK_HEADERS("wnaspi32.h", [], [], [#include <windows.h>])
AC_DEFINE(_WIN32_IE, 0x0500)
;;
*freebsd*)
yabause_arch=freebsd
AC_DEFINE([ARCH_IS_FREEBSD])
;;
*netbsd* | *openbsd*)
yabause_arch=netbsd
AC_DEFINE([ARCH_IS_NETBSD])
;;
*)
case $host_alias in
psp)
yabause_arch=psp
;;
*)
yabause_arch="."
AC_DEFINE(UNKNOWN_ARCH)
;;
esac
;;
esac
# users can turn c68k compilation off (forced off on PSP)
if test "x$yabause_arch" = "xpsp"; then
compile_c68k=no
else
compile_c68k=yes
fi
AC_ARG_WITH(c68k, AC_HELP_STRING(--without-c68k, don't compile C68k), [compile_c68k=$withval])
if test x$compile_c68k = xyes ; then
if test "x$yabause_arch" = "xpsp"; then
AC_MSG_ERROR([c68k is not supported on PSP])
fi
AC_DEFINE(HAVE_C68K)
fi
AM_CONDITIONAL(COMPILE_C68K, test x$compile_c68k = xyes)
# Q68 emulator is optional (but required on PSP)
if test "x$yabause_arch" = "xpsp"; then
compile_q68=yes
else
compile_q68=no
fi
AC_ARG_WITH(q68, AC_HELP_STRING(--with-q68, [include Q68 68k emulator (requires a C99-compliant compiler like GCC)]), [compile_q68=$withval])
if test "x$compile_q68" = "xyes"; then
AC_DEFINE(HAVE_Q68)
elif test "x$yabause_arch" = "xpsp"; then
AC_MSG_ERROR([Q68 is required on PSP])
fi
AM_CONDITIONAL(COMPILE_Q68, test "x$compile_q68" = "xyes")
# JIT for Q68 can be disabled (and is automatically disabled on unsupported
# systems)
q68_use_jit=maybe
AC_ARG_ENABLE(q68-jit, AC_HELP_STRING(--disable-q68-jit, [disable dynamic (Just-In-Time) translation for Q68]), [q68_use_jit=$enableval])
case $yabause_cpu in
x86|x64|psp)
if test "x$q68_use_jit" = "xmaybe"; then
q68_use_jit=yes
fi
;;
*)
if test "x$q68_use_jit" = "xyes"; then
AC_MSG_ERROR([Q68 dynamic translation is not supported on this CPU]);
elif test "x$q68_use_jit" = "xmaybe"; then
AC_MSG_WARN([Disabling Q68 dynamic translation (not supported on this CPU)]);
fi
;;
esac
if test "x$q68_use_jit" = "xyes"; then
AC_DEFINE(Q68_USE_JIT)
fi
AM_CONDITIONAL([Q68_USE_JIT], test "x$q68_use_jit" = "xyes")
# Allow disabling of dynarec
AC_ARG_ENABLE(dynarec, AC_HELP_STRING(--disable-dynarec, [Disable dynarec core]), [], [use_dynarec=yes])
if test "x$use_dynarec" = "xyes"; then
AC_DEFINE(USE_DYNAREC)
fi
AM_CONDITIONAL([USE_DYNAREC], test "x$use_dynarec" = "xyes")
#################################################################################
# #
# phase 2, we're done with Yabause library, now we're tring to configure ports #
# #
#################################################################################
# qt
AC_PATH_PROGS(HAVE_QMAKE, [qmake-qt4 qmake])
if test ! x$HAVE_QMAKE = x ; then
yabause_available_yuis="qt $yabause_available_yuis"
fi
# gtk
want_gtk=yes
AC_ARG_WITH(gtk, AC_HELP_STRING(--without-gtk, don't try to configure the gtk port), [want_gtk=$withval])
YAB_CHECK_HOST_TOOLS(HAVE_PKG, [pkg-config])
if test ! x$HAVE_PKG = x ; then
if test "x$want_gtk" = "xyes" && `$HAVE_PKG gtk+-2.0` ; then
if test "x$use_opengl" = "xyes" ; then
if `$HAVE_PKG gtkglext-1.0` ; then
yabause_available_yuis="gtk $yabause_available_yuis"
YUI_gtk_CFLAGS=`$HAVE_PKG gtkglext-1.0 --cflags`
YUI_gtk_LIBS=`$HAVE_PKG gtkglext-1.0 --libs`
AC_DEFINE(HAVE_LIBGTKGLEXT)
else
AC_MSG_NOTICE([Found OpenGL and Gtk+ but not libgtkglext.])
AC_MSG_NOTICE([You can either:])
AC_MSG_NOTICE([- install libgtkglext to compile a gtk port with OpenGL support])
AC_MSG_NOTICE([- re-run configure with --without-opengl flag to compile a gtk port without OpenGL support])
AC_MSG_NOTICE([- re-run configure with --without-gtk flag to disable gtk port compilation])
AC_MSG_ERROR([Can't go further, please install libgtkglext or re-run configure with --without-opengl or --without-gtk])
fi
else
yabause_available_yuis="gtk $yabause_available_yuis"
YUI_gtk_CFLAGS=`$HAVE_PKG gtk+-2.0 --cflags`
YUI_gtk_LIBS=`$HAVE_PKG gtk+-2.0 --libs`
fi
fi
fi
# carbon
OLDLDFLAGS="$LDFLAGS"
LDFLAGS="$LDFLAGS -framework Carbon"
AC_LINK_IFELSE([AC_LANG_PROGRAM([[
int t(void) { return 0; }
]],[[
int foo = t();
]])],[YUI_carbon_LIBS="-framework Carbon -framework AGL"
yabause_available_yuis="carbon $yabause_available_yuis"], [])
LDFLAGS="$OLDLDFLAGS"
# windows
YAB_CHECK_HOST_TOOLS(WINDRES, [windres])
AC_CHECK_HEADER([windows.h], [yabause_available_yuis="windows $yabause_available_yuis"], [])
# wii
if test "x$host_alias" = "xpowerpc-gekko" ; then
if test \( "x$LIBOGC" = "x" \) -a \( ! "x$DEVKITPRO" = "x" \) ; then
LIBOGC="$DEVKITPRO/libogc"
fi
if test "x$LIBOGC" = "x" ; then
AC_MSG_ERROR([Please set the LIBOGC variable])
else
CPPFLAGS="-I$LIBOGC/include $CPPFLAGS"
LDFLAGS="-L$LIBOGC/lib/wii $LDFLAGS"
CFLAGS="-mrvl -mcpu=750 -meabi -mhard-float $CFLAGS"
LIBS="-lfat -lwiiuse -lbte -logc -lm $LIBS"
fi
AC_DEFINE(GEKKO)
yabause_available_yuis="wii"
fi
# PSP
if test "x$host_alias" = "xpsp" ; then
AC_DEFINE(PSP)
yabause_available_yuis="psp"
fi
# adding . as a fallback when no other port is available
yabause_available_yuis="$yabause_available_yuis ."
yabause_yui=`echo $yabause_available_yuis | cut -d\ -f1`
AC_ARG_WITH([port], AC_HELP_STRING(--with-port, choose your port), [yabause_manual_yui=$withval])
for yabause_available_yui in $yabause_available_yuis; do
if test x$yabause_available_yui = x$yabause_manual_yui; then
yabause_yui=$yabause_manual_yui
fi
done
if ! test "x$yabause_yui" = "x." ; then
eval YAB_CFLAGS=\$YUI_${yabause_yui}_CFLAGS
eval YAB_LIBS=\$YUI_${yabause_yui}_LIBS
AC_SUBST(YAB_CFLAGS)
AC_SUBST(YAB_LIBS)
fi
AC_SUBST(yabause_yui)
AC_ARG_ENABLE(debug, AC_HELP_STRING(--enable-debug, enable general debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(DEBUG)
fi])
AC_ARG_ENABLE(vdp1-debug, AC_HELP_STRING(--enable-vdp1-debug, enable vdp1 debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(VDP1_DEBUG)
fi])
AC_ARG_ENABLE(vdp2-debug, AC_HELP_STRING(--enable-vdp2-debug, enable vdp2 debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(VDP2_DEBUG)
fi])
AC_ARG_ENABLE(cd-debug, AC_HELP_STRING(--enable-cd-debug, enable cdblock debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(CDDEBUG)
fi])
AC_ARG_ENABLE(smpc-debug, AC_HELP_STRING(--enable-smpc-debug, enable smpc debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(SMPC_DEBUG)
fi])
AC_ARG_ENABLE(scsp-debug, AC_HELP_STRING(--enable-scsp-debug, enable scsp debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(SCSP_DEBUG)
fi])
AC_ARG_ENABLE(idle-debug, AC_HELP_STRING(--enable-idle-debug, enable idle cpu debug information) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(IDLE_DETECT_VERBOSE)
fi])
AC_ARG_ENABLE(mic-shaders, AC_HELP_STRING(--enable-mic-shaders, enable OpenGL shaders for gouraud and mesh) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(USEMICSHADERS)
fi])
AC_ARG_ENABLE(network, AC_HELP_STRING(--enable-network, enable network) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(USESOCKET)
fi])
AC_ARG_ENABLE(perkeyname, AC_HELP_STRING(--enable-perkeyname, use peripheral key name callback) ,
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(PERKEYNAME)
fi])
AC_ARG_ENABLE(exec-from-cache, AC_HELP_STRING(--enable-exec-from-cache, [allow code execution from 0xC0000000]),
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(EXEC_FROM_CACHE)
fi])
AC_ARG_ENABLE(optimized-dma, AC_HELP_STRING(--enable-optimized-dma, [use optimized DMA when possible]),
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(OPTIMIZED_DMA)
fi])
AC_ARG_ENABLE(new-scsp, AC_HELP_STRING(--enable-new-scsp, [enable experimental new SCSP implementation]),
[if test "x$enableval" = "xyes" ; then
AC_DEFINE(USE_SCSP2)
fi])
AM_CONDITIONAL([USE_SCSP2], [test "${enable_new_scsp}" = "yes"])
#### PSP options
AC_ARG_ENABLE(psp-debug, AC_HELP_STRING(--enable-psp-debug, [enable PSP debugging output]),
[if test "x$enableval" = "xyes" ; then
AC_DEFINE([PSP_DEBUG])
fi])
AC_ARG_ENABLE(psp-profile, AC_HELP_STRING(--enable-psp-profile, [enable profiling on PSP port]),
[if test "x$enableval" = "xyes" ; then
AC_DEFINE([SYS_PROFILE_H], ["psp/profile.h"])
fi])
AC_ARG_WITH(psp-me-test, AC_HELP_STRING(--with-psp-me-test, [build ME library test program]))
AM_CONDITIONAL([BUILD_ME_TEST], [test "${with_psp_me_test}" = "yes"])
AC_ARG_ENABLE(debug-psp-sh2, AC_HELP_STRING(--enable-debug-psp-sh2, [include PSP SH-2 core for testing]),
[if test "x$enableval" = "xyes" ; then
AC_DEFINE([TEST_PSP_SH2])
fi])
AM_CONDITIONAL([TEST_PSP_SH2], [test "${enable_debug_psp_sh2}" = "yes"])
### End PSP options
AC_CONFIG_FILES([Makefile
l10n/Makefile
doc/Doxyfile
src/Makefile
src/carbon/Makefile
src/dreamcast/Makefile
src/gtk/Makefile
src/gtk/doc/Makefile
src/psp/Makefile
src/qt/Makefile
src/qt/yabause.pro
src/qt/doc/Makefile
src/wii/Makefile
src/windows/Makefile
autopackage/default.apspec
])
if test x$yabause_yui = xqt ; then
case $host in
*mingw*)
case $build in
*linux*)
qmake_spec="-win32 -spec mkspecs/win32-x11-g++"
;;
*darwin*)
qmake_spec="-win32 -spec mkspecs/win32-osx-g++"
;;
*)
if test "x$cross_compiling" = "xyes" ; then
AC_MSG_ERROR([cross-compiling $host port on $build is not supported yet])
fi
;;
esac
;;
*darwin*)
case $build in
*darwin*)
qmake_spec="-spec macx-g++"
;;
*)
AC_MSG_ERROR([cross-compiling $host port on $build is not supported yet])
;;
esac
;;
*)
if test "x$cross_compiling" = "xyes" ; then
AC_MSG_ERROR([cross-compiling $host port on $build is not supported yet])
fi
;;
esac
AC_CONFIG_FILES([src/qt/Makefile.qmake:src/qt/yabause.pro],
[( cd src/qt && $QMAKE yabause.pro $QMAKE_SPEC -o Makefile.qmake )],
[QMAKE=$HAVE_QMAKE QMAKE_SPEC="$qmake_spec"])
fi
AC_CONFIG_COMMANDS([src/c68k/Makefile], [( cd src/c68k/ && $CONFIG_SHELL ${ac_srcdir}/configure )])
AM_CONDITIONAL([YUI_IS_CARBON], [test ${yabause_yui} = "carbon"])
AM_CONDITIONAL([YUI_IS_DREAMCAST], [test ${yabause_yui} = "dreamcast"])
AM_CONDITIONAL([YUI_IS_GTK], [test ${yabause_yui} = "gtk"])
AM_CONDITIONAL([YUI_IS_PSP], [test ${yabause_yui} = "psp"])
AM_CONDITIONAL([YUI_IS_QT], [test ${yabause_yui} = "qt"])
AM_CONDITIONAL([YUI_IS_WII], [test ${yabause_yui} = "wii"])
AM_CONDITIONAL([YUI_IS_WINDOWS], [test ${yabause_yui} = "windows"])
AM_CONDITIONAL([ARCH_IS_FREEBSD], [test ${yabause_arch} = "freebsd"])
AM_CONDITIONAL([ARCH_IS_LINUX], [test ${yabause_arch} = "linux"])
AM_CONDITIONAL([ARCH_IS_MACOSX], [test ${yabause_arch} = "macosx"])
AM_CONDITIONAL([ARCH_IS_NETBSD], [test ${yabause_arch} = "netbsd"])
AM_CONDITIONAL([ARCH_IS_WINDOWS], [test ${yabause_arch} = "windows"])
AM_CONDITIONAL([CPU_IS_ARM], [test ${yabause_cpu} = "arm"])
AM_CONDITIONAL([CPU_IS_X86], [test ${yabause_cpu} = "x86"])
AM_CONDITIONAL([CPU_IS_X64], [test ${yabause_cpu} = "x64"])
AM_CONDITIONAL([CPU_IS_PSP], [test ${yabause_cpu} = "psp"])
AC_OUTPUT
echo "=================="
echo "WARNING"
echo
echo "Compiling Yabause with autootols is deprecated"
echo
echo "Please use CMake instead"
echo
echo "=================="
echo "configure report"
echo
echo "available ports: $yabause_available_yuis"
echo "selected port: $yabause_yui"
echo "=================="

11
yabause/doc/CMakeLists.txt
View File

@ -1,11 +0,0 @@
project(yabause-doc)
find_package(Doxygen)
if(DOXYGEN_FOUND)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
add_custom_target(doc
${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating documentation with Doxygen" VERBATIM
)
endif(DOXYGEN_FOUND)

1356
yabause/doc/Doxyfile.in
View File

File diff suppressed because it is too large Load Diff

13
yabause/l10n/CMakeLists.txt
View File

@ -1,13 +0,0 @@
project(yabause-l10n)
set(LANGS de es fr it lt pt pt_BR sv)
if (UNIX AND NOT APPLE)
foreach(LANG ${LANGS})
install(FILES "yabause_${LANG}.yts" DESTINATION "share/yabause/yts" RENAME "${LANG}.yts")
endforeach()
elseif (WIN32)
foreach(LANG ${LANGS})
install(FILES "yabause_${LANG}.yts" DESTINATION "trans" RENAME "${LANG}.yts")
endforeach()
endif ()

19
yabause/l10n/Makefile.am
View File

@ -1,19 +0,0 @@
LANGS=de es fr it lt pt pt_BR sv
dist-hook:
@for l in $(LANGS) ; do \
cp -p "$(srcdir)/$(PACKAGE)_$$l.yts" "$(distdir)/$(PACKAGE)_$$l.yts" ; \
done
install-data-hook:
test -z "$(DESTDIR)$(datadir)/$(PACKAGE)/yts" || $(MKDIR_P) "$(DESTDIR)$(datadir)/$(PACKAGE)/yts"
@for l in $(LANGS) ; do \
echo " $(INSTALL_DATA) $(PACKAGE)_$$l.yts $(DESTDIR)$(datadir)/$(PACKAGE)/yts/$$l.yts" ; \
$(INSTALL_DATA) "$(srcdir)/$(PACKAGE)_$$l.yts" "$(DESTDIR)$(datadir)/$(PACKAGE)/yts/$$l.yts" ; \
done
uninstall-hook:
@for l in $(LANGS) ; do \
echo " rm -f $(DESTDIR)$(datadir)/$(PACKAGE)/yts/$$l.yts" ; \
rm -f "$(DESTDIR)$(datadir)/$(PACKAGE)/yts/$$l.yts" ; \
done

195
yabause/l10n/yabause_de.yts
View File

@ -1,195 +0,0 @@
%1/%2 blocks free|%1/%2 blöcke frei
%1 Images (*.%2)|Bilder %1 (*.%2)
503/512 blocks free|503/512 blöcke frei
510/512 blocks free|510/512 blöcke frei
About...|Über...
&About...|&Ü Über...
About|Über
&Action Replay|&Action Replay
Action Replay Code :|Action Replay Code :
Add Action Replay Code|Action Replay Code zufügen
Add Codes...|Codes zufügen...
Add Raw Memory Code|Raw Memory Code zufügen
Address :|Adresse :
Advanced|Sonstiges
<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>|<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>
Are you sure you want to delete '%1' ?|Sind Sie sicher, dass Sie '%1' löschen möchten ?
Are you sure you want to format '%1' ?|Sind Sie sicher, dass Sie '%1' formatieren möchten ?
Backup Manager|Backup Manager
Backup Manager...|Backup Manager...
&Backup Ram Manager|&Backup Ram Manager
Backup Ram Manager|Backup Ram Manager
Bios|Bios
Block Size :|Blockgröße :
&Browse|&Browse
Browse|Suchen
Byte Write|Byte schreiben
Cancel|Abbrechen
Cannot initialize|Initialisierung fehlgeschlagen
&Capture Screen|&Capture Screen
Cart/Memory|Cartridge/Speicher
Cartridge|Cartridge
CD Images (*.iso *.cue *.bin)|CD Images (*.iso *.cue *.bin)
Cd-Rom|Cd-Rom
&Cheats|&Cheats
Cheats|Cheats
Cheats File|Cheatdatei
&Cheat List|&Cheat List
Cheats List|Cheatliste
Cheats List...|Cheatliste...
Cheat Type|Cheattyp
Choose a cdrom drive/mount point|CD-Rom Laufwerk/Mount-Punkt auswählen
Choose a cheat file to open|Cheatdatei zum öffnen auswählen
Choose a cheat file to save to|Cheatdatei zum speichern auswählen
Choose a file to save your state|Datei zum speichern des Status auswählen
Choose a location for your screenshot|Speicherort für das Bildschirmfoto auswählen
&Clear|&Leeren
Close|Schliessen
Code|Code
Comment :|Kommentar :
Data Size :|Datengrösse :
_Debug|_Debug
&Debug|&Debug
&Delete|&Löschen
Delete|Löschen
Description|Beschreibung
Description :|Beschreibung :
Device List|Geräteliste
Disabled|Deaktiviert
Down|Runter
Download|Herunterladen
Emu-Compatibility|Emu-Kombatibilität
Emulation|Emulation
End Address:|Adressende
Enable|Aktivieren
Enabled|Aktiviert
English|Englisch
&File|&Datei
File|Datei
File :|File :
File Name :|Dateiname :
File transfer|Dateiübertragung
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>WARNUNG :</b>Mastercodes werden <b>NICHT</b> unterstützt.</font>
Format|Formatieren
FPS|BPS
Frame Skip/Limiter|Frames überspringen/limitieren
French|Französisch
From|Von
From File|Von Datei
From File...|Von Datei...
&Fullscreen|&Vollbild
Fullscreen|Vollbild
General|Allgemein
German|Deutsch
Hard Reset|Hard Reset
Height|Höhe
_Help|_Hilfe
&Help|&Hilfe
http://www.emu-compatibility.com/yabause/index.php?lang=uk|http://www.emu-compatibility.com/yabause/index.php?lang=de
http://www.monkeystudio.org|http://www.monkeystudio.org
Input|Eingabe
Invalid Address|Ungültige Adresse
Invalid Value|Ungültiger Wert
Italian|Italienisch
Japanese|Japanisch
Language :|Sprache :
&Layer|&Schicht
Layer|Schicht
Left|Links
Left trigger|Linker Trigger
Load as executable|Als ausführbar laden
Load|Laden
&Load From File|&Von Datei laden
Load State|Spielstand laden
Load State As|Spielstand laden als
Log|Protokoll
Long Write|Long schreiben
M68K|M68K
Memory dump|Speicherabzug
Memory Dump|Speicherabzug
Memory Editor|Memory Editor
&Memory Transfer|&Memory Transfer
Memory Transfer|Memory Transfer
Memory|Speicher
Mpeg ROM|Mpeg ROM
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
Ok|Ok
&OK|&OK
Open CD Rom|CD-Rom öffnen
Open CD Rom...|CD-Rom öffnen...
Open ISO|ISO öffnen
Open ISO...|ISO öffnen...
&Pause|&Pause
Pause|Pause
&Quit|&Schliessen
Quit|Schliessen
&Raw Memory Address|&Raw Speicheradresse
RBG0|RBG0
Region|Region
&Reset|&Zurücksetzen
Reset|Zurücksetzen
Resolution|Auflösung
Right|Rechts
Right trigger|Rechter Trigger
R&un|S&tarten
Run|Starten
Save Information|Informationen speichern
Save List|Liste speichern
Save|Speichern
Save State|Status speichern
Save State As|Save State As
Save States|Stati speichern
&Save To File|&In Datei speichern
Screenshot|Bilschirmfoto
SCSP|SCSP
SCU-DSP|SCU-DSP
Select a file to load your state|Wählen Sie die Statusdatei aus
Select your iso/cue/bin file|Wählen Sie Ihre iso/cue/bin-Datei
&Settings...|Einstellungen...
Settings|Einstellungen
SH2 Interpreter|SH2 Interpreter
Sound Core|Sound Kern
Sound|Sound
Spanish|Spanisch
SSH2|SSH2
Start|Start
Start Address:|Adressanfang
Status|Status
Store|Sichern
To File|in Datei
To File...|in Datei...
toolBar|Werkzeugleiste
Tools|Tools
To|zu
Transfer|Transferieren
Translation|Übersetzung
Unable to add code|Code konnte nicht zugefügt werden
Unable to change description|Beschreibung konnte nicht geändert werden
Unable to open file for loading|Datei konnte nicht geöffnet werden
Unable to open file for saving|Datei konnte nicht geschrieben werden
Unable to remove code|Code konnte nicht entfernt werden
Unknow (%1)|Unbekannt (%1)
Up|Hoch
Upload|Upload
Value :|Wert :
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Video Kern
Video Driver|Video Treiber
Video Format|Video Format
Video|Video
_View|_Sicht
&View|&Sicht
Waiting Input...|Warte auf EIngaben...
Width|Breite
Word Write|Word schreiben
Yabause Cheat Files (*.yct);;All Files (*)|Yabause Cheat Dateien (*ycf);;Alle Dateien (*)
Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>
Yabause Qt GUI|Qt Grafik-Interface für Yabause
Yabause Save State (*.yss)|Yabause Speicherstände (*.yss)

198
yabause/l10n/yabause_es.yts
View File

@ -1,198 +0,0 @@
%1/%2 blocks free|%1/%2 bloques libres
%1 Images (*.%2)|%1 Imágenes (*.%2)
503/512 blocks free|503/512 bloques libres
510/512 blocks free|510/512 bloques libres
About...|Acerca de...
&About...|&Acerca de...
About|Acerca de
&Action Replay|&Action Replay
Action Replay Code :|Código de Action Replay
Add Action Replay Code|Añadir Código de Action Replay
Add Codes...|Añadir Códigos...
Add Raw Memory Code|Añadir código dirección de memoria
Address :|Dirección :
Advanced|Avanzado
<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>|<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>
Are you sure you want to delete '%1' ?|¿Estás seguro de borrar '%1' ?
Are you sure you want to format '%1' ?|¿Estás seguro de formatear '%1' ?
Backup Manager|Gestor de memoria de backup
Backup Manager...|Gestor de memoria de backup...
&Backup Ram Manager|Gestor de RAM de &backup
Backup Ram Manager|Gestor de RAM de backup
Bios|Bios
Block Size :|Tamaño de bloque:
&Browse|&Examinar
Browse|Examinar
Byte Write|Escritura de byte
Cancel|Cancelar
Cannot initialize|Imposible iniciar
&Capture Screen|&Capturar pantalla
Cart/Memory|Cartucho/Memoria
Cartridge|Cartucho
CD Images (*.iso *.cue *.bin)|Imágenes de CD (*.iso *.cue *.bin)
Cd-Rom|Cd-Rom
&Cheats|&Trucos
Cheats|Trucos
Cheats File|Archivo de trucos
&Cheat List|Listado de &Trucos
Cheats List|Lista de trucos
Cheats List...|Lista de trucos...
Cheat Type|Tipo de truco
Choose a cdrom drive/mount point|Selecciona una unidad de cdrom/punto de montaje
Choose a cheat file to open|Selecciona un archivo de trucos para abrir
Choose a cheat file to save to|Selecciona el archivo de trucos para guardar
Choose a file to save your state|Selecciona un archivo para guardar tu estado
Choose a location for your screenshot|Selecciona ubicación para tu captura
&Clear|&Limpiar
Close|Cerrar
Code|Código
Comment :|Comentario :
Data Size :|Tamaño de datos :
_Debug|_Debug
&Debug|&Debug
&Delete|&Borrar
Delete|Borrar
Description|Descripción
Description :|Descripción :
Device List|Lista de Dispositivos
Disabled|Desactivado
Down|Abajo
Download|Descargar
Emu-Compatibility|Compatibilidad del emulador
Emulation|Emulación
End Address:|Dirección final:
Enable|Activar
Enabled|Activado
English|Inglés
&File|&Archivo
File|Archivo
File :|Archivo:
File Name :|Nombre de archivo :
File transfer|Transferencia de archivo
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>AVISO:</b> Códigos Maestros <b>NO</b> soportados.</font>
Format|Formato
FPS|FPS
Frame Skip/Limiter|Salto de cuadros/Limitador
French|Francés
From|De
From File|De archivo
From File...|De archivo...
&Fullscreen|&Pantalla completa
Fullscreen|Pantalla completa
General|General
German|Alemán
Hard Reset|Reiniciar en frío
Height|Altura
_Help|_Ayuda
&Help|&Ayuda
http://www.emu-compatibility.com/yabause/index.php?lang=uk|http://www.emu-compatibility.com/yabause/index.php?lang=uk
http://www.monkeystudio.org|http://www.monkeystudio.org
Input|Entrada
Invalid Address|Dirección inválida
Invalid Value|Valor inválido
Italian|Italiano
Japanese|Japonés
Language :|Idioma :
&Layer|&Capa
Layer|Capa
Left|Izquierda
Left trigger|Gatillo izquierdo
Load as executable|Cargar como ejecutable
Load|Cargar
&Load From File|&Cargar desde archivo
Load State|Cargar estado
Load State As|Cargar estado como
Log|Log
Long Write|Escritura larga
M68K|M68K
Memory dump|Volcado de memoria
Memory Dump|Volcado de Memoria
Memory Editor|Editor de memoria
&Memory Transfer|Transferir &memoria
Memory Transfer|Transferir memoria
Memory|Memoria
Mpeg ROM|ROM Mpeg
Mouse|Ratón
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
None|Ninguno
Ok|Ok
&OK|&OK
Open CD Rom|Abrir CD Rom
Open CD Rom...|Abrir CD Rom...
Open ISO|Abrir ISO
Open ISO...|Abrir ISO...
Pad|Pad
&Pause|&Pausar
Pause|Pausar
&Quit|&Sair
Quit|Sair
&Raw Memory Address|&Dirección de memoria Raw
RBG0|RBG0
Region|Región
&Reset|&Resetear
Reset|Resetear
Resolution|Resolución
Right|Derecha
Right trigger|Gatillo derecho
R&un|E&jecutar
Run|Ejecutar
Save Information|Guardar informes
Save List|Lista de salvaguardados
Save|Salvar
Save State|Guardar Estado
Save State As|Guardar estado como
Save States|Guardar estados
&Save To File|&Guardar a archivo
Screenshot|Captura de pantalla
SCSP|SCSP
SCU-DSP|SCU-DSP
Select a file to load your state|Selecciona el archivo para cargar tu estado
Select your iso/cue/bin file|Selecciona tu archivo iso/cue/bin
&Settings...|&Configuración...
Settings|Configuración
SH2 Interpreter|Intérprete SH2
Sound Core|Núcleo de sonido
Sound|Sonido
Spanish|Español
SSH2|SSH2
Start|Iniciar
Start Address:|Dirección inicial:
Status|Estado
Store|Almacenar
To File|A archivo
To File...|A archivo...
toolBar|Barra de herramientas
Tools|Herramientas
To|Para
Transfer|Transferencia
Translation|Traducción
Unable to add code|Imposible añadir código
Unable to change description|Imposible cambiar descripción
Unable to open file for loading|Imposible abrir archivo para cargar
Unable to open file for saving|Imposible abrir archivo para guardar
Unable to remove code|Imposible eliminar código
Unknow (%1)|Desconocido (%1)
Up|Arriba
Upload|Subir
Value :|Valor :
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Núcleo de Vídeo
Video Driver|Driver de Vídeo
Video Format|Formato de Vídeo
Video|Vídeo
_View|_Ver
&View|&Ver
Waiting Input...|Esperando Entrada de Datos...
Width|Ancho
Word Write|Escribir WORD
Yabause Cheat Files (*.yct);;All Files (*)|Archivos de trucos para Yabause (*.yct);;Todos los archivos (*)
Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Interfaz gráfica QT<br />Basada en Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />El equipo de Yabause<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>
Yabause Qt GUI|Interfaz gráfica Qt
Yabause Save State (*.yss)|Salvaguardados de Yabause (*.yss)

276
yabause/l10n/yabause_fr.yts
View File

@ -1,276 +0,0 @@
%1/%2 blocks free|%1/%2 blocs libre
%1 Images (*.%2)|Images %1 (*.%2)
503/512 blocks free|503/512 blocs libre
510/512 blocks free|510/512 blocs libre
About...|A Propos De...
&About...|&A Propos De...
About|A Propos De
&Action Replay|&Action Replay
Action Replay Code :|Code Action Replay :
Add Action Replay Code|Ajouter un Code Action Replay
Add Cheat|Ajouter un Cheat
Add Codes...|Ajouter un Code...
Add Raw Memory Code|Ajouter un Code Mémoire Brut
Address|Adresse
Address :|Adresse :
Advanced|Avancé
Always|Toujours
Asia (NTSC)|Asie (NTSC)
Asia (PAL)|Asie (PAL)
Are you sure you want to delete '%1' ?|Etes vous sûr de vouloir supprimer '%1' ?
Are you sure you want to format '%1' ?|Etes vous sûr de vouloir formater '%1' ?
Auto-detect|Détection Auto
Autostart|Démarrage Automatique
Backup Manager|Gestion des Sauvegardes
&Backup Manager...|&Gestion des Sauvegardes...
Backup Manager...|Gestion des Sauvegardes...
&Backup Ram Manager|&Gestion des Sauvegardes
Backup Ram Manager|Gestion des Sauvegardes
Bios|Bios :
Block Size :|Taille du Bloc :
&Browse|&Parcourir
Browse|Parcourir
Byte Write|Ecrire un Byte
&Cancel|&Annuler
Cancel|Annuler
Cannot initialize|Ne peut pas Initialiser
Cannot initialize Windows SPTI Driver|Ne peut pas initialiser le pilote SPTI
&Capture Screen|&Capture d'Ecran
Cart/Memory|Cartouche/Mémoire
Cartridge|Cartouche :
CD Images (*.iso *.cue *.bin)|Images CD (*.iso *.cue *.bin)
Cd-Rom|CD-Rom :
Central/South America (NTSC)|Amérique du Sud/Centrale (NTSC)
Central/South America (PAL)|Amérique du Sud/Centrale (PAL)
&Cheats|&Cheats
Cheats|Cheats
Cheats File|Fichier Cheat
&Cheat List|Liste de &Cheat
Cheats List|Liste de Cheat
&Cheats List...|Liste de &Cheat...
Cheats List...|Liste de Cheat...
Cheat &Search...|&Rechercher un Cheat...
Cheat Search|Rechercher un Cheat
Cheat Type|Type de Cheat
Choose a cdrom drive/mount point|Choisir un lecteur CD ou un point de montage
Choose a cheat file to open|Choisir un fichier de Cheat à ouvrir
Choose a cheat file to save to|Choisir un fichier de Cheat à enregistrer
Choose a file to save your state|Choisir un fichier où enregistrer l'état
Choose a location for your screenshot|Choisir un nom de fichier pour votre capture d'écran
&Clear|&Effacer
Clear configuration|Vider la Configuration
&Close|&Fermer
Close|Fermer
Code|Code
Comment :|Commentaire :
Compare Type|Type de Comparaison
Data Size|Taille Donnée
Data Size :|Taille des Données :
Data Type|Type Donnée
_Debug|_Débug
&Debug|&Débug
&Delete|&Effacer
Delete|Effacer
Description|Description
Description :|Description :
Device List|Liste des Périphériques
Disabled|Désactivé
Down|Bas
Download|Télécharger
Dummy CD Drive|Lecteur de CD Factice
Dummy Input Interface|Interface Contrôleur Factice
Dummy OSD Interface|Interface OSD Factice
Dummy Sound Interface|Interface Son Factice
Dummy Video Interface|Interface Vidéo Factice
Edit configuration|Editer la Configuration
Emu-Compatibility|Emu-Compatibility
&Emulation|&Emulation
Emulation|Emulation
End Address:|Adresse de Fin :
Enable|Activer
Enable Frame Skip/Limiter|Active le Saut d'Image/Limitateur
Enabled|Activé
English|Anglais
Europe + others (PAL)|Europe + Autres (PAL)
Exact|Identique
&File|&Fichier
File|Fichier
File :|Fichier :
File:|Fichier :
File Name :|Nom du Fichier :
File transfer|Transfert de Fichier
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>AVERTISSEMENT :</b> Les Codes Maîtres <b>NE SONT PAS</b> supportés.</font>
Format|Formater
FPS|FPS
Frame Skip/Limiter|Saut d'Image/Limitateur
&Frame Skip/Limiter|&Saut d'Image/Limitateur
French|Français
From|A Partir De
From File|A Partir d'un Fichier
From File...|A Partir d'un Fichier...
&Fullscreen|&Plein Ecran
Fullscreen|Plein Ecran
General|Général
German|Allemand
Glut OSD Interface|Interface OSD GLut
Greater then|Plus grand que
Hard Reset|Redémarrage Matériel
Height|Hauteur :
_Help|_Aide
&Help|&Aide
Hide menubar|Cacher la Barre de Menu
Hide toolbar|Cacher la Barre d'Outils
http://www.emu-compatibility.com/yabause/index.php?lang=uk|http://www.emu-compatibility.com/yabause/index.php?lang=fr
http://www.monkeystudio.org|http://www.monkeystudio.org
Information...|Information...
Input|Contrôleur
Invalid Address|Adresse Invalide
Invalid Value|Valeur Invalide
ISO-File Virtual Drive|Lecteur de Fichier ISO Virtuel
Italian|Italien
Japan (NTSC)|Japon (NTSC)
Japanese|Japonais
Korea (NTSC)|Corée (NTSC)
Language :|Langage :
&Layer|&Couche
Layer|Couche
Left|Gauche
Left trigger|Gâchette Gauche
Less than|Moins que
Linux CD Drive|Lecteur CD Linux
Load as executable|Charger en tant qu'Executable
Load|Charger
&Load From File|&Charger à Partir d'un Fichier
L&oad State|&Charger un Etat
Load State|Charger l'Etat
Load State As|Charger l'Etat sous
&Log|&Journal
Log|Journal
Long Write|Ecrire un Long
M68K|M68K
&Master SH2|&Master SH2
Master SH2|Master SH2
Memory dump|Copier la mémoire
Memory Dump|Copier la Mémoire
Memory &Editor|&Editeur de Mémoire
Memory Editor|Editeur de Mémoire
&Memory Transfer|&Transfert de Mémoire
Memory Transfer|Transfert de Mémoire
Memory|Mémoire :
Mpeg ROM|ROM MPEG :
Mouse|Souris
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
Never|Jamais
None|Aucun
North America (NTSC)|Amérique du Nord (NTSC)
Ok|Ok
&OK|&OK
On fullscreen|Plein Ecran
Open CD Rom|Ouvrir un CD ROM
Open &CD Rom...|Ouvrir un &CD Rom...
Open CD Rom...|Ouvrir un CD ROM...
Open ISO|Ouvrir un Fichier ISO
Open &ISO...|Ouvrir un &ISO...
Open ISO...|Ouvrir un Fichier ISO...
OpenGL Video Interface|Interface Vidéo OpenGL
OSD Core|Noyau OSD
Pad|Manette
Pad Configuration|Configuration de la Manette
&Pause|&Pause
Pause|Pause
Qt Keyboard Input Interface|Interface Qt du Clavier
&Quit|&Quitter
Quit|Quitter
&Raw Memory Address|Adresse Mémoire &Brut
RBG0|RBG0
Region|Région :
&Reset|&Redémarrer
Reset|Redémarrer
Resolution|Résolution :
Right|Droite
Right trigger|Gâchette Droite
R&un|L&ancer
Run|Lancer
Save Information|Informations sur la Sauvegarde
Save List|Liste des Sauvegardes
Save|Sauvegarder
S&ave State|S&auvegarder un Etat
Save State|Sauvegarder l'Etat
Save State As|Sauvegarder l'Etat sous
Save States|Sauvegarde d'Etat :
&Save To File|&Sauvegarder Vers le Fichier
Sc&reenshot|Copie d'Ec&ran
Screenshot|Capture d'Ecran
SCSP|SCSP
SCU-DSP|SCU-DSP
SDL Joystick Interface|Interface SDL du Joystick
SDL Sound Interface|Interface SDL du Son
Search|Rechercher
Search/Add Cheats|Rechercher/Ajouter un Cheat
Search Value:|Rechercher une Valeur :
Select a file to load your state|Choisissez un fichier pour charger l'état
Select your iso/cue/bin file|Choisissez votre fichier iso/cue/bin
Set PC to Start Address|Sélection PC vers l'Adresse de Démarrage
&Settings...|&Paramétres...
Settings|Paramétres
SH2 Debugger Interpreter|Interpréteur de Débugeur SH2
SH2 Dynamic Recompiler|Recompileur Dynamique SH2
SH2 Interpreter|Interpréteur SH2 :
Show FPS|Afficher les FPS
&Slave SH2|&Slave SH2
Slave SH2|Slave SH2
Software Video Interface|Interface Vidéo Logiciel
Sound Core|Noyau Son :
Sound|Son
Spanish|Espagnol
SSH2|SSH2
Signed|Signé
Software OSD Interface|Interface OSD Logiciel
Start|Démarrer
Start Address:|Adresse de Début :
Status|Statut
Store|Stocker
To File|Vers un Fichier
To File...|Vers un Fichier...
toolBar|Barre d'Outils
&Tools|Ou&tils
Tools|Outils
To|Vers
&Transfer|&Transfert
Transfer|Transfert
Translation|Traduction :
Unable to add code|Ne peut pas ajouter de Code
Unable to change description|Ne peut pas changer la Description
Unable to open file for loading|Ne peut pas ouvrir le fichier à Charger
Unable to open file for saving|Ne peut pas ouvrir le fichier à sauvegarder
Unable to remove code|Ne peut pas enlever le Code
Unknow (%1)|Inconnu (%1)
Unsigned|Non Signé
Up|Haut
Upload|Upload
Value|Valeur
Value :|Valeur :
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Noyau Vidéo :
Video Driver|Pilote Vidéo :
Video Format|Format Vidéo :
Video|Vidéo
_View|_Visualiser
&View|&Visualiser
View|Visualiser
Waiting Input...|En Attente du Contrôleur
Width|Largeur :
Windows SPTI Driver|Pilote Windows SPTI
Word Write|Ecrire un Word
Yabause Cheat Files (*.yct);;All Files (*)|Fichiers de Cheat Yabause (*ycf);;Tous les Fichiers (*)
Yabause is not initialized, can't manage backup ram.|Yabause n'est pas initialisé. Ne peut pas gérer la sauvegarde.
Yabause Qt Gui<br />Based on Yabause %1<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Yabause Qt Gui<br />Basé sur Yabause %1 :<br /><a href="http://yabause.org">http://yabause.org</a><br />L'équipe de Yabause :<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>
Yabause Qt GUI|Interface Graphique Qt pour Yabause
Yabause Save State (*.yss)|Sauvegarde d'État Yabause (*.yss)

198
yabause/l10n/yabause_it.yts
View File

@ -1,198 +0,0 @@
%1/%2 blocks free|%1%2 blocchi liberi
%1 Images (*.%2)|%1 Immagini (*.%2)
503/512 blocks free|503/512 blocchi liberi
510/512 blocks free|510/512 blocchi liberi
About...|Informazioni...
&About...|&Informazioni...
About|Informazioni
&Action Replay|&Action Replay
Action Replay Code :|Codice Action Replay
Add Action Replay Code|Aggiungi codice Action Replay
Add Codes...|Aggiungi codici....
Add Raw Memory Code|Aggiungi Raw Memory Code
Address :|Indirizzo:
Advanced|Avanzate
<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>|<a href="<a href="http://www.monkeystudio.org" class="external free" rel="nofollow">http://www.monkeystudio.org</a>"><img src=":/icons/icons/made.png"></a>
Are you sure you want to delete '%1' ?|Sicuro di voler cancellare '%1'?
Are you sure you want to format '%1' ?|Sicuro di voler formattare '%1'?
Backup Manager|Gestione Backup
Backup Manager...|Gestione Backup...
&Backup Ram Manager|&Gestione Backup RAM
Backup Ram Manager|Gestione Backup RAM
Bios|BIOS
Block Size :|Dimensioni Blocco:
&Browse|&Sfoglia
Browse|Sfoglia
Byte Write|Scrivi Byte
Cancel|Annulla
Cannot initialize|Impossibile Inizializzare
&Capture Screen|&Cattura Schermo
Cart/Memory|Cart/Memoria
Cartridge|Cartuccia
CD Images (*.iso *.cue *.bin)|Immagine CD (*.iso *.cue *.bin)
Cd-Rom|Cd-Rom
&Cheats|&Cheats
Cheats|Cheats
Cheats File|File Cheats
&Cheat List|Lista &Cheat
Cheats List|Lista Cheat
Cheats List...|Lista Cheat...
Cheat Type|Tipo di Cheat
Choose a cdrom drive/mount point|Choose a cdrom drive/mount point
Choose a cheat file to open|Selezionare un file cheat da aprire
Choose a cheat file to save to|Selezionare un file cheat per salvare
Choose a file to save your state|Selezionare un file per salvare lo stato
Choose a location for your screenshot|Selezionare una directory per gli screenshoot
&Clear|&Svuota
Close|Chiudi
Code|Codice
Comment :|Commento:
Data Size :|Dimensioni Dati:
_Debug|_Debug
&Debug|&Debug
&Delete|&Elimina
Delete|Elimina
Description|Descrizione
Description :|Descrizione:
Device List|Lista periferiche
Disabled|Disattivo
Down|Giù
Download|Download
Emu-Compatibility|Compatibilità Emulatore
Emulation|Emulazione
End Address:|Indirizzo Finale:
Enable|Abilita
Enabled|Abilitato
English|Inglese
&File|&File
File|File
File :|File:
File Name :|Nome file:
File transfer|Trasferimento file
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>ATTENZIONE:</b> I Codici Master <b>NON</b> sono supportati.</font>
Format|Formato
FPS|FPS
Frame Skip/Limiter|Limitatore frame
French|Francese
From|Da
From File|Dal file
From File...|Dal file...
&Fullscreen|&Schermo Intero
Fullscreen|Schermo Intero
General|Generale
German|Tedesco
Hard Reset|Hard Reset
Height|Altezza
_Help|_Aiuto
&Help|&Aiuto
http://www.emu-compatibility.com/yabause/index.php?lang=uk|<a href="http://www.emu-compatibility.com/yabause/index.php?lang=it" class="external free" rel="nofollow">http://www.emu-compatibility.com/yabause/index.php?lang=it</a>
http://www.monkeystudio.org|<a href="http://www.monkeystudio.org" class="external free" rel="nofollow">http://www.monkeystudio.org</a>
Input|Input
Invalid Address|Indirizzo non valido
Invalid Value|Valore non valido
Italian|Italiano
Japanese|Giapponese
Language :|Lingua:
&Layer|&Layer
Layer|Layer
Left|Sinistra
Left trigger|Left trigger
Load as executable|Carica come eseguibile
Load|Carica
&Load From File|Carica da&l file
Load State|Carica stato
Load State As|Carica stato come
Log|Log
Long Write|Scrivi Log
M68K|M68K
Memory dump|Dump Memoria
Memory Dump|Dump Memoria
Memory Editor|Editor Memoria
&Memory Transfer|Trasferimento &Memoria
Memory Transfer|Trasferimento Memoria
Memory|Memoria
Mpeg ROM|Mpeg ROM
Mouse|Mouse
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
None|Nessuno
Ok|Ok
&OK|&OK
Open CD Rom|Apri CD Rom
Open CD Rom...|Apri CD Rom...
Open ISO|Apri ISO
Open ISO...|Apri ISO...
Pad|Pad
&Pause|&Pausa
Pause|Pausa
&Quit|&Esci
Quit|Esci
&Raw Memory Address|Indirizzo Grezzo Memoria
RBG0|RBG0
Region|Regione
&Reset|&Reset
Reset|Reset
Resolution|Risoluzione
Right|Destra
Right trigger|Right trigger
R&un|Eseg&ui
Run|Esegui
Save Information|Salva Informazioni
Save List|Salva lista
Save|Salva
Save State|Salva stato
Save State As|Salva stato come
Save States|Salva stati
&Save To File|$Salva su file
Screenshot|Screenshot
SCSP|SCSP
SCU-DSP|SCU-DSP
Select a file to load your state|Selezionare un file per caricare il tuo stato
Select your iso/cue/bin file|Selezionare un file iso/cue/bin
&Settings...|Impo&stazioni...
Settings|Impostazioni
SH2 Interpreter|Interprete SH2
Sound Core|Sistema Audio
Sound|Suono
Spanish|Spagnolo
SSH2|SSH2
Start|Inizia
Start Address:|Indirizzo Iniziale:
Status|Stato
Store|Store
To File|Nel file
To File...|Nel file...
toolBar|Barra degli Strumenti
Tools|Strumenti
To|A
Transfer|Trasferimento
Translation|Traduzione
Unable to add code|Impossibile aggiungere il codice
Unable to change description|Impossibile cambiare la descrizione
Unable to open file for loading|Impossibile aprire il file per il caricamento
Unable to open file for saving|Impossibile aprire il file per il salvataggio
Unable to remove code|Impossibile rimuovere il codice
Unknow (%1)|Sconosciuto (%1)
Up|Su
Upload|Upload
Value :|Valore:
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Sistema Video
Video Driver|Driver Video
Video Format|Formato Video
Video|Video
_View|_Visualizza
&View|&Visualizza
Waiting Input...|In attesa di input...
Width|Larghezza
Word Write|Word Write
Yabause Cheat Files (*.yct);;All Files (*)|Yabause File Cheat (*.yct);;Tutti i file (*)
Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Interfaccia Qt Yabause<br />Basata su Yabause 0.9.5<br /><a href="<a href="http://yabause.org" class="external free" rel="nofollow">http://yabause.org</a>"><a href="http://yabause.org" class="external free" rel="nofollow">http://yabause.org</a></a><br />Il Team Yabause<br /><a href="<a href="mailto:pasnox@gmail.com" class="external free" rel="nofollow">mailto:pasnox@gmail.com</a>">Filipe AZEVEDO</a>
Yabause Qt GUI|Interfaccia Qt Yabause
Yabause Save State (*.yss)|Yabause Salvataggio Stato (*.yss)

195
yabause/l10n/yabause_lt.yts
View File

@ -1,195 +0,0 @@
%1/%2 blocks free|%1/%2 blokų laisvų
%1 Images (*.%2)|%1 Images (*.%2)
503/512 blocks free|503/512 blokų laisvų
510/512 blocks free|510/512 blokų laisvų
About...|Apie...
&About...|&Apie...
About|Apie
&Action Replay|&Veiksmo pakartojimas
Action Replay Code :|Veiksmo pakartojimo kodas:
Add Action Replay Code|Pridėti veiksmo pakartojimo kodą:
Add Codes...|Pridėti kodų...
Add Raw Memory Code|Pridėti "Raw" atminties kodą
Address :|Adresas&#160;:
Advanced|Papildoma
<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>|<a href="<a href="http://www.monkeystudio.org" class="external free" rel="nofollow">http://www.monkeystudio.org</a>"><img src=":/icons/icons/made.png"></a>
Are you sure you want to delete '%1' ?|Ar tu įsitikinęs,kad nori ištrinti '%1'&#160;?
Are you sure you want to format '%1' ?|Ar tu įsitikinęs,kad nori suformatuoti '%1'&#160;?
Backup Manager|Atsarginių failų tvarkyklė
Backup Manager...|Atsarginių failų tvarkyklė...
&Backup Ram Manager|&Atsarginės darbinės atminties tvarkyklė
Backup Ram Manager|Atsarginės darbinės atminties tvarkyklė
Bios|Bios'as
Block Size :|Bloko dydis:
&Browse|&Naršyti
Browse|Browse
Byte Write|Byte Write
Cancel|Atšaukti
Cannot initialize|Negalima pradėti
&Capture Screen|&Nufotografuoti ekraną
Cart/Memory|Darbinė atmintis
Cartridge|Disketė
CD Images (*.iso *.cue *.bin)|CD atvaizdai (*.iso *.cue *.bin)
Cd-Rom|CD-ROM
&Cheats|&Kodai
Cheats|Kodai
Cheats File|Kodų failas
&Cheat List|&Kodų sąrašas
Cheats List|Kodų sąrašas
Cheats List...|Kodų sąrašas...
Cheat Type|Kodų tipas
Choose a cdrom drive/mount point|Pasirink CD-ROM prijungimo tašką
Choose a cheat file to open|Pasirink kodų failą
Choose a cheat file to save to|Pasirink kodų failą išsaugojimui į
Choose a file to save your state|Pasirink failą išsaugoti žaidimui
Choose a location for your screenshot|Pasirink vietą žaidimo ekranvaizdžiui
&Clear|&Išvalyti
Close|Uždaryti
Code|Kodas
Comment :|Komentaras:
Data Size :|Duomenų dydis:
_Debug|_Taisyti klaidas
&Debug|&Klaidų taisymas
&Delete|&Trinti
Delete|Trinti
Description|Aprašymas
Description :|Aprašymas&#160;:
Device List|Įrenginių sąrašas
Disabled|Neįgalinta
Down|Žemyn
Download|Atsisiųsti
Emu-Compatibility|Emuliatoriaus suderinamumas
Emulation|Emuliacija
End Address:|End Adress:
Enable|Įgalinti
Enabled|Įgalinta
English|Anglų
&File|&Failas
File|Failas
File :|Failas
File Name :|Failo pavadinimas:
File transfer|Failo perkėlimas
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>
Format|Formatuoti
FPS|KPS
Frame Skip/Limiter|Kadrų praleidimas
French|Prancūzų
From|Iš
From File|Iš failo
From File...|Iš failo...
&Fullscreen|&Pilnas ekranas
Fullscreen|Pilnas ekranas
General|Pagrindiniai
German|Vokiečių
Hard Reset|"Gilus" perkrovimas
Height|Aukštis
_Help|_Pagalba
&Help|&Pagalba
http://www.emu-compatibility.com/yabause/index.php?lang=uk|<a href="http://www.emu-compatibility.com/yabause/index.php?lang=uk" class="external free" rel="nofollow">http://www.emu-compatibility.com/yabause/index.php?lang=uk</a>
http://www.monkeystudio.org|<a href="http://www.monkeystudio.org" class="external free" rel="nofollow">http://www.monkeystudio.org</a>
Input|Įvedimas
Invalid Address|Neteisingas adresas
Invalid Value|Neteisinga vertė
Italian|Italų
Japanese|Japonų
Language :|Kalba&#160;:
&Layer|&Sluoksniai
Layer|Sluoksniai
Left|Kairė
Left trigger|Kairysis mygtukas
Load as executable|Įkrauti kaip paleidžiamąjį failą
Load|Įkrauti
&Load From File|&Įkelti iš failo
Load State|Įkelti išsaugotą žaidimą
Load State As|Išsaugoti žaidimą kaip
Log|Log'as
Long Write|Long Write
M68K|M68K
Memory dump|Atminties "išmetimas"
Memory Dump|Atminties "išmetimas"
Memory Editor|Atminties tvarkymas
&Memory Transfer|&Atminties pervedimas
Memory Transfer|Atminties pervedimas
Memory|Atmintis
Mpeg ROM|Mpeg ROM'as
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
Ok|Gerai
&OK|&Gerai
Open CD Rom|Atverti CD-ROM'ą
Open CD Rom...|Atverti CD-ROM'ą...
Open ISO|Atverti ISO
Open ISO...|Atverti ISO...
&Pause|&Pauzė
Pause|Pauzė
&Quit|&Išeiti
Quit|Išeiti
&Raw Memory Address|&Priėjimas prie Raw atminties
RBG0|RBG0
Region|Regionas
&Reset|&Perkrauti
Reset|Perkrauti
Resolution|Raiška
Right|Dešinė
Right trigger|Dešinysis mygtukas
R&un|&Leisti
Run|Leisti
Save Information|Išsaugoti informaciją
Save List|Išsaugojimų sąrašas
Save|Išsaugoti
Save State|Išsaugoti žaidimą
Save State As|Išsaugoti žaidimą kaip
Save States|Žaidimų išsaugojimo failai
&Save To File|&Išsaugoti į failą
Screenshot|Ekrano nuotrauka
SCSP|SCSP
SCU-DSP|SCU-DSP
Select a file to load your state|Pasirink žaidimo išsaugojimo failą įkėlimui
Select your iso/cue/bin file|Pasirink iso/cue/bin failą
&Settings...|&Nuostatos
Settings|Nuostatos
SH2 Interpreter|SH2 Interpretatorius
Sound Core|Garso įranga
Sound|Garsas
Spanish|Ispanų
SSH2|SSH2
Start|Pradėti
Start Address:|Pradžios adresas:
Status|Statusas
Store|Saugoti
To File|Į failą
To File...|Į failą...
toolBar|Įrankų juosta
Tools|Įrankiai
To|Į
Transfer|Pervedimas
Translation|Vertimas
Unable to add code|Neįmanoma pridėti kodo
Unable to change description|Neįmanoma keisti aprašymo
Unable to open file for loading|Neįmanoma atverti failo įkrovimui
Unable to open file for saving|Neįmanoma atverti failo saugojimui
Unable to remove code|Neįmanoma pašalinti kodo
Unknow (%1)|Nežinoma (%1)
Up|Aukštyn
Upload|Įkrauti
Value :|Vertė:
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Video įranga
Video Driver|Video tvarkyklė
Video Format|Video formatas
Video|Video
_View|_Žiūrėti
&View|&Žiūrėti
Waiting Input...|Laukiama įvedimo
Width|Plotis
Word Write|Žodžių rašymas
Yabause Cheat Files (*.yct);;All Files (*)|Yabause kodų failai (*.yct);;Visi failai (*)
Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Yabause Qt Gui<br />Paremtas pagal Yabause 0.9.5<br /><a href="<a href="http://yabause.org" class="external free" rel="nofollow">http://yabause.org</a>"><a href="http://yabause.org" class="external free" rel="nofollow">http://yabause.org</a></a><br />Yabause komanda<br /><a href="<a href="mailto:pasnox@gmail.com" class="external free" rel="nofollow">mailto:pasnox@gmail.com</a>">Filipe AZEVEDO</a>
Yabause Qt GUI|Yabause Qt grafinė sąsaja
Yabause Save State (*.yss)|Yabause žaidimo išsaugojimo failas (*.yss)

195
yabause/l10n/yabause_pt.yts
View File

@ -1,195 +0,0 @@
%1/%2 blocks free|%1/%2 blocos livres
%1 Images (*.%2)|%1 Images (*.%2)
503/512 blocks free|503/512 blocos livres
510/512 blocks free|510/512 blocos livres
About...|Sobre...
&About...|&Sobre...
About|Sobre
&Action Replay|&Action Replay
Action Replay Code :|Código do Action Replay
Add Action Replay Code|Adicionar Código do Action Replay
Add Codes...|Adicionar Códigos...
Add Raw Memory Code|Adicionar o Endereço Original da Memória
Address :|Endereço :
Advanced|Avançado
<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>|<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>
Are you sure you want to delete '%1' ?|Você tem certeza de que deseja excluir '%1' ?
Are you sure you want to format '%1' ?|Você tem certeza de que deseja formatar '%1' ?
Backup Manager|Gerenciador de Backups
Backup Manager...|Gerenciador de Backups...
&Backup Ram Manager|&Gerenciador da Ram de Backup
Backup Ram Manager|Gerenciador da Ram de Backup
Bios|Bios
Block Size :|Tamanho dos Blocos :
&Browse|&Procurar
Browse|Procurar
Byte Write|Gravar Byte
Cancel|Cancelar
Cannot initialize|Não pode inicializar
&Capture Screen|&Capturar Tela
Cart/Memory|Cartucho/Memória
Cartridge|Cartucho
CD Images (*.iso *.cue *.bin)|Imagens de CD (*.iso *.cue *.bin)
Cd-Rom|CD-Rom
&Cheats|&Trapaças
Cheats|Trapaças
Cheats File|Arquivo de Trapaças
&Cheat List|Lista de &Trapaças
Cheats List|Lista de Trapaças
Cheats List...|Lista de Trapaças
Cheat Type|Tipo de Trapaça
Choose a cdrom drive/mount point|Escolha um leitor de CD ou um ponto de montagem
Choose a cheat file to open|Escolha um arquivo de trapaças para abrir
Choose a cheat file to save to|Escolha um arquivo de trapaças para salvar
Choose a file to save your state|Escolha um arquivo para salvar seu estado
Choose a location for your screenshot|Escolha um local para sua captura de tela
&Clear|&Limpar
Close|Fechar
Code|Código
Comment :|Comentário :
Data Size :|Tamanho dos Dados :
_Debug|_Debug
&Debug|&Debug
&Delete|&Excluir
Delete|Excluir
Description|Descrição
Description :|Descrição :
Device List|Lista de Dispositivos
Disabled|Desativado
Down|Para baixo
Download|Baixar
Emu-Compatibility|Compatibilidade com o Emu
Emulation|Emulação
End Address:|Endereço Final:
Enable|Ativar
Enabled|Ativado
English|Inglês
&File|&Arquivo
File|Arquivo
File :|Arquivo :
File Name :|Nome do Arquivo :
File transfer|Transferência de arquivo
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>AVISO:</b> Códigos Mestres <b>NÃO</b> são suportados.</font>
Format|Formato
FPS|QPS
Frame Skip/Limiter|Pulo de quadros/Limitador
French|Francês
From|De
From File|Do Arquivo
From File...|Do Arquivo...
&Fullscreen|Tela cheia
Fullscreen|Tela cheia
General|Geral
German|Alemão
Hard Reset|Reiniciar Hardware
Height|Altura
_Help|_Ajuda
&Help|&Ajuda
http://www.emu-compatibility.com/yabause/index.php?lang=uk|http://www.emu-compatibility.com/yabause/index.php?lang=uk
http://www.monkeystudio.org|http://www.monkeystudio.org
Input|Controles
Invalid Address|Endereço Inválido
Invalid Value|Valor Inválido
Italian|Italiano
Japanese|Japonês
Language :|Idioma :
&Layer|&Camada
Layer|Camada
Left|Esquerda
Left trigger|Gatilho esquerdo
Load as executable|Carregar como executável
Load|Carregar
&Load From File|&Carregar Do Arquivo
Load State|Carregar Estado
Load State As|Carregar Estado como
Log|Log
Long Write|Escrita Longa
M68K|M68K
Memory dump|Dump de memória
Memory Dump|Dump de Memória
Memory Editor|Editor de Memória
&Memory Transfer|&Transferência de Memória
Memory Transfer|Transferência de Memória
Memory|Memória
Mpeg ROM|ROM Mpeg
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
Ok|Ok
&OK|&OK
Open CD Rom|Abrir CD Rom
Open CD Rom...|Abrir CD Rom...
Open ISO|Abrir ISO
Open ISO...|Abrir ISO...
&Pause|&Pausar
Pause|Pausar
&Quit|&Sair
Quit|Sair
&Raw Memory Address|&Endereço Original da Memória
RBG0|RBG0
Region|Região
&Reset|&Reiniciar
Reset|Reiniciar
Resolution|Resolução
Right|Direita
Right trigger|Gatilho direito
R&un|Exec&utar
Run|Executar
Save Information|Informações sobre os Saves
Save List|Lista dos Saves
Save|Salvar
Save State|Salvar Estado
Save State As|Salvar Estado Como
Save States|Salvar Estado
&Save To File|&Salvar Para Arquivo
Screenshot|Captura de tela
SCSP|SCSP
SCU-DSP|SCU-DSP
Select a file to load your state|Escolha um arquivo para carregar seu estado
Select your iso/cue/bin file|Escolha seu arquivo iso/cue/bin
&Settings...|Configuraçõe&s...
Settings|Configurações
SH2 Interpreter|Interpretador SH2
Sound Core|Núcleo de Som
Sound|Som
Spanish|Espanhol
SSH2|SSH2
Start|Iniciar
Start Address:|Endereço Inicial:
Status|Estado
Store|Armazenar
To File|Para Arquivo
To File...|Para arquivo...
toolBar|Barra de ferramentas
Tools|Ferramentas
To|Para
Transfer|Transferência
Translation|Tradução
Unable to add code|Não foi possível adicionar código
Unable to change description|Não foi possível modificar a descrição
Unable to open file for loading|Não foi possível carregar o arquivo
Unable to open file for saving|Não foi possível salvar o arquivo
Unable to remove code|Não foi possível remover o código
Unknow (%1)|Desconh (%1)
Up|Para cima
Upload|Subir
Value :|Valor :
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Núcleo de Vídeo
Video Driver|Driver de Vídeo
Video Format|Formato do Vídeo
Video|Vídeo
_View|_Visualizar
&View|&Visualizar
Waiting Input...|Aguardando Entrada de Dados...
Width|Largura
Word Write|Escrita Word
Yabause Cheat Files (*.yct);;All Files (*)|Arquivos de trapaça Yabause (*.yct);;Todos os arquivos (*)
Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Gui Qt do Yabause<br />Baseada no Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />O Time do Yabause<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>
Yabause Qt GUI|Interface Gráfica do Usuário em Qt do Yabause
Yabause Save State (*.yss)|Estado Salvo do Yabause

274
yabause/l10n/yabause_pt_BR.yts
View File

@ -1,274 +0,0 @@
%1/%2 blocks free|%1/%2 blocos livres
%1 Images (*.%2)|%1 Imagens (*.%2)
503/512 blocks free|503/512 blocos livres
510/512 blocks free|510/512 blocos livres
About...|Sobre...
&About...|&Sobre...
About|Sobre
&Action Replay|&Action Replay
Action Replay Code :|Código do Action Replay
Add Action Replay Code|Adicionar Código do Action Replay
Add Cheat|Adicionar Trapaça
Add Codes...|Adicionar Códigos...
Add Raw Memory Code|Adicionar o Código da Memória Original
Address|Endereço
Address :|Endereço :
Advanced|Avançado
Always|Sempre
Asia (NTSC)|Ásia (NTSC)
Asia (PAL)|Ásia (PAL)
Are you sure you want to delete '%1' ?|Você tem certeza que você quer apagar '%1' ?
Are you sure you want to format '%1' ?|Você tem certeza que você quer formatar '%1' ?
Auto-detect|Auto-detectar
Autostart|Auto-iniciar
Backup Manager|Gerenciador de Backups
&Backup Manager...|&Gerenciador de Backups...
Backup Manager...|Gerenciador de Backups...
&Backup Ram Manager|&Gerenciador da Ram de Backup
Backup Ram Manager|Gerenciador da Ram de Backup
Bios|Bios
Block Size :|Tamanho dos Blocos :
&Browse|&Explorar
Browse|Explorar
Byte Write|Gravação do Byte
&Cancel|&Cancelar
Cancel|Cancelar
Cannot initialize|Não consegue inicializar
&Capture Screen|&Capturar Tela
Cart/Memory|Cartucho/Memória
Cartridge|Cartucho
CD Images (*.iso *.cue *.bin)|Imagens de CD (*.iso *.cue *.bin)
Cd-Rom|Cd-Rom
Central/South America (NTSC)|América Central/do Sul (NTSC)
Central/South America (PAL)|América Central/do Sul (PAL)
&Cheats|&Códigos
Cheats|Trapaças
Cheats File|Arquivo das Trapaças
&Cheat List|Lista de &Trapaças
Cheats List|Lista de Trapaças
&Cheats List...|&Lista de Trapaças...
Cheats List...|Lista de Trapaças...
Cheat &Search...|Busca de &Trapaças...
Cheat Search|Busca de Trapaças
Cheat Type|Tipo de Trapaça
Choose a cdrom drive/mount point|Escolha um drive de cdrom/ponto de montagem
Choose a cheat file to open|Escolha um arquivo de códigos para abrir
Choose a cheat file to save to|Escolha um arquivo de códigos para salvar
Choose a file to save your state|Escolha um arquivo para salvar seu estado
Choose a location for your screenshot|Escolha um local para seu screenshot
&Clear|&Limpar
Clear configuration|Limpar configuração
&Close|&Fechar
Close|Fechar
Code|Código
Comment :|Comentário :
Compare Type|Tipo de Comparação
Data Size|Tamanho dos Dados
Data Size :|Tamanho dos Dados :
Data Type|Tipo de Dados
_Debug|_Debug
&Debug|&Debug
&Delete|&Apagar
Delete|Apagar
Description|Descrição
Description :|Descrição :
Device List|Lista de Dispositivos
Disabled|Desativado
Down|Pra baixo
Download|Baixar
Dummy CD Drive|Imitação do Drive de CD
Dummy Input Interface|Imitação da Interface de Entrada de Dados
Dummy OSD Interface|Imitação da Interface OSD
Dummy Sound Interface|Imitação da Interface de Som
Dummy Video Interface|Imitação da Interface de Vídeo
Edit configuration|Editar configuração
Emu-Compatibility|Compatibilidade com o Emu
&Emulation|&Emulação
Emulation|Emulação
End Address:|Endereço Final:
Enable|Ativar
Enable Frame Skip/Limiter|Ativar o Frame Skip/Limitador
Enabled|Ativado
English|Inglês
Europe + others (PAL)|Europa + outros (PAL)
Exact|Exato
&File|&Arquivo
File|Arquivo
File :|Arquivo :
File:|Arquivo:
File Name :|Nome do Arquivo :
File transfer|Transferência de arquivo
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>AVISO:</b> Códigos Mestres <b>NÃO</b> são suportados.</font>
Format|Formato
FPS|FPS
Frame Skip/Limiter|Frame Skip/Limitador
&Frame Skip/Limiter|&Frame Skip/Limitador
French|Francês
From|De
From File|Do Arquivo
From File...|Do Arquivo...
&Fullscreen|&Tela cheia
Fullscreen|Tela cheia
General|Geral
German|Alemão
Glut OSD Interface|Interface OSD do Glut
Greater then|Maior do que
Hard Reset|Reset Rígido
Height|Altura
_Help|_Ajuda
&Help|&Ajuda
Hide menubar|Esconder a barra do menu
Hide toolbar|Esconder a barra de ferramentas
http://www.emu-compatibility.com/yabause/index.php?lang=uk|http://www.emu-compatibility.com/yabause/index.php?lang=uk
http://www.monkeystudio.org|http://www.monkeystudio.org
Information...|Informação...
Input|Controles
Invalid Address|Endereço Inválido
Invalid Value|Valor Inválido
ISO-File Virtual Drive|Drive Virtual do Arquivo-ISO
Italian|Italiano
Japan (NTSC)|Japão (NTSC)
Japanese|Japonês
Korea (NTSC)|Coréia (NTSC)
Language :|Idioma :
&Layer|&Camada
Layer|Camada
Left|Esquerda
Left trigger|Gatilho esquerdo
Less than|Menos do que
Linux CD Drive|Drive de CD do Linux
Load as executable|Carregar como executável
Load|Carregar
&Load From File|&Carregar Do Arquivo
L&oad State|C&arregar o State
Load State|Carregar State
Load State As|Carregar State Como
&Log|&Log
Log|Log
Long Write|Gravação Longa
M68K|M68K
&Master SH2|&SH2 Mestre
Master SH2|SH2 Mestre
Memory dump|Dump da memória
Memory Dump|Dump da Memória
Memory &Editor|Editor de &Memória
Memory Editor|Editor de Memória
&Memory Transfer|&Transferência de Memória
Memory Transfer|Transferência de Memória
Memory|Memória
Mpeg ROM|ROM Mpeg
Mouse|Mouse
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
Never|Nunca
None|Nenhum
North America (NTSC)|América do Norte (NTSC)
Ok|Ok
&OK|&OK
On fullscreen|Na tela cheia
Open CD Rom|Abrir o CD Rom
Open &CD Rom...|Abrir &CD Rom...
Open CD Rom...|Abrir o CD Rom...
Open ISO|Abrir a ISO
Open &ISO...|Abrir &ISO...
Open ISO...|Abrir a ISO...
OpenGL Video Interface|Interface de Vídeo do OpenGL
OSD Core|Núcleo do OSD
Pad|Pad
&Pause|&Pausar
Pause|Pausar
Qt Keyboard Input Interface|Interface da Entrada de Dados do Teclado do Qt
&Quit|&Sair
Quit|Sair
&Raw Memory Address|&Endereço da Memória Original
RBG0|RBG0
Region|Região
&Reset|&Resetar
Reset|Resetar
Resolution|Resolução
Right|Direita
Right trigger|Gatilho direito
R&un|E&xecutar
Run|Executar
Save Information|Informações sobre os Saves
Save List|Lista dos Saves
Save|Salvar
S&ave State|S&ave State
Save State|Salvar o State
Save State As|Salvar o State Como
Save States|Salvar os States
&Save To File|&Salvar para o Arquivo
Sc&reenshot|Sc&reenshot
Screenshot|Screenshot
SCSP|SCSP
SCU-DSP|SCU-DSP
SDL Joystick Interface|Interface SDL do Joystick
SDL Sound Interface|Interface de Som SDL
Search|Busca
Search/Add Cheats|Procurar/Adicionar Trapaças
Search Value:|Procurar Valor:
Select a file to load your state|Selecione um arquivo para carregar seu state
Select your iso/cue/bin file|Selecione seu arquivo iso/cue/bin
Set PC to Start Address|Configurar o PC pra Iniciar no Endereço
&Settings...|&Configurações...
Settings|Configurações
SH2 Debugger Interpreter|Interpretador do Debugger SH2
SH2 Dynamic Recompiler|Recompilador Dinâmico do SH2
SH2 Interpreter|Interpretador SH2
Show FPS|Mostrar FPS
&Slave SH2|&SH2 Escravo
Slave SH2|SH2 Escravo
Software Video Interface|Interface de Vídeo do Software
Sound Core|Núcleo do Som
Sound|Som
Spanish|Espanhol
SSH2|SSH2
Signed|Assinado
Software OSD Interface|Interface OSD do Software
Start|Iniciar
Start Address:|Endereço Inicial:
Status|Status
Store|Armazenar
To File|Para o Arquivo
To File...|Para o Arquivo...
toolBar|Barra de ferramentas
&Tools|&Ferramentas
Tools|Ferramentas
To|Para
&Transfer|&Transferência
Transfer|Transferência
Translation|Tradução
Unable to add code|Incapaz de adicionar o código
Unable to change description|Incapaz de mudar a descrição
Unable to open file for loading|Incapaz de abrir o arquivo para carregar
Unable to open file for saving|Incapaz de abrir o arquivo para salvar
Unable to remove code|Incapaz de remover o código
Unknow (%1)|(%1) Desconhecido
Unsigned|Não Assinado
Up|Para cima
Upload|Upload
Value|Valor
Value :|Valor :
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Núcleo do Vídeo
Video Driver|Driver do Vídeo
Video Format|Formato do Vídeo
Video|Vídeo
_View|_Visualizar
&View|&Visualizar
View|Visualizar
Waiting Input...|Esperando a Entrada dos Dados...
Width|Largura
Windows SPTI Driver|Drive SPTI do Windows
Word Write|Gravação das Palavras
Yabause Cheat Files (*.yct);;All Files (*)|Arquivos das Trapaças do Yabause (*.yct);;Todos os Arquivos (*)
Yabause is not initialized, can't manage backup ram.|O Yabause não está inicializado, não pode gerenciar a ram do backup.
Yabause Qt Gui<br />Based on Yabause %1<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Gui Qt do Yabause<br />Baseada no Yabause %1<br /><a href="http://yabause.org">http://yabause.org</a><br />O Time Yabause<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>
Yabause Qt GUI|GUI Qt do Yabause
Yabause Save State (*.yss)|Save State do Yabause (*.yss)

195
yabause/l10n/yabause_sv.yts
View File

@ -1,195 +0,0 @@
%1/%2 blocks free|%1/%2 block fria
%1 Images (*.%2)|%1 Avbilder (*.%2)
503/512 blocks free|503/512 block fria
510/512 blocks free|510/512 block fria
About...|Om...
&About...|&Om...
About|Om
&Action Replay|&Action Replay
Action Replay Code :|Action Replay-kod
Add Action Replay Code|Lägg till en Action Replay-kod
Add Codes...|Lägg till kod...
Add Raw Memory Code|Lägg till råminneskod
Address :|Adress :
Advanced|Avancerat
<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>|<a href="http://www.monkeystudio.org"><img src=":/icons/icons/made.png"></a>
Are you sure you want to delete '%1' ?|Är du säker på att du vill ta bort '%1' ?
Are you sure you want to format '%1' ?|Är du säker på att du vill formatera '%1' ?
Backup Manager|Backuphanterare
Backup Manager...|Backuphanterare...
&Backup Ram Manager|&Backup Ram Manager
Backup Ram Manager|Backup Ram Manager
Bios|Bios
Block Size :|Blockstorlek
&Browse|&Bläddra
Browse|Bläddra
Byte Write|Byteskrivning
Cancel|Avbryt
Cannot initialize|Kan inte initialisera
&Capture Screen|&Skärmdump
Cart/Memory|Kassett/Minne
Cartridge|Kassett
CD Images (*.iso *.cue *.bin)|CD-avbild (*.iso *.cue *.bin)
Cd-Rom|CD-ROM
&Cheats|&Fusk
Cheats|Fusk
Cheats File|Fuskfil
&Cheat List|&Lista över fusk
Cheats List|Lista över fusk
Cheats List...|Lista över fusk...
Cheat Type|Typ av fusk
Choose a cdrom drive/mount point|Välj en CD-läsare eller en monteringspunkt
Choose a cheat file to open|Välj fuskfil att öppna
Choose a cheat file to save to|Välj fuskfil att spara till
Choose a file to save your state|Välj en fil att spara ditt läge till
Choose a location for your screenshot|Välj plats att spara skärmdump till
&Clear|&Rensa
Close|Stäng
Code|Kod
Comment :|Kommentar :
Data Size :|Datastorlek :
_Debug|_Debug
&Debug|%Debug
&Delete|&Ta bort
Delete|Ta bort
Description|Beskrivning
Description :|Beskrivning :
Device List|Lista över enheter
Disabled|Inaktiverad
Down|Ner
Download|Nerladdning
Emu-Compatibility|Emu-kompatibilitet
Emulation|Emulering
End Address:|Slutadress
Enable|Aktivera
Enabled|Aktiverad
English|Engelska
&File|&Fil
File|Fil
File :|File :
File Name :|Filnamn :
File transfer|Filöverföring
<font color="red"><b>WARNING:</b> Master Codes are <b>NOT</b> supported.</font>|<font color="red"><b>VARNING:</b> Master Codes stöds <b>INTE</b></font>
Format|Formatera
FPS|FPS
Frame Skip/Limiter|Frame Skip/Limiter
French|Franska
From|Från
From File|Från fil
From File...|Från fil...
&Fullscreen|&Helskärm
Fullscreen|Helskärm
General|Allmänt
German|Tyska
Hard Reset|Hård reset
Height|Höjd
_Help|_Hjälp
&Help|&Hjälp
http://www.emu-compatibility.com/yabause/index.php?lang=uk|http://www.emu-compatibility.com/yabause/index.php?lang=uk
http://www.monkeystudio.org|http://www.monkeystudio.org
Input|Kontroller
Invalid Address|Ogiltig adress
Invalid Value|Ogiltigt värde
Italian|Italienska
Japanese|Japanska
Language :|Språk :
&Layer|&Lager
Layer|Lager
Left|Vänster
Left trigger|Vänster avtryckare
Load as executable|Ladda som exekverbar
Load|Ladda
&Load From File|Ladda från fil
Load State|Ladda läge
Load State As|Ladda läge som
Log|Logg
Long Write|Lång skrivning
M68K|M68K
Memory dump|Minnesdump
Memory Dump|Minnesdump
Memory Editor|Minnesredigerare
&Memory Transfer|&Minnesöverföring
Memory Transfer|Minnesöverföring
Memory|Minne
Mpeg ROM|MPEG ROM
MSH2|MSH2
NBG0|NBG0
NBG1|NBG1
NBG2|NBG2
NBG3|NBG3
Ok|OK
&OK|&OK
Open CD Rom|Öppna CD-ROM
Open CD Rom...|Öppna CD-ROM...
Open ISO|Öppna ISO
Open ISO...|Öppna ISO...
&Pause|&Paus
Pause|Paus
&Quit|&Avsluta
Quit|Avsluta
&Raw Memory Address|&Rå minnesadress
RBG0|RBG0
Region|Region
&Reset|&Reset
Reset|Reset
Resolution|Upplösning
Right|Höger
Right trigger|Höger avtryckare
R&un|&Kör
Run|Kör
Save Information|Spara information
Save List|Spara lista
Save|Spara
Save State|Spara läge
Save State As|Spara läge som
Save States|Spara lägen
&Save To File|&Spara till fil
Screenshot|Skärmdump
SCSP|SCSP
SCU-DSP|SCU-DSP
Select a file to load your state|Välj fil för att ladda ditt läge
Select your iso/cue/bin file|Välj din iso/cue/bin-fil
&Settings...|&Inställningar...
Settings|Inställningar
SH2 Interpreter|SH2-tolkare
Sound Core|Ljudgränssnitt
Sound|Ljud
Spanish|Spanska
SSH2|SSH2
Start|Start
Start Address:|Startadress
Status|Status
Store|Lagra
To File|Till fil
To File...|Till fil...
toolBar|Verktygsfält
Tools|Verktyg
To|Till
Transfer|Överföring
Translation|Översättning
Unable to add code|Kan inte lägga till kod
Unable to change description|Kan inte ändra beskrivning
Unable to open file for loading|Kan inte öppna fil för att ladda
Unable to open file for saving|Kan inte öppna fil för att spara
Unable to remove code|Kan inte ta bort kod
Unknow (%1)|Okänt (%1)
Up|Upp
Upload|Uppladdning
Value :|Värde :
Vdp1|Vdp1
VDP1|VDP1
Vdp2|Vdp2
VDP2|VDP2
Video Core|Videogränssnitt
Video Driver|Videodrivrutin
Video Format|Videoformat
Video|Video
_View|_Visa
&View|&Visa
Waiting Input...|Väntar på input...
Width|Bredd
Word Write|Ordskrivning
Yabause Cheat Files (*.yct);;All Files (*)|Yabause fuskfil (*.yct);;Alla filer (*)
Yabause Qt Gui<br />Based on Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />The Yabause Team<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>|Yabause Qt GUI<br />Baserat på Yabause 0.9.5<br /><a href="http://yabause.org">http://yabause.org</a><br />Yabause-teamet<br /><a href="mailto:pasnox@gmail.com">Filipe AZEVEDO</a>
Yabause Qt GUI|Yabause Qt GUI
Yabause Save State (*.yss)|Yabause Sparat Läge (*.yss)