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

Merge pull request #1582 from MrWint/update-gambatte-speedrun 

Update Gambatte core
This commit is contained in:
alyosha-tas 2019-06-02 09:14:39 -04:00 committed by GitHub
parent e60896c1b7 a93916e24c
commit 50a0b36572
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
76 changed files with 8615 additions and 9263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
BizHawk.Emulation.Cores/Consoles/Nintendo/Gameboy/Gambatte.ISaveRam.cs
View File

@ -41,31 +41,9 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
break;
default:
throw new ArgumentException("Size of saveram data does not match expected!");
case 44:
data = FixRTC(data, 44);
break;
case 40:
data = FixRTC(data, 40);
break;
}
LibGambatte.gambatte_loadsavedata(GambatteState, data);
}
private byte[] FixRTC(byte[] data, int offset)
{
// length - offset is the start of the VBA-only data; so
// length - offset - 4 is the start of the RTC block
int idx = data.Length - offset - 4;
byte[] ret = new byte[idx + 4];
Buffer.BlockCopy(data, 0, ret, 0, idx);
data[idx] = (byte)zerotime;
data[idx + 1] = (byte)(zerotime >> 8);
data[idx + 2] = (byte)(zerotime >> 16);
data[idx + 3] = (byte)(zerotime >> 24);
return ret;
}
}
}

23
BizHawk.Emulation.Cores/Consoles/Nintendo/Gameboy/Gambatte.ISettable.cs
View File

@ -116,17 +116,10 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
[DefaultValue(false)]
public bool RealTimeRTC { get; set; }
[DisplayName("RTC Initial Time")]
[Description("Set the initial RTC time in terms of elapsed seconds. Only used when RealTimeRTC is false.")]
[DisplayName("RTC Divisor Offset")]
[Description("CPU clock frequency relative to real time clock. Base value is 2^22 Hz. Used in cycle-based RTC to sync on real hardware to account for RTC imperfections.")]
[DefaultValue(0)]
public int RTCInitialTime
{
get { return _RTCInitialTime; }
set { _RTCInitialTime = Math.Max(0, Math.Min(1024 * 24 * 60 * 60, value)); }
}
[JsonIgnore]
private int _RTCInitialTime;
public int RTCDivisorOffset { get; set; }
[DisplayName("Equal Length Frames")]
[Description("When false, emulation frames sync to vblank. Only useful for high level TASing.")]
@ -141,11 +134,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
[DeepEqualsIgnore]
private bool _equalLengthFrames;
[DisplayName("Initial DIV offset")]
[Description("Internal. Probably doesn't work. Leave this set to 0. Accepts values from 0 to 65532 in steps of 4")]
[DefaultValue(0)]
public int InitialDiv { get; set; }
public GambatteSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
@ -160,11 +148,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
{
return !DeepEquality.DeepEquals(x, y);
}
public uint GetInitialDivInternal()
{
return (uint)(InitialDiv & 0xfffc);
}
}
}
}

92
BizHawk.Emulation.Cores/Consoles/Nintendo/Gameboy/Gambatte.cs
View File

@ -58,13 +58,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
{
_syncSettings = (GambatteSyncSettings)syncSettings ?? new GambatteSyncSettings();
// copy over non-loadflag syncsettings now; they won't take effect if changed later
zerotime = (uint)_syncSettings.RTCInitialTime;
real_rtc_time = !DeterministicEmulation && _syncSettings.RealTimeRTC;
DivInternal = _syncSettings.GetInitialDivInternal();
LibGambatte.LoadFlags flags = 0;
switch (_syncSettings.ConsoleMode)
@ -90,33 +83,26 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
flags |= LibGambatte.LoadFlags.MULTICART_COMPAT;
}
if (LibGambatte.gambatte_load(GambatteState, file, (uint)file.Length, GetCurrentTime(), flags, DivInternal) != 0)
if (LibGambatte.gambatte_load(GambatteState, file, (uint)file.Length, flags) != 0)
{
throw new InvalidOperationException($"{nameof(LibGambatte.gambatte_load)}() returned non-zero (is this not a gb or gbc rom?)");
}
byte[] Bios;
if ((flags & LibGambatte.LoadFlags.FORCE_DMG) == LibGambatte.LoadFlags.FORCE_DMG)
{
byte[] Bios = comm.CoreFileProvider.GetFirmware("GB", "World", true, "BIOS Not Found, Cannot Load");
Bios = comm.CoreFileProvider.GetFirmware("GB", "World", true, "BIOS Not Found, Cannot Load");
IsCgb = false;
if (LibGambatte.gambatte_loaddmgbios(GambatteState, Bios) != 0)
{
throw new InvalidOperationException($"{nameof(LibGambatte.gambatte_loaddmgbios)}() returned non-zero (bios error)");
}
}
else
{
byte[] Bios = comm.CoreFileProvider.GetFirmware("GBC", "World", true, "BIOS Not Found, Cannot Load");
Bios = comm.CoreFileProvider.GetFirmware("GBC", "World", true, "BIOS Not Found, Cannot Load");
IsCgb = true;
if (LibGambatte.gambatte_loadgbcbios(GambatteState, Bios) != 0)
{
throw new InvalidOperationException($"{nameof(LibGambatte.gambatte_loadgbcbios)}() returned non-zero (bios error)");
}
}
if (LibGambatte.gambatte_loadbios(GambatteState, Bios, (uint)Bios.Length) != 0)
{
throw new InvalidOperationException($"{nameof(LibGambatte.gambatte_loadbios)}() returned non-zero (bios error)");
}
// set real default colors (before anyone mucks with them at all)
PutSettings((GambatteSettings)settings ?? new GambatteSettings());
@ -140,8 +126,11 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
string romname = System.Text.Encoding.ASCII.GetString(buff);
Console.WriteLine("Core reported rom name: {0}", romname);
TimeCallback = new LibGambatte.RTCCallback(GetCurrentTime);
LibGambatte.gambatte_setrtccallback(GambatteState, TimeCallback);
if (!DeterministicEmulation && _syncSettings.RealTimeRTC)
{
LibGambatte.gambatte_settimemode(GambatteState, false);
}
LibGambatte.gambatte_setrtcdivisoroffset(GambatteState, _syncSettings.RTCDivisorOffset);
_cdCallback = new LibGambatte.CDCallback(CDCallbackProc);
@ -174,59 +163,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
/// </summary>
private LibGambatte.Buttons CurrentButtons = 0;
private uint DivInternal = 0;
#region RTC
/// <summary>
/// RTC time when emulation begins.
/// </summary>
private readonly uint zerotime = 0;
/// <summary>
/// if true, RTC will run off of real elapsed time
/// </summary>
private bool real_rtc_time = false;
private LibGambatte.RTCCallback TimeCallback;
private static long GetUnixNow()
{
// because internally the RTC works off of relative time, we don't need to base
// this off of any particular canonical epoch.
return DateTime.UtcNow.Ticks / 10000000L - 60000000000L;
}
private uint GetCurrentTime()
{
if (real_rtc_time)
{
return (uint)GetUnixNow();
}
ulong fn = (ulong)Frame;
// as we're exactly tracking cpu cycles, this can be pretty accurate
fn *= 4389;
fn /= 262144;
fn += zerotime;
return (uint)fn;
}
private uint GetInitialTime()
{
if (real_rtc_time)
{
return (uint)GetUnixNow();
}
// setting the initial boot time to 0 will cause our zerotime
// to function as an initial offset, which is what we want
return 0;
}
#endregion
#region ALL SAVESTATEABLE STATE GOES HERE
/// <summary>
@ -327,7 +263,7 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
if (controller.IsPressed("Power"))
{
LibGambatte.gambatte_reset(GambatteState, GetCurrentTime(), DivInternal);
LibGambatte.gambatte_reset(GambatteState);
}
if (Tracer.Enabled)

53
BizHawk.Emulation.Cores/Consoles/Nintendo/Gameboy/LibGambatte.cs
View File

@ -53,29 +53,20 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
/// <param name="core">opaque state pointer</param>
/// <param name="romdata">the rom data, can be disposed of once this function returns</param>
/// <param name="length">length of romdata in bytes</param>
/// <param name="now">RTC time when the rom is loaded</param>
/// <param name="flags">ORed combination of LoadFlags.</param>
/// <returns>0 on success, negative value on failure.</returns>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int gambatte_load(IntPtr core, byte[] romdata, uint length, long now, LoadFlags flags, uint div);
public static extern int gambatte_load(IntPtr core, byte[] romdata, uint length, LoadFlags flags);
/// <summary>
/// Load GB BIOS image.
/// Load GB(C) BIOS image.
/// </summary>
/// <param name="core">opaque state pointer</param>
/// <param name="biosdata">the bios data, can be disposed of once this function returns</param>
/// <param name="length">length of romdata in bytes</param>
/// <returns>0 on success, negative value on failure.</returns>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int gambatte_loaddmgbios(IntPtr core, byte[] biosdata);
/// <summary>
/// Load GBC BIOS image.
/// </summary>
/// <param name="core">opaque state pointer</param>
/// <param name="biosdata">the bios data, can be disposed of once this function returns</param>
/// <returns>0 on success, negative value on failure.</returns>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int gambatte_loadgbcbios(IntPtr core, byte[] biosdata);
public static extern int gambatte_loadbios(IntPtr core, byte[] biosdata, uint length);
/// <summary>
/// Emulates until at least 'samples' stereo sound samples are produced in the supplied buffer,
@ -122,9 +113,8 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
/// Equivalent to reloading a ROM image, or turning a Game Boy Color off and on again.
/// </summary>
/// <param name="core">opaque state pointer</param>
/// <param name="now">RTC time when the reset occurs</param>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void gambatte_reset(IntPtr core, long now, uint div);
public static extern void gambatte_reset(IntPtr core);
/// <summary>
/// palette type for gambatte_setdmgpalettecolor
@ -267,21 +257,6 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
/// <param name="sl">0-153 inclusive</param>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void gambatte_setscanlinecallback(IntPtr core, ScanlineCallback callback, int sl);
/// <summary>
/// type of the RTC callback
/// </summary>
/// <returns>what time is it, unixy</returns>
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate uint RTCCallback();
/// <summary>
/// sets RTC callback. probably mandatory.
/// </summary>
/// <param name="core">opaque state pointer</param>
/// <param name="callback">the callback</param>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void gambatte_setrtccallback(IntPtr core, RTCCallback callback);
/// <summary>
/// type of the link data sent callback
@ -297,6 +272,24 @@ namespace BizHawk.Emulation.Cores.Nintendo.Gameboy
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void gambatte_setlinkcallback(IntPtr core, LinkCallback callback);
/// <summary>
/// Changes between cycle-based and real-time RTC. Defaults to cycle-based.
/// </summary>
/// <param name="core">opaque state pointer</param>
/// <param name="useCycles">use cycle-based RTC</param>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void gambatte_settimemode(IntPtr core, bool useCycles);
/// <summary>
/// Adjusts the CPU clock frequency relative to real time. Base value is 2^22 Hz.
/// This is used to account for drift in the RTC when syncing cycle-based RTC to real hardware.
/// RTCs in carts are not perfectly accurate, and the value will differ from cart to cart.
/// </summary>
/// <param name="core">opaque state pointer</param>
/// <param name="rtcDivisorOffset">CPU frequency adjustment</param>
[DllImport("libgambatte.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void gambatte_setrtcdivisoroffset(IntPtr core, int rtcDivisorOffset);
/// <summary>
/// Returns true if the currently loaded ROM image is treated as having CGB support.
/// </summary>

4
libgambatte/Makefile
View File

@ -25,12 +25,12 @@ SRCS = \
src/cpu.cpp \
src/gambatte.cpp \
src/initstate.cpp \
src/interrupter.cpp \
src/interruptrequester.cpp \
src/memory.cpp \
src/mem/cartridge.cpp \
src/mem/memptrs.cpp \
src/mem/rtc.cpp \
src/mem/time.cpp \
src/newstate.cpp \
src/sound.cpp \
src/sound/channel1.cpp \
@ -61,6 +61,6 @@ $(TARGET) : $(OBJS)
clean:
$(RM) $(OBJS)
$(RM) $(TARGET)
install:
$(CP) $(TARGET) $(DEST_$(ARCH))

144
libgambatte/include/gambatte.h
View File

@ -1,31 +1,32 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef GAMBATTE_H
#define GAMBATTE_H
#include "gbint.h"
#include "loadres.h"
#include <cstddef>
#include <string>
#include <sstream>
#include <cstdint>
#include "newstate.h"
namespace gambatte {
enum { BG_PALETTE = 0, SP1_PALETTE = 1, SP2_PALETTE = 2 };
typedef void (*MemoryCallback)(int32_t address, int64_t cycleOffset);
@ -48,99 +49,116 @@ class GB {
public:
GB();
~GB();
enum LoadFlag {
FORCE_DMG = 1, /**< Treat the ROM as not having CGB support regardless of what its header advertises. */
GBA_CGB = 2, /**< Use GBA intial CPU register values when in CGB mode. */
MULTICART_COMPAT = 4, /**< Use heuristics to detect and support some multicart MBCs disguised as MBC1. */
};
/** Load ROM image.
/**
* Load ROM image.
*
* @param romfile Path to rom image file. Typically a .gbc, .gb, or .zip-file (if zip-support is compiled in).
* @param romfile Path to rom image file. Typically a .gbc, .gb, or .zip-file (if
* zip-support is compiled in).
* @param flags ORed combination of LoadFlags.
* @return 0 on success, negative value on failure.
*/
int load(const char *romfiledata, unsigned romfilelength, std::uint32_t now, unsigned flags, unsigned div);
int loadGBCBios(const char* biosfiledata);
int loadDMGBios(const char* biosfiledata);
LoadRes load(char const *romfiledata, unsigned romfilelength, unsigned flags);
/** Emulates until at least 'samples' stereo sound samples are produced in the supplied buffer,
* or until a video frame has been drawn.
int loadBios(char const *biosfiledata, std::size_t size);
/**
* Emulates until at least 'samples' audio samples are produced in the
* supplied audio buffer, or until a video frame has been drawn.
*
* There are 35112 stereo sound samples in a video frame.
* May run for up to 2064 stereo samples too long.
* A stereo sample consists of two native endian 2s complement 16-bit PCM samples,
* with the left sample preceding the right one. Usually casting soundBuf to/from
* short* is OK and recommended. The reason for not using a short* in the interface
* is to avoid implementation-defined behaviour without compromising performance.
* There are 35112 audio (stereo) samples in a video frame.
* May run for up to 2064 audio samples too long.
*
* An audio sample consists of two native endian 2s complement 16-bit PCM samples,
* with the left sample preceding the right one. Usually casting audioBuf to
* int16_t* is OK. The reason for using an uint_least32_t* in the interface is to
* avoid implementation-defined behavior without compromising performance.
* libgambatte is strictly c++98, so fixed-width types are not an option (and even
* c99/c++11 cannot guarantee their availability).
*
* Returns early when a new video frame has finished drawing in the video buffer,
* such that the caller may update the video output before the frame is overwritten.
* The return value indicates whether a new video frame has been drawn, and the
* exact time (in number of samples) at which it was drawn.
* exact time (in number of samples) at which it was completed.
*
* @param soundBuf buffer with space >= samples + 2064
* @param samples in: number of stereo samples to produce, out: actual number of samples produced
* @return sample number at which the video frame was produced. -1 means no frame was produced.
* @param videoBuf 160x144 RGB32 (native endian) video frame buffer or 0
* @param pitch distance in number of pixels (not bytes) from the start of one line
* to the next in videoBuf.
* @param audioBuf buffer with space >= samples + 2064
* @param samples in: number of stereo samples to produce,
* out: actual number of samples produced
* @return sample offset in audioBuf at which the video frame was completed, or -1
* if no new video frame was completed.
*/
long runFor(gambatte::uint_least32_t *soundBuf, unsigned &samples);
std::ptrdiff_t runFor(gambatte::uint_least32_t *soundBuf, std::size_t &samples);
void blitTo(gambatte::uint_least32_t *videoBuf, int pitch);
void blitTo(gambatte::uint_least32_t *videoBuf, std::ptrdiff_t pitch);
void setLayers(unsigned mask);
/** Reset to initial state.
/**
* Reset to initial state.
* Equivalent to reloading a ROM image, or turning a Game Boy Color off and on again.
*/
void reset(std::uint32_t now, unsigned div);
/** @param palNum 0 <= palNum < 3. One of BG_PALETTE, SP1_PALETTE and SP2_PALETTE.
void reset();
/**
* @param palNum 0 <= palNum < 3. One of BG_PALETTE, SP1_PALETTE and SP2_PALETTE.
* @param colorNum 0 <= colorNum < 4
*/
void setDmgPaletteColor(unsigned palNum, unsigned colorNum, unsigned rgb32);
void setDmgPaletteColor(int palNum, int colorNum, unsigned long rgb32);
void setCgbPalette(unsigned *lut);
/** Sets the callback used for getting input state. */
void setInputGetter(unsigned (*getInput)());
void setReadCallback(MemoryCallback);
void setWriteCallback(MemoryCallback);
void setExecCallback(MemoryCallback);
void setCDCallback(CDCallback);
void setTraceCallback(void (*callback)(void *));
void setScanlineCallback(void (*callback)(), int sl);
void setRTCCallback(std::uint32_t (*callback)());
void setLinkCallback(void(*callback)());
/** Use cycle-based RTC instead of real-time. */
void setTimeMode(bool useCycles);
/** adjust the assumed clock speed of the CPU compared to the RTC */
void setRtcDivisorOffset(long const rtcDivisorOffset);
/** Returns true if the currently loaded ROM image is treated as having CGB support. */
bool isCgb() const;
/** Returns true if a ROM image is loaded. */
bool isLoaded() const;
/** Writes persistent cartridge data to disk. NOT Done implicitly on ROM close. */
void loadSavedata(const char *data);
void loadSavedata(char const *data);
int saveSavedataLength();
void saveSavedata(char *dest);
// 0 = vram, 1 = rom, 2 = wram, 3 = cartram, 4 = oam, 5 = hram
bool getMemoryArea(int which, unsigned char **data, int *length);
/** ROM header title of currently loaded ROM image. */
const std::string romTitle() const;
std::string const romTitle() const;
unsigned char ExternalRead(unsigned short addr);
void ExternalWrite(unsigned short addr, unsigned char val);
unsigned char externalRead(unsigned short addr);
void externalWrite(unsigned short addr, unsigned char val);
int LinkStatus(int which);
int linkStatus(int which);
void GetRegs(int *dest);
void getRegs(int *dest);
void SetInterruptAddresses(int *addrs, int numAddrs);
int GetHitInterruptAddress();
void setInterruptAddresses(int *addrs, int numAddrs);
int getHitInterruptAddress();
template<bool isReader>void SyncState(NewState *ns);
@ -148,8 +166,8 @@ private:
struct Priv;
Priv *const p_;
GB(const GB &);
GB & operator=(const GB &);
GB(GB const &);
GB & operator=(GB const &);
};
}

36
libgambatte/include/gbint.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef GAMBATTE_INT_H
#define GAMBATTE_INT_H

23
libgambatte/include/loadres.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef GAMBATTE_LOADRES_H
#define GAMBATTE_LOADRES_H
#include <string>
namespace gambatte {
enum LoadRes {
LOADRES_BAD_FILE_OR_UNKNOWN_MBC = -0x7FFF,
LOADRES_IO_ERROR,
LOADRES_UNSUPPORTED_MBC_HUC3 = -0x1FE,
LOADRES_UNSUPPORTED_MBC_TAMA5,
LOADRES_UNSUPPORTED_MBC_POCKET_CAMERA,
LOADRES_UNSUPPORTED_MBC_MBC7 = -0x122,
LOADRES_UNSUPPORTED_MBC_MBC6 = -0x120,
LOADRES_UNSUPPORTED_MBC_MBC4 = -0x117,
LOADRES_UNSUPPORTED_MBC_MMM01 = -0x10D,
LOADRES_OK = 0
};
}
#endif

11
libgambatte/libgambatte.vcxproj
View File

@ -22,7 +22,7 @@
<ProjectGuid>{5D630682-7BDA-474D-B387-0EB420DDC199}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>libgambatte</RootNamespace>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
<WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@ -156,20 +156,18 @@
<ItemGroup>
<ClInclude Include="include\gambatte.h" />
<ClInclude Include="include\gbint.h" />
<ClInclude Include="include\loadres.h" />
<ClInclude Include="src\cinterface.h" />
<ClInclude Include="src\common\array.h" />
<ClInclude Include="src\common\uncopyable.h" />
<ClInclude Include="src\counterdef.h" />
<ClInclude Include="src\cpu.h" />
<ClInclude Include="src\file\stdfile.h" />
<ClInclude Include="src\initstate.h" />
<ClInclude Include="src\insertion_sort.h" />
<ClInclude Include="src\interrupter.h" />
<ClInclude Include="src\interruptrequester.h" />
<ClInclude Include="src\memory.h" />
<ClInclude Include="src\mem\cartridge.h" />
<ClInclude Include="src\mem\memptrs.h" />
<ClInclude Include="src\mem\rtc.h" />
<ClInclude Include="src\mem\time.h" />
<ClInclude Include="src\minkeeper.h" />
<ClInclude Include="src\newstate.h" />
<ClInclude Include="src\savestate.h" />
@ -188,6 +186,7 @@
<ClInclude Include="src\video.h" />
<ClInclude Include="src\video\lyc_irq.h" />
<ClInclude Include="src\video\ly_counter.h" />
<ClInclude Include="src\video\m0_irq.h" />
<ClInclude Include="src\video\next_m0_time.h" />
<ClInclude Include="src\video\ppu.h" />
<ClInclude Include="src\video\sprite_mapper.h" />
@ -197,12 +196,12 @@
<ClCompile Include="src\cpu.cpp" />
<ClCompile Include="src\gambatte.cpp" />
<ClCompile Include="src\initstate.cpp" />
<ClCompile Include="src\interrupter.cpp" />
<ClCompile Include="src\interruptrequester.cpp" />
<ClCompile Include="src\memory.cpp" />
<ClCompile Include="src\mem\cartridge.cpp" />
<ClCompile Include="src\mem\memptrs.cpp" />
<ClCompile Include="src\mem\rtc.cpp" />
<ClCompile Include="src\mem\time.cpp" />
<ClCompile Include="src\newstate.cpp" />
<ClCompile Include="src\sound.cpp" />
<ClCompile Include="src\sound\channel1.cpp" />

181
libgambatte/libgambatte.vcxproj.filters
View File

@ -15,46 +15,58 @@
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="src\cinterface.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\gambatte.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video.h">
<ClInclude Include="include\gbint.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\loadres.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\cinterface.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\counterdef.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\cpu.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\initstate.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\insertion_sort.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\interruptrequester.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\memory.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\ppu.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\minkeeper.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\mem\cartridge.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\mem\memptrs.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\cpu.h">
<ClInclude Include="src\mem\rtc.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\mem\rtc.h">
<ClInclude Include="src\mem\time.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\minkeeper.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\newstate.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\savestate.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\common\array.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\interrupter.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\file\stdfile.h">
<ClInclude Include="src\sound.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\sound\channel1.h">
@ -69,39 +81,12 @@
<ClInclude Include="src\sound\channel4.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\initstate.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\ly_counter.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\lyc_irq.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\next_m0_time.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\tima.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="include\gbint.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\sound.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\counterdef.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\sound\duty_unit.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\sound\envelope_unit.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\interruptrequester.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\sound\length_counter.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -111,60 +96,69 @@
<ClInclude Include="src\sound\sound_unit.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\sprite_mapper.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\common\uncopyable.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\insertion_sort.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\newstate.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\sound\static_output_tester.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\tima.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\lyc_irq.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\ly_counter.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\m0_irq.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\next_m0_time.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\ppu.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\video\sprite_mapper.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="src\cinterface.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\gambatte.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\ppu.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\cpu.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\mem\cartridge.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\memory.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\mem\memptrs.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\sprite_mapper.cpp">
<ClCompile Include="src\gambatte.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\initstate.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\interruptrequester.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\memory.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\mem\cartridge.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\mem\memptrs.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\mem\rtc.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\interrupter.cpp">
<ClCompile Include="src\mem\time.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\next_m0_time.cpp">
<ClCompile Include="src\newstate.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\sound.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\sound\channel1.cpp">
@ -185,25 +179,28 @@
<ClCompile Include="src\sound\envelope_unit.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\interruptrequester.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\sound\length_counter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\ly_counter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\lyc_irq.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\sound.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\tima.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\newstate.cpp">
<ClCompile Include="src\video.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\lyc_irq.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\ly_counter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\next_m0_time.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\ppu.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="src\video\sprite_mapper.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>

178
libgambatte/src/cinterface.cpp
View File

@ -1,225 +1,205 @@
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "cinterface.h"
#include "gambatte.h"
#include <cstdlib>
#include <cstring>
#include "newstate.h"
using namespace gambatte;
// new is actually called in a few different places, so replace all of them for determinism guarantees
void *operator new(std::size_t n)
{
void *operator new(std::size_t n) {
void *p = std::malloc(n);
std::memset(p, 0, n);
return p;
}
void operator delete(void *p)
{
void operator delete(void *p) {
std::free(p);
}
GBEXPORT GB *gambatte_create()
{
namespace {
using namespace gambatte;
GBEXPORT GB * gambatte_create() {
return new GB();
}
GBEXPORT void gambatte_destroy(GB *g)
{
GBEXPORT void gambatte_destroy(GB *g) {
delete g;
}
GBEXPORT int gambatte_load(GB *g, const char *romfiledata, unsigned romfilelength, long long now, unsigned flags, unsigned div)
{
int ret = g->load(romfiledata, romfilelength, now, flags, div);
return ret;
GBEXPORT int gambatte_load(GB *g, char const *romfiledata, unsigned romfilelength, unsigned flags) {
return g->load(romfiledata, romfilelength, flags);
}
GBEXPORT int gambatte_loadgbcbios(GB* g, const char* biosfiledata)
{
int ret = g->loadGBCBios(biosfiledata);
return ret;
GBEXPORT int gambatte_loadbios(GB *g, char const *biosfiledata, unsigned size) {
return g->loadBios(biosfiledata, size);
}
GBEXPORT int gambatte_loaddmgbios(GB* g, const char* biosfiledata)
{
int ret = g->loadDMGBios(biosfiledata);
return ret;
}
GBEXPORT int gambatte_runfor(GB *g, short *soundbuf, unsigned *samples)
{
unsigned sampv = *samples;
GBEXPORT int gambatte_runfor(GB *g, short *soundbuf, unsigned *samples) {
std::size_t sampv = *samples;
int ret = g->runFor((unsigned int *) soundbuf, sampv);
*samples = sampv;
return ret;
}
GBEXPORT void gambatte_blitto(GB *g, unsigned int *videobuf, int pitch)
{
GBEXPORT void gambatte_blitto(GB *g, unsigned int *videobuf, int pitch) {
g->blitTo((unsigned int *)videobuf, pitch);
}
GBEXPORT void gambatte_setlayers(GB *g, unsigned mask)
{
GBEXPORT void gambatte_setlayers(GB *g, unsigned mask) {
g->setLayers(mask);
}
GBEXPORT void gambatte_reset(GB *g, long long now, unsigned div)
{
g->reset(now, div);
GBEXPORT void gambatte_settimemode(GB *g, bool useCycles) {
g->setTimeMode(useCycles);
}
GBEXPORT void gambatte_setdmgpalettecolor(GB *g, unsigned palnum, unsigned colornum, unsigned rgb32)
{
GBEXPORT void gambatte_setrtcdivisoroffset(GB *g, int rtcDivisorOffset) {
g->setRtcDivisorOffset(rtcDivisorOffset);
}
GBEXPORT void gambatte_reset(GB *g) {
g->reset();
}
GBEXPORT void gambatte_setdmgpalettecolor(GB *g, unsigned palnum, unsigned colornum, unsigned rgb32) {
g->setDmgPaletteColor(palnum, colornum, rgb32);
}
GBEXPORT void gambatte_setcgbpalette(GB *g, unsigned *lut)
{
GBEXPORT void gambatte_setcgbpalette(GB *g, unsigned *lut) {
g->setCgbPalette(lut);
}
GBEXPORT void gambatte_setinputgetter(GB *g, unsigned (*getinput)(void))
{
GBEXPORT void gambatte_setinputgetter(GB *g, unsigned (*getinput)(void)) {
g->setInputGetter(getinput);
}
GBEXPORT void gambatte_setreadcallback(GB *g, MemoryCallback callback)
{
GBEXPORT void gambatte_setreadcallback(GB *g, MemoryCallback callback) {
g->setReadCallback(callback);
}
GBEXPORT void gambatte_setwritecallback(GB *g, MemoryCallback callback)
{
GBEXPORT void gambatte_setwritecallback(GB *g, MemoryCallback callback) {
g->setWriteCallback(callback);
}
GBEXPORT void gambatte_setexeccallback(GB *g, MemoryCallback callback)
{
GBEXPORT void gambatte_setexeccallback(GB *g, MemoryCallback callback) {
g->setExecCallback(callback);
}
GBEXPORT void gambatte_setcdcallback(GB *g, CDCallback cdc)
{
GBEXPORT void gambatte_setcdcallback(GB *g, CDCallback cdc) {
g->setCDCallback(cdc);
}
GBEXPORT void gambatte_settracecallback(GB *g, void (*callback)(void *))
{
GBEXPORT void gambatte_settracecallback(GB *g, void (*callback)(void *)) {
g->setTraceCallback(callback);
}
GBEXPORT void gambatte_setscanlinecallback(GB *g, void (*callback)(), int sl)
{
GBEXPORT void gambatte_setscanlinecallback(GB *g, void (*callback)(), int sl) {
g->setScanlineCallback(callback, sl);
}
GBEXPORT void gambatte_setrtccallback(GB *g, unsigned int (*callback)())
{
g->setRTCCallback(callback);
}
GBEXPORT void gambatte_setlinkcallback(GB *g, void(*callback)())
{
GBEXPORT void gambatte_setlinkcallback(GB *g, void(*callback)()) {
g->setLinkCallback(callback);
}
GBEXPORT int gambatte_iscgb(GB *g)
{
GBEXPORT int gambatte_iscgb(GB *g) {
return g->isCgb();
}
GBEXPORT int gambatte_isloaded(GB *g)
{
GBEXPORT int gambatte_isloaded(GB *g) {
return g->isLoaded();
}
GBEXPORT void gambatte_savesavedata(GB *g, char *dest)
{
GBEXPORT void gambatte_savesavedata(GB *g, char *dest) {
g->saveSavedata(dest);
}
GBEXPORT void gambatte_loadsavedata(GB *g, const char *data)
{
GBEXPORT void gambatte_loadsavedata(GB *g, char const *data) {
g->loadSavedata(data);
}
GBEXPORT int gambatte_savesavedatalength(GB *g)
{
GBEXPORT int gambatte_savesavedatalength(GB *g) {
return g->saveSavedataLength();
}
GBEXPORT int gambatte_newstatelen(GB *g)
{
GBEXPORT int gambatte_newstatelen(GB *g) {
NewStateDummy dummy;
g->SyncState<false>(&dummy);
return dummy.GetLength();
}
GBEXPORT int gambatte_newstatesave(GB *g, char *data, int len)
{
GBEXPORT int gambatte_newstatesave(GB *g, char *data, int len) {
NewStateExternalBuffer saver(data, len);
g->SyncState<false>(&saver);
return !saver.Overflow() && saver.GetLength() == len;
}
GBEXPORT int gambatte_newstateload(GB *g, const char *data, int len)
{
GBEXPORT int gambatte_newstateload(GB *g, char const *data, int len) {
NewStateExternalBuffer loader((char *)data, len);
g->SyncState<true>(&loader);
return !loader.Overflow() && loader.GetLength() == len;
}
GBEXPORT void gambatte_newstatesave_ex(GB *g, FPtrs *ff)
{
GBEXPORT void gambatte_newstatesave_ex(GB *g, FPtrs *ff) {
NewStateExternalFunctions saver(ff);
g->SyncState<false>(&saver);
}
GBEXPORT void gambatte_newstateload_ex(GB *g, FPtrs *ff)
{
GBEXPORT void gambatte_newstateload_ex(GB *g, FPtrs *ff) {
NewStateExternalFunctions loader(ff);
g->SyncState<true>(&loader);
}
GBEXPORT void gambatte_romtitle(GB *g, char *dest)
{
GBEXPORT void gambatte_romtitle(GB *g, char *dest) {
std::strcpy(dest, g->romTitle().c_str());
}
GBEXPORT int gambatte_getmemoryarea(GB *g, int which, unsigned char **data, int *length)
{
GBEXPORT int gambatte_getmemoryarea(GB *g, int which, unsigned char **data, int *length) {
return g->getMemoryArea(which, data, length);
}
GBEXPORT unsigned char gambatte_cpuread(GB *g, unsigned short addr)
{
return g->ExternalRead(addr);
GBEXPORT unsigned char gambatte_cpuread(GB *g, unsigned short addr) {
return g->externalRead(addr);
}
GBEXPORT void gambatte_cpuwrite(GB *g, unsigned short addr, unsigned char val)
{
g->ExternalWrite(addr, val);
GBEXPORT void gambatte_cpuwrite(GB *g, unsigned short addr, unsigned char val) {
g->externalWrite(addr, val);
}
GBEXPORT int gambatte_linkstatus(GB *g, int which)
{
return g->LinkStatus(which);
return g->linkStatus(which);
}
GBEXPORT void gambatte_getregs(GB *g, int *dest)
{
g->GetRegs(dest);
GBEXPORT void gambatte_getregs(GB *g, int *dest) {
g->getRegs(dest);
}
GBEXPORT void gambatte_setinterruptaddresses(GB *g, int *addrs, int numAddrs)
{
g->SetInterruptAddresses(addrs, numAddrs);
GBEXPORT void gambatte_setinterruptaddresses(GB *g, int *addrs, int numAddrs) {
g->setInterruptAddresses(addrs, numAddrs);
}
GBEXPORT int gambatte_gethitinterruptaddress(GB *g) {
return g->getHitInterruptAddress();
}
GBEXPORT int gambatte_gethitinterruptaddress(GB *g)
{
return g->GetHitInterruptAddress();
}

18
libgambatte/src/cinterface.h
View File

@ -1,3 +1,21 @@
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef CINTERFACE_H
#define CINTERFACE_H

52
libgambatte/src/common/array.h
View File

@ -1,52 +0,0 @@
/***************************************************************************
* Copyright (C) 2008 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef ARRAY_H
#define ARRAY_H
#include <cstddef>
#include "uncopyable.h"
template<typename T>
class Array : Uncopyable {
T *a;
std::size_t sz;
public:
explicit Array(const std::size_t size = 0) : a(size ? new T[size] : 0), sz(size) {}
~Array() { delete []a; }
void reset(const std::size_t size = 0) { delete []a; a = size ? new T[size] : 0; sz = size; }
std::size_t size() const { return sz; }
T * get() const { return a; }
operator T*() const { return a; }
};
template<typename T>
class ScopedArray : Uncopyable {
T *a_;
public:
explicit ScopedArray(T *a = 0) : a_(a) {}
~ScopedArray() { delete []a_; }
void reset(T *a = 0) { delete []a_; a_ = a; }
T * release() { T *a = a_; a_ = 0; return a; }
T * get() const { return a_; }
operator T*() const { return a_; }
};
#endif

29
libgambatte/src/common/uncopyable.h
View File

@ -1,29 +0,0 @@
/***************************************************************************
* Copyright (C) 2009 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef UNCOPYABLE_H
#define UNCOPYABLE_H
class Uncopyable {
Uncopyable(const Uncopyable&);
Uncopyable& operator=(const Uncopyable&);
public:
Uncopyable() {}
};
#endif

4
libgambatte/src/counterdef.h
View File

@ -2,7 +2,9 @@
#define COUNTERDEF_H
namespace gambatte {
enum { DISABLED_TIME = 0xFFFFFFFFul };
enum { disabled_time = 0xfffffffful };
}
#endif

3604
libgambatte/src/cpu.cpp
View File

File diff suppressed because it is too large Load Diff

171
libgambatte/src/cpu.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef CPU_H
#define CPU_H
@ -25,67 +25,40 @@
namespace gambatte {
class CPU {
Memory memory;
unsigned long cycleCounter_;
unsigned short PC;
unsigned short SP;
unsigned HF1, HF2, ZF, CF;
unsigned char A, B, C, D, E, /*F,*/ H, L;
bool skip;
int *interruptAddresses;
int numInterruptAddresses;
int hitInterruptAddress;
void process(unsigned long cycles);
void (*tracecallback)(void *);
public:
CPU();
// void halt();
// unsigned interrupt(unsigned address, unsigned cycleCounter);
long runFor(unsigned long cycles);
void setStatePtrs(SaveState &state);
void loadState(const SaveState &state);
void setLayers(unsigned mask) { memory.setLayers(mask); }
void loadSavedata(const char *data) { memory.loadSavedata(data); }
int saveSavedataLength() {return memory.saveSavedataLength(); }
void saveSavedata(char *dest) { memory.saveSavedata(dest); }
bool getMemoryArea(int which, unsigned char **data, int *length) { return memory.getMemoryArea(which, data, length); }
void loadState(SaveState const &state);
void setLayers(unsigned mask) { mem_.setLayers(mask); }
void loadSavedata(char const *data) { mem_.loadSavedata(data, cycleCounter_); }
int saveSavedataLength() {return mem_.saveSavedataLength(); }
void saveSavedata(char *dest) { mem_.saveSavedata(dest, cycleCounter_); }
void setVideoBuffer(uint_least32_t *const videoBuf, const int pitch) {
memory.setVideoBuffer(videoBuf, pitch);
bool getMemoryArea(int which, unsigned char **data, int *length) { return mem_.getMemoryArea(which, data, length); }
void setVideoBuffer(uint_least32_t *videoBuf, std::ptrdiff_t pitch) {
mem_.setVideoBuffer(videoBuf, pitch);
}
void setInputGetter(unsigned (*getInput)()) {
memory.setInputGetter(getInput);
mem_.setInputGetter(getInput);
}
void setReadCallback(MemoryCallback callback) {
memory.setReadCallback(callback);
mem_.setReadCallback(callback);
}
void setWriteCallback(MemoryCallback callback) {
memory.setWriteCallback(callback);
mem_.setWriteCallback(callback);
}
void setExecCallback(MemoryCallback callback) {
memory.setExecCallback(callback);
mem_.setExecCallback(callback);
}
void setCDCallback(CDCallback cdc) {
memory.setCDCallback(cdc);
mem_.setCDCallback(cdc);
}
void setTraceCallback(void (*callback)(void *)) {
@ -93,52 +66,66 @@ public:
}
void setScanlineCallback(void (*callback)(), int sl) {
memory.setScanlineCallback(callback, sl);
}
void setRTCCallback(std::uint32_t (*callback)()) {
memory.setRTCCallback(callback);
mem_.setScanlineCallback(callback, sl);
}
void setLinkCallback(void(*callback)()) {
memory.setLinkCallback(callback);
mem_.setLinkCallback(callback);
}
int load(const char *romfiledata, unsigned romfilelength, bool forceDmg, bool multicartCompat) {
return memory.loadROM(romfiledata, romfilelength, forceDmg, multicartCompat);
LoadRes load(char const *romfiledata, unsigned romfilelength, bool forceDmg, bool multicartCompat) {
return mem_.loadROM(romfiledata, romfilelength, forceDmg, multicartCompat);
}
bool loaded() const { return memory.loaded(); }
const char * romTitle() const { return memory.romTitle(); }
void setSoundBuffer(uint_least32_t *const buf) { memory.setSoundBuffer(buf); }
unsigned fillSoundBuffer() { return memory.fillSoundBuffer(cycleCounter_); }
bool isCgb() const { return memory.isCgb(); }
void setDmgPaletteColor(unsigned palNum, unsigned colorNum, unsigned rgb32) {
memory.setDmgPaletteColor(palNum, colorNum, rgb32);
bool loaded() const { return mem_.loaded(); }
char const * romTitle() const { return mem_.romTitle(); }
void setSoundBuffer(uint_least32_t *buf) { mem_.setSoundBuffer(buf); }
std::size_t fillSoundBuffer() { return mem_.fillSoundBuffer(cycleCounter_); }
bool isCgb() const { return mem_.isCgb(); }
void setDmgPaletteColor(int palNum, int colorNum, unsigned long rgb32) {
mem_.setDmgPaletteColor(palNum, colorNum, rgb32);
}
void setCgbPalette(unsigned *lut) {
memory.setCgbPalette(lut);
mem_.setCgbPalette(lut);
}
unsigned char* cgbBiosBuffer() { return memory.cgbBiosBuffer(); }
unsigned char* dmgBiosBuffer() { return memory.dmgBiosBuffer(); }
bool gbIsCgb() { return memory.gbIsCgb(); }
void setTimeMode(bool useCycles) { mem_.setTimeMode(useCycles, cycleCounter_); }
void setRtcDivisorOffset(long const rtcDivisorOffset) { mem_.setRtcDivisorOffset(rtcDivisorOffset); }
//unsigned char ExternalRead(unsigned short addr) { return memory.read(addr, cycleCounter_); }
unsigned char ExternalRead(unsigned short addr) { return memory.peek(addr); }
void ExternalWrite(unsigned short addr, unsigned char val) { memory.write_nocb(addr, val, cycleCounter_); }
void setBios(char const *buffer, std::size_t size) { mem_.setBios(buffer, size); }
bool gbIsCgb() { return mem_.gbIsCgb(); }
int LinkStatus(int which) { return memory.LinkStatus(which); }
unsigned char externalRead(unsigned short addr) {return mem_.peek(addr); }
void GetRegs(int *dest);
void externalWrite(unsigned short addr, unsigned char val) {
mem_.write_nocb(addr, val, cycleCounter_);
}
void SetInterruptAddresses(int *addrs, int numAddrs);
int GetHitInterruptAddress();
int linkStatus(int which) { return mem_.linkStatus(which); }
void getRegs(int *dest);
void setInterruptAddresses(int *addrs, int numAddrs);
int getHitInterruptAddress();
private:
Memory mem_;
unsigned long cycleCounter_;
unsigned short pc;
unsigned short sp;
unsigned hf1, hf2, zf, cf;
unsigned char a, b, c, d, e, /*f,*/ h, l;
bool skip_;
int *interruptAddresses;
int numInterruptAddresses;
int hitInterruptAddress;
void process(unsigned long cycles);
void (*tracecallback)(void *);
public:
template<bool isReader>void SyncState(NewState *ns);
};

53
libgambatte/src/file/stdfile.h
View File

@ -1,53 +0,0 @@
/***************************************************************************
Copyright (C) 2007 by Nach
http://nsrt.edgeemu.com
Copyright (C) 2007-2011 by Sindre Aamås
aamas@stud.ntnu.no
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.
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 version 2 for more details.
You should have received a copy of the GNU General Public License
version 2 along with this program; if not, write to the
Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
***************************************************************************/
#ifndef GAMBATTE_STD_FILE_H
#define GAMBATTE_STD_FILE_H
#include "file.h"
#include <fstream>
namespace gambatte {
class StdFile : public File {
std::ifstream stream;
std::size_t fsize;
public:
explicit StdFile(const char *filename)
: stream(filename, std::ios::in | std::ios::binary), fsize(0)
{
if (stream) {
stream.seekg(0, std::ios::end);
fsize = stream.tellg();
stream.seekg(0, std::ios::beg);
}
}
virtual void rewind() { stream.seekg(0, std::ios::beg); }
virtual std::size_t size() const { return fsize; };
virtual void read(char *buffer, std::size_t amount) { stream.read(buffer, amount); }
virtual bool fail() const { return stream.fail(); }
};
}
#endif

155
libgambatte/src/gambatte.cpp
View File

@ -1,89 +1,83 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "gambatte.h"
#include "cpu.h"
#include "savestate.h"
#include "initstate.h"
#include <sstream>
#include "savestate.h"
#include <cstring>
#include <sstream>
namespace gambatte {
struct GB::Priv {
CPU cpu;
unsigned loadflags;
unsigned layersMask;
uint_least32_t vbuff[160*144];
Priv() : loadflags(0), layersMask(LAYER_MASK_BG | LAYER_MASK_OBJ)
{
}
~Priv()
Priv() : loadflags(0), layersMask(layer_mask_bg | layer_mask_window | layer_mask_obj)
{
}
};
GB::GB() : p_(new Priv) {}
GB::~GB() {
//if (p_->cpu.loaded())
// p_->cpu.saveSavedata();
delete p_;
}
long GB::runFor(gambatte::uint_least32_t *const soundBuf, unsigned &samples) {
std::ptrdiff_t GB::runFor(gambatte::uint_least32_t *const soundBuf, std::size_t &samples) {
if (!p_->cpu.loaded()) {
samples = 0;
return -1;
}
p_->cpu.setVideoBuffer(p_->vbuff, 160);
p_->cpu.setSoundBuffer(soundBuf);
const long cyclesSinceBlit = p_->cpu.runFor(samples * 2);
long const cyclesSinceBlit = p_->cpu.runFor(samples * 2);
samples = p_->cpu.fillSoundBuffer();
return cyclesSinceBlit < 0 ? cyclesSinceBlit : static_cast<long>(samples) - (cyclesSinceBlit >> 1);
return cyclesSinceBlit >= 0
? static_cast<std::ptrdiff_t>(samples) - (cyclesSinceBlit >> 1)
: cyclesSinceBlit;
}
void GB::setLayers(unsigned mask)
{
void GB::setLayers(unsigned mask) {
p_->cpu.setLayers(mask);
}
void GB::blitTo(gambatte::uint_least32_t *videoBuf, int pitch)
{
void GB::blitTo(gambatte::uint_least32_t *videoBuf, std::ptrdiff_t pitch) {
gambatte::uint_least32_t *src = p_->vbuff;
gambatte::uint_least32_t *dst = videoBuf;
for (int i = 0; i < 144; i++)
{
std::memcpy(dst, src, sizeof(gambatte::uint_least32_t) * 160);
std::memcpy(dst, src, sizeof gambatte::uint_least32_t * 160);
src += 160;
dst += pitch;
}
}
void GB::reset(const std::uint32_t now, const unsigned div) {
void GB::reset() {
if (p_->cpu.loaded()) {
int length = p_->cpu.saveSavedataLength();
char *s;
if (length > 0)
@ -91,10 +85,10 @@ void GB::reset(const std::uint32_t now, const unsigned div) {
s = (char *) std::malloc(length);
p_->cpu.saveSavedata(s);
}
SaveState state;
p_->cpu.setStatePtrs(state);
setInitState(state, !(p_->loadflags & FORCE_DMG), p_->loadflags & GBA_CGB, now, div);
setInitState(state, !(p_->loadflags & FORCE_DMG), p_->loadflags & GBA_CGB);
p_->cpu.loadState(state);
if (length > 0)
{
@ -132,39 +126,34 @@ void GB::setScanlineCallback(void (*callback)(), int sl) {
p_->cpu.setScanlineCallback(callback, sl);
}
void GB::setRTCCallback(std::uint32_t (*callback)()) {
p_->cpu.setRTCCallback(callback);
}
void GB::setLinkCallback(void(*callback)()) {
p_->cpu.setLinkCallback(callback);
}
int GB::load(const char *romfiledata, unsigned romfilelength, const std::uint32_t now, const unsigned flags, const unsigned div) {
//if (p_->cpu.loaded())
// p_->cpu.saveSavedata();
const int failed = p_->cpu.load(romfiledata, romfilelength, flags & FORCE_DMG, flags & MULTICART_COMPAT);
if (!failed) {
void GB::setTimeMode(bool useCycles) {
p_->cpu.setTimeMode(useCycles);
}
void GB::setRtcDivisorOffset(long const rtcDivisorOffset) {
p_->cpu.setRtcDivisorOffset(rtcDivisorOffset);
}
LoadRes GB::load(char const *romfiledata, unsigned romfilelength, unsigned const flags) {
LoadRes const loadres = p_->cpu.load(romfiledata, romfilelength, flags & FORCE_DMG, flags & MULTICART_COMPAT);
if (loadres == LOADRES_OK) {
SaveState state;
p_->cpu.setStatePtrs(state);
p_->loadflags = flags;
setInitState(state, !(flags & FORCE_DMG), flags & GBA_CGB, now, div);
setInitState(state, !(flags & FORCE_DMG), flags & GBA_CGB);
p_->cpu.loadState(state);
//p_->cpu.loadSavedata();
}
return failed;
return loadres;
}
int GB::loadGBCBios(const char* biosfiledata) {
memcpy(p_->cpu.cgbBiosBuffer(), biosfiledata, 0x900);
return 0;
}
int GB::loadDMGBios(const char* biosfiledata) {
memcpy(p_->cpu.dmgBiosBuffer(), biosfiledata, 0x100);
int GB::loadBios(char const* biosfiledata, std::size_t size) {
p_->cpu.setBios(biosfiledata, size);
return 0;
}
@ -180,7 +169,7 @@ void GB::saveSavedata(char *dest) {
if (p_->cpu.loaded())
p_->cpu.saveSavedata(dest);
}
void GB::loadSavedata(const char *data) {
void GB::loadSavedata(char const *data) {
if (p_->cpu.loaded())
p_->cpu.loadSavedata(data);
}
@ -198,20 +187,20 @@ bool GB::getMemoryArea(int which, unsigned char **data, int *length) {
return false;
}
unsigned char GB::ExternalRead(unsigned short addr) {
unsigned char GB::externalRead(unsigned short addr) {
if (p_->cpu.loaded())
return p_->cpu.ExternalRead(addr);
return p_->cpu.externalRead(addr);
else
return 0;
}
void GB::ExternalWrite(unsigned short addr, unsigned char val) {
void GB::externalWrite(unsigned short addr, unsigned char val) {
if (p_->cpu.loaded())
p_->cpu.ExternalWrite(addr, val);
p_->cpu.externalWrite(addr, val);
}
void GB::setDmgPaletteColor(unsigned palNum, unsigned colorNum, unsigned rgb32) {
void GB::setDmgPaletteColor(int palNum, int colorNum, unsigned long rgb32) {
p_->cpu.setDmgPaletteColor(palNum, colorNum, rgb32);
}
@ -219,33 +208,31 @@ void GB::setCgbPalette(unsigned *lut) {
p_->cpu.setCgbPalette(lut);
}
const std::string GB::romTitle() const {
std::string const GB::romTitle() const {
if (p_->cpu.loaded()) {
char title[0x11];
std::memcpy(title, p_->cpu.romTitle(), 0x10);
title[(title[0xF] & 0x80) ? 0xF : 0x10] = '\0';
title[title[0xF] & 0x80 ? 0xF : 0x10] = '\0';
return std::string(title);
}
return std::string();
}
int GB::LinkStatus(int which) {
return p_->cpu.LinkStatus(which);
int GB::linkStatus(int which) {
return p_->cpu.linkStatus(which);
}
void GB::GetRegs(int *dest) {
p_->cpu.GetRegs(dest);
void GB::getRegs(int *dest) {
p_->cpu.getRegs(dest);
}
void GB::SetInterruptAddresses(int *addrs, int numAddrs)
{
p_->cpu.SetInterruptAddresses(addrs, numAddrs);
void GB::setInterruptAddresses(int *addrs, int numAddrs) {
p_->cpu.setInterruptAddresses(addrs, numAddrs);
}
int GB::GetHitInterruptAddress()
{
return p_->cpu.GetHitInterruptAddress();
int GB::getHitInterruptAddress() {
return p_->cpu.getHitInterruptAddress();
}
SYNCFUNC(GB)

272
libgambatte/src/initstate.cpp
View File

@ -1,32 +1,33 @@
/***************************************************************************
* Copyright (C) 2008 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2008 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "initstate.h"
#include "counterdef.h"
#include "savestate.h"
#include "sound/sound_unit.h"
#include "mem/time.h"
#include <algorithm>
#include <cstring>
namespace {
static void setInitialCgbWram(unsigned char *const wram) {
static const struct { unsigned short addr; unsigned char val; } cgbWramDumpDiff[] = {
static void setInitialCgbWram(unsigned char wram[]) {
static struct { unsigned short addr; unsigned char val; } const cgbWramDumpDiff[] = {
{ 0x0083, 0x7F }, { 0x008B, 0x10 }, { 0x00C0, 0x7F }, { 0x00E1, 0x7F },
{ 0x00E2, 0x7F }, { 0x00EA, 0x10 }, { 0x010A, 0x40 }, { 0x0179, 0x01 },
{ 0x01AF, 0x01 }, { 0x0201, 0xFB }, { 0x0254, 0xF7 }, { 0x0264, 0x7F },
@ -677,35 +678,35 @@ static void setInitialCgbWram(unsigned char *const wram) {
{ 0x7FCD, 0xBF }, { 0x7FCE, 0x7F }, { 0x7FCF, 0xFB }, { 0x7FDB, 0xF7 },
{ 0x7FDF, 0x7F }, { 0x7FE8, 0xDF }, { 0x7FEC, 0xFB }, { 0x7FF2, 0xF7 }
};
for (unsigned addr = 0x0000; addr < 0x0800; addr += 0x10) {
std::memset(wram + addr + 0x00, 0xFF, 0x08);
std::memset(wram + addr + 0x08, 0x00, 0x08);
}
for (unsigned addr = 0x0800; addr < 0x1000; addr += 0x10) {
std::memset(wram + addr + 0x00, 0x00, 0x08);
std::memset(wram + addr + 0x08, 0xFF, 0x08);
}
for (unsigned addr = 0x0E00; addr < 0x1000; addr += 0x10) {
wram[addr + 0x02] = 0xFF;
wram[addr + 0x0A] = 0x00;
}
for (unsigned addr = 0x1000; addr < 0x8000; addr += 0x1000) {
if (0x2000 != addr)
std::memcpy(wram + addr, wram, 0x1000);
}
std::memset(wram + 0x2000, 0, 0x1000);
for (std::size_t i = 0; i < sizeof(cgbWramDumpDiff) / sizeof(cgbWramDumpDiff[0]); ++i)
for (std::size_t i = 0; i < sizeof cgbWramDumpDiff / sizeof cgbWramDumpDiff[0]; ++i)
wram[cgbWramDumpDiff[i].addr] = cgbWramDumpDiff[i].val;
}
static void setInitialDmgWram(unsigned char *const wram) {
static const struct { unsigned short addr; unsigned char val; } dmgWramDumpDiff[] = {
static void setInitialDmgWram(unsigned char wram[]) {
static struct { unsigned short addr; unsigned char val; } const dmgWramDumpDiff[] = {
{ 0x0000, 0x08 }, { 0x0004, 0x08 }, { 0x0008, 0x4D }, { 0x000A, 0x80 },
{ 0x0010, 0x02 }, { 0x0018, 0x04 }, { 0x0020, 0x10 }, { 0x0028, 0x05 },
{ 0x002C, 0x08 }, { 0x0038, 0x21 }, { 0x003A, 0x40 }, { 0x0060, 0x02 },
@ -959,25 +960,25 @@ static void setInitialDmgWram(unsigned char *const wram) {
{ 0x1FA2, 0x40 }, { 0x1FB6, 0x80 }, { 0x1FC6, 0x10 }, { 0x1FCC, 0x20 },
{ 0x1FD2, 0x20 }, { 0x1FD8, 0x04 }, { 0x1FDC, 0x10 }, { 0x1FDE, 0x04 }
};
for (unsigned addr = 0x0000; addr < 0x0800; addr += 0x200) {
std::memset(wram + addr , 0x00, 0x100);
std::memset(wram + addr + 0x100, 0xFF, 0x100);
}
for (unsigned addr = 0x0800; addr < 0x1000; addr += 0x200) {
std::memset(wram + addr , 0xFF, 0x100);
std::memset(wram + addr + 0x100, 0x00, 0x100);
}
std::memcpy(wram + 0x1000, wram, 0x1000);
for (std::size_t i = 0; i < sizeof(dmgWramDumpDiff) / sizeof(dmgWramDumpDiff[0]); ++i)
for (std::size_t i = 0; i < sizeof dmgWramDumpDiff / sizeof dmgWramDumpDiff[0]; ++i)
wram[dmgWramDumpDiff[i].addr] = dmgWramDumpDiff[i].val;
}
static void setInitialVram(unsigned char *const vram, const bool cgb) {
static const unsigned char even_numbered_8010_to_81a0_dump[] = {
static void setInitialVram(unsigned char vram[], bool const cgb) {
static unsigned char const even_numbered_8010_to_81a0_dump[] = {
0xF0, 0xF0, 0xFC, 0xFC, 0xFC, 0xFC, 0xF3, 0xF3,
0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C,
0xF0, 0xF0, 0xF0, 0xF0, 0x00, 0x00, 0xF3, 0xF3,
@ -1004,28 +1005,28 @@ static void setInitialVram(unsigned char *const vram, const bool cgb) {
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0xFC, 0xFC,
0x3C, 0x42, 0xB9, 0xA5, 0xB9, 0xA5, 0x42, 0x3C
};
std::memset(vram, 0, 0x4000);
for (std::size_t i = 0; i < sizeof(even_numbered_8010_to_81a0_dump) / sizeof(even_numbered_8010_to_81a0_dump[0]); ++i) {
for (std::size_t i = 0; i < sizeof even_numbered_8010_to_81a0_dump; ++i) {
vram[0x0010 + i * 2] = even_numbered_8010_to_81a0_dump[i];
}
if (!cgb) {
unsigned i = 1;
for (unsigned addr = 0x1904; addr < 0x1910; ++addr)
vram[addr] = i++;
vram[0x1910] = 0x19;
for (unsigned addr = 0x1924; addr < 0x1930; ++addr)
vram[addr] = i++;
}
}
static void setInitialCgbIoamhram(unsigned char *const ioamhram) {
static const unsigned char feaxDump[0x60] = {
static void setInitialCgbIoamhram(unsigned char ioamhram[]) {
static unsigned char const feaxDump[0x60] = {
0x08, 0x01, 0xEF, 0xDE, 0x06, 0x4A, 0xCD, 0xBD,
0x08, 0x01, 0xEF, 0xDE, 0x06, 0x4A, 0xCD, 0xBD,
0x08, 0x01, 0xEF, 0xDE, 0x06, 0x4A, 0xCD, 0xBD,
@ -1039,8 +1040,8 @@ static void setInitialCgbIoamhram(unsigned char *const ioamhram) {
0x24, 0x13, 0xFD, 0x3A, 0x10, 0x10, 0xAD, 0x45,
0x24, 0x13, 0xFD, 0x3A, 0x10, 0x10, 0xAD, 0x45
};
static const unsigned char ffxxDump[0x100] = {
static unsigned char const ffxxDump[0x100] = {
0xCF, 0x00, 0x7C, 0xFF, 0x00, 0x00, 0x00, 0xF8,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE1,
0x80, 0x3F, 0x00, 0xFF, 0xBF, 0xFF, 0x3F, 0x00,
@ -1074,14 +1075,14 @@ static void setInitialCgbIoamhram(unsigned char *const ioamhram) {
0x98, 0xD1, 0x71, 0x02, 0x4D, 0x01, 0xC1, 0xFF,
0x0D, 0x00, 0xD3, 0x05, 0xF9, 0x00, 0x0B, 0x00
};
std::memset(ioamhram, 0x00, 0x0A0);
std::memcpy(ioamhram + 0x0A0, feaxDump, sizeof(feaxDump));
std::memcpy(ioamhram + 0x100, ffxxDump, sizeof(ffxxDump));
std::memcpy(ioamhram + 0x0A0, feaxDump, sizeof feaxDump);
std::memcpy(ioamhram + 0x100, ffxxDump, sizeof ffxxDump);
}
static void setInitialDmgIoamhram(unsigned char *const ioamhram) {
static const unsigned char oamDump[0xA0] = {
static void setInitialDmgIoamhram(unsigned char ioamhram[]) {
static unsigned char const oamDump[0xA0] = {
0xBB, 0xD8, 0xC4, 0x04, 0xCD, 0xAC, 0xA1, 0xC7,
0x7D, 0x85, 0x15, 0xF0, 0xAD, 0x19, 0x11, 0x6A,
0xBA, 0xC7, 0x76, 0xF8, 0x5C, 0xA0, 0x67, 0x0A,
@ -1103,13 +1104,13 @@ static void setInitialDmgIoamhram(unsigned char *const ioamhram) {
0x24, 0x40, 0x42, 0x05, 0x0E, 0x04, 0x20, 0xA6,
0x5E, 0xC1, 0x97, 0x7E, 0x44, 0x05, 0x01, 0xA9
};
static const unsigned char ffxxDump[0x100] = {
static unsigned char const ffxxDump[0x100] = {
0xCF, 0x00, 0x7E, 0xFF, 0xD3, 0x00, 0x00, 0xF8,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE1,
0x80, 0xBF, 0xF3, 0xFF, 0xBF, 0xFF, 0x3F, 0x00,
0x80, 0x3F, 0x00, 0xFF, 0xBF, 0xFF, 0x3F, 0x00,
0xFF, 0xBF, 0x7F, 0xFF, 0x9F, 0xFF, 0xBF, 0xFF,
0xFF, 0x00, 0x00, 0xBF, 0x77, 0xF3, 0xF1, 0xFF,
0xFF, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x70, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x71, 0x72, 0xD5, 0x91, 0x58, 0xBB, 0x2A, 0xFA,
0xCF, 0x3C, 0x54, 0x75, 0x48, 0xCF, 0x8F, 0xD9,
@ -1138,52 +1139,52 @@ static void setInitialDmgIoamhram(unsigned char *const ioamhram) {
0xBC, 0x7F, 0x7E, 0xD0, 0xC7, 0xC3, 0xBD, 0xCF,
0x59, 0xEA, 0x39, 0x01, 0x2E, 0x00, 0x69, 0x00
};
std::memcpy(ioamhram , oamDump, sizeof(oamDump));
std::memcpy(ioamhram , oamDump, sizeof oamDump);
std::memset(ioamhram + 0x0A0, 0x00, 0x060);
std::memcpy(ioamhram + 0x100, ffxxDump, sizeof(ffxxDump));
std::memcpy(ioamhram + 0x100, ffxxDump, sizeof ffxxDump);
}
} // anon namespace
void gambatte::setInitState(SaveState &state, const bool cgb, const bool gbaCgbMode, const std::uint32_t now, const unsigned div) {
static const unsigned char cgbObjpDump[0x40] = {
0x00, 0x00, 0xF2, 0xAB,
0x61, 0xC2, 0xD9, 0xBA,
0x88, 0x6E, 0xDD, 0x63,
0x28, 0x27, 0xFB, 0x9F,
0x35, 0x42, 0xD6, 0xD4,
0x50, 0x48, 0x57, 0x5E,
0x23, 0x3E, 0x3D, 0xCA,
0x71, 0x21, 0x37, 0xC0,
0xC6, 0xB3, 0xFB, 0xF9,
0x08, 0x00, 0x8D, 0x29,
0xA3, 0x20, 0xDB, 0x87,
0x62, 0x05, 0x5D, 0xD4,
0x0E, 0x08, 0xFE, 0xAF,
0x20, 0x02, 0xD7, 0xFF,
0x07, 0x6A, 0x55, 0xEC,
void gambatte::setInitState(SaveState &state, const bool cgb, const bool gbaCgbMode) {
static unsigned char const cgbObjpDump[0x40] = {
0x00, 0x00, 0xF2, 0xAB,
0x61, 0xC2, 0xD9, 0xBA,
0x88, 0x6E, 0xDD, 0x63,
0x28, 0x27, 0xFB, 0x9F,
0x35, 0x42, 0xD6, 0xD4,
0x50, 0x48, 0x57, 0x5E,
0x23, 0x3E, 0x3D, 0xCA,
0x71, 0x21, 0x37, 0xC0,
0xC6, 0xB3, 0xFB, 0xF9,
0x08, 0x00, 0x8D, 0x29,
0xA3, 0x20, 0xDB, 0x87,
0x62, 0x05, 0x5D, 0xD4,
0x0E, 0x08, 0xFE, 0xAF,
0x20, 0x02, 0xD7, 0xFF,
0x07, 0x6A, 0x55, 0xEC,
0x83, 0x40, 0x0B, 0x77
};
state.cpu.cycleCounter = 8;
state.cpu.PC = 0;
state.cpu.SP = 0;
state.cpu.A = 0;
state.cpu.B = 0;
state.cpu.C = 0;
state.cpu.D = 0;
state.cpu.E = 0;
state.cpu.F = 0;
state.cpu.H = 0;
state.cpu.L = 0;
state.cpu.pc = 0;
state.cpu.sp = 0;
state.cpu.a = 0;
state.cpu.b = 0;
state.cpu.c = 0;
state.cpu.d = 0;
state.cpu.e = 0;
state.cpu.f = 0;
state.cpu.h = 0;
state.cpu.l = 0;
state.cpu.skip = false;
state.mem.biosMode = true;
state.mem.cgbSwitching = false;
state.mem.agbMode = gbaCgbMode;
std::memset(state.mem.sram.ptr, 0xFF, state.mem.sram.getSz());
std::memset(state.mem.sram.ptr, 0xFF, state.mem.sram.size());
setInitialVram(state.mem.vram.ptr, cgb);
if (cgb) {
@ -1193,18 +1194,20 @@ void gambatte::setInitState(SaveState &state, const bool cgb, const bool gbaCgbM
setInitialDmgWram(state.mem.wram.ptr);
setInitialDmgIoamhram(state.mem.ioamhram.ptr);
}
state.mem.ioamhram.ptr[0x104] = 0;
state.mem.ioamhram.ptr[0x140] = 0;
state.mem.ioamhram.ptr[0x144] = 0x00;
state.mem.divLastUpdate = 0 - div;
state.mem.divLastUpdate = 0;
state.mem.timaBasetime = 0;
state.mem.timaLastUpdate = 0;
state.mem.tmatime = DISABLED_TIME;
state.mem.nextSerialtime = DISABLED_TIME;
state.mem.lastOamDmaUpdate = DISABLED_TIME;
state.mem.unhaltTime = DISABLED_TIME;
state.mem.tmatime = disabled_time;
state.mem.nextSerialtime = disabled_time;
state.mem.lastOamDmaUpdate = disabled_time;
state.mem.unhaltTime = disabled_time;
state.mem.minIntTime = 0;
state.mem.halttime = 0;
state.mem.rombank = 1;
state.mem.dmaSource = 0;
state.mem.dmaDestination = 0;
@ -1216,28 +1219,29 @@ void gambatte::setInitState(SaveState &state, const bool cgb, const bool gbaCgbM
state.mem.rambankMode = false;
state.mem.hdmaTransfer = false;
state.mem.gbIsCgb = cgb;
state.mem.stopped = false;
for (unsigned i = 0x00; i < 0x40; i += 0x02) {
for (int i = 0x00; i < 0x40; i += 0x02) {
state.ppu.bgpData.ptr[i ] = 0xFF;
state.ppu.bgpData.ptr[i + 1] = 0x7F;
}
std::memcpy(state.ppu.objpData.ptr, cgbObjpDump, sizeof(cgbObjpDump));
std::memcpy(state.ppu.objpData.ptr, cgbObjpDump, sizeof cgbObjpDump);
if (!cgb) {
state.ppu.bgpData.ptr[0] = state.mem.ioamhram.get()[0x147];
state.ppu.objpData.ptr[0] = state.mem.ioamhram.get()[0x148];
state.ppu.objpData.ptr[1] = state.mem.ioamhram.get()[0x149];
}
for (unsigned pos = 0; pos < 80; ++pos)
for (int pos = 0; pos < 80; ++pos)
state.ppu.oamReaderBuf.ptr[pos] = state.mem.ioamhram.ptr[(pos * 2 & ~3) | (pos & 1)];
std::fill_n(state.ppu.oamReaderSzbuf.ptr, 40, false);
std::memset(state.ppu.spAttribList, 0, sizeof(state.ppu.spAttribList));
std::memset(state.ppu.spByte0List, 0, sizeof(state.ppu.spByte0List));
std::memset(state.ppu.spByte1List, 0, sizeof(state.ppu.spByte1List));
std::memset(state.ppu.spAttribList, 0, sizeof state.ppu.spAttribList);
std::memset(state.ppu.spByte0List, 0, sizeof state.ppu.spByte0List);
std::memset(state.ppu.spByte1List, 0, sizeof state.ppu.spByte1List);
state.ppu.videoCycles = 0;
state.ppu.enableDisplayM0Time = state.cpu.cycleCounter;
state.ppu.winYPos = 0xFF;
@ -1263,57 +1267,61 @@ void gambatte::setInitState(SaveState &state, const bool cgb, const bool gbaCgbM
state.ppu.pendingLcdstatIrq = false;
state.ppu.isCgb = cgb;
state.spu.cycleCounter = 0; // spu.cycleCounter >> 12 & 7 represents the frame sequencer position.
state.spu.ch1.sweep.counter = SoundUnit::COUNTER_DISABLED;
// spu.cycleCounter >> 12 & 7 represents the frame sequencer position.
state.spu.cycleCounter = state.cpu.cycleCounter >> 1;
state.spu.ch1.sweep.counter = SoundUnit::counter_disabled;
state.spu.ch1.sweep.shadow = 0;
state.spu.ch1.sweep.nr0 = 0;
state.spu.ch1.sweep.negging = false;
state.spu.ch1.duty.nextPosUpdate = (state.spu.cycleCounter & ~1ul) + 37 * 2;
state.spu.ch1.duty.nr3 = 0;
state.spu.ch1.duty.nextPosUpdate = SoundUnit::counter_disabled;
state.spu.ch1.duty.pos = 0;
state.spu.ch1.env.counter = SoundUnit::COUNTER_DISABLED;
state.spu.ch1.duty.high = false;
state.spu.ch1.duty.nr3 = 0;
state.spu.ch1.env.counter = SoundUnit::counter_disabled;
state.spu.ch1.env.volume = 0;
state.spu.ch1.lcounter.counter = SoundUnit::COUNTER_DISABLED;
state.spu.ch1.lcounter.counter = SoundUnit::counter_disabled;
state.spu.ch1.lcounter.lengthCounter = 0;
state.spu.ch1.nr4 = 0;
state.spu.ch1.master = false;
state.spu.ch2.duty.nextPosUpdate = SoundUnit::COUNTER_DISABLED;
state.spu.ch2.duty.nextPosUpdate = SoundUnit::counter_disabled;
state.spu.ch2.duty.nr3 = 0;
state.spu.ch2.duty.pos = 0;
state.spu.ch2.env.counter = SoundUnit::COUNTER_DISABLED;
state.spu.ch2.duty.high = false;
state.spu.ch2.env.counter = SoundUnit::counter_disabled;
state.spu.ch2.env.volume = 0;
state.spu.ch2.lcounter.counter = SoundUnit::COUNTER_DISABLED;
state.spu.ch2.lcounter.counter = SoundUnit::counter_disabled;
state.spu.ch2.lcounter.lengthCounter = 0;
state.spu.ch2.nr4 = 0;
state.spu.ch2.master = false;
for (unsigned i = 0; i < 0x10; ++i)
state.spu.ch3.waveRam.ptr[i] = state.mem.ioamhram.get()[0x130 + i];
state.spu.ch3.lcounter.counter = SoundUnit::COUNTER_DISABLED;
std::memcpy(state.spu.ch3.waveRam.ptr, state.mem.ioamhram.get() + 0x130, 0x10);
state.spu.ch3.lcounter.counter = SoundUnit::counter_disabled;
state.spu.ch3.lcounter.lengthCounter = 0x100;
state.spu.ch3.waveCounter = SoundUnit::COUNTER_DISABLED;
state.spu.ch3.lastReadTime = SoundUnit::COUNTER_DISABLED;
state.spu.ch3.waveCounter = SoundUnit::counter_disabled;
state.spu.ch3.lastReadTime = SoundUnit::counter_disabled;
state.spu.ch3.nr3 = 0;
state.spu.ch3.nr4 = 0;
state.spu.ch3.wavePos = 0;
state.spu.ch3.sampleBuf = 0;
state.spu.ch3.master = false;
state.spu.ch4.lfsr.counter = state.spu.cycleCounter + 4;
state.spu.ch4.lfsr.reg = 0xFF;
state.spu.ch4.env.counter = SoundUnit::COUNTER_DISABLED;
state.spu.ch4.env.counter = SoundUnit::counter_disabled;
state.spu.ch4.env.volume = 0;
state.spu.ch4.lcounter.counter = SoundUnit::COUNTER_DISABLED;
state.spu.ch4.lcounter.counter = SoundUnit::counter_disabled;
state.spu.ch4.lcounter.lengthCounter = 0;
state.spu.ch4.nr4 = 0;
state.spu.ch4.master = false;
state.rtc.baseTime = now;
state.rtc.haltTime = state.rtc.baseTime;
state.time.seconds = 0;
state.time.lastTimeSec = Time::now().tv_sec;
state.time.lastTimeUsec = Time::now().tv_usec;
state.time.lastCycles = state.cpu.cycleCounter;
state.rtc.haltTime = state.time.seconds;
state.rtc.dataDh = 0;
state.rtc.dataDl = 0;
state.rtc.dataH = 0;

39
libgambatte/src/initstate.h
View File

@ -1,28 +1,29 @@
/***************************************************************************
* Copyright (C) 2008 by Sindre Aams *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2008 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef INITSTATE_H
#define INITSTATE_H
#include <cstdint>
namespace gambatte {
void setInitState(struct SaveState &state, bool cgb, bool gbaCgbMode, std::uint32_t now, unsigned div);
void setInitState(struct SaveState &state, bool cgb, bool gbaCgbMode);
}
#endif

48
libgambatte/src/insertion_sort.h
View File

@ -1,21 +1,20 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef INSERTION_SORT_H
#define INSERTION_SORT_H
@ -26,25 +25,24 @@ template<typename T, class Less>
void insertionSort(T *const start, T *const end, Less less) {
if (start >= end)
return;
T *a = start;
while (++a < end) {
const T e = *a;
T const e = *a;
T *b = a;
while (b != start && less(e, *(b - 1))) {
*b = *(b - 1);
b = b - 1;
}
*b = e;
}
}
template<typename T>
inline void insertionSort(T *const start, T *const end) {
inline void insertionSort(T *start, T *end) {
insertionSort(start, end, std::less<T>());
}

42
libgambatte/src/interrupter.cpp
View File

@ -1,42 +0,0 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "interrupter.h"
#include "memory.h"
namespace gambatte {
Interrupter::Interrupter(unsigned short &SP_in, unsigned short &PC_in) :
SP(SP_in),
PC(PC_in)
{}
unsigned long Interrupter::interrupt(const unsigned address, unsigned long cycleCounter, Memory &memory) {
cycleCounter += 8;
SP = (SP - 1) & 0xFFFF;
memory.write(SP, PC >> 8, cycleCounter);
cycleCounter += 4;
SP = (SP - 1) & 0xFFFF;
memory.write(SP, PC & 0xFF, cycleCounter);
PC = address;
cycleCounter += 8;
return cycleCounter;
}
}

37
libgambatte/src/interrupter.h
View File

@ -1,37 +0,0 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef INTERRUPTER_H
#define INTERRUPTER_H
#include <string>
#include <vector>
namespace gambatte {
class Interrupter {
unsigned short &SP;
unsigned short &PC;
public:
Interrupter(unsigned short &SP, unsigned short &PC);
unsigned long interrupt(const unsigned address, unsigned long cycleCounter, class Memory &memory);
};
}
#endif

136
libgambatte/src/interruptrequester.cpp
View File

@ -1,106 +1,120 @@
/***************************************************************************
* Copyright (C) 2010 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2010 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "interruptrequester.h"
#include "savestate.h"
namespace gambatte {
InterruptRequester::InterruptRequester() : minIntTime(0), ifreg_(0), iereg_(0) {}
InterruptRequester::InterruptRequester()
: eventTimes_(disabled_time)
, minIntTime_(0)
, ifreg_(0)
, iereg_(0)
{
}
void InterruptRequester::loadState(const SaveState &state) {
minIntTime = state.mem.minIntTime;
void InterruptRequester::loadState(SaveState const &state) {
minIntTime_ = state.mem.minIntTime;
ifreg_ = state.mem.ioamhram.get()[0x10F];
iereg_ = state.mem.ioamhram.get()[0x1FF] & 0x1F;
intFlags.set(state.mem.IME, state.mem.halted);
eventTimes.setValue<INTERRUPTS>(intFlags.imeOrHalted() && pendingIrqs() ? minIntTime : static_cast<unsigned long>(DISABLED_TIME));
intFlags_.set(state.mem.IME, state.mem.halted);
eventTimes_.setValue<intevent_interrupts>(intFlags_.imeOrHalted() && pendingIrqs()
? minIntTime_
: static_cast<unsigned long>(disabled_time));
}
void InterruptRequester::resetCc(const unsigned long oldCc, const unsigned long newCc) {
minIntTime = minIntTime < oldCc ? 0 : minIntTime - (oldCc - newCc);
if (eventTimes.value(INTERRUPTS) != DISABLED_TIME)
eventTimes.setValue<INTERRUPTS>(minIntTime);
void InterruptRequester::resetCc(unsigned long oldCc, unsigned long newCc) {
minIntTime_ = minIntTime_ < oldCc ? 0 : minIntTime_ - (oldCc - newCc);
if (eventTimes_.value(intevent_interrupts) != disabled_time)
eventTimes_.setValue<intevent_interrupts>(minIntTime_);
}
void InterruptRequester::ei(const unsigned long cc) {
intFlags.setIme();
minIntTime = cc + 1;
void InterruptRequester::ei(unsigned long cc) {
intFlags_.setIme();
minIntTime_ = cc + 1;
if (pendingIrqs())
eventTimes.setValue<INTERRUPTS>(minIntTime);
eventTimes_.setValue<intevent_interrupts>(minIntTime_);
}
void InterruptRequester::di() {
intFlags.unsetIme();
if (!intFlags.imeOrHalted())
eventTimes.setValue<INTERRUPTS>(DISABLED_TIME);
intFlags_.unsetIme();
if (!intFlags_.imeOrHalted())
eventTimes_.setValue<intevent_interrupts>(disabled_time);
}
void InterruptRequester::halt() {
intFlags.setHalted();
intFlags_.setHalted();
if (pendingIrqs())
eventTimes.setValue<INTERRUPTS>(minIntTime);
eventTimes_.setValue<intevent_interrupts>(minIntTime_);
}
void InterruptRequester::unhalt() {
intFlags.unsetHalted();
if (!intFlags.imeOrHalted())
eventTimes.setValue<INTERRUPTS>(DISABLED_TIME);
intFlags_.unsetHalted();
if (!intFlags_.imeOrHalted())
eventTimes_.setValue<intevent_interrupts>(disabled_time);
}
void InterruptRequester::flagIrq(const unsigned bit) {
void InterruptRequester::flagIrq(unsigned bit) {
ifreg_ |= bit;
if (intFlags.imeOrHalted() && pendingIrqs())
eventTimes.setValue<INTERRUPTS>(minIntTime);
if (intFlags_.imeOrHalted() && pendingIrqs())
eventTimes_.setValue<intevent_interrupts>(minIntTime_);
}
void InterruptRequester::ackIrq(const unsigned bit) {
void InterruptRequester::ackIrq(unsigned bit) {
ifreg_ ^= bit;
di();
}
void InterruptRequester::setIereg(const unsigned iereg) {
void InterruptRequester::setIereg(unsigned iereg) {
iereg_ = iereg & 0x1F;
if (intFlags.imeOrHalted())
eventTimes.setValue<INTERRUPTS>(pendingIrqs() ? minIntTime : static_cast<unsigned long>(DISABLED_TIME));
if (intFlags_.imeOrHalted()) {
eventTimes_.setValue<intevent_interrupts>(pendingIrqs()
? minIntTime_
: static_cast<unsigned long>(disabled_time));
}
}
void InterruptRequester::setIfreg(const unsigned ifreg) {
void InterruptRequester::setIfreg(unsigned ifreg) {
ifreg_ = ifreg;
if (intFlags.imeOrHalted())
eventTimes.setValue<INTERRUPTS>(pendingIrqs() ? minIntTime : static_cast<unsigned long>(DISABLED_TIME));
if (intFlags_.imeOrHalted()) {
eventTimes_.setValue<intevent_interrupts>(pendingIrqs()
? minIntTime_
: static_cast<unsigned long>(disabled_time));
}
}
SYNCFUNC(InterruptRequester)
{
SSS(eventTimes);
NSS(minIntTime);
SSS(eventTimes_);
NSS(minIntTime_);
NSS(ifreg_);
NSS(iereg_);
NSS(intFlags.flags_);
NSS(intFlags_.flags_);
}
}

133
libgambatte/src/interruptrequester.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2010 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2010 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef INTERRUPT_REQUESTER_H
#define INTERRUPT_REQUESTER_H
@ -24,49 +24,29 @@
#include "newstate.h"
namespace gambatte {
struct SaveState;
enum MemEventId { UNHALT, END, BLIT, SERIAL, OAM, DMA, TIMA, VIDEO, INTERRUPTS };
enum IntEventId { intevent_unhalt,
intevent_end,
intevent_blit,
intevent_serial,
intevent_oam,
intevent_dma,
intevent_tima,
intevent_video,
intevent_interrupts, intevent_last = intevent_interrupts };
class InterruptRequester {
MinKeeper<INTERRUPTS + 1> eventTimes;
unsigned long minIntTime;
unsigned ifreg_;
unsigned iereg_;
class IntFlags {
friend class InterruptRequester;
unsigned char flags_;
enum { IME_MASK = 1, HALTED_MASK = 2 };
public:
IntFlags() : flags_(0) {}
bool ime() const { return flags_ & IME_MASK; }
bool halted() const { return flags_ & HALTED_MASK; }
bool imeOrHalted() const { return flags_; }
void setIme() { flags_ |= IME_MASK; }
void unsetIme() { flags_ &= ~IME_MASK; }
void setHalted() { flags_ |= HALTED_MASK; }
void unsetHalted() { flags_ &= ~HALTED_MASK; }
void set(const bool ime, const bool halted) { flags_ = halted * HALTED_MASK + ime * IME_MASK; }
} intFlags;
public:
InterruptRequester();
void loadState(const SaveState &);
void loadState(SaveState const &);
void resetCc(unsigned long oldCc, unsigned long newCc);
unsigned ifreg() const { return ifreg_; }
unsigned iereg() const { return iereg_; }
unsigned pendingIrqs() const { return ifreg_ & iereg_; }
bool ime() const { return intFlags.ime(); }
bool halted() const { return intFlags.halted(); }
bool ime() const { return intFlags_.ime(); }
bool halted() const { return intFlags_.halted(); }
void ei(unsigned long cc);
void di();
void halt();
@ -75,21 +55,48 @@ public:
void ackIrq(unsigned bit);
void setIereg(unsigned iereg);
void setIfreg(unsigned ifreg);
MemEventId minEventId() const { return static_cast<MemEventId>(eventTimes.min()); }
unsigned long minEventTime() const { return eventTimes.minValue(); }
template<MemEventId id> void setEventTime(unsigned long value) { eventTimes.setValue<id>(value); }
void setEventTime(const MemEventId id, unsigned long value) { eventTimes.setValue(id, value); }
unsigned long eventTime(MemEventId id) const { return eventTimes.value(id); }
IntEventId minEventId() const { return static_cast<IntEventId>(eventTimes_.min()); }
unsigned long minEventTime() const { return eventTimes_.minValue(); }
template<IntEventId id> void setEventTime(unsigned long value) { eventTimes_.setValue<id>(value); }
void setEventTime(IntEventId id, unsigned long value) { eventTimes_.setValue(id, value); }
unsigned long eventTime(IntEventId id) const { return eventTimes_.value(id); }
private:
class IntFlags {
friend class InterruptRequester;
public:
IntFlags() : flags_(0) {}
bool ime() const { return flags_ & flag_ime; }
bool halted() const { return flags_ & flag_halted; }
bool imeOrHalted() const { return flags_; }
void setIme() { flags_ |= flag_ime; }
void unsetIme() { flags_ &= ~flag_ime; }
void setHalted() { flags_ |= flag_halted; }
void unsetHalted() { flags_ &= ~flag_halted; }
void set(bool ime, bool halted) { flags_ = halted * flag_halted + ime * flag_ime; }
private:
unsigned char flags_;
enum { flag_ime = 1, flag_halted = 2 };
};
MinKeeper<intevent_last + 1> eventTimes_;
unsigned long minIntTime_;
unsigned ifreg_;
unsigned iereg_;
IntFlags intFlags_;
public:
template<bool isReader>void SyncState(NewState *ns);
};
inline void flagHdmaReq(InterruptRequester *const intreq) { intreq->setEventTime<DMA>(0); }
inline void flagGdmaReq(InterruptRequester *const intreq) { intreq->setEventTime<DMA>(1); }
inline void ackDmaReq(InterruptRequester *const intreq) { intreq->setEventTime<DMA>(DISABLED_TIME); }
inline bool hdmaReqFlagged(const InterruptRequester &intreq) { return intreq.eventTime(DMA) == 0; }
inline bool gdmaReqFlagged(const InterruptRequester &intreq) { return intreq.eventTime(DMA) == 1; }
inline void flagHdmaReq(InterruptRequester &intreq) { intreq.setEventTime<intevent_dma>(0); }
inline void flagGdmaReq(InterruptRequester &intreq) { intreq.setEventTime<intevent_dma>(1); }
inline void ackDmaReq(InterruptRequester &intreq) { intreq.setEventTime<intevent_dma>(disabled_time); }
inline bool hdmaReqFlagged(InterruptRequester const &intreq) { return intreq.eventTime(intevent_dma) == 0; }
inline bool gdmaReqFlagged(InterruptRequester const &intreq) { return intreq.eventTime(intevent_dma) == 1; }
}

801
libgambatte/src/mem/cartridge.cpp
View File

File diff suppressed because it is too large Load Diff

131
libgambatte/src/mem/cartridge.h
View File

@ -1,25 +1,27 @@
/***************************************************************************
* Copyright (C) 2007-2010 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007-2010 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef CARTRIDGE_H
#define CARTRIDGE_H
#include "loadres.h"
#include "memptrs.h"
#include "time.h"
#include "rtc.h"
#include "savestate.h"
#include <memory>
@ -29,26 +31,12 @@
namespace gambatte {
//DOOM
//enum eAddressMappingType
//{
// eAddressMappingType_ROM,
// eAddressMappingType_RAM
//};
//
//struct AddressMapping
//{
// int32_t address;
// eAddressMappingType type;
//};
class Mbc {
public:
virtual ~Mbc() {}
virtual void romWrite(unsigned P, unsigned data) = 0;
virtual void loadState(const SaveState::Mem &ss) = 0;
virtual void romWrite(unsigned P, unsigned data, unsigned long cycleCounter) = 0;
virtual void loadState(SaveState::Mem const &ss) = 0;
virtual bool isAddressWithinAreaRombankCanBeMappedTo(unsigned address, unsigned rombank) const = 0;
//virtual void mapAddress(AddressMapping* mapping, unsigned address) const = 0; //DOOM
template<bool isReader>void SyncState(NewState *ns)
{
@ -59,52 +47,47 @@ public:
};
class Cartridge {
MemPtrs memptrs;
Rtc rtc;
std::auto_ptr<Mbc> mbc;
public:
Cartridge();
void setStatePtrs(SaveState &);
void loadState(const SaveState &);
bool loaded() const { return mbc.get(); }
const unsigned char * rmem(unsigned area) const { return memptrs.rmem(area); }
unsigned char * wmem(unsigned area) const { return memptrs.wmem(area); }
unsigned char * vramdata() const { return memptrs.vramdata(); }
unsigned char * romdata(unsigned area) const { return memptrs.romdata(area); }
unsigned char * wramdata(unsigned area) const { return memptrs.wramdata(area); }
const unsigned char * rdisabledRam() const { return memptrs.rdisabledRam(); }
const unsigned char * rsrambankptr() const { return memptrs.rsrambankptr(); }
unsigned char * wsrambankptr() const { return memptrs.wsrambankptr(); }
unsigned char * vrambankptr() const { return memptrs.vrambankptr(); }
OamDmaSrc oamDmaSrc() const { return memptrs.oamDmaSrc(); }
unsigned curRomBank() const { return memptrs.curRomBank(); }
void setVrambank(unsigned bank) { memptrs.setVrambank(bank); }
void setWrambank(unsigned bank) { memptrs.setWrambank(bank); }
void setOamDmaSrc(OamDmaSrc oamDmaSrc) { memptrs.setOamDmaSrc(oamDmaSrc); }
void mbcWrite(unsigned addr, unsigned data) { mbc->romWrite(addr, data); }
bool isCgb() const { return gambatte::isCgb(memptrs); }
void rtcWrite(unsigned data) { rtc.write(data); }
unsigned char rtcRead() const { return *rtc.getActive(); }
void loadSavedata(const char *data);
void loadState(SaveState const &);
bool loaded() const { return mbc_.get(); }
unsigned char const * rmem(unsigned area) const { return memptrs_.rmem(area); }
unsigned char * wmem(unsigned area) const { return memptrs_.wmem(area); }
unsigned char * vramdata() const { return memptrs_.vramdata(); }
unsigned char * romdata(unsigned area) const { return memptrs_.romdata(area); }
unsigned char * wramdata(unsigned area) const { return memptrs_.wramdata(area); }
unsigned char const * rdisabledRam() const { return memptrs_.rdisabledRam(); }
unsigned char const * rsrambankptr() const { return memptrs_.rsrambankptr(); }
unsigned char * wsrambankptr() const { return memptrs_.wsrambankptr(); }
unsigned char * vrambankptr() const { return memptrs_.vrambankptr(); }
OamDmaSrc oamDmaSrc() const { return memptrs_.oamDmaSrc(); }
void setVrambank(unsigned bank) { memptrs_.setVrambank(bank); }
void setWrambank(unsigned bank) { memptrs_.setWrambank(bank); }
void setOamDmaSrc(OamDmaSrc oamDmaSrc) { memptrs_.setOamDmaSrc(oamDmaSrc); }
unsigned curRomBank() const { return memptrs_.curRomBank(); }
void mbcWrite(unsigned addr, unsigned data, unsigned long const cc) { mbc_->romWrite(addr, data, cc); }
bool isCgb() const { return gambatte::isCgb(memptrs_); }
void resetCc(unsigned long const oldCc, unsigned long const newCc) { time_.resetCc(oldCc, newCc); }
void speedChange(unsigned long const cc) { time_.speedChange(cc); }
void setTimeMode(bool useCycles, unsigned long const cc) { time_.setTimeMode(useCycles, cc); }
void setRtcDivisorOffset(long const rtcDivisorOffset) { time_.setRtcDivisorOffset(rtcDivisorOffset); }
void rtcWrite(unsigned data, unsigned long const cc) { rtc_.write(data, cc); }
unsigned char rtcRead() const { return *rtc_.activeData(); }
void loadSavedata(char const *data, unsigned long cycleCounter);
int saveSavedataLength();
void saveSavedata(char *dest);
void saveSavedata(char *dest, unsigned long cycleCounter);
bool getMemoryArea(int which, unsigned char **data, int *length) const;
LoadRes loadROM(char const *romfiledata, unsigned romfilelength, bool forceDmg, bool multicartCompat);
char const * romTitle() const { return reinterpret_cast<char const *>(memptrs_.romdata() + 0x134); }
int loadROM(const char *romfiledata, unsigned romfilelength, bool forceDmg, bool multicartCompat);
const char * romTitle() const { return reinterpret_cast<const char *>(memptrs.romdata() + 0x134); }
void setRTCCallback(std::uint32_t (*callback)()) {
rtc.setRTCCallback(callback);
}
private:
MemPtrs memptrs_;
Time time_;
Rtc rtc_;
std::unique_ptr<Mbc> mbc_;
public:
template<bool isReader>void SyncState(NewState *ns);
};

140
libgambatte/src/mem/memptrs.cpp
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007-2010 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007-2010 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "memptrs.h"
#include <algorithm>
#include <cstring>
@ -23,10 +23,19 @@
namespace gambatte {
MemPtrs::MemPtrs()
: rmem_(), wmem_(), romdata_(), wramdata_(), vrambankptr_(0), rsrambankptr_(0),
wsrambankptr_(0), memchunk_(0), rambankdata_(0), wramdataend_(0), oamDmaSrc_(OAM_DMA_SRC_OFF),
curRomBank_(1),
memchunk_len(0)
: rmem_()
, wmem_()
, romdata_()
, wramdata_()
, vrambankptr_(0)
, rsrambankptr_(0)
, wsrambankptr_(0)
, memchunk_(0)
, rambankdata_(0)
, wramdataend_(0)
, oamDmaSrc_(oam_dma_src_off)
, curRomBank_(1)
, memchunk_len(0)
{
}
@ -34,9 +43,15 @@ MemPtrs::~MemPtrs() {
delete []memchunk_;
}
void MemPtrs::reset(const unsigned rombanks, const unsigned rambanks, const unsigned wrambanks) {
void MemPtrs::reset(unsigned const rombanks, unsigned const rambanks, unsigned const wrambanks) {
delete []memchunk_;
memchunk_len = 0x4000 + rombanks * 0x4000ul + 0x4000 + rambanks * 0x2000ul + wrambanks * 0x1000ul + 0x4000;
memchunk_len =
0x4000
+ rombanks * 0x4000ul
+ 0x4000
+ rambanks * 0x2000ul
+ wrambanks * 0x1000ul
+ 0x4000;
memchunk_ = new unsigned char[memchunk_len];
romdata_[0] = romdata();
@ -45,8 +60,8 @@ void MemPtrs::reset(const unsigned rombanks, const unsigned rambanks, const unsi
wramdataend_ = wramdata_[0] + wrambanks * 0x1000ul;
std::memset(rdisabledRamw(), 0xFF, 0x2000);
oamDmaSrc_ = OAM_DMA_SRC_OFF;
oamDmaSrc_ = oam_dma_src_off;
rmem_[0x3] = rmem_[0x2] = rmem_[0x1] = rmem_[0x0] = romdata_[0];
rmem_[0xC] = wmem_[0xC] = wramdata_[0] - 0xC000;
rmem_[0xE] = wmem_[0xE] = wramdata_[0] - 0xE000;
@ -60,39 +75,43 @@ void MemPtrs::reset(const unsigned rombanks, const unsigned rambanks, const unsi
memchunk_savelen = wramdataend() - memchunk_ - memchunk_saveoffs;
}
void MemPtrs::setRombank0(const unsigned bank) {
void MemPtrs::setRombank0(unsigned bank) {
romdata_[0] = romdata() + bank * 0x4000ul;
rmem_[0x3] = rmem_[0x2] = rmem_[0x1] = rmem_[0x0] = romdata_[0];
disconnectOamDmaAreas();
}
void MemPtrs::setRombank(const unsigned bank) {
void MemPtrs::setRombank(unsigned bank) {
curRomBank_ = bank;
romdata_[1] = romdata() + bank * 0x4000ul - 0x4000;
rmem_[0x7] = rmem_[0x6] = rmem_[0x5] = rmem_[0x4] = romdata_[1];
disconnectOamDmaAreas();
}
void MemPtrs::setRambank(const unsigned flags, const unsigned rambank) {
unsigned char *const srambankptr = flags & RTC_EN
? 0
: (rambankdata() != rambankdataend()
? rambankdata_ + rambank * 0x2000ul - 0xA000 : wdisabledRam() - 0xA000);
void MemPtrs::setRambank(unsigned const flags, unsigned const rambank) {
unsigned char *srambankptr = 0;
if (!(flags & rtc_en)) {
srambankptr = rambankdata() != rambankdataend()
? rambankdata_ + rambank * 0x2000ul - 0xA000
: wdisabledRam() - 0xA000;
}
rsrambankptr_ = (flags & READ_EN) && srambankptr != wdisabledRam() - 0xA000 ? srambankptr : rdisabledRamw() - 0xA000;
wsrambankptr_ = flags & WRITE_EN ? srambankptr : wdisabledRam() - 0xA000;
rsrambankptr_ = (flags & read_en) && srambankptr != wdisabledRam() - 0xA000
? srambankptr
: rdisabledRamw() - 0xA000;
wsrambankptr_ = flags & write_en ? srambankptr : wdisabledRam() - 0xA000;
rmem_[0xB] = rmem_[0xA] = rsrambankptr_;
wmem_[0xB] = wmem_[0xA] = wsrambankptr_;
disconnectOamDmaAreas();
}
void MemPtrs::setWrambank(const unsigned bank) {
wramdata_[1] = wramdata_[0] + ((bank & 0x07) ? (bank & 0x07) : 1) * 0x1000;
void MemPtrs::setWrambank(unsigned bank) {
wramdata_[1] = wramdata_[0] + (bank & 0x07 ? bank & 0x07 : 1) * 0x1000;
rmem_[0xD] = wmem_[0xD] = wramdata_[1] - 0xD000;
disconnectOamDmaAreas();
}
void MemPtrs::setOamDmaSrc(const OamDmaSrc oamDmaSrc) {
void MemPtrs::setOamDmaSrc(OamDmaSrc oamDmaSrc) {
rmem_[0x3] = rmem_[0x2] = rmem_[0x1] = rmem_[0x0] = romdata_[0];
rmem_[0x7] = rmem_[0x6] = rmem_[0x5] = rmem_[0x4] = romdata_[1];
rmem_[0xB] = rmem_[0xA] = rsrambankptr_;
@ -100,7 +119,7 @@ void MemPtrs::setOamDmaSrc(const OamDmaSrc oamDmaSrc) {
rmem_[0xC] = wmem_[0xC] = wramdata_[0] - 0xC000;
rmem_[0xD] = wmem_[0xD] = wramdata_[1] - 0xD000;
rmem_[0xE] = wmem_[0xE] = wramdata_[0] - 0xE000;
oamDmaSrc_ = oamDmaSrc;
disconnectOamDmaAreas();
}
@ -108,37 +127,37 @@ void MemPtrs::setOamDmaSrc(const OamDmaSrc oamDmaSrc) {
void MemPtrs::disconnectOamDmaAreas() {
if (isCgb(*this)) {
switch (oamDmaSrc_) {
case OAM_DMA_SRC_ROM: // fall through
case OAM_DMA_SRC_SRAM:
case OAM_DMA_SRC_INVALID:
case oam_dma_src_rom: // fall through
case oam_dma_src_sram:
case oam_dma_src_invalid:
std::fill(rmem_, rmem_ + 8, static_cast<unsigned char *>(0));
rmem_[0xB] = rmem_[0xA] = 0;
wmem_[0xB] = wmem_[0xA] = 0;
break;
case OAM_DMA_SRC_VRAM:
case oam_dma_src_vram:
break;
case OAM_DMA_SRC_WRAM:
case oam_dma_src_wram:
rmem_[0xE] = rmem_[0xD] = rmem_[0xC] = 0;
wmem_[0xE] = wmem_[0xD] = wmem_[0xC] = 0;
break;
case OAM_DMA_SRC_OFF:
case oam_dma_src_off:
break;
}
} else {
switch (oamDmaSrc_) {
case OAM_DMA_SRC_ROM: // fall through
case OAM_DMA_SRC_SRAM:
case OAM_DMA_SRC_WRAM:
case OAM_DMA_SRC_INVALID:
case oam_dma_src_rom: // fall through
case oam_dma_src_sram:
case oam_dma_src_wram:
case oam_dma_src_invalid:
std::fill(rmem_, rmem_ + 8, static_cast<unsigned char *>(0));
rmem_[0xB] = rmem_[0xA] = 0;
wmem_[0xB] = wmem_[0xA] = 0;
rmem_[0xE] = rmem_[0xD] = rmem_[0xC] = 0;
wmem_[0xE] = wmem_[0xD] = wmem_[0xC] = 0;
break;
case OAM_DMA_SRC_VRAM:
case oam_dma_src_vram:
break;
case OAM_DMA_SRC_OFF:
case oam_dma_src_off:
break;
}
}
@ -150,24 +169,10 @@ void MemPtrs::disconnectOamDmaAreas() {
SYNCFUNC(MemPtrs)
{
/*
int memchunk_len_old = memchunk_len;
int memchunk_saveoffs_old = memchunk_saveoffs;
int memchunk_savelen_old = memchunk_savelen;
*/
NSS(memchunk_len);
NSS(memchunk_saveoffs);
NSS(memchunk_savelen);
/*
if (isReader)
{
if (memchunk_len != memchunk_len_old || memchunk_saveoffs != memchunk_saveoffs_old || memchunk_savelen != memchunk_savelen_old)
__debugbreak();
}
*/
PSS(memchunk_ + memchunk_saveoffs, memchunk_savelen);
MSS(rmem_[0x0]);
@ -202,11 +207,6 @@ SYNCFUNC(MemPtrs)
MSS(wmem_[0xe]);
MSS(rmem_[0xf]);
MSS(wmem_[0xf]);
//for (int i = 0; i < 0x10; i++)
//{
// MSS(rmem_[i]);
// MSS(wmem_[i]);
//}
MSS(romdata_[0]);
MSS(romdata_[1]);
MSS(wramdata_[0]);

109
libgambatte/src/mem/memptrs.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007-2010 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007-2010 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef MEMPTRS_H
#define MEMPTRS_H
@ -23,43 +23,22 @@
namespace gambatte {
enum OamDmaSrc { OAM_DMA_SRC_ROM, OAM_DMA_SRC_SRAM, OAM_DMA_SRC_VRAM,
OAM_DMA_SRC_WRAM, OAM_DMA_SRC_INVALID, OAM_DMA_SRC_OFF };
enum OamDmaSrc { oam_dma_src_rom,
oam_dma_src_sram,
oam_dma_src_vram,
oam_dma_src_wram,
oam_dma_src_invalid,
oam_dma_src_off, };
class MemPtrs {
const unsigned char *rmem_[0x10];
unsigned char *wmem_[0x10];
unsigned char *romdata_[2];
unsigned char *wramdata_[2];
unsigned char *vrambankptr_;
unsigned char *rsrambankptr_;
unsigned char *wsrambankptr_;
unsigned char *memchunk_;
unsigned char *rambankdata_;
unsigned char *wramdataend_;
OamDmaSrc oamDmaSrc_;
unsigned curRomBank_;
int memchunk_len;
int memchunk_saveoffs;
int memchunk_savelen;
MemPtrs(const MemPtrs &);
MemPtrs & operator=(const MemPtrs &);
void disconnectOamDmaAreas();
unsigned char * rdisabledRamw() const { return wramdataend_ ; }
unsigned char * wdisabledRam() const { return wramdataend_ + 0x2000; }
public:
enum RamFlag { READ_EN = 1, WRITE_EN = 2, RTC_EN = 4 };
enum RamFlag { read_en = 1, write_en = 2, rtc_en = 4 };
MemPtrs();
~MemPtrs();
void reset(unsigned rombanks, unsigned rambanks, unsigned wrambanks);
const unsigned char * rmem(unsigned area) const { return rmem_[area]; }
unsigned char const * rmem(unsigned area) const { return rmem_[area]; }
unsigned char * wmem(unsigned area) const { return wmem_[area]; }
unsigned char * vramdata() const { return rambankdata_ - 0x4000; }
unsigned char * vramdataend() const { return rambankdata_; }
@ -70,8 +49,8 @@ public:
unsigned char * wramdataend() const { return wramdataend_; }
unsigned char * rambankdata() const { return rambankdata_; }
unsigned char * rambankdataend() const { return wramdata_[0]; }
const unsigned char * rdisabledRam() const { return rdisabledRamw(); }
const unsigned char * rsrambankptr() const { return rsrambankptr_; }
unsigned char const * rdisabledRam() const { return rdisabledRamw(); }
unsigned char const * rsrambankptr() const { return rsrambankptr_; }
unsigned char * wsrambankptr() const { return wsrambankptr_; }
unsigned char * vrambankptr() const { return vrambankptr_; }
OamDmaSrc oamDmaSrc() const { return oamDmaSrc_; }
@ -84,10 +63,36 @@ public:
void setWrambank(unsigned bank);
void setOamDmaSrc(OamDmaSrc oamDmaSrc);
private:
unsigned char const *rmem_[0x10];
unsigned char *wmem_[0x10];
unsigned char *romdata_[2];
unsigned char *wramdata_[2];
unsigned char *vrambankptr_;
unsigned char *rsrambankptr_;
unsigned char *wsrambankptr_;
unsigned char *memchunk_;
unsigned char *rambankdata_;
unsigned char *wramdataend_;
OamDmaSrc oamDmaSrc_;
unsigned curRomBank_;
int memchunk_len;
int memchunk_saveoffs;
int memchunk_savelen;
MemPtrs(MemPtrs const &);
MemPtrs & operator=(MemPtrs const &);
void disconnectOamDmaAreas();
unsigned char * rdisabledRamw() const { return wramdataend_ ; }
unsigned char * wdisabledRam() const { return wramdataend_ + 0x2000; }
public:
template<bool isReader>void SyncState(NewState *ns);
};
inline bool isCgb(const MemPtrs &memptrs) {
inline bool isCgb(MemPtrs const &memptrs) {
return memptrs.wramdataend() - memptrs.wramdata(0) == 0x8000;
}

253
libgambatte/src/mem/rtc.cpp
View File

@ -1,177 +1,178 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "rtc.h"
#include "../savestate.h"
#include <cstdlib>
namespace gambatte {
Rtc::Rtc()
: activeData(NULL),
activeSet(NULL),
baseTime(0),
haltTime(0),
index(5),
dataDh(0),
dataDl(0),
dataH(0),
dataM(0),
dataS(0),
enabled(false),
lastLatchData(false),
timeCB(0)
Rtc::Rtc(Time &time)
: time_(time)
, activeData_(0)
, activeSet_(0)
, haltTime_(0)
, index_(5)
, dataDh_(0)
, dataDl_(0)
, dataH_(0)
, dataM_(0)
, dataS_(0)
, enabled_(false)
, lastLatchData_(false)
{
}
void Rtc::doLatch() {
std::uint32_t tmp = ((dataDh & 0x40) ? haltTime : timeCB()) - baseTime;
while (tmp > 0x1FF * 86400) {
baseTime += 0x1FF * 86400;
tmp -= 0x1FF * 86400;
dataDh |= 0x80;
void Rtc::doLatch(unsigned long const cc) {
std::uint32_t tmp = time(cc);
if (tmp >= 0x200 * 86400) {
tmp %= 0x200 * 86400;
time_.set(tmp, cc);
dataDh_ |= 0x80;
}
dataDl = (tmp / 86400) & 0xFF;
dataDh &= 0xFE;
dataDh |= ((tmp / 86400) & 0x100) >> 8;
dataDl_ = (tmp / 86400) & 0xFF;
dataDh_ &= 0xFE;
dataDh_ |= ((tmp / 86400) & 0x100) >> 8;
tmp %= 86400;
dataH = tmp / 3600;
dataH_ = tmp / 3600;
tmp %= 3600;
dataM = tmp / 60;
dataM_ = tmp / 60;
tmp %= 60;
dataS = tmp;
dataS_ = tmp;
}
void Rtc::doSwapActive() {
if (!enabled || index > 4) {
activeData = NULL;
activeSet = NULL;
} else switch (index) {
if (!enabled_ || index_ > 4) {
activeData_ = 0;
activeSet_ = 0;
} else switch (index_) {
case 0x00:
activeData = &dataS;
activeSet = &Rtc::setS;
activeData_ = &dataS_;
activeSet_ = &Rtc::setS;
break;
case 0x01:
activeData = &dataM;
activeSet = &Rtc::setM;
activeData_ = &dataM_;
activeSet_ = &Rtc::setM;
break;
case 0x02:
activeData = &dataH;
activeSet = &Rtc::setH;
activeData_ = &dataH_;
activeSet_ = &Rtc::setH;
break;
case 0x03:
activeData = &dataDl;
activeSet = &Rtc::setDl;
activeData_ = &dataDl_;
activeSet_ = &Rtc::setDl;
break;
case 0x04:
activeData = &dataDh;
activeSet = &Rtc::setDh;
activeData_ = &dataDh_;
activeSet_ = &Rtc::setDh;
break;
}
}
void Rtc::loadState(const SaveState &state) {
baseTime = state.rtc.baseTime;
haltTime = state.rtc.haltTime;
dataDh = state.rtc.dataDh;
dataDl = state.rtc.dataDl;
dataH = state.rtc.dataH;
dataM = state.rtc.dataM;
dataS = state.rtc.dataS;
lastLatchData = state.rtc.lastLatchData;
void Rtc::loadState(SaveState const &state) {
haltTime_ = state.rtc.haltTime;
dataDh_ = state.rtc.dataDh;
dataDl_ = state.rtc.dataDl;
dataH_ = state.rtc.dataH;
dataM_ = state.rtc.dataM;
dataS_ = state.rtc.dataS;
lastLatchData_ = state.rtc.lastLatchData;
doSwapActive();
}
void Rtc::setDh(const unsigned new_dh) {
const std::uint32_t unixtime = (dataDh & 0x40) ? haltTime : timeCB();
const std::uint32_t old_highdays = ((unixtime - baseTime) / 86400) & 0x100;
baseTime += old_highdays * 86400;
baseTime -= ((new_dh & 0x1) << 8) * 86400;
if ((dataDh ^ new_dh) & 0x40) {
if (new_dh & 0x40)
haltTime = timeCB();
void Rtc::setDh(unsigned const newDh, unsigned const long cc) {
std::uint32_t seconds = time(cc);
std::uint32_t const oldHighdays = (seconds / 86400) & 0x100;
seconds -= oldHighdays * 86400;
seconds += ((newDh & 0x1) << 8) * 86400;
time_.set(seconds, cc);
if ((dataDh_ ^ newDh) & 0x40) {
if (newDh & 0x40)
haltTime_ = seconds;
else
baseTime += timeCB() - haltTime;
time_.set(haltTime_, cc);
}
}
void Rtc::setDl(const unsigned new_lowdays) {
const std::uint32_t unixtime = (dataDh & 0x40) ? haltTime : timeCB();
const std::uint32_t old_lowdays = ((unixtime - baseTime) / 86400) & 0xFF;
baseTime += old_lowdays * 86400;
baseTime -= new_lowdays * 86400;
void Rtc::setDl(unsigned const newLowdays, unsigned const long cc) {
std::uint32_t seconds = time(cc);
std::uint32_t const oldLowdays = (seconds / 86400) & 0xFF;
seconds -= oldLowdays * 86400;
seconds += newLowdays * 86400;
time_.set(seconds, cc);
}
void Rtc::setH(const unsigned new_hours) {
const std::uint32_t unixtime = (dataDh & 0x40) ? haltTime : timeCB();
const std::uint32_t old_hours = ((unixtime - baseTime) / 3600) % 24;
baseTime += old_hours * 3600;
baseTime -= new_hours * 3600;
void Rtc::setH(unsigned const newHours, unsigned const long cc) {
std::uint32_t seconds = time(cc);
std::uint32_t const oldHours = (seconds / 3600) % 24;
seconds -= oldHours * 3600;
seconds += newHours * 3600;
time_.set(seconds, cc);
}
void Rtc::setM(const unsigned new_minutes) {
const std::uint32_t unixtime = (dataDh & 0x40) ? haltTime : timeCB();
const std::uint32_t old_minutes = ((unixtime - baseTime) / 60) % 60;
baseTime += old_minutes * 60;
baseTime -= new_minutes * 60;
void Rtc::setM(unsigned const newMinutes, unsigned const long cc) {
std::uint32_t seconds = time(cc);
std::uint32_t const oldMinutes = (seconds / 60) % 60;
seconds -= oldMinutes * 60;
seconds += newMinutes * 60;
time_.set(seconds, cc);
}
void Rtc::setS(const unsigned new_seconds) {
const std::uint32_t unixtime = (dataDh & 0x40) ? haltTime : timeCB();
baseTime += (unixtime - baseTime) % 60;
baseTime -= new_seconds;
void Rtc::setS(unsigned const newSeconds, unsigned const long cc) {
std::uint32_t seconds = time(cc);
seconds -= seconds % 60;
seconds += newSeconds;
time_.reset(seconds, cc);
}
SYNCFUNC(Rtc)
{
EBS(activeData, 0);
EVS(activeData, &dataS, 1);
EVS(activeData, &dataM, 2);
EVS(activeData, &dataH, 3);
EVS(activeData, &dataDl, 4);
EVS(activeData, &dataDh, 5);
EES(activeData, NULL);
EBS(activeData_, 0);
EVS(activeData_, &dataS_, 1);
EVS(activeData_, &dataM_, 2);
EVS(activeData_, &dataH_, 3);
EVS(activeData_, &dataDl_, 4);
EVS(activeData_, &dataDh_, 5);
EES(activeData_, NULL);
EBS(activeSet, 0);
EVS(activeSet, &Rtc::setS, 1);
EVS(activeSet, &Rtc::setM, 2);
EVS(activeSet, &Rtc::setH, 3);
EVS(activeSet, &Rtc::setDl, 4);
EVS(activeSet, &Rtc::setDh, 5);
EES(activeSet, NULL);
EBS(activeSet_, 0);
EVS(activeSet_, &Rtc::setS, 1);
EVS(activeSet_, &Rtc::setM, 2);
EVS(activeSet_, &Rtc::setH, 3);
EVS(activeSet_, &Rtc::setDl, 4);
EVS(activeSet_, &Rtc::setDh, 5);
EES(activeSet_, NULL);
NSS(baseTime);
NSS(haltTime);
NSS(index);
NSS(dataDh);
NSS(dataDl);
NSS(dataH);
NSS(dataM);
NSS(dataS);
NSS(enabled);
NSS(lastLatchData);
NSS(haltTime_);
NSS(index_);
NSS(dataDh_);
NSS(dataDl_);
NSS(dataH_);
NSS(dataM_);
NSS(dataS_);
NSS(enabled_);
NSS(lastLatchData_);
}
}

135
libgambatte/src/mem/rtc.h
View File

@ -1,25 +1,26 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef RTC_H
#define RTC_H
#include <cstdint>
#include "time.h"
#include "newstate.h"
namespace gambatte {
@ -27,69 +28,59 @@ namespace gambatte {
struct SaveState;
class Rtc {
private:
unsigned char *activeData;
void (Rtc::*activeSet)(unsigned);
std::uint32_t baseTime;
std::uint32_t haltTime;
unsigned char index;
unsigned char dataDh;
unsigned char dataDl;
unsigned char dataH;
unsigned char dataM;
unsigned char dataS;
bool enabled;
bool lastLatchData;
std::uint32_t (*timeCB)();
void doLatch();
void doSwapActive();
void setDh(unsigned new_dh);
void setDl(unsigned new_lowdays);
void setH(unsigned new_hours);
void setM(unsigned new_minutes);
void setS(unsigned new_seconds);
public:
Rtc();
const unsigned char* getActive() const { return activeData; }
std::uint32_t getBaseTime() const { return baseTime; }
void setBaseTime(const std::uint32_t baseTime) {
this->baseTime = baseTime;
// doLatch();
Rtc(Time &time);
unsigned char const * activeData() const { return activeData_; }
void latch(unsigned data, unsigned long const cc) {
if (!lastLatchData_ && data == 1)
doLatch(cc);
lastLatchData_ = data;
}
void latch(const unsigned data) {
if (!lastLatchData && data == 1)
doLatch();
lastLatchData = data;
}
void loadState(const SaveState &state);
void set(const bool enabled, unsigned bank) {
void loadState(SaveState const &state);
void set(bool enabled, unsigned bank) {
bank &= 0xF;
bank -= 8;
this->enabled = enabled;
this->index = bank;
enabled_ = enabled;
index_ = bank;
doSwapActive();
}
void write(const unsigned data) {
// if (activeSet)
(this->*activeSet)(data);
*activeData = data;
void write(unsigned data, unsigned long const cc) {
(this->*activeSet_)(data, cc);
*activeData_ = data;
}
void setRTCCallback(std::uint32_t (*callback)()) {
timeCB = callback;
}
private:
Time &time_;
unsigned char *activeData_;
void (Rtc::*activeSet_)(unsigned, unsigned long);
std::uint32_t haltTime_;
unsigned char index_;
unsigned char dataDh_;
unsigned char dataDl_;
unsigned char dataH_;
unsigned char dataM_;
unsigned char dataS_;
bool enabled_;
bool lastLatchData_;
void doLatch(unsigned long cycleCounter);
void doSwapActive();
void setDh(unsigned newDh, unsigned long cycleCounter);
void setDl(unsigned newLowdays, unsigned long cycleCounter);
void setH(unsigned newHours, unsigned long cycleCounter);
void setM(unsigned newMinutes, unsigned long cycleCounter);
void setS(unsigned newSeconds, unsigned long cycleCounter);
std::uint32_t time(unsigned long const cc) {
return dataDh_ & 0x40 ? haltTime_ : time_.get(cc);
}
public:
template<bool isReader>void SyncState(NewState *ns);
};

145
libgambatte/src/mem/time.cpp Normal file
View File

@ -0,0 +1,145 @@
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "time.h"
#include "../savestate.h"
namespace gambatte {
static timeval operator-(timeval l, timeval r) {
timeval t;
t.tv_sec = l.tv_sec - r.tv_sec;
t.tv_usec = l.tv_usec - r.tv_usec;
if (t.tv_usec < 0) {
t.tv_sec--;
t.tv_usec += 1000000;
}
return t;
}
Time::Time()
: useCycles_(true)
, rtcDivisor_(0x400000)
{
}
void Time::loadState(SaveState const &state) {
seconds_ = state.time.seconds;
lastTime_.tv_sec = state.time.lastTimeSec;
lastTime_.tv_usec = state.time.lastTimeUsec;
lastCycles_ = state.time.lastCycles;
ds_ = state.ppu.isCgb & state.mem.ioamhram.get()[0x14D] >> 7;
}
std::uint32_t Time::get(unsigned long const cc) {
update(cc);
return seconds_;
}
void Time::set(std::uint32_t seconds, unsigned long const cc) {
update(cc);
seconds_ = seconds;
}
void Time::reset(std::uint32_t seconds, unsigned long const cc) {
set(seconds, cc);
lastTime_ = now();
lastCycles_ = cc;
}
void Time::resetCc(unsigned long const oldCc, unsigned long const newCc) {
update(oldCc);
lastCycles_ -= oldCc - newCc;
}
void Time::speedChange(unsigned long const cc) {
update(cc);
if (useCycles_) {
unsigned long diff = cc - lastCycles_;
lastCycles_ = cc - (ds_ ? diff >> 1 : diff << 1);
}
ds_ = !ds_;
}
timeval Time::baseTime(unsigned long const cc) {
if (useCycles_)
timeFromCycles(cc);
timeval baseTime = lastTime_;
baseTime.tv_sec -= seconds_;
return baseTime;
}
void Time::setBaseTime(timeval baseTime, unsigned long const cc) {
seconds_ = (now() - baseTime).tv_sec;
lastTime_ = baseTime;
lastTime_.tv_sec += seconds_;
if (useCycles_)
cyclesFromTime(cc);
}
void Time::setTimeMode(bool useCycles, unsigned long const cc) {
if (useCycles != useCycles_) {
if (useCycles_)
timeFromCycles(cc);
else
cyclesFromTime(cc);
useCycles_ = useCycles;
}
}
void Time::update(unsigned long const cc) {
if (useCycles_) {
std::uint32_t diff = (cc - lastCycles_) / (rtcDivisor_ << ds_);
seconds_ += diff;
lastCycles_ += diff * (rtcDivisor_ << ds_);
} else {
std::uint32_t diff = (now() - lastTime_).tv_sec;
seconds_ += diff;
lastTime_.tv_sec += diff;
}
}
void Time::cyclesFromTime(unsigned long const cc) {
update(cc);
timeval diff = now() - lastTime_;
lastCycles_ = cc - diff.tv_usec * ((rtcDivisor_ << ds_) / 1000000.0f);
}
void Time::timeFromCycles(unsigned long const cc) {
update(cc);
unsigned long diff = cc - lastCycles_;
timeval usec = { 0, (long)(diff / ((rtcDivisor_ << ds_) / 1000000.0f)) };
lastTime_ = now() - usec;
}
SYNCFUNC(Time)
{
NSS(seconds_);
NSS(lastTime_.tv_sec);
NSS(lastTime_.tv_usec);
NSS(lastCycles_);
NSS(useCycles_);
NSS(ds_);
}
}

80
libgambatte/src/mem/time.h Normal file
View File

@ -0,0 +1,80 @@
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef TIME_H
#define TIME_H
#include <chrono>
#include <cstdint>
#include <ctime>
#include "newstate.h"
namespace gambatte {
struct SaveState;
struct timeval {
std::uint32_t tv_sec;
std::uint32_t tv_usec;
};
class Time {
public:
static timeval now() {
long long micros = std::chrono::duration_cast<std::chrono::microseconds>(
std::chrono::high_resolution_clock::now().time_since_epoch())
.count();
timeval t;
t.tv_usec = micros % 1000000;
t.tv_sec = micros / 1000000;
return t;
}
Time();
void loadState(SaveState const &state);
std::uint32_t get(unsigned long cycleCounter);
void set(std::uint32_t seconds, unsigned long cycleCounter);
void reset(std::uint32_t seconds, unsigned long cycleCounter);
void resetCc(unsigned long oldCc, unsigned long newCc);
void speedChange(unsigned long cycleCounter);
timeval baseTime(unsigned long cycleCounter);
void setBaseTime(timeval baseTime, unsigned long cycleCounter);
void setTimeMode(bool useCycles, unsigned long cycleCounter);
void setRtcDivisorOffset(long const rtcDivisorOffset) { rtcDivisor_ = 0x400000L + rtcDivisorOffset; }
private:
std::uint32_t seconds_;
timeval lastTime_;
unsigned long lastCycles_;
bool useCycles_;
unsigned long rtcDivisor_;
bool ds_;
void update(unsigned long cycleCounter);
void cyclesFromTime(unsigned long cycleCounter);
void timeFromCycles(unsigned long cycleCounter);
public:
template<bool isReader>void SyncState(NewState *ns);
};
}
#endif

1292
libgambatte/src/memory.cpp
View File

File diff suppressed because it is too large Load Diff

457
libgambatte/src/memory.h
View File

@ -1,145 +1,93 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef MEMORY_H
#define MEMORY_H
static unsigned char const agbOverride[0xD] = { 0xFF, 0x00, 0xCD, 0x03, 0x35, 0xAA, 0x31, 0x90, 0x94, 0x00, 0x00, 0x00, 0x00 };
#include "mem/cartridge.h"
#include "video.h"
#include "sound.h"
#include "interrupter.h"
#include "tima.h"
#include "video.h"
#include "newstate.h"
#include "gambatte.h"
namespace gambatte {
class InputGetter;
class FilterInfo;
class Memory {
Cartridge cart;
unsigned char ioamhram[0x200];
unsigned char cgbBios[0x900];
unsigned char dmgBios[0x100];
bool biosMode;
bool cgbSwitching;
bool agbMode;
bool gbIsCgb_;
bool stopped;
unsigned short &SP;
unsigned short &PC;
unsigned long basetime;
unsigned long halttime;
MemoryCallback readCallback;
MemoryCallback writeCallback;
MemoryCallback execCallback;
CDCallback cdCallback;
void(*linkCallback)();
unsigned (*getInput)();
unsigned long divLastUpdate;
unsigned long lastOamDmaUpdate;
InterruptRequester intreq;
Tima tima;
LCD display;
PSG sound;
Interrupter interrupter;
unsigned short dmaSource;
unsigned short dmaDestination;
unsigned char oamDmaPos;
unsigned char serialCnt;
bool blanklcd;
bool LINKCABLE;
bool linkClockTrigger;
void decEventCycles(MemEventId eventId, unsigned long dec);
void oamDmaInitSetup();
void updateOamDma(unsigned long cycleCounter);
void startOamDma(unsigned long cycleCounter);
void endOamDma(unsigned long cycleCounter);
const unsigned char * oamDmaSrcPtr() const;
unsigned nontrivial_ff_read(unsigned P, unsigned long cycleCounter);
unsigned nontrivial_read(unsigned P, unsigned long cycleCounter);
void nontrivial_ff_write(unsigned P, unsigned data, unsigned long cycleCounter);
void nontrivial_write(unsigned P, unsigned data, unsigned long cycleCounter);
unsigned nontrivial_peek(unsigned P);
unsigned nontrivial_ff_peek(unsigned P);
void updateSerial(unsigned long cc);
void updateTimaIrq(unsigned long cc);
void updateIrqs(unsigned long cc);
bool isDoubleSpeed() const { return display.isDoubleSpeed(); }
public:
explicit Memory(const Interrupter &interrupter, unsigned short &sp, unsigned short &pc);
bool loaded() const { return cart.loaded(); }
unsigned curRomBank() const { return cart.curRomBank(); }
const char * romTitle() const { return cart.romTitle(); }
int debugGetLY() const { return display.debugGetLY(); }
explicit Memory(unsigned short &sp, unsigned short &pc);
~Memory();
bool loaded() const { return cart_.loaded(); }
unsigned curRomBank() const { return cart_.curRomBank(); }
char const * romTitle() const { return cart_.romTitle(); }
int debugGetLY() const { return lcd_.debugGetLY(); }
void setStatePtrs(SaveState &state);
void loadState(const SaveState &state/*, unsigned long oldCc*/);
void loadSavedata(const char *data) { cart.loadSavedata(data); }
int saveSavedataLength() {return cart.saveSavedataLength(); }
void saveSavedata(char *dest) { cart.saveSavedata(dest); }
void loadState(SaveState const &state);
void loadSavedata(char const *data, unsigned long const cc) { cart_.loadSavedata(data, cc); }
int saveSavedataLength() {return cart_.saveSavedataLength(); }
void saveSavedata(char *dest, unsigned long const cc) { cart_.saveSavedata(dest, cc); }
void updateInput();
unsigned char* cgbBiosBuffer() { return (unsigned char*)cgbBios; }
unsigned char* dmgBiosBuffer() { return (unsigned char*)dmgBios; }
void setBios(char const *buffer, std::size_t size) {
delete []bios_;
bios_ = new unsigned char[size];
memcpy(bios_, buffer, size);
biosSize_ = size;
}
bool gbIsCgb() { return gbIsCgb_; }
bool getMemoryArea(int which, unsigned char **data, int *length); // { return cart.getMemoryArea(which, data, length); }
bool getMemoryArea(int which, unsigned char **data, int *length);
unsigned long stop(unsigned long cycleCounter);
bool isCgb() const { return display.isCgb(); }
bool ime() const { return intreq.ime(); }
bool halted() const { return intreq.halted(); }
unsigned long nextEventTime() const { return intreq.minEventTime(); }
bool isCgb() const { return lcd_.isCgb(); }
bool ime() const { return intreq_.ime(); }
bool halted() const { return intreq_.halted(); }
unsigned long nextEventTime() const { return intreq_.minEventTime(); }
void setLayers(unsigned mask) { lcd_.setLayers(mask); }
bool isActive() const { return intreq_.eventTime(intevent_end) != disabled_time; }
void setLayers(unsigned mask) { display.setLayers(mask); }
bool isActive() const { return intreq.eventTime(END) != DISABLED_TIME; }
long cyclesSinceBlit(const unsigned long cc) const {
return cc < intreq.eventTime(BLIT) ? -1 : static_cast<long>((cc - intreq.eventTime(BLIT)) >> isDoubleSpeed());
long cyclesSinceBlit(unsigned long cc) const {
if (cc < intreq_.eventTime(intevent_blit))
return -1;
return (cc - intreq_.eventTime(intevent_blit)) >> isDoubleSpeed();
}
void halt(unsigned long cycleCounter) { halttime = cycleCounter; intreq.halt(); }
void ei(unsigned long cycleCounter) { if (!ime()) { intreq.ei(cycleCounter); } }
void halt(unsigned long cycleCounter) { halttime_ = cycleCounter; intreq_.halt(); }
void ei(unsigned long cycleCounter) { if (!ime()) { intreq_.ei(cycleCounter); } }
void di() { intreq_.di(); }
void di() { intreq.di(); }
unsigned readBios(unsigned p) {
if(agbMode_ && p >= 0xF3 && p < 0x100) {
return (agbOverride[p-0xF3] + bios_[p]) & 0xFF;
}
return bios_[p];
}
unsigned ff_read(const unsigned P, const unsigned long cycleCounter) {
if (readCallback)
readCallback(P, (cycleCounter - basetime) >> 1);
return P < 0xFF80 ? nontrivial_ff_read(P, cycleCounter) : ioamhram[P - 0xFE00];
unsigned ff_read(unsigned p, unsigned long cc) {
if (readCallback_)
readCallback_(p, (cc - basetime_) >> 1);
return p < 0x80 ? nontrivial_ff_read(p, cc) : ioamhram_[p + 0x100];
}
struct CDMapResult
@ -148,30 +96,30 @@ public:
unsigned addr;
};
CDMapResult CDMap(const unsigned P) const
CDMapResult CDMap(const unsigned p) const
{
if(P<0x4000)
if(p < 0x4000)
{
CDMapResult ret = { eCDLog_AddrType_ROM, P };
CDMapResult ret = { eCDLog_AddrType_ROM, p };
return ret;
}
else if(P<0x8000)
else if(p < 0x8000)
{
unsigned bank = cart.rmem(P>>12) - cart.rmem(0);
unsigned addr = P+bank;
unsigned bank = cart_.rmem(p >> 12) - cart_.rmem(0);
unsigned addr = p + bank;
CDMapResult ret = { eCDLog_AddrType_ROM, addr };
return ret;
}
else if(P<0xA000) {}
else if(P<0xC000)
else if(p < 0xA000) {}
else if(p < 0xC000)
{
if(cart.wsrambankptr())
if(cart_.wsrambankptr())
{
//not bankable. but. we're not sure how much might be here
unsigned char *data;
int length;
bool has = cart.getMemoryArea(3,&data,&length);
unsigned addr = P&(length-1);
bool has = cart_.getMemoryArea(3,&data,&length);
unsigned addr = p & (length-1);
if(has && length!=0)
{
CDMapResult ret = { eCDLog_AddrType_CartRAM, addr };
@ -179,15 +127,15 @@ public:
}
}
}
else if(P<0xE000)
else if(p < 0xE000)
{
unsigned bank = cart.wramdata(P >> 12 & 1) - cart.wramdata(0);
unsigned addr = (P&0xFFF)+bank;
unsigned bank = cart_.wramdata(p >> 12 & 1) - cart_.wramdata(0);
unsigned addr = (p & 0xFFF) + bank;
CDMapResult ret = { eCDLog_AddrType_WRAM, addr };
return ret;
}
else if(P<0xFF80) {}
else
else if(p < 0xFF80) {}
else
{
////this is just for debugging, really, it's pretty useless
//CDMapResult ret = { eCDLog_AddrType_HRAM, (P-0xFF80) };
@ -198,154 +146,183 @@ public:
return ret;
}
unsigned readBios(const unsigned P) {
if (gbIsCgb_) {
if (agbMode && P >= 0xF3 && P < 0x100) {
return (agbOverride[P - 0xF3] + cgbBios[P]) & 0xFF;
}
return cgbBios[P];
unsigned read(unsigned p, unsigned long cc) {
if (readCallback_)
readCallback_(p, (cc - basetime_) >> 1);
if(biosMode_) {
if (p < biosSize_ && !(p >= 0x100 && p < 0x200))
return readBios(p);
}
return dmgBios[P];
}
unsigned read(const unsigned P, const unsigned long cycleCounter) {
if (readCallback)
readCallback(P, (cycleCounter - basetime) >> 1);
bool biosRange = ((!gbIsCgb_ && P < 0x100) || (gbIsCgb_ && P < 0x900 && (P < 0x100 || P >= 0x200)));
if(biosMode) {
if (biosRange)
return readBios(P);
}
else
{
if(cdCallback)
{
CDMapResult map = CDMap(P);
if(map.type != eCDLog_AddrType_None)
cdCallback(map.addr,map.type,eCDLog_Flags_Data);
}
}
return cart.rmem(P >> 12) ? cart.rmem(P >> 12)[P] : nontrivial_read(P, cycleCounter);
}
unsigned read_excb(const unsigned P, const unsigned long cycleCounter, bool first) {
if (execCallback)
execCallback(P, (cycleCounter - basetime) >> 1);
bool biosRange = ((!gbIsCgb_ && P < 0x100) || (gbIsCgb_ && P < 0x900 && (P < 0x100 || P >= 0x200)));
if (biosMode) {
if(biosRange)
return readBios(P);
}
else
{
if(cdCallback)
{
CDMapResult map = CDMap(P);
if(map.type != eCDLog_AddrType_None)
cdCallback(map.addr,map.type,first?eCDLog_Flags_ExecFirst : eCDLog_Flags_ExecOperand);
}
}
return cart.rmem(P >> 12) ? cart.rmem(P >> 12)[P] : nontrivial_read(P, cycleCounter);
}
unsigned peek(const unsigned P) {
if (biosMode && ((!gbIsCgb_ && P < 0x100) || (gbIsCgb_ && P < 0x900 && (P < 0x100 || P >= 0x200)))) {
return readBios(P);
}
return cart.rmem(P >> 12) ? cart.rmem(P >> 12)[P] : nontrivial_peek(P);
}
void write_nocb(const unsigned P, const unsigned data, const unsigned long cycleCounter) {
if (cart.wmem(P >> 12)) {
cart.wmem(P >> 12)[P] = data;
} else
nontrivial_write(P, data, cycleCounter);
}
void write(const unsigned P, const unsigned data, const unsigned long cycleCounter) {
if (cart.wmem(P >> 12)) {
cart.wmem(P >> 12)[P] = data;
} else
nontrivial_write(P, data, cycleCounter);
if (writeCallback)
writeCallback(P, (cycleCounter - basetime) >> 1);
if(cdCallback && !biosMode)
{
CDMapResult map = CDMap(P);
else if(cdCallback_) {
CDMapResult map = CDMap(p);
if(map.type != eCDLog_AddrType_None)
cdCallback(map.addr,map.type,eCDLog_Flags_Data);
cdCallback_(map.addr, map.type, eCDLog_Flags_Data);
}
return cart_.rmem(p >> 12) ? cart_.rmem(p >> 12)[p] : nontrivial_read(p, cc);
}
unsigned read_excb(unsigned p, unsigned long cc, bool first) {
if (execCallback_)
execCallback_(p, (cc - basetime_) >> 1);
if (biosMode_) {
if(p < biosSize_ && !(p >= 0x100 && p < 0x200))
return readBios(p);
}
else if(cdCallback_) {
CDMapResult map = CDMap(p);
if(map.type != eCDLog_AddrType_None)
cdCallback_(map.addr, map.type, first ? eCDLog_Flags_ExecFirst : eCDLog_Flags_ExecOperand);
}
return cart_.rmem(p >> 12) ? cart_.rmem(p >> 12)[p] : nontrivial_read(p, cc);
}
unsigned peek(unsigned p) {
if (biosMode_ && p < biosSize_ && !(p >= 0x100 && p < 0x200)) {
return readBios(p);
}
return cart_.rmem(p >> 12) ? cart_.rmem(p >> 12)[p] : nontrivial_peek(p);
}
void write_nocb(unsigned p, unsigned data, unsigned long cc) {
if (cart_.wmem(p >> 12)) {
cart_.wmem(p >> 12)[p] = data;
} else
nontrivial_write(p, data, cc);
}
void write(unsigned p, unsigned data, unsigned long cc) {
if (cart_.wmem(p >> 12)) {
cart_.wmem(p >> 12)[p] = data;
} else
nontrivial_write(p, data, cc);
if (writeCallback_)
writeCallback_(p, (cc - basetime_) >> 1);
if(cdCallback_ && !biosMode_) {
CDMapResult map = CDMap(p);
if(map.type != eCDLog_AddrType_None)
cdCallback_(map.addr, map.type, eCDLog_Flags_Data);
}
}
void ff_write(const unsigned P, const unsigned data, const unsigned long cycleCounter) {
if (P - 0xFF80u < 0x7Fu) {
ioamhram[P - 0xFE00] = data;
void ff_write(unsigned p, unsigned data, unsigned long cc) {
if (p - 0x80u < 0x7Fu) {
ioamhram_[p + 0x100] = data;
} else
nontrivial_ff_write(P, data, cycleCounter);
if (writeCallback)
writeCallback(P, (cycleCounter - basetime) >> 1);
if(cdCallback && !biosMode)
nontrivial_ff_write(p, data, cc);
if (writeCallback_)
writeCallback_(0xff00 + p, (cc - basetime_) >> 1);
if(cdCallback_ && !biosMode_)
{
CDMapResult map = CDMap(P);
CDMapResult map = CDMap(0xff00 + p);
if(map.type != eCDLog_AddrType_None)
cdCallback(map.addr,map.type,eCDLog_Flags_Data);
cdCallback_(map.addr, map.type, eCDLog_Flags_Data);
}
}
unsigned long event(unsigned long cycleCounter);
unsigned long resetCounters(unsigned long cycleCounter);
int loadROM(const char *romfiledata, unsigned romfilelength, bool forceDmg, bool multicartCompat);
LoadRes loadROM(char const *romfiledata, unsigned romfilelength, bool forceDmg, bool multicartCompat);
void setInputGetter(unsigned (*getInput)()) {
this->getInput = getInput;
getInput_ = getInput;
}
void setReadCallback(MemoryCallback callback) {
this->readCallback = callback;
this->readCallback_ = callback;
}
void setWriteCallback(MemoryCallback callback) {
this->writeCallback = callback;
this->writeCallback_ = callback;
}
void setExecCallback(MemoryCallback callback) {
this->execCallback = callback;
this->execCallback_ = callback;
}
void setCDCallback(CDCallback cdc) {
this->cdCallback = cdc;
this->cdCallback_ = cdc;
}
void setScanlineCallback(void (*callback)(), int sl) {
display.setScanlineCallback(callback, sl);
}
void setRTCCallback(std::uint32_t (*callback)()) {
cart.setRTCCallback(callback);
lcd_.setScanlineCallback(callback, sl);
}
void setLinkCallback(void(*callback)()) {
this->linkCallback = callback;
this->linkCallback_ = callback;
}
void setBasetime(unsigned long cc) { basetime = cc; }
void setEndtime(unsigned long cc, unsigned long inc);
void setSoundBuffer(uint_least32_t *const buf) { sound.setBuffer(buf); }
unsigned fillSoundBuffer(unsigned long cc);
void setVideoBuffer(uint_least32_t *const videoBuf, const int pitch) {
display.setVideoBuffer(videoBuf, pitch);
void setBasetime(unsigned long cc) { basetime_ = cc; }
void setSoundBuffer(uint_least32_t *buf) { psg_.setBuffer(buf); }
std::size_t fillSoundBuffer(unsigned long cc);
void setVideoBuffer(uint_least32_t *videoBuf, std::ptrdiff_t pitch) {
lcd_.setVideoBuffer(videoBuf, pitch);
}
void setDmgPaletteColor(unsigned palNum, unsigned colorNum, unsigned long rgb32);
void setDmgPaletteColor(int palNum, int colorNum, unsigned long rgb32) {
lcd_.setDmgPaletteColor(palNum, colorNum, rgb32);
}
void setCgbPalette(unsigned *lut);
void blackScreen() {
display.blackScreen();
void setTimeMode(bool useCycles, unsigned long const cc) {
cart_.setTimeMode(useCycles, cc);
}
void setRtcDivisorOffset(long const rtcDivisorOffset) { cart_.setRtcDivisorOffset(rtcDivisorOffset); }
int LinkStatus(int which);
int linkStatus(int which);
private:
Cartridge cart_;
unsigned char ioamhram_[0x200];
unsigned char *bios_;
std::size_t biosSize_;
unsigned (*getInput_)();
unsigned long divLastUpdate_;
unsigned long lastOamDmaUpdate_;
InterruptRequester intreq_;
Tima tima_;
LCD lcd_;
PSG psg_;
unsigned short dmaSource_;
unsigned short dmaDestination_;
unsigned char oamDmaPos_;
unsigned char serialCnt_;
bool blanklcd_;
bool biosMode_;
bool cgbSwitching_;
bool agbMode_;
bool gbIsCgb_;
unsigned short &sp_;
unsigned short &pc_;
unsigned long basetime_;
unsigned long halttime_;
bool stopped_;
MemoryCallback readCallback_;
MemoryCallback writeCallback_;
MemoryCallback execCallback_;
CDCallback cdCallback_;
void(*linkCallback_)();
bool LINKCABLE_;
bool linkClockTrigger_;
void decEventCycles(IntEventId eventId, unsigned long dec);
void oamDmaInitSetup();
void updateOamDma(unsigned long cycleCounter);
void startOamDma(unsigned long cycleCounter);
void endOamDma(unsigned long cycleCounter);
unsigned char const * oamDmaSrcPtr() const;
unsigned nontrivial_ff_read(unsigned p, unsigned long cycleCounter);
unsigned nontrivial_read(unsigned p, unsigned long cycleCounter);
void nontrivial_ff_write(unsigned p, unsigned data, unsigned long cycleCounter);
void nontrivial_write(unsigned p, unsigned data, unsigned long cycleCounter);
unsigned nontrivial_peek(unsigned p);
unsigned nontrivial_ff_peek(unsigned p);
void updateSerial(unsigned long cc);
void updateTimaIrq(unsigned long cc);
void updateIrqs(unsigned long cc);
bool isDoubleSpeed() const { return lcd_.isDoubleSpeed(); }
public:
template<bool isReader>void SyncState(NewState *ns);
};

235
libgambatte/src/minkeeper.h
View File

@ -1,157 +1,168 @@
/***************************************************************************
* Copyright (C) 2009 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2009 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef MINKEEPER_H
#define MINKEEPER_H
#include <algorithm>
#include "newstate.h"
namespace MinKeeperUtil {
template<int n> struct CeiledLog2 { enum { R = 1 + CeiledLog2<(n + 1) / 2>::R }; };
template<> struct CeiledLog2<1> { enum { R = 0 }; };
namespace min_keeper_detail {
template<int v, int n> struct RoundedDiv2n { enum { R = RoundedDiv2n<(v + 1) / 2, n - 1>::R }; };
template<int v> struct RoundedDiv2n<v,1> { enum { R = v }; };
template<int n> struct CeiledLog2 { enum { r = 1 + CeiledLog2<(n + 1) / 2>::r }; };
template<> struct CeiledLog2<1> { enum { r = 0 }; };
template<int v, int n> struct CeiledDiv2n { enum { r = CeiledDiv2n<(v + 1) / 2, n - 1>::r }; };
template<int v> struct CeiledDiv2n<v, 0> { enum { r = v }; };
// alternatively: template<int v, int n> struct CeiledDiv2n { enum { r = (v + (1 << n) - 1) >> n }; };
template<template<int> class T, int n> struct Sum { enum { r = T<n-1>::r + Sum<T, n-1>::r }; };
template<template<int> class T> struct Sum<T, 0> { enum { r = 0 }; };
template<template<int> class T, int n> struct Sum { enum { R = T<n-1>::R + Sum<T, n-1>::R }; };
template<template<int> class T> struct Sum<T,0> { enum { R = 0 }; };
}
// Keeps track of minimum value identified by id as values change.
// Higher ids prioritized (as min value) if values are equal. Can easily be reversed by swapping < for <=.
// Higher ids prioritized (as min value) if values are equal. (Can be inverted by swapping < for <=).
// Higher ids can be faster to change when the number of ids isn't a power of 2.
// Thus the ones that change more frequently should have higher ids if priority allows it.
// Thus, the ones that change more frequently should have higher ids if priority allows for it.
template<int ids>
class MinKeeper {
enum { LEVELS = MinKeeperUtil::CeiledLog2<ids>::R };
template<int l> struct Num { enum { R = MinKeeperUtil::RoundedDiv2n<ids, LEVELS + 1 - l>::R }; };
template<int l> struct Sum { enum { R = MinKeeperUtil::Sum<Num, l>::R }; };
template<int id, int level>
struct UpdateValue {
enum { P = Sum<level-1>::R + id };
enum { C0 = Sum<level>::R + id * 2 };
static void updateValue(MinKeeper<ids> &m) {
// GCC 4.3 generates better code with the ternary operator on i386.
m.a[P] = (id * 2 + 1 == Num<level>::R || m.values[m.a[C0]] < m.values[m.a[C0 + 1]]) ? m.a[C0] : m.a[C0 + 1];
UpdateValue<id / 2, level - 1>::updateValue(m);
}
};
template<int id>
struct UpdateValue<id,0> {
static void updateValue(MinKeeper<ids> &m) {
m.minValue_ = m.values[m.a[0]];
}
};
class UpdateValueLut {
template<int id, int dummy> struct FillLut {
static void fillLut(UpdateValueLut & l) {
l.lut_[id] = updateValue<id>;
FillLut<id-1,dummy>::fillLut(l);
}
};
template<int dummy> struct FillLut<-1,dummy> {
static void fillLut(UpdateValueLut &) {}
};
void (*lut_[Num<LEVELS-1>::R])(MinKeeper<ids>&);
public:
UpdateValueLut() { FillLut<Num<LEVELS-1>::R-1,0>::fillLut(*this); }
void call(int id, MinKeeper<ids> &mk) const { lut_[id](mk); }
};
static UpdateValueLut updateValueLut;
unsigned long values[ids];
unsigned long minValue_;
int a[Sum<LEVELS>::R];
template<int id> static void updateValue(MinKeeper<ids> &m);
public:
explicit MinKeeper(unsigned long initValue = 0xFFFFFFFF);
int min() const { return a[0]; }
explicit MinKeeper(unsigned long initValue);
int min() const { return a_[0]; }
unsigned long minValue() const { return minValue_; }
template<int id>
void setValue(const unsigned long cnt) {
values[id] = cnt;
void setValue(unsigned long cnt) {
values_[id] = cnt;
updateValue<id / 2>(*this);
}
void setValue(const int id, const unsigned long cnt) {
values[id] = cnt;
void setValue(int id, unsigned long cnt) {
values_[id] = cnt;
updateValueLut.call(id >> 1, *this);
}
unsigned long value(const int id) const { return values[id]; }
unsigned long value(int id) const { return values_[id]; }
private:
enum { height = min_keeper_detail::CeiledLog2<ids>::r };
template<int depth> struct Num { enum { r = min_keeper_detail::CeiledDiv2n<ids, height - depth>::r }; };
template<int depth> struct Sum { enum { r = min_keeper_detail::Sum<Num, depth>::r }; };
template<int id, int depth>
struct UpdateValue {
enum { p = Sum<depth - 1>::r + id
, c0 = Sum<depth>::r + id * 2
, c1 = id * 2 + 1 < Num<depth>::r ? c0 + 1 : c0 };
static void updateValue(MinKeeper<ids> &m) {
m.a_[p] = m.values_[m.a_[c0]] < m.values_[m.a_[c1]] ? m.a_[c0] : m.a_[c1];
UpdateValue<id / 2, depth - 1>::updateValue(m);
}
};
template<int id>
struct UpdateValue<id, 0> {
static void updateValue(MinKeeper<ids> &m) {
m.minValue_ = m.values_[m.a_[0]];
}
};
class UpdateValueLut {
public:
UpdateValueLut() { FillLut<Num<height - 1>::r - 1, 0>::fillLut(*this); }
void call(int id, MinKeeper<ids> &mk) const { lut_[id](mk); }
private:
template<int id, int dummy>
struct FillLut {
static void fillLut(UpdateValueLut & l) {
l.lut_[id] = updateValue<id>;
FillLut<id - 1, dummy>::fillLut(l);
}
};
template<int dummy>
struct FillLut<-1, dummy> {
static void fillLut(UpdateValueLut &) {}
};
void (*lut_[Num<height - 1>::r])(MinKeeper<ids> &);
};
static UpdateValueLut updateValueLut;
unsigned long values_[ids];
unsigned long minValue_;
int a_[Sum<height>::r];
template<int id> static void updateValue(MinKeeper<ids> &m);
public:
// not sure if i understood everything in minkeeper correctly, so something might be missing here?
template<bool isReader>
void SyncState(gambatte::NewState *ns)
{
NSS(values);
NSS(values_);
NSS(minValue_);
NSS(a);
NSS(a_);
}
};
template<int ids> typename MinKeeper<ids>::UpdateValueLut MinKeeper<ids>::updateValueLut;
template<int ids>
MinKeeper<ids>::MinKeeper(const unsigned long initValue) {
std::fill(values, values + ids, initValue);
for (int i = 0; i < Num<LEVELS-1>::R; ++i) {
a[Sum<LEVELS-1>::R + i] = (i * 2 + 1 == ids || values[i * 2] < values[i * 2 + 1]) ? i * 2 : i * 2 + 1;
MinKeeper<ids>::MinKeeper(unsigned long const initValue) {
std::fill(values_, values_ + ids, initValue);
// todo: simplify/less template bloat.
for (int i = 0; i < Num<height - 1>::r; ++i) {
int const c0 = i * 2;
int const c1 = c0 + 1 < ids ? c0 + 1 : c0;
a_[Sum<height - 1>::r + i] = values_[c0] < values_[c1] ? c0 : c1;
}
int n = Num<LEVELS-1>::R;
int off = Sum<LEVELS-1>::R;
while (off) {
const int pn = (n + 1) >> 1;
const int poff = off - pn;
int n = Num<height - 1>::r;
int offset = Sum<height - 1>::r;
while (offset) {
int const pn = (n + 1) >> 1;
int const poff = offset - pn;
for (int i = 0; i < pn; ++i) {
a[poff + i] = (i * 2 + 1 == n ||
values[a[off + i * 2]] < values[a[off + i * 2 + 1]]) ?
a[off + i * 2] : a[off + i * 2 + 1];
int const c0 = offset + i * 2;
int const c1 = i * 2 + 1 < n ? c0 + 1 : c0;
a_[poff + i] = values_[a_[c0]] < values_[a_[c1]] ? a_[c0] : a_[c1];
}
off = poff;
n = pn;
offset = poff;
n = pn;
}
minValue_ = values[a[0]];
minValue_ = values_[a_[0]];
}
template<int ids>
template<int id>
void MinKeeper<ids>::updateValue(MinKeeper<ids> &m) {
m.a[Sum<LEVELS-1>::R + id] = (id * 2 + 1 == ids || m.values[id * 2] < m.values[id * 2 + 1]) ? id * 2 : id * 2 + 1;
UpdateValue<id / 2, LEVELS-1>::updateValue(m);
enum { c0 = id * 2
, c1 = c0 + 1 < ids ? c0 + 1 : c0 };
m.a_[Sum<height - 1>::r + id] = m.values_[c0] < m.values_[c1] ? c0 : c1;
UpdateValue<id / 2, height - 1>::updateValue(m);
}
#endif

16
libgambatte/src/newstate.cpp
View File

@ -8,11 +8,11 @@ NewStateDummy::NewStateDummy()
:length(0)
{
}
void NewStateDummy::Save(const void *ptr, size_t size, const char *name)
void NewStateDummy::Save(void const *ptr, size_t size, char const *name)
{
length += size;
}
void NewStateDummy::Load(void *ptr, size_t size, const char *name)
void NewStateDummy::Load(void *ptr, size_t size, char const *name)
{
}
@ -21,7 +21,7 @@ NewStateExternalBuffer::NewStateExternalBuffer(char *buffer, long maxlength)
{
}
void NewStateExternalBuffer::Save(const void *ptr, size_t size, const char *name)
void NewStateExternalBuffer::Save(void const *ptr, size_t size, char const *name)
{
if (maxlength - length >= (long)size)
{
@ -30,7 +30,7 @@ void NewStateExternalBuffer::Save(const void *ptr, size_t size, const char *name
length += size;
}
void NewStateExternalBuffer::Load(void *ptr, size_t size, const char *name)
void NewStateExternalBuffer::Load(void *ptr, size_t size, char const *name)
{
char *dst = static_cast<char *>(ptr);
if (maxlength - length >= (long)size)
@ -48,19 +48,19 @@ NewStateExternalFunctions::NewStateExternalFunctions(const FPtrs *ff)
{
}
void NewStateExternalFunctions::Save(const void *ptr, size_t size, const char *name)
void NewStateExternalFunctions::Save(void const *ptr, size_t size, char const *name)
{
Save_(ptr, size, name);
}
void NewStateExternalFunctions::Load(void *ptr, size_t size, const char *name)
void NewStateExternalFunctions::Load(void *ptr, size_t size, char const *name)
{
Load_(ptr, size, name);
}
void NewStateExternalFunctions::EnterSection(const char *name)
void NewStateExternalFunctions::EnterSection(char const *name)
{
EnterSection_(name);
}
void NewStateExternalFunctions::ExitSection(const char *name)
void NewStateExternalFunctions::ExitSection(char const *name)
{
ExitSection_(name);
}

52
libgambatte/src/newstate.h
View File

@ -9,10 +9,10 @@ namespace gambatte {
class NewState
{
public:
virtual void Save(const void *ptr, size_t size, const char *name) = 0;
virtual void Load(void *ptr, size_t size, const char *name) = 0;
virtual void EnterSection(const char *name) { }
virtual void ExitSection(const char *name) { }
virtual void Save(void const *ptr, std::size_t size, char const *name) = 0;
virtual void Load(void *ptr, std::size_t size, char const *name) = 0;
virtual void EnterSection(char const *name) { }
virtual void ExitSection(char const *name) { }
};
class NewStateDummy : public NewState
@ -23,8 +23,8 @@ public:
NewStateDummy();
long GetLength() { return length; }
void Rewind() { length = 0; }
virtual void Save(const void *ptr, size_t size, const char *name);
virtual void Load(void *ptr, size_t size, const char *name);
virtual void Save(void const *ptr, std::size_t size, char const *name);
virtual void Load(void *ptr, std::size_t size, char const *name);
};
class NewStateExternalBuffer : public NewState
@ -38,34 +38,34 @@ public:
long GetLength() { return length; }
void Rewind() { length = 0; }
bool Overflow() { return length > maxlength; }
virtual void Save(const void *ptr, size_t size, const char *name);
virtual void Load(void *ptr, size_t size, const char *name);
virtual void Save(void const *ptr, std::size_t size, char const *name);
virtual void Load(void *ptr, std::size_t size, char const *name);
};
struct FPtrs
{
void (*Save_)(const void *ptr, size_t size, const char *name);
void (*Load_)(void *ptr, size_t size, const char *name);
void (*EnterSection_)(const char *name);
void (*ExitSection_)(const char *name);
void (*Save_)(void const *ptr, std::size_t size, char const *name);
void (*Load_)(void *ptr, std::size_t size, char const *name);
void (*EnterSection_)(char const *name);
void (*ExitSection_)(char const *name);
};
class NewStateExternalFunctions : public NewState
{
private:
void (*Save_)(const void *ptr, size_t size, const char *name);
void (*Load_)(void *ptr, size_t size, const char *name);
void (*EnterSection_)(const char *name);
void (*ExitSection_)(const char *name);
void (*Save_)(void const *ptr, std::size_t size, char const *name);
void (*Load_)(void *ptr, std::size_t size, char const *name);
void (*EnterSection_)(char const *name);
void (*ExitSection_)(char const *name);
public:
NewStateExternalFunctions(const FPtrs *ff);
virtual void Save(const void *ptr, size_t size, const char *name);
virtual void Load(void *ptr, size_t size, const char *name);
virtual void EnterSection(const char *name);
virtual void ExitSection(const char *name);
virtual void Save(void const *ptr, std::size_t size, char const *name);
virtual void Load(void *ptr, std::size_t size, char const *name);
virtual void EnterSection(char const *name);
virtual void ExitSection(char const *name);
};
// defines and explicitly instantiates
// defines and explicitly instantiates
#define SYNCFUNC(x)\
template void x::SyncState<false>(NewState *ns);\
template void x::SyncState<true>(NewState *ns);\
@ -80,18 +80,18 @@ public:
// first line is default value in converted enum; last line is default value in argument x
#define EBS(x,d) do { int _ttmp = (d); if (isReader) ns->Load(&_ttmp, sizeof(_ttmp), #x); if (0)
#define EBS(x,d) do { int _ttmp = (d); if (isReader) ns->Load(&_ttmp, sizeof _ttmp, #x); if (0)
#define EVS(x,v,n) else if (!isReader && (x) == (v)) _ttmp = (n); else if (isReader && _ttmp == (n)) (x) = (v)
#define EES(x,d) else if (isReader) (x) = (d); if (!isReader) ns->Save(&_ttmp, sizeof(_ttmp), #x); } while (0)
#define EES(x,d) else if (isReader) (x) = (d); if (!isReader) ns->Save(&_ttmp, sizeof _ttmp, #x); } while (0)
#define RSS(x,b) do { if (isReader)\
{ ptrdiff_t _ttmp; ns->Load(&_ttmp, sizeof(_ttmp), #x); (x) = (_ttmp == (ptrdiff_t)0xdeadbeef ? 0 : (b) + _ttmp); }\
{ std::ptrdiff_t _ttmp; ns->Load(&_ttmp, sizeof _ttmp, #x); (x) = (_ttmp == (std::ptrdiff_t)0xdeadbeef ? 0 : (b) + _ttmp); }\
else\
{ ptrdiff_t _ttmp = (x) == 0 ? 0xdeadbeef : (x) - (b); ns->Save(&_ttmp, sizeof(_ttmp), #x); } } while (0)
{ std::ptrdiff_t _ttmp = (x) == 0 ? 0xdeadbeef : (x) - (b); ns->Save(&_ttmp, sizeof _ttmp, #x); } } while (0)
#define PSS(x,s) do { if (isReader) ns->Load((x), (s), #x); else ns->Save((x), (s), #x); } while (0)
#define NSS(x) do { if (isReader) ns->Load(&(x), sizeof(x), #x); else ns->Save(&(x), sizeof(x), #x); } while (0)
#define NSS(x) do { if (isReader) ns->Load(&(x), sizeof x, #x); else ns->Save(&(x), sizeof x, #x); } while (0)
#define SSS(x) do { ns->EnterSection(#x); (x).SyncState<isReader>(ns); ns->ExitSection(#x); } while (0)

149
libgambatte/src/savestate.h
View File

@ -1,24 +1,25 @@
/***************************************************************************
* Copyright (C) 2008 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2008 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SAVESTATE_H
#define SAVESTATE_H
#include <cstddef>
#include <cstdint>
namespace gambatte {
@ -28,69 +29,72 @@ class SaverList;
struct SaveState {
template<typename T>
class Ptr {
T *ptr;
unsigned long sz;
public:
Ptr() : ptr(0), sz(0) {}
const T* get() const { return ptr; }
unsigned long getSz() const { return sz; }
void set(T *ptr, const unsigned long sz) { this->ptr = ptr; this->sz = sz; }
Ptr() : ptr(0), size_(0) {}
T const * get() const { return ptr; }
std::size_t size() const { return size_; }
void set(T *p, std::size_t size) { ptr = p; size_ = size; }
friend class SaverList;
friend void setInitState(SaveState &, bool, bool, std::uint32_t, unsigned);
friend void setInitState(SaveState &, bool, bool);
private:
T *ptr;
std::size_t size_;
};
struct CPU {
unsigned long cycleCounter;
unsigned short PC;
unsigned short SP;
unsigned char A;
unsigned char B;
unsigned char C;
unsigned char D;
unsigned char E;
unsigned char F;
unsigned char H;
unsigned char L;
bool skip;
unsigned short pc;
unsigned short sp;
unsigned char a;
unsigned char b;
unsigned char c;
unsigned char d;
unsigned char e;
unsigned char f;
unsigned char h;
unsigned char l;
unsigned char /*bool*/ skip;
} cpu;
struct Mem {
Ptr<unsigned char> vram;
Ptr<unsigned char> sram;
Ptr<unsigned char> wram;
Ptr<unsigned char> ioamhram;
unsigned long divLastUpdate;
unsigned long timaBasetime;
unsigned long timaLastUpdate;
unsigned long tmatime;
unsigned long nextSerialtime;
unsigned long lastOamDmaUpdate;
unsigned long minIntTime;
unsigned long unhaltTime;
unsigned long halttime;
unsigned short rombank;
unsigned short dmaSource;
unsigned short dmaDestination;
unsigned char rambank;
unsigned char oamDmaPos;
bool IME;
bool halted;
bool enableRam;
bool rambankMode;
bool hdmaTransfer;
bool biosMode;
bool cgbSwitching;
bool agbMode;
bool gbIsCgb;
unsigned char /*bool*/ IME;
unsigned char /*bool*/ halted;
unsigned char /*bool*/ enableRam;
unsigned char /*bool*/ rambankMode;
unsigned char /*bool*/ hdmaTransfer;
unsigned char /*bool*/ biosMode;
unsigned char /*bool*/ cgbSwitching;
unsigned char /*bool*/ agbMode;
unsigned char /*bool*/ gbIsCgb;
unsigned char /*bool*/ stopped;
} mem;
struct PPU {
Ptr<unsigned char> bgpData;
Ptr<unsigned char> objpData;
//SpriteMapper::OamReader
Ptr<unsigned char> oamReaderBuf;
Ptr<bool> oamReaderSzbuf;
unsigned long videoCycles;
unsigned long enableDisplayM0Time;
unsigned short lastM0Time;
@ -115,50 +119,51 @@ struct SaveState {
unsigned char oldWy;
unsigned char winDrawState;
unsigned char wscx;
bool weMaster;
bool pendingLcdstatIrq;
bool isCgb;
unsigned char /*bool*/ weMaster;
unsigned char /*bool*/ pendingLcdstatIrq;
unsigned char /*bool*/ isCgb;
} ppu;
struct SPU {
struct Duty {
unsigned long nextPosUpdate;
unsigned char nr3;
unsigned char pos;
unsigned char /*bool*/ high;
};
struct Env {
unsigned long counter;
unsigned char volume;
};
struct LCounter {
unsigned long counter;
unsigned short lengthCounter;
};
struct {
struct {
unsigned long counter;
unsigned short shadow;
unsigned char nr0;
bool negging;
unsigned char /*bool*/ negging;
} sweep;
Duty duty;
Env env;
LCounter lcounter;
unsigned char nr4;
bool master;
unsigned char /*bool*/ master;
} ch1;
struct {
Duty duty;
Env env;
LCounter lcounter;
unsigned char nr4;
bool master;
unsigned char /*bool*/ master;
} ch2;
struct {
Ptr<unsigned char> waveRam;
LCounter lcounter;
@ -168,9 +173,9 @@ struct SaveState {
unsigned char nr4;
unsigned char wavePos;
unsigned char sampleBuf;
bool master;
unsigned char /*bool*/ master;
} ch3;
struct {
struct {
unsigned long counter;
@ -179,21 +184,27 @@ struct SaveState {
Env env;
LCounter lcounter;
unsigned char nr4;
bool master;
unsigned char /*bool*/ master;
} ch4;
unsigned long cycleCounter;
} spu;
struct Time {
unsigned long seconds;
unsigned long lastTimeSec;
unsigned long lastTimeUsec;
unsigned long lastCycles;
} time;
struct RTC {
unsigned long baseTime;
unsigned long haltTime;
unsigned char dataDh;
unsigned char dataDl;
unsigned char dataH;
unsigned char dataM;
unsigned char dataS;
bool lastLatchData;
unsigned char /*bool*/ lastLatchData;
} rtc;
};

219
libgambatte/src/sound.cpp
View File

@ -1,33 +1,33 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "sound.h"
#include "savestate.h"
#include <cstring>
#include <algorithm>
#include <cstring>
/*
Frame Sequencer
Step Length Ctr Vol Env Sweep
- - - - - - - - - - - - - - - - - - - -
0 Clock - Clock
S 1 - Clock -
S0 0 Clock - Clock
S1 1 - Clock -
2 Clock - -
3 - - -
4 Clock - Clock
@ -37,84 +37,84 @@ S 1 - Clock -
- - - - - - - - - - - - - - - - - - - -
Rate 256 Hz 64 Hz 128 Hz
S) start step on sound power on.
S0) start step on sound power on.
S1) step gets immediately incremented at power on if closer to previous edge than next.
Clock) clock timer on transition to step.
*/
namespace gambatte {
PSG::PSG()
: buffer(0),
lastUpdate(0),
soVol(0),
rsum(0x8000), // initialize to 0x8000 to prevent borrows from high word, xor away later
bufferPos(0),
enabled(false)
: buffer_(0)
, bufferPos_(0)
, lastUpdate_(0)
, soVol_(0)
, rsum_(0x8000) // initialize to 0x8000 to prevent borrows from high word, xor away later
, enabled_(false)
{
}
void PSG::init(const bool cgb) {
ch1.init(cgb);
ch2.init(cgb);
ch3.init(cgb);
ch4.init(cgb);
void PSG::init(bool cgb) {
ch1_.init(cgb);
ch3_.init(cgb);
}
void PSG::reset() {
ch1.reset();
ch2.reset();
ch3.reset();
ch4.reset();
ch1_.reset();
ch2_.reset();
ch3_.reset();
ch4_.reset();
}
void PSG::setStatePtrs(SaveState &state) {
ch3.setStatePtrs(state);
ch3_.setStatePtrs(state);
}
void PSG::loadState(const SaveState &state) {
ch1.loadState(state);
ch2.loadState(state);
ch3.loadState(state);
ch4.loadState(state);
lastUpdate = state.cpu.cycleCounter;
set_so_volume(state.mem.ioamhram.get()[0x124]);
map_so(state.mem.ioamhram.get()[0x125]);
enabled = state.mem.ioamhram.get()[0x126] >> 7 & 1;
void PSG::loadState(SaveState const &state) {
ch1_.loadState(state);
ch2_.loadState(state);
ch3_.loadState(state);
ch4_.loadState(state);
lastUpdate_ = state.cpu.cycleCounter;
setSoVolume(state.mem.ioamhram.get()[0x124]);
mapSo(state.mem.ioamhram.get()[0x125]);
enabled_ = state.mem.ioamhram.get()[0x126] >> 7 & 1;
}
void PSG::accumulate_channels(const unsigned long cycles) {
uint_least32_t *const buf = buffer + bufferPos;
std::memset(buf, 0, cycles * sizeof(uint_least32_t));
ch1.update(buf, soVol, cycles);
ch2.update(buf, soVol, cycles);
ch3.update(buf, soVol, cycles);
ch4.update(buf, soVol, cycles);
void PSG::accumulateChannels(unsigned long const cycles) {
uint_least32_t *const buf = buffer_ + bufferPos_;
std::memset(buf, 0, cycles * sizeof *buf);
ch1_.update(buf, soVol_, cycles);
ch2_.update(buf, soVol_, cycles);
ch3_.update(buf, soVol_, cycles);
ch4_.update(buf, soVol_, cycles);
}
void PSG::generate_samples(const unsigned long cycleCounter, const unsigned doubleSpeed) {
const unsigned long cycles = (cycleCounter - lastUpdate) >> (1 + doubleSpeed);
lastUpdate += cycles << (1 + doubleSpeed);
void PSG::generateSamples(unsigned long const cycleCounter, bool const doubleSpeed) {
unsigned long const cycles = (cycleCounter - lastUpdate_) >> (1 + doubleSpeed);
lastUpdate_ += cycles << (1 + doubleSpeed);
if (cycles)
accumulate_channels(cycles);
bufferPos += cycles;
accumulateChannels(cycles);
bufferPos_ += cycles;
}
void PSG::resetCounter(const unsigned long newCc, const unsigned long oldCc, const unsigned doubleSpeed) {
generate_samples(oldCc, doubleSpeed);
lastUpdate = newCc - (oldCc - lastUpdate);
void PSG::resetCounter(unsigned long newCc, unsigned long oldCc, bool doubleSpeed) {
generateSamples(oldCc, doubleSpeed);
lastUpdate_ = newCc - (oldCc - lastUpdate_);
}
unsigned PSG::fillBuffer() {
uint_least32_t sum = rsum;
uint_least32_t *b = buffer;
unsigned n = bufferPos;
if (unsigned n2 = n >> 3) {
std::size_t PSG::fillBuffer() {
uint_least32_t sum = rsum_;
uint_least32_t *b = buffer_;
std::size_t n = bufferPos_;
if (std::size_t n2 = n >> 3) {
n -= n2 << 3;
do {
sum += b[0];
b[0] = sum ^ 0x8000;
@ -132,57 +132,66 @@ unsigned PSG::fillBuffer() {
b[6] = sum ^ 0x8000;
sum += b[7];
b[7] = sum ^ 0x8000;
b += 8;
} while (--n2);
}
while (n--) {
sum += *b;
*b++ = sum ^ 0x8000; // xor away the initial rsum value of 0x8000 (which prevents borrows from the high word) from the low word
// xor away the initial rsum value of 0x8000 (which prevents
// borrows from the high word) from the low word
*b++ = sum ^ 0x8000;
}
rsum = sum;
return bufferPos;
rsum_ = sum;
return bufferPos_;
}
#ifdef WORDS_BIGENDIAN
static const unsigned long so1Mul = 0x00000001;
static const unsigned long so2Mul = 0x00010000;
#else
static const unsigned long so1Mul = 0x00010000;
static const unsigned long so2Mul = 0x00000001;
#endif
void PSG::set_so_volume(const unsigned nr50) {
soVol = (((nr50 & 0x7) + 1) * so1Mul + ((nr50 >> 4 & 0x7) + 1) * so2Mul) * 64;
static bool isBigEndianSampleOrder() {
union {
uint_least32_t ul32;
unsigned char uc[sizeof(uint_least32_t)];
} u;
u.ul32 = -0x10000;
return u.uc[0];
}
void PSG::map_so(const unsigned nr51) {
const unsigned long tmp = nr51 * so1Mul + (nr51 >> 4) * so2Mul;
ch1.setSo((tmp & 0x00010001) * 0xFFFF);
ch2.setSo((tmp >> 1 & 0x00010001) * 0xFFFF);
ch3.setSo((tmp >> 2 & 0x00010001) * 0xFFFF);
ch4.setSo((tmp >> 3 & 0x00010001) * 0xFFFF);
static unsigned long so1Mul() { return isBigEndianSampleOrder() ? 0x00000001 : 0x00010000; }
static unsigned long so2Mul() { return isBigEndianSampleOrder() ? 0x00010000 : 0x00000001; }
void PSG::setSoVolume(unsigned nr50) {
soVol_ = ((nr50 & 0x7) + 1) * so1Mul() * 64
+ ((nr50 >> 4 & 0x7) + 1) * so2Mul() * 64;
}
void PSG::mapSo(unsigned nr51) {
unsigned long so = nr51 * so1Mul() + (nr51 >> 4) * so2Mul();
ch1_.setSo((so & 0x00010001) * 0xFFFF);
ch2_.setSo((so >> 1 & 0x00010001) * 0xFFFF);
ch3_.setSo((so >> 2 & 0x00010001) * 0xFFFF);
ch4_.setSo((so >> 3 & 0x00010001) * 0xFFFF);
}
unsigned PSG::getStatus() const {
return ch1.isActive() | ch2.isActive() << 1 | ch3.isActive() << 2 | ch4.isActive() << 3;
return ch1_.isActive()
| ch2_.isActive() << 1
| ch3_.isActive() << 2
| ch4_.isActive() << 3;
}
// the buffer and position are not saved, as they're set and flushed on each runfor() call
SYNCFUNC(PSG)
{
SSS(ch1);
SSS(ch2);
SSS(ch3);
SSS(ch4);
NSS(lastUpdate);
NSS(soVol);
NSS(rsum);
NSS(enabled);
SSS(ch1_);
SSS(ch2_);
SSS(ch3_);
SSS(ch4_);
NSS(lastUpdate_);
NSS(soVol_);
NSS(rsum_);
NSS(enabled_);
}
}

130
libgambatte/src/sound.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SOUND_H
#define SOUND_H
@ -28,67 +28,65 @@
namespace gambatte {
class PSG {
Channel1 ch1;
Channel2 ch2;
Channel3 ch3;
Channel4 ch4;
uint_least32_t *buffer;
unsigned long lastUpdate;
unsigned long soVol;
uint_least32_t rsum;
unsigned bufferPos;
bool enabled;
void accumulate_channels(unsigned long cycles);
public:
PSG();
void init(bool cgb);
void reset();
void setStatePtrs(SaveState &state);
void loadState(const SaveState &state);
void loadState(SaveState const &state);
void generate_samples(unsigned long cycleCounter, unsigned doubleSpeed);
void resetCounter(unsigned long newCc, unsigned long oldCc, unsigned doubleSpeed);
unsigned fillBuffer();
void setBuffer(uint_least32_t *const buf) { buffer = buf; bufferPos = 0; }
bool isEnabled() const { return enabled; }
void setEnabled(bool value) { enabled = value; }
void generateSamples(unsigned long cycleCounter, bool doubleSpeed);
void resetCounter(unsigned long newCc, unsigned long oldCc, bool doubleSpeed);
std::size_t fillBuffer();
void setBuffer(uint_least32_t *buf) { buffer_ = buf; bufferPos_ = 0; }
void set_nr10(unsigned data) { ch1.setNr0(data); }
void set_nr11(unsigned data) { ch1.setNr1(data); }
void set_nr12(unsigned data) { ch1.setNr2(data); }
void set_nr13(unsigned data) { ch1.setNr3(data); }
void set_nr14(unsigned data) { ch1.setNr4(data); }
bool isEnabled() const { return enabled_; }
void setEnabled(bool value) { enabled_ = value; }
void set_nr21(unsigned data) { ch2.setNr1(data); }
void set_nr22(unsigned data) { ch2.setNr2(data); }
void set_nr23(unsigned data) { ch2.setNr3(data); }
void set_nr24(unsigned data) { ch2.setNr4(data); }
void setNr10(unsigned data) { ch1_.setNr0(data); }
void setNr11(unsigned data) { ch1_.setNr1(data); }
void setNr12(unsigned data) { ch1_.setNr2(data); }
void setNr13(unsigned data) { ch1_.setNr3(data); }
void setNr14(unsigned data) { ch1_.setNr4(data); }
void set_nr30(unsigned data) { ch3.setNr0(data); }
void set_nr31(unsigned data) { ch3.setNr1(data); }
void set_nr32(unsigned data) { ch3.setNr2(data); }
void set_nr33(unsigned data) { ch3.setNr3(data); }
void set_nr34(unsigned data) { ch3.setNr4(data); }
unsigned waveRamRead(unsigned index) const { return ch3.waveRamRead(index); }
void waveRamWrite(unsigned index, unsigned data) { ch3.waveRamWrite(index, data); }
void setNr21(unsigned data) { ch2_.setNr1(data); }
void setNr22(unsigned data) { ch2_.setNr2(data); }
void setNr23(unsigned data) { ch2_.setNr3(data); }
void setNr24(unsigned data) { ch2_.setNr4(data); }
void set_nr41(unsigned data) { ch4.setNr1(data); }
void set_nr42(unsigned data) { ch4.setNr2(data); }
void set_nr43(unsigned data) { ch4.setNr3(data); }
void set_nr44(unsigned data) { ch4.setNr4(data); }
void setNr30(unsigned data) { ch3_.setNr0(data); }
void setNr31(unsigned data) { ch3_.setNr1(data); }
void setNr32(unsigned data) { ch3_.setNr2(data); }
void setNr33(unsigned data) { ch3_.setNr3(data); }
void setNr34(unsigned data) { ch3_.setNr4(data); }
unsigned waveRamRead(unsigned index) const { return ch3_.waveRamRead(index); }
void waveRamWrite(unsigned index, unsigned data) { ch3_.waveRamWrite(index, data); }
void set_so_volume(unsigned nr50);
void map_so(unsigned nr51);
void setNr41(unsigned data) { ch4_.setNr1(data); }
void setNr42(unsigned data) { ch4_.setNr2(data); }
void setNr43(unsigned data) { ch4_.setNr3(data); }
void setNr44(unsigned data) { ch4_.setNr4(data); }
void setSoVolume(unsigned nr50);
void mapSo(unsigned nr51);
unsigned getStatus() const;
private:
Channel1 ch1_;
Channel2 ch2_;
Channel3 ch3_;
Channel4 ch4_;
uint_least32_t *buffer_;
std::size_t bufferPos_;
unsigned long lastUpdate_;
unsigned long soVol_;
uint_least32_t rsum_;
bool enabled_;
void accumulateChannels(unsigned long cycles);
public:
template<bool isReader>void SyncState(NewState *ns);
};

367
libgambatte/src/sound/channel1.cpp
View File

@ -1,275 +1,276 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aam<EFBFBD>s *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "channel1.h"
#include "../savestate.h"
#include <algorithm>
namespace gambatte {
Channel1::SweepUnit::SweepUnit(MasterDisabler &disabler, DutyUnit &dutyUnit) :
disableMaster(disabler),
dutyUnit(dutyUnit),
shadow(0),
nr0(0),
negging(false)
{}
Channel1::SweepUnit::SweepUnit(MasterDisabler &disabler, DutyUnit &dutyUnit)
: disableMaster_(disabler)
, dutyUnit_(dutyUnit)
, shadow_(0)
, nr0_(0)
, negging_(false)
, cgb_(false)
{
}
unsigned Channel1::SweepUnit::calcFreq() {
unsigned freq = shadow >> (nr0 & 0x07);
if (nr0 & 0x08) {
freq = shadow - freq;
negging = true;
unsigned freq = shadow_ >> (nr0_ & 0x07);
if (nr0_ & 0x08) {
freq = shadow_ - freq;
negging_ = true;
} else
freq = shadow + freq;
freq = shadow_ + freq;
if (freq & 2048)
disableMaster();
disableMaster_();
return freq;
}
void Channel1::SweepUnit::event() {
const unsigned long period = nr0 >> 4 & 0x07;
unsigned long const period = nr0_ >> 4 & 0x07;
if (period) {
const unsigned freq = calcFreq();
if (!(freq & 2048) && (nr0 & 0x07)) {
shadow = freq;
dutyUnit.setFreq(freq, counter);
unsigned const freq = calcFreq();
if (!(freq & 2048) && (nr0_ & 0x07)) {
shadow_ = freq;
dutyUnit_.setFreq(freq, counter_);
calcFreq();
}
counter += period << 14;
counter_ += period << 14;
} else
counter += 8ul << 14;
counter_ += 8ul << 14;
}
void Channel1::SweepUnit::nr0Change(const unsigned newNr0) {
if (negging && !(newNr0 & 0x08))
disableMaster();
nr0 = newNr0;
void Channel1::SweepUnit::nr0Change(unsigned newNr0) {
if (negging_ && !(newNr0 & 0x08))
disableMaster_();
nr0_ = newNr0;
}
void Channel1::SweepUnit::nr4Init(const unsigned long cc) {
negging = false;
shadow = dutyUnit.getFreq();
const unsigned period = nr0 >> 4 & 0x07;
const unsigned shift = nr0 & 0x07;
void Channel1::SweepUnit::nr4Init(unsigned long const cc) {
negging_ = false;
shadow_ = dutyUnit_.freq();
unsigned const period = nr0_ >> 4 & 0x07;
unsigned const shift = nr0_ & 0x07;
if (period | shift)
counter = ((cc >> 14) + (period ? period : 8)) << 14;
counter_ = ((((cc + 2 + cgb_ * 2) >> 14) + (period ? period : 8)) << 14) + 2;
else
counter = COUNTER_DISABLED;
counter_ = counter_disabled;
if (shift)
calcFreq();
}
void Channel1::SweepUnit::reset() {
counter = COUNTER_DISABLED;
counter_ = counter_disabled;
}
void Channel1::SweepUnit::loadState(const SaveState &state) {
counter = std::max(state.spu.ch1.sweep.counter, state.spu.cycleCounter);
shadow = state.spu.ch1.sweep.shadow;
nr0 = state.spu.ch1.sweep.nr0;
negging = state.spu.ch1.sweep.negging;
void Channel1::SweepUnit::loadState(SaveState const &state) {
counter_ = std::max(state.spu.ch1.sweep.counter, state.spu.cycleCounter);
shadow_ = state.spu.ch1.sweep.shadow;
nr0_ = state.spu.ch1.sweep.nr0;
negging_ = state.spu.ch1.sweep.negging;
}
template<bool isReader>
void Channel1::SweepUnit::SyncState(NewState *ns)
{
NSS(counter);
NSS(shadow);
NSS(nr0);
NSS(negging);
NSS(counter_);
NSS(shadow_);
NSS(nr0_);
NSS(negging_);
NSS(cgb_);
}
Channel1::Channel1() :
staticOutputTest(*this, dutyUnit),
disableMaster(master, dutyUnit),
lengthCounter(disableMaster, 0x3F),
envelopeUnit(staticOutputTest),
sweepUnit(disableMaster, dutyUnit),
cycleCounter(0),
soMask(0),
prevOut(0),
nr4(0),
master(false)
Channel1::Channel1()
: staticOutputTest_(*this, dutyUnit_)
, disableMaster_(master_, dutyUnit_)
, lengthCounter_(disableMaster_, 0x3F)
, envelopeUnit_(staticOutputTest_)
, sweepUnit_(disableMaster_, dutyUnit_)
, nextEventUnit_(0)
, cycleCounter_(0)
, soMask_(0)
, prevOut_(0)
, nr4_(0)
, master_(false)
{
setEvent();
}
void Channel1::setEvent() {
// nextEventUnit = &dutyUnit;
// if (sweepUnit.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &sweepUnit;
if (envelopeUnit.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &envelopeUnit;
if (lengthCounter.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &lengthCounter;
nextEventUnit_ = &sweepUnit_;
if (envelopeUnit_.counter() < nextEventUnit_->counter())
nextEventUnit_ = &envelopeUnit_;
if (lengthCounter_.counter() < nextEventUnit_->counter())
nextEventUnit_ = &lengthCounter_;
}
void Channel1::setNr0(const unsigned data) {
sweepUnit.nr0Change(data);
void Channel1::setNr0(unsigned data) {
sweepUnit_.nr0Change(data);
setEvent();
}
void Channel1::setNr1(const unsigned data) {
lengthCounter.nr1Change(data, nr4, cycleCounter);
dutyUnit.nr1Change(data, cycleCounter);
void Channel1::setNr1(unsigned data) {
lengthCounter_.nr1Change(data, nr4_, cycleCounter_);
dutyUnit_.nr1Change(data, cycleCounter_);
setEvent();
}
void Channel1::setNr2(const unsigned data) {
if (envelopeUnit.nr2Change(data))
disableMaster();
void Channel1::setNr2(unsigned data) {
if (envelopeUnit_.nr2Change(data))
disableMaster_();
else
staticOutputTest(cycleCounter);
staticOutputTest_(cycleCounter_);
setEvent();
}
void Channel1::setNr3(const unsigned data) {
dutyUnit.nr3Change(data, cycleCounter);
void Channel1::setNr3(unsigned data) {
dutyUnit_.nr3Change(data, cycleCounter_);
setEvent();
}
void Channel1::setNr4(const unsigned data) {
lengthCounter.nr4Change(nr4, data, cycleCounter);
nr4 = data;
dutyUnit.nr4Change(data, cycleCounter);
if (data & 0x80) { //init-bit
nr4 &= 0x7F;
master = !envelopeUnit.nr4Init(cycleCounter);
sweepUnit.nr4Init(cycleCounter);
staticOutputTest(cycleCounter);
void Channel1::setNr4(unsigned const data) {
lengthCounter_.nr4Change(nr4_, data, cycleCounter_);
nr4_ = data;
dutyUnit_.nr4Change(data, cycleCounter_, master_);
if (data & 0x80) { // init-bit
nr4_ &= 0x7F;
master_ = !envelopeUnit_.nr4Init(cycleCounter_);
sweepUnit_.nr4Init(cycleCounter_);
staticOutputTest_(cycleCounter_);
}
setEvent();
}
void Channel1::setSo(const unsigned long soMask) {
this->soMask = soMask;
staticOutputTest(cycleCounter);
void Channel1::setSo(unsigned long soMask) {
soMask_ = soMask;
staticOutputTest_(cycleCounter_);
setEvent();
}
void Channel1::reset() {
cycleCounter = 0x1000 | (cycleCounter & 0xFFF); // cycleCounter >> 12 & 7 represents the frame sequencer position.
// cycleCounter >> 12 & 7 represents the frame sequencer position.
cycleCounter_ &= 0xFFF;
cycleCounter_ += ~(cycleCounter_ + 2) << 1 & 0x1000;
// lengthCounter.reset();
dutyUnit.reset();
envelopeUnit.reset();
sweepUnit.reset();
dutyUnit_.reset();
envelopeUnit_.reset();
sweepUnit_.reset();
setEvent();
}
void Channel1::init(const bool cgb) {
lengthCounter.init(cgb);
void Channel1::init(bool cgb) {
sweepUnit_.init(cgb);
}
void Channel1::loadState(const SaveState &state) {
sweepUnit.loadState(state);
dutyUnit.loadState(state.spu.ch1.duty, state.mem.ioamhram.get()[0x111], state.spu.ch1.nr4, state.spu.cycleCounter);
envelopeUnit.loadState(state.spu.ch1.env, state.mem.ioamhram.get()[0x112], state.spu.cycleCounter);
lengthCounter.loadState(state.spu.ch1.lcounter, state.spu.cycleCounter);
cycleCounter = state.spu.cycleCounter;
nr4 = state.spu.ch1.nr4;
master = state.spu.ch1.master;
void Channel1::loadState(SaveState const &state) {
sweepUnit_.loadState(state);
dutyUnit_.loadState(state.spu.ch1.duty, state.mem.ioamhram.get()[0x111],
state.spu.ch1.nr4, state.spu.cycleCounter);
envelopeUnit_.loadState(state.spu.ch1.env, state.mem.ioamhram.get()[0x112],
state.spu.cycleCounter);
lengthCounter_.loadState(state.spu.ch1.lcounter, state.spu.cycleCounter);
cycleCounter_ = state.spu.cycleCounter;
nr4_ = state.spu.ch1.nr4;
master_ = state.spu.ch1.master;
}
void Channel1::update(uint_least32_t *buf, const unsigned long soBaseVol, unsigned long cycles) {
const unsigned long outBase = envelopeUnit.dacIsOn() ? soBaseVol & soMask : 0;
const unsigned long outLow = outBase * (0 - 15ul);
const unsigned long endCycles = cycleCounter + cycles;
void Channel1::update(uint_least32_t *buf, unsigned long const soBaseVol, unsigned long cycles) {
unsigned long const outBase = envelopeUnit_.dacIsOn() ? soBaseVol & soMask_ : 0;
unsigned long const outLow = outBase * (0 - 15ul);
unsigned long const endCycles = cycleCounter_ + cycles;
for (;;) {
const unsigned long outHigh = master ? outBase * (envelopeUnit.getVolume() * 2 - 15ul) : outLow;
const unsigned long nextMajorEvent = nextEventUnit->getCounter() < endCycles ? nextEventUnit->getCounter() : endCycles;
unsigned long out = dutyUnit.isHighState() ? outHigh : outLow;
while (dutyUnit.getCounter() <= nextMajorEvent) {
*buf = out - prevOut;
prevOut = out;
buf += dutyUnit.getCounter() - cycleCounter;
cycleCounter = dutyUnit.getCounter();
dutyUnit.event();
out = dutyUnit.isHighState() ? outHigh : outLow;
unsigned long const outHigh = master_
? outBase * (envelopeUnit_.getVolume() * 2 - 15ul)
: outLow;
unsigned long const nextMajorEvent = std::min(nextEventUnit_->counter(), endCycles);
unsigned long out = dutyUnit_.isHighState() ? outHigh : outLow;
while (dutyUnit_.counter() <= nextMajorEvent) {
*buf = out - prevOut_;
prevOut_ = out;
buf += dutyUnit_.counter() - cycleCounter_;
cycleCounter_ = dutyUnit_.counter();
dutyUnit_.event();
out = dutyUnit_.isHighState() ? outHigh : outLow;
}
if (cycleCounter < nextMajorEvent) {
*buf = out - prevOut;
prevOut = out;
buf += nextMajorEvent - cycleCounter;
cycleCounter = nextMajorEvent;
if (cycleCounter_ < nextMajorEvent) {
*buf = out - prevOut_;
prevOut_ = out;
buf += nextMajorEvent - cycleCounter_;
cycleCounter_ = nextMajorEvent;
}
if (nextEventUnit->getCounter() == nextMajorEvent) {
nextEventUnit->event();
if (nextEventUnit_->counter() == nextMajorEvent) {
nextEventUnit_->event();
setEvent();
} else
break;
}
if (cycleCounter & SoundUnit::COUNTER_MAX) {
dutyUnit.resetCounters(cycleCounter);
lengthCounter.resetCounters(cycleCounter);
envelopeUnit.resetCounters(cycleCounter);
sweepUnit.resetCounters(cycleCounter);
cycleCounter -= SoundUnit::COUNTER_MAX;
if (cycleCounter_ >= SoundUnit::counter_max) {
dutyUnit_.resetCounters(cycleCounter_);
lengthCounter_.resetCounters(cycleCounter_);
envelopeUnit_.resetCounters(cycleCounter_);
sweepUnit_.resetCounters(cycleCounter_);
cycleCounter_ -= SoundUnit::counter_max;
}
}
SYNCFUNC(Channel1)
{
SSS(lengthCounter);
SSS(dutyUnit);
SSS(envelopeUnit);
SSS(sweepUnit);
SSS(lengthCounter_);
SSS(dutyUnit_);
SSS(envelopeUnit_);
SSS(sweepUnit_);
EBS(nextEventUnit, 0);
EVS(nextEventUnit, &dutyUnit, 1);
EVS(nextEventUnit, &sweepUnit, 2);
EVS(nextEventUnit, &envelopeUnit, 3);
EVS(nextEventUnit, &lengthCounter, 4);
EES(nextEventUnit, NULL);
EBS(nextEventUnit_, 0);
EVS(nextEventUnit_, &dutyUnit_, 1);
EVS(nextEventUnit_, &sweepUnit_, 2);
EVS(nextEventUnit_, &envelopeUnit_, 3);
EVS(nextEventUnit_, &lengthCounter_, 4);
EES(nextEventUnit_, NULL);
NSS(cycleCounter);
NSS(soMask);
NSS(prevOut);
NSS(cycleCounter_);
NSS(soMask_);
NSS(prevOut_);
NSS(nr4);
NSS(master);
NSS(nr4_);
NSS(master_);
}
}

132
libgambatte/src/sound/channel1.h
View File

@ -1,29 +1,29 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SOUND_CHANNEL1_H
#define SOUND_CHANNEL1_H
#include "gbint.h"
#include "master_disabler.h"
#include "length_counter.h"
#include "duty_unit.h"
#include "envelope_unit.h"
#include "gbint.h"
#include "length_counter.h"
#include "master_disabler.h"
#include "static_output_tester.h"
#include "newstate.h"
@ -32,46 +32,6 @@ namespace gambatte {
struct SaveState;
class Channel1 {
class SweepUnit : public SoundUnit {
MasterDisabler &disableMaster;
DutyUnit &dutyUnit;
unsigned short shadow;
unsigned char nr0;
bool negging;
unsigned calcFreq();
public:
SweepUnit(MasterDisabler &disabler, DutyUnit &dutyUnit);
void event();
void nr0Change(unsigned newNr0);
void nr4Init(unsigned long cycleCounter);
void reset();
void loadState(const SaveState &state);
template<bool isReader>void SyncState(NewState *ns);
};
friend class StaticOutputTester<Channel1,DutyUnit>;
StaticOutputTester<Channel1,DutyUnit> staticOutputTest;
DutyMasterDisabler disableMaster;
LengthCounter lengthCounter;
DutyUnit dutyUnit;
EnvelopeUnit envelopeUnit;
SweepUnit sweepUnit;
SoundUnit *nextEventUnit;
unsigned long cycleCounter;
unsigned long soMask;
unsigned long prevOut;
unsigned char nr4;
bool master;
void setEvent();
public:
Channel1();
void setNr0(unsigned data);
@ -79,16 +39,56 @@ public:
void setNr2(unsigned data);
void setNr3(unsigned data);
void setNr4(unsigned data);
void setSo(unsigned long soMask);
bool isActive() const { return master; }
bool isActive() const { return master_; }
void update(uint_least32_t *buf, unsigned long soBaseVol, unsigned long cycles);
void reset();
void init(bool cgb);
void loadState(const SaveState &state);
void loadState(SaveState const &state);
private:
class SweepUnit : public SoundUnit {
public:
SweepUnit(MasterDisabler &disabler, DutyUnit &dutyUnit);
virtual void event();
void nr0Change(unsigned newNr0);
void nr4Init(unsigned long cycleCounter);
void reset();
void init(bool cgb) { cgb_ = cgb; }
void loadState(SaveState const &state);
private:
MasterDisabler &disableMaster_;
DutyUnit &dutyUnit_;
unsigned short shadow_;
unsigned char nr0_;
bool negging_;
bool cgb_;
unsigned calcFreq();
public:
template<bool isReader>void SyncState(NewState *ns);
};
friend class StaticOutputTester<Channel1, DutyUnit>;
StaticOutputTester<Channel1, DutyUnit> staticOutputTest_;
DutyMasterDisabler disableMaster_;
LengthCounter lengthCounter_;
DutyUnit dutyUnit_;
EnvelopeUnit envelopeUnit_;
SweepUnit sweepUnit_;
SoundUnit *nextEventUnit_;
unsigned long cycleCounter_;
unsigned long soMask_;
unsigned long prevOut_;
unsigned char nr4_;
bool master_;
void setEvent();
public:
template<bool isReader>void SyncState(NewState *ns);
};

233
libgambatte/src/sound/channel2.cpp
View File

@ -1,176 +1,171 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "channel2.h"
#include "../savestate.h"
#include <algorithm>
namespace gambatte {
Channel2::Channel2() :
staticOutputTest(*this, dutyUnit),
disableMaster(master, dutyUnit),
lengthCounter(disableMaster, 0x3F),
envelopeUnit(staticOutputTest),
cycleCounter(0),
soMask(0),
prevOut(0),
nr4(0),
master(false)
Channel2::Channel2()
: staticOutputTest_(*this, dutyUnit_)
, disableMaster_(master_, dutyUnit_)
, lengthCounter_(disableMaster_, 0x3F)
, envelopeUnit_(staticOutputTest_)
, cycleCounter_(0)
, soMask_(0)
, prevOut_(0)
, nr4_(0)
, master_(false)
{
setEvent();
}
void Channel2::setEvent() {
// nextEventUnit = &dutyUnit;
// if (envelopeUnit.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &envelopeUnit;
if (lengthCounter.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &lengthCounter;
nextEventUnit = &envelopeUnit_;
if (lengthCounter_.counter() < nextEventUnit->counter())
nextEventUnit = &lengthCounter_;
}
void Channel2::setNr1(const unsigned data) {
lengthCounter.nr1Change(data, nr4, cycleCounter);
dutyUnit.nr1Change(data, cycleCounter);
void Channel2::setNr1(unsigned data) {
lengthCounter_.nr1Change(data, nr4_, cycleCounter_);
dutyUnit_.nr1Change(data, cycleCounter_);
setEvent();
}
void Channel2::setNr2(const unsigned data) {
if (envelopeUnit.nr2Change(data))
disableMaster();
void Channel2::setNr2(unsigned data) {
if (envelopeUnit_.nr2Change(data))
disableMaster_();
else
staticOutputTest(cycleCounter);
staticOutputTest_(cycleCounter_);
setEvent();
}
void Channel2::setNr3(const unsigned data) {
dutyUnit.nr3Change(data, cycleCounter);
void Channel2::setNr3(unsigned data) {
dutyUnit_.nr3Change(data, cycleCounter_);
setEvent();
}
void Channel2::setNr4(const unsigned data) {
lengthCounter.nr4Change(nr4, data, cycleCounter);
nr4 = data;
if (data & 0x80) { //init-bit
nr4 &= 0x7F;
master = !envelopeUnit.nr4Init(cycleCounter);
staticOutputTest(cycleCounter);
void Channel2::setNr4(unsigned const data) {
lengthCounter_.nr4Change(nr4_, data, cycleCounter_);
nr4_ = data;
dutyUnit_.nr4Change(data, cycleCounter_, master_);
if (data & 0x80) { // init-bit
nr4_ &= 0x7F;
master_ = !envelopeUnit_.nr4Init(cycleCounter_);
staticOutputTest_(cycleCounter_);
}
dutyUnit.nr4Change(data, cycleCounter);
setEvent();
}
void Channel2::setSo(const unsigned long soMask) {
this->soMask = soMask;
staticOutputTest(cycleCounter);
void Channel2::setSo(unsigned long soMask) {
soMask_ = soMask;
staticOutputTest_(cycleCounter_);
setEvent();
}
void Channel2::reset() {
cycleCounter = 0x1000 | (cycleCounter & 0xFFF); // cycleCounter >> 12 & 7 represents the frame sequencer position.
// lengthCounter.reset();
dutyUnit.reset();
envelopeUnit.reset();
// cycleCounter >> 12 & 7 represents the frame sequencer position.
cycleCounter_ &= 0xFFF;
cycleCounter_ += ~(cycleCounter_ + 2) << 1 & 0x1000;
dutyUnit_.reset();
envelopeUnit_.reset();
setEvent();
}
void Channel2::init(const bool cgb) {
lengthCounter.init(cgb);
void Channel2::loadState(SaveState const &state) {
dutyUnit_.loadState(state.spu.ch2.duty, state.mem.ioamhram.get()[0x116],
state.spu.ch2.nr4, state.spu.cycleCounter);
envelopeUnit_.loadState(state.spu.ch2.env, state.mem.ioamhram.get()[0x117],
state.spu.cycleCounter);
lengthCounter_.loadState(state.spu.ch2.lcounter, state.spu.cycleCounter);
cycleCounter_ = state.spu.cycleCounter;
nr4_ = state.spu.ch2.nr4;
master_ = state.spu.ch2.master;
}
void Channel2::loadState(const SaveState &state) {
dutyUnit.loadState(state.spu.ch2.duty, state.mem.ioamhram.get()[0x116], state.spu.ch2.nr4,state.spu.cycleCounter);
envelopeUnit.loadState(state.spu.ch2.env, state.mem.ioamhram.get()[0x117], state.spu.cycleCounter);
lengthCounter.loadState(state.spu.ch2.lcounter, state.spu.cycleCounter);
cycleCounter = state.spu.cycleCounter;
nr4 = state.spu.ch2.nr4;
master = state.spu.ch2.master;
}
void Channel2::update(uint_least32_t *buf, unsigned long const soBaseVol, unsigned long cycles) {
unsigned long const outBase = envelopeUnit_.dacIsOn() ? soBaseVol & soMask_ : 0;
unsigned long const outLow = outBase * (0 - 15ul);
unsigned long const endCycles = cycleCounter_ + cycles;
void Channel2::update(uint_least32_t *buf, const unsigned long soBaseVol, unsigned long cycles) {
const unsigned long outBase = envelopeUnit.dacIsOn() ? soBaseVol & soMask : 0;
const unsigned long outLow = outBase * (0 - 15ul);
const unsigned long endCycles = cycleCounter + cycles;
for (;;) {
const unsigned long outHigh = master ? outBase * (envelopeUnit.getVolume() * 2 - 15ul) : outLow;
const unsigned long nextMajorEvent = nextEventUnit->getCounter() < endCycles ? nextEventUnit->getCounter() : endCycles;
unsigned long out = dutyUnit.isHighState() ? outHigh : outLow;
while (dutyUnit.getCounter() <= nextMajorEvent) {
*buf += out - prevOut;
prevOut = out;
buf += dutyUnit.getCounter() - cycleCounter;
cycleCounter = dutyUnit.getCounter();
dutyUnit.event();
out = dutyUnit.isHighState() ? outHigh : outLow;
unsigned long const outHigh = master_
? outBase * (envelopeUnit_.getVolume() * 2 - 15ul)
: outLow;
unsigned long const nextMajorEvent = std::min(nextEventUnit->counter(), endCycles);
unsigned long out = dutyUnit_.isHighState() ? outHigh : outLow;
while (dutyUnit_.counter() <= nextMajorEvent) {
*buf += out - prevOut_;
prevOut_ = out;
buf += dutyUnit_.counter() - cycleCounter_;
cycleCounter_ = dutyUnit_.counter();
dutyUnit_.event();
out = dutyUnit_.isHighState() ? outHigh : outLow;
}
if (cycleCounter < nextMajorEvent) {
*buf += out - prevOut;
prevOut = out;
buf += nextMajorEvent - cycleCounter;
cycleCounter = nextMajorEvent;
if (cycleCounter_ < nextMajorEvent) {
*buf += out - prevOut_;
prevOut_ = out;
buf += nextMajorEvent - cycleCounter_;
cycleCounter_ = nextMajorEvent;
}
if (nextEventUnit->getCounter() == nextMajorEvent) {
if (nextEventUnit->counter() == nextMajorEvent) {
nextEventUnit->event();
setEvent();
} else
break;
}
if (cycleCounter & SoundUnit::COUNTER_MAX) {
dutyUnit.resetCounters(cycleCounter);
lengthCounter.resetCounters(cycleCounter);
envelopeUnit.resetCounters(cycleCounter);
cycleCounter -= SoundUnit::COUNTER_MAX;
if (cycleCounter_ >= SoundUnit::counter_max) {
dutyUnit_.resetCounters(cycleCounter_);
lengthCounter_.resetCounters(cycleCounter_);
envelopeUnit_.resetCounters(cycleCounter_);
cycleCounter_ -= SoundUnit::counter_max;
}
}
SYNCFUNC(Channel2)
{
SSS(lengthCounter);
SSS(dutyUnit);
SSS(envelopeUnit);
SSS(lengthCounter_);
SSS(dutyUnit_);
SSS(envelopeUnit_);
EBS(nextEventUnit, 0);
EVS(nextEventUnit, &dutyUnit, 1);
EVS(nextEventUnit, &envelopeUnit, 2);
EVS(nextEventUnit, &lengthCounter, 3);
EVS(nextEventUnit, &dutyUnit_, 1);
EVS(nextEventUnit, &envelopeUnit_, 2);
EVS(nextEventUnit, &lengthCounter_, 3);
EES(nextEventUnit, NULL);
NSS(cycleCounter);
NSS(soMask);
NSS(prevOut);
NSS(cycleCounter_);
NSS(soMask_);
NSS(prevOut_);
NSS(nr4);
NSS(master);
NSS(nr4_);
NSS(master_);
}
}

86
libgambatte/src/sound/channel2.h
View File

@ -1,28 +1,28 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SOUND_CHANNEL2_H
#define SOUND_CHANNEL2_H
#include "gbint.h"
#include "length_counter.h"
#include "duty_unit.h"
#include "envelope_unit.h"
#include "gbint.h"
#include "length_counter.h"
#include "static_output_tester.h"
#include "newstate.h"
@ -31,42 +31,36 @@ namespace gambatte {
struct SaveState;
class Channel2 {
friend class StaticOutputTester<Channel2,DutyUnit>;
StaticOutputTester<Channel2,DutyUnit> staticOutputTest;
DutyMasterDisabler disableMaster;
LengthCounter lengthCounter;
DutyUnit dutyUnit;
EnvelopeUnit envelopeUnit;
SoundUnit *nextEventUnit;
unsigned long cycleCounter;
unsigned long soMask;
unsigned long prevOut;
unsigned char nr4;
bool master;
void setEvent();
public:
Channel2();
void setNr1(unsigned data);
void setNr2(unsigned data);
void setNr3(unsigned data);
void setNr4(unsigned data);
void setSo(unsigned long soMask);
// void deactivate() { disableMaster(); setEvent(); }
bool isActive() const { return master; }
bool isActive() const { return master_; }
void update(uint_least32_t *buf, unsigned long soBaseVol, unsigned long cycles);
void reset();
void init(bool cgb);
void loadState(const SaveState &state);
void loadState(SaveState const &state);
private:
friend class StaticOutputTester<Channel2, DutyUnit>;
StaticOutputTester<Channel2, DutyUnit> staticOutputTest_;
DutyMasterDisabler disableMaster_;
LengthCounter lengthCounter_;
DutyUnit dutyUnit_;
EnvelopeUnit envelopeUnit_;
SoundUnit *nextEventUnit;
unsigned long cycleCounter_;
unsigned long soMask_;
unsigned long prevOut_;
unsigned char nr4_;
bool master_;
void setEvent();
public:
template<bool isReader>void SyncState(NewState *ns);
};

322
libgambatte/src/sound/channel3.cpp
View File

@ -1,222 +1,222 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "channel3.h"
#include "../savestate.h"
#include <cstring>
#include <algorithm>
#include <cstring>
static inline unsigned toPeriod(const unsigned nr3, const unsigned nr4) {
static inline unsigned toPeriod(unsigned nr3, unsigned nr4) {
return 0x800 - ((nr4 << 8 & 0x700) | nr3);
}
namespace gambatte {
Channel3::Channel3() :
disableMaster(master, waveCounter),
lengthCounter(disableMaster, 0xFF),
cycleCounter(0),
soMask(0),
prevOut(0),
waveCounter(SoundUnit::COUNTER_DISABLED),
lastReadTime(0),
nr0(0),
nr3(0),
nr4(0),
wavePos(0),
rShift(4),
sampleBuf(0),
master(false),
cgb(false)
{}
Channel3::Channel3()
: disableMaster_(master_, waveCounter_)
, lengthCounter_(disableMaster_, 0xFF)
, cycleCounter_(0)
, soMask_(0)
, prevOut_(0)
, waveCounter_(SoundUnit::counter_disabled)
, lastReadTime_(0)
, nr0_(0)
, nr3_(0)
, nr4_(0)
, wavePos_(0)
, rshift_(4)
, sampleBuf_(0)
, master_(false)
, cgb_(false)
{
}
void Channel3::setNr0(unsigned data) {
nr0_ = data & 0x80;
void Channel3::setNr0(const unsigned data) {
nr0 = data & 0x80;
if (!(data & 0x80))
disableMaster();
disableMaster_();
}
void Channel3::setNr2(const unsigned data) {
rShift = (data >> 5 & 3U) - 1;
if (rShift > 3)
rShift = 4;
void Channel3::setNr2(unsigned data) {
rshift_ = (data >> 5 & 3U) - 1;
if (rshift_ > 3)
rshift_ = 4;
}
void Channel3::setNr4(const unsigned data) {
lengthCounter.nr4Change(nr4, data, cycleCounter);
nr4 = data & 0x7F;
if (data & nr0/* & 0x80*/) {
if (!cgb && waveCounter == cycleCounter + 1) {
const unsigned pos = ((wavePos + 1) & 0x1F) >> 1;
void Channel3::setNr4(unsigned const data) {
lengthCounter_.nr4Change(nr4_, data, cycleCounter_);
nr4_ = data & 0x7F;
if (data & nr0_/* & 0x80*/) {
if (!cgb_ && waveCounter_ == cycleCounter_ + 1) {
unsigned const pos = ((wavePos_ + 1) & 0x1F) >> 1;
if (pos < 4)
waveRam[0] = waveRam[pos];
waveRam_[0] = waveRam_[pos];
else
std::memcpy(waveRam, waveRam + (pos & ~3), 4);
std::memcpy(waveRam_, waveRam_ + (pos & ~3), 4);
}
master = true;
wavePos = 0;
lastReadTime = waveCounter = cycleCounter + toPeriod(nr3, data) + 3;
master_ = true;
wavePos_ = 0;
lastReadTime_ = waveCounter_ = cycleCounter_ + toPeriod(nr3_, data) + 3;
}
}
void Channel3::setSo(const unsigned long soMask) {
this->soMask = soMask;
void Channel3::setSo(unsigned long soMask) {
soMask_ = soMask;
}
void Channel3::reset() {
cycleCounter = 0x1000 | (cycleCounter & 0xFFF); // cycleCounter >> 12 & 7 represents the frame sequencer position.
// cycleCounter >> 12 & 7 represents the frame sequencer position.
cycleCounter_ &= 0xFFF;
cycleCounter_ += ~(cycleCounter_ + 2) << 1 & 0x1000;
// lengthCounter.reset();
sampleBuf = 0;
sampleBuf_ = 0;
}
void Channel3::init(const bool cgb) {
this->cgb = cgb;
lengthCounter.init(cgb);
void Channel3::init(bool cgb) {
cgb_ = cgb;
}
void Channel3::setStatePtrs(SaveState &state) {
state.spu.ch3.waveRam.set(waveRam, sizeof waveRam);
state.spu.ch3.waveRam.set(waveRam_, sizeof waveRam_);
}
void Channel3::loadState(const SaveState &state) {
lengthCounter.loadState(state.spu.ch3.lcounter, state.spu.cycleCounter);
cycleCounter = state.spu.cycleCounter;
waveCounter = std::max(state.spu.ch3.waveCounter, state.spu.cycleCounter);
lastReadTime = state.spu.ch3.lastReadTime;
nr3 = state.spu.ch3.nr3;
nr4 = state.spu.ch3.nr4;
wavePos = state.spu.ch3.wavePos & 0x1F;
sampleBuf = state.spu.ch3.sampleBuf;
master = state.spu.ch3.master;
nr0 = state.mem.ioamhram.get()[0x11A] & 0x80;
void Channel3::loadState(SaveState const &state) {
lengthCounter_.loadState(state.spu.ch3.lcounter, state.spu.cycleCounter);
cycleCounter_ = state.spu.cycleCounter;
waveCounter_ = std::max(state.spu.ch3.waveCounter, state.spu.cycleCounter);
lastReadTime_ = state.spu.ch3.lastReadTime;
nr3_ = state.spu.ch3.nr3;
nr4_ = state.spu.ch3.nr4;
wavePos_ = state.spu.ch3.wavePos & 0x1F;
sampleBuf_ = state.spu.ch3.sampleBuf;
master_ = state.spu.ch3.master;
nr0_ = state.mem.ioamhram.get()[0x11A] & 0x80;
setNr2(state.mem.ioamhram.get()[0x11C]);
}
void Channel3::updateWaveCounter(const unsigned long cc) {
if (cc >= waveCounter) {
const unsigned period = toPeriod(nr3, nr4);
const unsigned long periods = (cc - waveCounter) / period;
void Channel3::updateWaveCounter(unsigned long const cc) {
if (cc >= waveCounter_) {
unsigned const period = toPeriod(nr3_, nr4_);
unsigned long const periods = (cc - waveCounter_) / period;
lastReadTime = waveCounter + periods * period;
waveCounter = lastReadTime + period;
lastReadTime_ = waveCounter_ + periods * period;
waveCounter_ = lastReadTime_ + period;
wavePos += periods + 1;
wavePos &= 0x1F;
wavePos_ += periods + 1;
wavePos_ &= 0x1F;
sampleBuf = waveRam[wavePos >> 1];
sampleBuf_ = waveRam_[wavePos_ >> 1];
}
}
void Channel3::update(uint_least32_t *buf, const unsigned long soBaseVol, unsigned long cycles) {
const unsigned long outBase = (nr0/* & 0x80*/) ? soBaseVol & soMask : 0;
if (outBase && rShift != 4) {
const unsigned long endCycles = cycleCounter + cycles;
void Channel3::update(uint_least32_t *buf, unsigned long const soBaseVol, unsigned long cycles) {
unsigned long const outBase = nr0_/* & 0x80*/ ? soBaseVol & soMask_ : 0;
if (outBase && rshift_ != 4) {
unsigned long const endCycles = cycleCounter_ + cycles;
for (;;) {
const unsigned long nextMajorEvent = lengthCounter.getCounter() < endCycles ? lengthCounter.getCounter() : endCycles;
unsigned long out = outBase * (master ? ((sampleBuf >> (~wavePos << 2 & 4) & 0xF) >> rShift) * 2 - 15ul : 0 - 15ul);
while (waveCounter <= nextMajorEvent) {
*buf += out - prevOut;
prevOut = out;
buf += waveCounter - cycleCounter;
cycleCounter = waveCounter;
lastReadTime = waveCounter;
waveCounter += toPeriod(nr3, nr4);
++wavePos;
wavePos &= 0x1F;
sampleBuf = waveRam[wavePos >> 1];
out = outBase * (/*master ? */((sampleBuf >> (~wavePos << 2 & 4) & 0xF) >> rShift) * 2 - 15ul/* : 0 - 15ul*/);
unsigned long const nextMajorEvent =
std::min(lengthCounter_.counter(), endCycles);
unsigned long out = master_
? ((sampleBuf_ >> (~wavePos_ << 2 & 4) & 0xF) >> rshift_) * 2 - 15ul
: 0 - 15ul;
out *= outBase;
while (waveCounter_ <= nextMajorEvent) {
*buf += out - prevOut_;
prevOut_ = out;
buf += waveCounter_ - cycleCounter_;
cycleCounter_ = waveCounter_;
lastReadTime_ = waveCounter_;
waveCounter_ += toPeriod(nr3_, nr4_);
++wavePos_;
wavePos_ &= 0x1F;
sampleBuf_ = waveRam_[wavePos_ >> 1];
out = ((sampleBuf_ >> (~wavePos_ << 2 & 4) & 0xF) >> rshift_) * 2 - 15ul;
out *= outBase;
}
if (cycleCounter < nextMajorEvent) {
*buf += out - prevOut;
prevOut = out;
buf += nextMajorEvent - cycleCounter;
cycleCounter = nextMajorEvent;
if (cycleCounter_ < nextMajorEvent) {
*buf += out - prevOut_;
prevOut_ = out;
buf += nextMajorEvent - cycleCounter_;
cycleCounter_ = nextMajorEvent;
}
if (lengthCounter.getCounter() == nextMajorEvent) {
lengthCounter.event();
if (lengthCounter_.counter() == nextMajorEvent) {
lengthCounter_.event();
} else
break;
}
} else {
if (outBase) {
const unsigned long out = outBase * (0 - 15ul);
*buf += out - prevOut;
prevOut = out;
unsigned long const out = outBase * (0 - 15ul);
*buf += out - prevOut_;
prevOut_ = out;
cycleCounter_ += cycles;
while (lengthCounter_.counter() <= cycleCounter_) {
updateWaveCounter(lengthCounter_.counter());
lengthCounter_.event();
}
cycleCounter += cycles;
while (lengthCounter.getCounter() <= cycleCounter) {
updateWaveCounter(lengthCounter.getCounter());
lengthCounter.event();
}
updateWaveCounter(cycleCounter);
updateWaveCounter(cycleCounter_);
}
if (cycleCounter & SoundUnit::COUNTER_MAX) {
lengthCounter.resetCounters(cycleCounter);
if (waveCounter != SoundUnit::COUNTER_DISABLED)
waveCounter -= SoundUnit::COUNTER_MAX;
lastReadTime -= SoundUnit::COUNTER_MAX;
cycleCounter -= SoundUnit::COUNTER_MAX;
if (cycleCounter_ >= SoundUnit::counter_max) {
lengthCounter_.resetCounters(cycleCounter_);
if (waveCounter_ != SoundUnit::counter_disabled)
waveCounter_ -= SoundUnit::counter_max;
lastReadTime_ -= SoundUnit::counter_max;
cycleCounter_ -= SoundUnit::counter_max;
}
}
SYNCFUNC(Channel3)
{
NSS(waveRam);
SSS(lengthCounter);
NSS(waveRam_);
NSS(cycleCounter);
NSS(soMask);
NSS(prevOut);
NSS(waveCounter);
NSS(lastReadTime);
SSS(lengthCounter_);
NSS(nr0);
NSS(nr3);
NSS(nr4);
NSS(wavePos);
NSS(rShift);
NSS(sampleBuf);
NSS(cycleCounter_);
NSS(soMask_);
NSS(prevOut_);
NSS(waveCounter_);
NSS(lastReadTime_);
NSS(master);
NSS(cgb);
NSS(nr0_);
NSS(nr3_);
NSS(nr4_);
NSS(wavePos_);
NSS(rshift_);
NSS(sampleBuf_);
NSS(master_);
NSS(cgb_);
}
}

146
libgambatte/src/sound/channel3.h
View File

@ -1,27 +1,27 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SOUND_CHANNEL3_H
#define SOUND_CHANNEL3_H
#include "gbint.h"
#include "master_disabler.h"
#include "length_counter.h"
#include "master_disabler.h"
#include "newstate.h"
namespace gambatte {
@ -29,74 +29,78 @@ namespace gambatte {
struct SaveState;
class Channel3 {
class Ch3MasterDisabler : public MasterDisabler {
unsigned long &waveCounter;
public:
Ch3MasterDisabler(bool &m, unsigned long &wC) : MasterDisabler(m), waveCounter(wC) {}
void operator()() { MasterDisabler::operator()(); waveCounter = SoundUnit::COUNTER_DISABLED; }
};
unsigned char waveRam[0x10];
Ch3MasterDisabler disableMaster;
LengthCounter lengthCounter;
unsigned long cycleCounter;
unsigned long soMask;
unsigned long prevOut;
unsigned long waveCounter;
unsigned long lastReadTime;
unsigned char nr0;
unsigned char nr3;
unsigned char nr4;
unsigned char wavePos;
unsigned char rShift;
unsigned char sampleBuf;
bool master;
bool cgb;
void updateWaveCounter(unsigned long cc);
public:
Channel3();
bool isActive() const { return master; }
bool isActive() const { return master_; }
void reset();
void init(bool cgb);
void setStatePtrs(SaveState &state);
void loadState(const SaveState &state);
void setNr0(unsigned data);
void setNr1(unsigned data) { lengthCounter.nr1Change(data, nr4, cycleCounter); }
void setNr1(unsigned data) { lengthCounter_.nr1Change(data, nr4_, cycleCounter_); }
void setNr2(unsigned data);
void setNr3(unsigned data) { nr3 = data; }
void setNr3(unsigned data) { nr3_ = data; }
void setNr4(unsigned data);
void setSo(unsigned long soMask);
void update(uint_least32_t *buf, unsigned long soBaseVol, unsigned long cycles);
unsigned waveRamRead(unsigned index) const {
if (master) {
if (!cgb && cycleCounter != lastReadTime)
if (master_) {
if (!cgb_ && cycleCounter_ != lastReadTime_)
return 0xFF;
index = wavePos >> 1;
index = wavePos_ >> 1;
}
return waveRam[index];
}
void waveRamWrite(unsigned index, unsigned data) {
if (master) {
if (!cgb && cycleCounter != lastReadTime)
return;
index = wavePos >> 1;
}
waveRam[index] = data;
return waveRam_[index];
}
void waveRamWrite(unsigned index, unsigned data) {
if (master_) {
if (!cgb_ && cycleCounter_ != lastReadTime_)
return;
index = wavePos_ >> 1;
}
waveRam_[index] = data;
}
private:
class Ch3MasterDisabler : public MasterDisabler {
public:
Ch3MasterDisabler(bool &m, unsigned long &wC) : MasterDisabler(m), waveCounter_(wC) {}
virtual void operator()() {
MasterDisabler::operator()();
waveCounter_ = SoundUnit::counter_disabled;
}
private:
unsigned long &waveCounter_;
};
unsigned char waveRam_[0x10];
Ch3MasterDisabler disableMaster_;
LengthCounter lengthCounter_;
unsigned long cycleCounter_;
unsigned long soMask_;
unsigned long prevOut_;
unsigned long waveCounter_;
unsigned long lastReadTime_;
unsigned char nr0_;
unsigned char nr3_;
unsigned char nr4_;
unsigned char wavePos_;
unsigned char rshift_;
unsigned char sampleBuf_;
bool master_;
bool cgb_;
void updateWaveCounter(unsigned long cc);
public:
template<bool isReader>void SyncState(NewState *ns);
};

388
libgambatte/src/sound/channel4.cpp
View File

@ -1,319 +1,275 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "channel4.h"
#include "../savestate.h"
#include <algorithm>
static unsigned long toPeriod(const unsigned nr3) {
static unsigned long toPeriod(unsigned const nr3) {
unsigned s = (nr3 >> 4) + 3;
unsigned r = nr3 & 7;
if (!r) {
r = 1;
--s;
}
return r << s;
}
namespace gambatte {
Channel4::Lfsr::Lfsr() :
backupCounter(COUNTER_DISABLED),
reg(0x7FFF),
nr3(0),
master(false)
{}
Channel4::Lfsr::Lfsr()
: backupCounter_(counter_disabled)
, reg_(0x7FFF)
, nr3_(0)
, master_(false)
{
}
void Channel4::Lfsr::updateBackupCounter(const unsigned long cc) {
/*if (backupCounter <= cc) {
const unsigned long period = toPeriod(nr3);
backupCounter = cc - (cc - backupCounter) % period + period;
}*/
if (backupCounter <= cc) {
const unsigned long period = toPeriod(nr3);
unsigned long periods = (cc - backupCounter) / period + 1;
backupCounter += periods * period;
if (master && nr3 < 0xE0) {
if (nr3 & 8) {
void Channel4::Lfsr::updateBackupCounter(unsigned long const cc) {
if (backupCounter_ <= cc) {
unsigned long const period = toPeriod(nr3_);
unsigned long periods = (cc - backupCounter_) / period + 1;
backupCounter_ += periods * period;
if (master_ && nr3_ < 0xE0) {
if (nr3_ & 8) {
while (periods > 6) {
const unsigned xored = (reg << 1 ^ reg) & 0x7E;
reg = (reg >> 6 & ~0x7E) | xored | xored << 8;
unsigned const xored = (reg_ << 1 ^ reg_) & 0x7E;
reg_ = (reg_ >> 6 & ~0x7E) | xored | xored << 8;
periods -= 6;
}
const unsigned xored = ((reg ^ reg >> 1) << (7 - periods)) & 0x7F;
reg = (reg >> periods & ~(0x80 - (0x80 >> periods))) | xored | xored << 8;
unsigned const xored = ((reg_ ^ reg_ >> 1) << (7 - periods)) & 0x7F;
reg_ = (reg_ >> periods & ~(0x80 - (0x80 >> periods))) | xored | xored << 8;
} else {
while (periods > 15) {
reg = reg ^ reg >> 1;
reg_ = reg_ ^ reg_ >> 1;
periods -= 15;
}
reg = reg >> periods | (((reg ^ reg >> 1) << (15 - periods)) & 0x7FFF);
reg_ = reg_ >> periods | (((reg_ ^ reg_ >> 1) << (15 - periods)) & 0x7FFF);
}
}
}
}
void Channel4::Lfsr::reviveCounter(const unsigned long cc) {
void Channel4::Lfsr::reviveCounter(unsigned long cc) {
updateBackupCounter(cc);
counter = backupCounter;
counter_ = backupCounter_;
}
/*static const unsigned char nextStateDistance[0x40] = {
6, 1, 1, 2, 2, 1, 1, 3,
3, 1, 1, 2, 2, 1, 1, 4,
4, 1, 1, 2, 2, 1, 1, 3,
3, 1, 1, 2, 2, 1, 1, 5,
5, 1, 1, 2, 2, 1, 1, 3,
3, 1, 1, 2, 2, 1, 1, 4,
4, 1, 1, 2, 2, 1, 1, 3,
3, 1, 1, 2, 2, 1, 1, 6,
};*/
inline void Channel4::Lfsr::event() {
if (nr3 < 0xE0) {
const unsigned shifted = reg >> 1;
const unsigned xored = (reg ^ shifted) & 1;
reg = shifted | xored << 14;
if (nr3 & 8)
reg = (reg & ~0x40) | xored << 6;
if (nr3_ < 0xE0) {
unsigned const shifted = reg_ >> 1;
unsigned const xored = (reg_ ^ shifted) & 1;
reg_ = shifted | xored << 14;
if (nr3_ & 8)
reg_ = (reg_ & ~0x40) | xored << 6;
}
counter += toPeriod(nr3);
backupCounter = counter;
/*if (nr3 < 0xE0) {
const unsigned periods = nextStateDistance[reg & 0x3F];
const unsigned xored = ((reg ^ reg >> 1) << (7 - periods)) & 0x7F;
reg = reg >> periods | xored << 8;
if (nr3 & 8)
reg = reg & ~(0x80 - (0x80 >> periods)) | xored;
}
const unsigned long period = toPeriod(nr3);
backupCounter = counter + period;
counter += period * nextStateDistance[reg & 0x3F];*/
counter_ += toPeriod(nr3_);
backupCounter_ = counter_;
}
void Channel4::Lfsr::nr3Change(const unsigned newNr3, const unsigned long cc) {
void Channel4::Lfsr::nr3Change(unsigned newNr3, unsigned long cc) {
updateBackupCounter(cc);
nr3 = newNr3;
// if (counter != COUNTER_DISABLED)
// counter = backupCounter + toPeriod(nr3) * (nextStateDistance[reg & 0x3F] - 1);
nr3_ = newNr3;
}
void Channel4::Lfsr::nr4Init(unsigned long cc) {
disableMaster();
updateBackupCounter(cc);
master = true;
backupCounter += 4;
counter = backupCounter;
// counter = backupCounter + toPeriod(nr3) * (nextStateDistance[reg & 0x3F] - 1);
master_ = true;
backupCounter_ += 4;
counter_ = backupCounter_;
}
void Channel4::Lfsr::reset(const unsigned long cc) {
nr3 = 0;
void Channel4::Lfsr::reset(unsigned long cc) {
nr3_ = 0;
disableMaster();
backupCounter = cc + toPeriod(nr3);
backupCounter_ = cc + toPeriod(nr3_);
}
void Channel4::Lfsr::resetCounters(const unsigned long oldCc) {
void Channel4::Lfsr::resetCounters(unsigned long oldCc) {
updateBackupCounter(oldCc);
backupCounter -= COUNTER_MAX;
backupCounter_ -= counter_max;
SoundUnit::resetCounters(oldCc);
}
void Channel4::Lfsr::loadState(const SaveState &state) {
counter = backupCounter = std::max(state.spu.ch4.lfsr.counter, state.spu.cycleCounter);
reg = state.spu.ch4.lfsr.reg;
master = state.spu.ch4.master;
nr3 = state.mem.ioamhram.get()[0x122];
void Channel4::Lfsr::loadState(SaveState const &state) {
counter_ = backupCounter_ = std::max(state.spu.ch4.lfsr.counter, state.spu.cycleCounter);
reg_ = state.spu.ch4.lfsr.reg;
master_ = state.spu.ch4.master;
nr3_ = state.mem.ioamhram.get()[0x122];
}
template<bool isReader>
void Channel4::Lfsr::SyncState(NewState *ns)
{
NSS(counter);
NSS(backupCounter);
NSS(reg);
NSS(nr3);
NSS(master);
NSS(counter_);
NSS(backupCounter_);
NSS(reg_);
NSS(nr3_);
NSS(master_);
}
Channel4::Channel4() :
staticOutputTest(*this, lfsr),
disableMaster(master, lfsr),
lengthCounter(disableMaster, 0x3F),
envelopeUnit(staticOutputTest),
cycleCounter(0),
soMask(0),
prevOut(0),
nr4(0),
master(false)
Channel4::Channel4()
: staticOutputTest_(*this, lfsr_)
, disableMaster_(master_, lfsr_)
, lengthCounter_(disableMaster_, 0x3F)
, envelopeUnit_(staticOutputTest_)
, nextEventUnit_(0)
, cycleCounter_(0)
, soMask_(0)
, prevOut_(0)
, nr4_(0)
, master_(false)
{
setEvent();
}
void Channel4::setEvent() {
// nextEventUnit = &lfsr;
// if (envelopeUnit.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &envelopeUnit;
if (lengthCounter.getCounter() < nextEventUnit->getCounter())
nextEventUnit = &lengthCounter;
nextEventUnit_ = &envelopeUnit_;
if (lengthCounter_.counter() < nextEventUnit_->counter())
nextEventUnit_ = &lengthCounter_;
}
void Channel4::setNr1(const unsigned data) {
lengthCounter.nr1Change(data, nr4, cycleCounter);
void Channel4::setNr1(unsigned data) {
lengthCounter_.nr1Change(data, nr4_, cycleCounter_);
setEvent();
}
void Channel4::setNr2(const unsigned data) {
if (envelopeUnit.nr2Change(data))
disableMaster();
void Channel4::setNr2(unsigned data) {
if (envelopeUnit_.nr2Change(data))
disableMaster_();
else
staticOutputTest(cycleCounter);
staticOutputTest_(cycleCounter_);
setEvent();
}
void Channel4::setNr4(const unsigned data) {
lengthCounter.nr4Change(nr4, data, cycleCounter);
nr4 = data;
if (data & 0x80) { //init-bit
nr4 &= 0x7F;
master = !envelopeUnit.nr4Init(cycleCounter);
if (master)
lfsr.nr4Init(cycleCounter);
staticOutputTest(cycleCounter);
void Channel4::setNr4(unsigned const data) {
lengthCounter_.nr4Change(nr4_, data, cycleCounter_);
nr4_ = data;
if (data & 0x80) { // init-bit
nr4_ &= 0x7F;
master_ = !envelopeUnit_.nr4Init(cycleCounter_);
if (master_)
lfsr_.nr4Init(cycleCounter_);
staticOutputTest_(cycleCounter_);
}
setEvent();
}
void Channel4::setSo(const unsigned long soMask) {
this->soMask = soMask;
staticOutputTest(cycleCounter);
void Channel4::setSo(unsigned long soMask) {
soMask_ = soMask;
staticOutputTest_(cycleCounter_);
setEvent();
}
void Channel4::reset() {
cycleCounter = 0x1000 | (cycleCounter & 0xFFF); // cycleCounter >> 12 & 7 represents the frame sequencer position.
// cycleCounter >> 12 & 7 represents the frame sequencer position.
cycleCounter_ &= 0xFFF;
cycleCounter_ += ~(cycleCounter_ + 2) << 1 & 0x1000;
// lengthCounter.reset();
lfsr.reset(cycleCounter);
envelopeUnit.reset();
lfsr_.reset(cycleCounter_);
envelopeUnit_.reset();
setEvent();
}
void Channel4::init(const bool cgb) {
lengthCounter.init(cgb);
void Channel4::loadState(SaveState const &state) {
lfsr_.loadState(state);
envelopeUnit_.loadState(state.spu.ch4.env, state.mem.ioamhram.get()[0x121],
state.spu.cycleCounter);
lengthCounter_.loadState(state.spu.ch4.lcounter, state.spu.cycleCounter);
cycleCounter_ = state.spu.cycleCounter;
nr4_ = state.spu.ch4.nr4;
master_ = state.spu.ch4.master;
}
void Channel4::loadState(const SaveState &state) {
lfsr.loadState(state);
envelopeUnit.loadState(state.spu.ch4.env, state.mem.ioamhram.get()[0x121], state.spu.cycleCounter);
lengthCounter.loadState(state.spu.ch4.lcounter, state.spu.cycleCounter);
cycleCounter = state.spu.cycleCounter;
nr4 = state.spu.ch4.nr4;
master = state.spu.ch4.master;
}
void Channel4::update(uint_least32_t *buf, unsigned long const soBaseVol, unsigned long cycles) {
unsigned long const outBase = envelopeUnit_.dacIsOn() ? soBaseVol & soMask_ : 0;
unsigned long const outLow = outBase * (0 - 15ul);
unsigned long const endCycles = cycleCounter_ + cycles;
void Channel4::update(uint_least32_t *buf, const unsigned long soBaseVol, unsigned long cycles) {
const unsigned long outBase = envelopeUnit.dacIsOn() ? soBaseVol & soMask : 0;
const unsigned long outLow = outBase * (0 - 15ul);
const unsigned long endCycles = cycleCounter + cycles;
for (;;) {
const unsigned long outHigh = /*master ? */outBase * (envelopeUnit.getVolume() * 2 - 15ul)/* : outLow*/;
const unsigned long nextMajorEvent = nextEventUnit->getCounter() < endCycles ? nextEventUnit->getCounter() : endCycles;
unsigned long out = lfsr.isHighState() ? outHigh : outLow;
while (lfsr.getCounter() <= nextMajorEvent) {
*buf += out - prevOut;
prevOut = out;
buf += lfsr.getCounter() - cycleCounter;
cycleCounter = lfsr.getCounter();
lfsr.event();
out = lfsr.isHighState() ? outHigh : outLow;
unsigned long const outHigh = outBase * (envelopeUnit_.getVolume() * 2 - 15ul);
unsigned long const nextMajorEvent = std::min(nextEventUnit_->counter(), endCycles);
unsigned long out = lfsr_.isHighState() ? outHigh : outLow;
while (lfsr_.counter() <= nextMajorEvent) {
*buf += out - prevOut_;
prevOut_ = out;
buf += lfsr_.counter() - cycleCounter_;
cycleCounter_ = lfsr_.counter();
lfsr_.event();
out = lfsr_.isHighState() ? outHigh : outLow;
}
if (cycleCounter < nextMajorEvent) {
*buf += out - prevOut;
prevOut = out;
buf += nextMajorEvent - cycleCounter;
cycleCounter = nextMajorEvent;
if (cycleCounter_ < nextMajorEvent) {
*buf += out - prevOut_;
prevOut_ = out;
buf += nextMajorEvent - cycleCounter_;
cycleCounter_ = nextMajorEvent;
}
if (nextEventUnit->getCounter() == nextMajorEvent) {
nextEventUnit->event();
if (nextEventUnit_->counter() == nextMajorEvent) {
nextEventUnit_->event();
setEvent();
} else
break;
}
if (cycleCounter & SoundUnit::COUNTER_MAX) {
lengthCounter.resetCounters(cycleCounter);
lfsr.resetCounters(cycleCounter);
envelopeUnit.resetCounters(cycleCounter);
cycleCounter -= SoundUnit::COUNTER_MAX;
if (cycleCounter_ >= SoundUnit::counter_max) {
lengthCounter_.resetCounters(cycleCounter_);
lfsr_.resetCounters(cycleCounter_);
envelopeUnit_.resetCounters(cycleCounter_);
cycleCounter_ -= SoundUnit::counter_max;
}
}
SYNCFUNC(Channel4)
{
SSS(lengthCounter);
SSS(envelopeUnit);
SSS(lfsr);
SSS(lengthCounter_);
SSS(envelopeUnit_);
SSS(lfsr_);
EBS(nextEventUnit, 0);
EVS(nextEventUnit, &lfsr, 1);
EVS(nextEventUnit, &envelopeUnit, 2);
EVS(nextEventUnit, &lengthCounter, 3);
EES(nextEventUnit, NULL);
EBS(nextEventUnit_, 0);
EVS(nextEventUnit_, &lfsr_, 1);
EVS(nextEventUnit_, &envelopeUnit_, 2);
EVS(nextEventUnit_, &lengthCounter_, 3);
EES(nextEventUnit_, NULL);
NSS(cycleCounter);
NSS(soMask);
NSS(prevOut);
NSS(nr4);
NSS(master);
NSS(cycleCounter_);
NSS(soMask_);
NSS(prevOut_);
NSS(nr4_);
NSS(master_);
}
}

155
libgambatte/src/sound/channel4.h
View File

@ -1,28 +1,28 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SOUND_CHANNEL4_H
#define SOUND_CHANNEL4_H
#include "gbint.h"
#include "master_disabler.h"
#include "length_counter.h"
#include "envelope_unit.h"
#include "gbint.h"
#include "length_counter.h"
#include "master_disabler.h"
#include "static_output_tester.h"
#include "newstate.h"
@ -31,72 +31,71 @@ namespace gambatte {
struct SaveState;
class Channel4 {
class Lfsr : public SoundUnit {
unsigned long backupCounter;
unsigned short reg;
unsigned char nr3;
bool master;
void updateBackupCounter(unsigned long cc);
public:
Lfsr();
void event();
bool isHighState() const { return ~reg & 1; }
void nr3Change(unsigned newNr3, unsigned long cc);
void nr4Init(unsigned long cc);
void reset(unsigned long cc);
void loadState(const SaveState &state);
void resetCounters(unsigned long oldCc);
void disableMaster() { killCounter(); master = false; reg = 0x7FFF; }
void killCounter() { counter = COUNTER_DISABLED; }
void reviveCounter(unsigned long cc);
template<bool isReader>void SyncState(NewState *ns);
};
class Ch4MasterDisabler : public MasterDisabler {
Lfsr &lfsr;
public:
Ch4MasterDisabler(bool &m, Lfsr &lfsr) : MasterDisabler(m), lfsr(lfsr) {}
void operator()() { MasterDisabler::operator()(); lfsr.disableMaster(); }
};
friend class StaticOutputTester<Channel4,Lfsr>;
StaticOutputTester<Channel4,Lfsr> staticOutputTest;
Ch4MasterDisabler disableMaster;
LengthCounter lengthCounter;
EnvelopeUnit envelopeUnit;
Lfsr lfsr;
SoundUnit *nextEventUnit;
unsigned long cycleCounter;
unsigned long soMask;
unsigned long prevOut;
unsigned char nr4;
bool master;
void setEvent();
public:
Channel4();
void setNr1(unsigned data);
void setNr2(unsigned data);
void setNr3(unsigned data) { lfsr.nr3Change(data, cycleCounter); /*setEvent();*/ }
void setNr3(unsigned data) { lfsr_.nr3Change(data, cycleCounter_); }
void setNr4(unsigned data);
void setSo(unsigned long soMask);
bool isActive() const { return master; }
bool isActive() const { return master_; }
void update(uint_least32_t *buf, unsigned long soBaseVol, unsigned long cycles);
void reset();
void init(bool cgb);
void loadState(const SaveState &state);
void loadState(SaveState const &state);
private:
class Lfsr : public SoundUnit {
public:
Lfsr();
virtual void event();
virtual void resetCounters(unsigned long oldCc);
bool isHighState() const { return ~reg_ & 1; }
void nr3Change(unsigned newNr3, unsigned long cc);
void nr4Init(unsigned long cc);
void reset(unsigned long cc);
void loadState(SaveState const &state);
void disableMaster() { killCounter(); master_ = false; reg_ = 0x7FFF; }
void killCounter() { counter_ = counter_disabled; }
void reviveCounter(unsigned long cc);
private:
unsigned long backupCounter_;
unsigned short reg_;
unsigned char nr3_;
bool master_;
void updateBackupCounter(unsigned long cc);
public:
template<bool isReader>void SyncState(NewState *ns);
};
class Ch4MasterDisabler : public MasterDisabler {
public:
Ch4MasterDisabler(bool &m, Lfsr &lfsr) : MasterDisabler(m), lfsr_(lfsr) {}
virtual void operator()() { MasterDisabler::operator()(); lfsr_.disableMaster(); }
private:
Lfsr &lfsr_;
};
friend class StaticOutputTester<Channel4, Lfsr>;
StaticOutputTester<Channel4, Lfsr> staticOutputTest_;
Ch4MasterDisabler disableMaster_;
LengthCounter lengthCounter_;
EnvelopeUnit envelopeUnit_;
Lfsr lfsr_;
SoundUnit *nextEventUnit_;
unsigned long cycleCounter_;
unsigned long soMask_;
unsigned long prevOut_;
unsigned char nr4_;
bool master_;
void setEvent();
public:
template<bool isReader>void SyncState(NewState *ns);
};

202
libgambatte/src/sound/duty_unit.cpp
View File

@ -1,156 +1,162 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "duty_unit.h"
#include <algorithm>
static inline bool toOutState(const unsigned duty, const unsigned pos) {
static const unsigned char duties[4] = { 0x80, 0x81, 0xE1, 0x7E };
return duties[duty] >> pos & 1;
static inline bool toOutState(unsigned duty, unsigned pos) {
return 0x7EE18180 >> (duty * 8 + pos) & 1;
}
static inline unsigned toPeriod(const unsigned freq) {
return (2048 - freq) << 1;
static inline unsigned toPeriod(unsigned freq) {
return (2048 - freq) * 2;
}
namespace gambatte {
void DutyUnit::updatePos(const unsigned long cc) {
if (cc >= nextPosUpdate) {
const unsigned long inc = (cc - nextPosUpdate) / period + 1;
nextPosUpdate += period * inc;
pos += inc;
pos &= 7;
DutyUnit::DutyUnit()
: nextPosUpdate_(counter_disabled)
, period_(4096)
, pos_(0)
, duty_(0)
, inc_(0)
, high_(false)
, enableEvents_(true)
{
}
void DutyUnit::updatePos(unsigned long const cc) {
if (cc >= nextPosUpdate_) {
unsigned long const inc = (cc - nextPosUpdate_) / period_ + 1;
nextPosUpdate_ += period_ * inc;
pos_ += inc;
pos_ &= 7;
high_ = toOutState(duty_, pos_);
}
}
void DutyUnit::setDuty(const unsigned nr1) {
duty = nr1 >> 6;
high = toOutState(duty, pos);
}
void DutyUnit::setCounter() {
static const unsigned char nextStateDistance[4 * 8] = {
6, 5, 4, 3, 2, 1, 0, 0,
0, 5, 4, 3, 2, 1, 0, 1,
0, 3, 2, 1, 0, 3, 2, 1,
0, 5, 4, 3, 2, 1, 0, 1
static unsigned char const nextStateDistance[4 * 8] = {
7, 6, 5, 4, 3, 2, 1, 1,
1, 6, 5, 4, 3, 2, 1, 2,
1, 4, 3, 2, 1, 4, 3, 2,
1, 6, 5, 4, 3, 2, 1, 2
};
if (enableEvents && nextPosUpdate != COUNTER_DISABLED)
counter = nextPosUpdate + period * nextStateDistance[(duty * 8) | pos];
else
counter = COUNTER_DISABLED;
if (enableEvents_ && nextPosUpdate_ != counter_disabled) {
unsigned const npos = (pos_ + 1) & 7;
counter_ = nextPosUpdate_;
inc_ = nextStateDistance[duty_ * 8 + npos];
if (toOutState(duty_, npos) == high_) {
counter_ += period_ * inc_;
inc_ = nextStateDistance[duty_ * 8 + ((npos + inc_) & 7)];
}
} else
counter_ = counter_disabled;
}
void DutyUnit::setFreq(const unsigned newFreq, const unsigned long cc) {
void DutyUnit::setFreq(unsigned newFreq, unsigned long cc) {
updatePos(cc);
period = toPeriod(newFreq);
period_ = toPeriod(newFreq);
setCounter();
}
void DutyUnit::event() {
unsigned inc = period << duty;
if (duty == 3)
inc -= period * 2;
if (!(high ^= true))
inc = period * 8 - inc;
counter += inc;
static unsigned char const inc[] = {
1, 7,
2, 6,
4, 4,
6, 2,
};
high_ ^= true;
counter_ += inc_ * period_;
inc_ = inc[duty_ * 2 + high_];
}
void DutyUnit::nr1Change(const unsigned newNr1, const unsigned long cc) {
void DutyUnit::nr1Change(unsigned newNr1, unsigned long cc) {
updatePos(cc);
setDuty(newNr1);
duty_ = newNr1 >> 6;
setCounter();
}
void DutyUnit::nr3Change(const unsigned newNr3, const unsigned long cc) {
setFreq((getFreq() & 0x700) | newNr3, cc);
void DutyUnit::nr3Change(unsigned newNr3, unsigned long cc) {
setFreq((freq() & 0x700) | newNr3, cc);
}
void DutyUnit::nr4Change(const unsigned newNr4, const unsigned long cc) {
setFreq((newNr4 << 8 & 0x700) | (getFreq() & 0xFF), cc);
void DutyUnit::nr4Change(unsigned const newNr4, unsigned long const cc,
bool const master) {
setFreq((newNr4 << 8 & 0x700) | (freq() & 0xFF), cc);
if (newNr4 & 0x80) {
nextPosUpdate = (cc & ~1) + period;
nextPosUpdate_ = (cc & ~1ul) + period_ + 4 - (master << 1);
setCounter();
}
}
DutyUnit::DutyUnit() :
nextPosUpdate(COUNTER_DISABLED),
period(4096),
pos(0),
duty(0),
high(false),
enableEvents(true)
{}
void DutyUnit::reset() {
pos = 0;
high = toOutState(duty, pos);
nextPosUpdate = COUNTER_DISABLED;
pos_ = 0;
high_ = false;
nextPosUpdate_ = counter_disabled;
setCounter();
}
void DutyUnit::loadState(const SaveState::SPU::Duty &dstate, const unsigned nr1, const unsigned nr4, const unsigned long cc) {
nextPosUpdate = std::max(dstate.nextPosUpdate, cc);
pos = dstate.pos & 7;
setDuty(nr1);
period = toPeriod((nr4 << 8 & 0x700) | dstate.nr3);
enableEvents = true;
void DutyUnit::loadState(SaveState::SPU::Duty const &dstate,
unsigned const nr1, unsigned const nr4, unsigned long const cc) {
nextPosUpdate_ = std::max(dstate.nextPosUpdate, cc);
pos_ = dstate.pos & 7;
high_ = dstate.high;
duty_ = nr1 >> 6;
period_ = toPeriod((nr4 << 8 & 0x700) | dstate.nr3);
enableEvents_ = true;
setCounter();
}
void DutyUnit::resetCounters(const unsigned long oldCc) {
if (nextPosUpdate == COUNTER_DISABLED)
void DutyUnit::resetCounters(unsigned long const oldCc) {
if (nextPosUpdate_ == counter_disabled)
return;
updatePos(oldCc);
nextPosUpdate -= COUNTER_MAX;
SoundUnit::resetCounters(oldCc);
nextPosUpdate_ -= counter_max;
setCounter();
}
void DutyUnit::killCounter() {
enableEvents = false;
enableEvents_ = false;
setCounter();
}
void DutyUnit::reviveCounter(const unsigned long cc) {
void DutyUnit::reviveCounter(unsigned long const cc) {
updatePos(cc);
high = toOutState(duty, pos);
enableEvents = true;
enableEvents_ = true;
setCounter();
}
SYNCFUNC(DutyUnit)
{
NSS(counter);
NSS(nextPosUpdate);
NSS(period);
NSS(pos);
NSS(duty);
NSS(high);
NSS(enableEvents);
NSS(counter_);
NSS(nextPosUpdate_);
NSS(period_);
NSS(pos_);
NSS(duty_);
NSS(inc_);
NSS(high_);
NSS(enableEvents_);
}
}

91
libgambatte/src/sound/duty_unit.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aam<EFBFBD>s *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef DUTY_UNIT_H
#define DUTY_UNIT_H
@ -27,42 +27,47 @@
namespace gambatte {
class DutyUnit : public SoundUnit {
unsigned long nextPosUpdate;
unsigned short period;
unsigned char pos;
unsigned char duty;
bool high;
bool enableEvents;
public:
DutyUnit();
virtual void event();
virtual void resetCounters(unsigned long oldCc);
bool isHighState() const { return high_; }
void nr1Change(unsigned newNr1, unsigned long cc);
void nr3Change(unsigned newNr3, unsigned long cc);
void nr4Change(unsigned newNr4, unsigned long cc, bool master);
void reset();
void loadState(SaveState::SPU::Duty const &dstate, unsigned nr1, unsigned nr4, unsigned long cc);
void killCounter();
void reviveCounter(unsigned long cc);
//intended for use by SweepUnit only.
unsigned freq() const { return 2048 - (period_ >> 1); }
void setFreq(unsigned newFreq, unsigned long cc);
private:
unsigned long nextPosUpdate_;
unsigned short period_;
unsigned char pos_;
unsigned char duty_;
unsigned char inc_;
bool high_;
bool enableEvents_;
void setCounter();
void setDuty(unsigned nr1);
void updatePos(unsigned long cc);
public:
DutyUnit();
void event();
bool isHighState() const { return high; }
void nr1Change(unsigned newNr1, unsigned long cc);
void nr3Change(unsigned newNr3, unsigned long cc);
void nr4Change(unsigned newNr4, unsigned long cc);
void reset();
void loadState(const SaveState::SPU::Duty &dstate, unsigned nr1, unsigned nr4, unsigned long cc);
void resetCounters(unsigned long oldCc);
void killCounter();
void reviveCounter(unsigned long cc);
//intended for use by SweepUnit only.
unsigned getFreq() const { return 2048 - (period >> 1); }
void setFreq(unsigned newFreq, unsigned long cc);
template<bool isReader>void SyncState(NewState *ns);
};
class DutyMasterDisabler : public MasterDisabler {
DutyUnit &dutyUnit;
public:
DutyMasterDisabler(bool &m, DutyUnit &dutyUnit) : MasterDisabler(m), dutyUnit(dutyUnit) {}
void operator()() { MasterDisabler::operator()(); dutyUnit.killCounter(); }
DutyMasterDisabler(bool &m, DutyUnit &dutyUnit) : MasterDisabler(m), dutyUnit_(dutyUnit) {}
virtual void operator()() { MasterDisabler::operator()(); dutyUnit_.killCounter(); }
private:
DutyUnit &dutyUnit_;
};
}

166
libgambatte/src/sound/envelope_unit.cpp
View File

@ -1,108 +1,98 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "envelope_unit.h"
#include <algorithm>
namespace gambatte {
EnvelopeUnit::VolOnOffEvent EnvelopeUnit::nullEvent;
void EnvelopeUnit::event() {
const unsigned long period = nr2 & 7;
if (period) {
unsigned newVol = volume;
if (nr2 & 8)
++newVol;
else
--newVol;
if (newVol < 0x10U) {
volume = newVol;
if (volume < 2)
volOnOffEvent(counter);
counter += period << 15;
} else
counter = COUNTER_DISABLED;
} else
counter += 8ul << 15;
}
bool EnvelopeUnit::nr2Change(const unsigned newNr2) {
if (!(nr2 & 7) && counter != COUNTER_DISABLED)
++volume;
else if (!(nr2 & 8))
volume += 2;
if ((nr2 ^ newNr2) & 8)
volume = 0x10 - volume;
volume &= 0xF;
nr2 = newNr2;
return !(newNr2 & 0xF8);
}
bool EnvelopeUnit::nr4Init(const unsigned long cc) {
{
unsigned long period = nr2 & 7;
if (!period)
period = 8;
if (!(cc & 0x7000))
++period;
counter = cc - ((cc - 0x1000) & 0x7FFF) + period * 0x8000;
}
volume = nr2 >> 4;
return !(nr2 & 0xF8);
}
EnvelopeUnit::VolOnOffEvent EnvelopeUnit::nullEvent_;
EnvelopeUnit::EnvelopeUnit(VolOnOffEvent &volOnOffEvent)
: volOnOffEvent(volOnOffEvent),
nr2(0),
volume(0)
: volOnOffEvent_(volOnOffEvent)
, nr2_(0)
, volume_(0)
{
}
void EnvelopeUnit::reset() {
counter = COUNTER_DISABLED;
counter_ = counter_disabled;
}
void EnvelopeUnit::loadState(const SaveState::SPU::Env &estate, const unsigned nr2, const unsigned long cc) {
counter = std::max(estate.counter, cc);
volume = estate.volume;
this->nr2 = nr2;
void EnvelopeUnit::loadState(SaveState::SPU::Env const &estate, unsigned nr2, unsigned long cc) {
counter_ = std::max(estate.counter, cc);
volume_ = estate.volume;
nr2_ = nr2;
}
void EnvelopeUnit::event() {
unsigned long const period = nr2_ & 7;
if (period) {
unsigned newVol = volume_;
if (nr2_ & 8)
++newVol;
else
--newVol;
if (newVol < 0x10U) {
volume_ = newVol;
if (volume_ < 2)
volOnOffEvent_(counter_);
counter_ += period << 15;
} else
counter_ = counter_disabled;
} else
counter_ += 8ul << 15;
}
bool EnvelopeUnit::nr2Change(unsigned const newNr2) {
if (!(nr2_ & 7) && counter_ != counter_disabled)
++volume_;
else if (!(nr2_ & 8))
volume_ += 2;
if ((nr2_ ^ newNr2) & 8)
volume_ = 0x10 - volume_;
volume_ &= 0xF;
nr2_ = newNr2;
return !(newNr2 & 0xF8);
}
bool EnvelopeUnit::nr4Init(unsigned long const cc) {
unsigned long period = nr2_ & 7 ? nr2_ & 7 : 8;
if (((cc + 2) & 0x7000) == 0x0000)
++period;
counter_ = cc - ((cc - 0x1000) & 0x7FFF) + period * 0x8000;
volume_ = nr2_ >> 4;
return !(nr2_ & 0xF8);
}
SYNCFUNC(EnvelopeUnit)
{
NSS(counter);
NSS(nr2);
NSS(volume);
NSS(counter_);
NSS(nr2_);
NSS(volume_);
}
}

60
libgambatte/src/sound/envelope_unit.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef ENVELOPE_UNIT_H
#define ENVELOPE_UNIT_H
@ -31,23 +31,23 @@ public:
virtual ~VolOnOffEvent() {}
virtual void operator()(unsigned long /*cc*/) {}
};
private:
static VolOnOffEvent nullEvent;
VolOnOffEvent &volOnOffEvent;
unsigned char nr2;
unsigned char volume;
public:
explicit EnvelopeUnit(VolOnOffEvent &volOnOffEvent = nullEvent);
explicit EnvelopeUnit(VolOnOffEvent &volOnOffEvent = nullEvent_);
void event();
bool dacIsOn() const { return nr2 & 0xF8; }
unsigned getVolume() const { return volume; }
bool dacIsOn() const { return nr2_ & 0xF8; }
unsigned getVolume() const { return volume_; }
bool nr2Change(unsigned newNr2);
bool nr4Init(unsigned long cycleCounter);
void reset();
void loadState(const SaveState::SPU::Env &estate, unsigned nr2, unsigned long cc);
void loadState(SaveState::SPU::Env const &estate, unsigned nr2, unsigned long cc);
private:
static VolOnOffEvent nullEvent_;
VolOnOffEvent &volOnOffEvent_;
unsigned char nr2_;
unsigned char volume_;
public:
template<bool isReader>void SyncState(NewState *ns);
};

114
libgambatte/src/sound/length_counter.cpp
View File

@ -1,93 +1,83 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "length_counter.h"
#include "master_disabler.h"
#include <algorithm>
namespace gambatte {
LengthCounter::LengthCounter(MasterDisabler &disabler, const unsigned mask) :
disableMaster(disabler),
lengthMask(mask)
LengthCounter::LengthCounter(MasterDisabler &disabler, unsigned const mask)
: disableMaster_(disabler)
, lengthCounter_(0)
, lengthMask_(mask)
{
init(false);
nr1Change(0, 0, 0);
}
void LengthCounter::event() {
counter = COUNTER_DISABLED;
lengthCounter = 0;
disableMaster();
counter_ = counter_disabled;
lengthCounter_ = 0;
disableMaster_();
}
void LengthCounter::nr1Change(const unsigned newNr1, const unsigned nr4, const unsigned long cycleCounter) {
lengthCounter = (~newNr1 & lengthMask) + 1;
counter = (nr4 & 0x40) ?( (cycleCounter >> 13) + lengthCounter) << 13 : static_cast<unsigned long>(COUNTER_DISABLED);
void LengthCounter::nr1Change(unsigned const newNr1, unsigned const nr4, unsigned long const cc) {
lengthCounter_ = (~newNr1 & lengthMask_) + 1;
counter_ = nr4 & 0x40
? ((cc >> 13) + lengthCounter_) << 13
: static_cast<unsigned long>(counter_disabled);
}
void LengthCounter::nr4Change(const unsigned oldNr4, const unsigned newNr4, const unsigned long cycleCounter) {
if (counter != COUNTER_DISABLED)
lengthCounter = (counter >> 13) - (cycleCounter >> 13);
void LengthCounter::nr4Change(unsigned const oldNr4, unsigned const newNr4, unsigned long const cc) {
if (counter_ != counter_disabled)
lengthCounter_ = (counter_ >> 13) - (cc >> 13);
{
unsigned dec = 0;
if (newNr4 & 0x40) {
dec = ~cycleCounter >> 12 & 1;
if (!(oldNr4 & 0x40) && lengthCounter) {
if (!(lengthCounter -= dec))
disableMaster();
dec = ~cc >> 12 & 1;
if (!(oldNr4 & 0x40) && lengthCounter_) {
if (!(lengthCounter_ -= dec))
disableMaster_();
}
}
if ((newNr4 & 0x80) && !lengthCounter)
lengthCounter = lengthMask + 1 - dec;
if ((newNr4 & 0x80) && !lengthCounter_)
lengthCounter_ = lengthMask_ + 1 - dec;
}
if ((newNr4 & 0x40) && lengthCounter)
counter = ((cycleCounter >> 13) + lengthCounter) << 13;
if ((newNr4 & 0x40) && lengthCounter_)
counter_ = ((cc >> 13) + lengthCounter_) << 13;
else
counter = COUNTER_DISABLED;
counter_ = counter_disabled;
}
/*void LengthCounter::reset() {
counter = COUNTER_DISABLED;
if (cgb)
lengthCounter = lengthMask + 1;
}*/
void LengthCounter::init(const bool cgb) {
this->cgb = cgb;
}
void LengthCounter::loadState(const SaveState::SPU::LCounter &lstate, const unsigned long cc) {
counter = std::max(lstate.counter, cc);
lengthCounter = lstate.lengthCounter;
void LengthCounter::loadState(SaveState::SPU::LCounter const &lstate, unsigned long const cc) {
counter_ = std::max(lstate.counter, cc);
lengthCounter_ = lstate.lengthCounter;
}
SYNCFUNC(LengthCounter)
{
NSS(counter);
NSS(lengthCounter);
NSS(cgb);
NSS(counter_);
NSS(lengthCounter_);
}
}

53
libgambatte/src/sound/length_counter.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef LENGTH_COUNTER_H
#define LENGTH_COUNTER_H
@ -28,20 +28,19 @@ namespace gambatte {
class MasterDisabler;
class LengthCounter : public SoundUnit {
MasterDisabler &disableMaster;
unsigned short lengthCounter;
const unsigned char lengthMask;
bool cgb;
public:
LengthCounter(MasterDisabler &disabler, unsigned lengthMask);
void event();
virtual void event();
void nr1Change(unsigned newNr1, unsigned nr4, unsigned long cc);
void nr4Change(unsigned oldNr4, unsigned newNr4, unsigned long cc);
// void reset();
void init(bool cgb);
void loadState(const SaveState::SPU::LCounter &lstate, unsigned long cc);
void loadState(SaveState::SPU::LCounter const &lstate, unsigned long cc);
private:
MasterDisabler &disableMaster_;
unsigned short lengthCounter_;
unsigned char const lengthMask_;
public:
template<bool isReader>void SyncState(NewState *ns);
};

47
libgambatte/src/sound/master_disabler.h
View File

@ -1,33 +1,36 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef MASTER_DISABLER_H
#define MASTER_DISABLER_H
namespace gambatte {
class MasterDisabler {
bool &master;
public:
MasterDisabler(bool &m) : master(m) {}
explicit MasterDisabler(bool &master) : master_(master) {}
virtual ~MasterDisabler() {}
virtual void operator()() { master = false; }
virtual void operator()() { master_ = false; }
private:
bool &master_;
};
}
#endif

56
libgambatte/src/sound/sound_unit.h
View File

@ -1,37 +1,43 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SOUND_UNIT_H
#define SOUND_UNIT_H
namespace gambatte {
class SoundUnit {
protected:
unsigned long counter;
public:
enum { COUNTER_MAX = 0x80000000u, COUNTER_DISABLED = 0xFFFFFFFFu };
SoundUnit() : counter(COUNTER_DISABLED) {}
enum { counter_max = 0x80000000u, counter_disabled = 0xFFFFFFFFu };
virtual ~SoundUnit() {}
virtual void event() = 0;
unsigned long getCounter() const { return counter; }
virtual void resetCounters(unsigned long /*oldCc*/) { if (counter != COUNTER_DISABLED) counter -= COUNTER_MAX; }
virtual void resetCounters(unsigned long /*oldCc*/) {
if (counter_ != counter_disabled)
counter_ -= counter_max;
}
unsigned long counter() const { return counter_; }
protected:
SoundUnit() : counter_(counter_disabled) {}
unsigned long counter_;
};
}

52
libgambatte/src/sound/static_output_tester.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef STATIC_OUTPUT_TESTER_H
#define STATIC_OUTPUT_TESTER_H
@ -25,19 +25,21 @@ namespace gambatte {
template<class Channel, class Unit>
class StaticOutputTester : public EnvelopeUnit::VolOnOffEvent {
const Channel &ch;
Unit &unit;
public:
StaticOutputTester(const Channel &ch, Unit &unit) : ch(ch), unit(unit) {}
StaticOutputTester(Channel const &ch, Unit &unit) : ch_(ch), unit_(unit) {}
void operator()(unsigned long cc);
private:
Channel const &ch_;
Unit &unit_;
};
template<class Channel, class Unit>
void StaticOutputTester<Channel, Unit>::operator()(const unsigned long cc) {
if (ch.soMask && ch.master && ch.envelopeUnit.getVolume())
unit.reviveCounter(cc);
void StaticOutputTester<Channel, Unit>::operator()(unsigned long cc) {
if (ch_.soMask_ && ch_.master_ && ch_.envelopeUnit_.getVolume())
unit_.reviveCounter(cc);
else
unit.killCounter();
unit_.killCounter();
}
}

178
libgambatte/src/tima.cpp
View File

@ -1,83 +1,81 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "tima.h"
#include "savestate.h"
static const unsigned char timaClock[4] = { 10, 4, 6, 8 };
static unsigned char const timaClock[4] = { 10, 4, 6, 8 };
namespace gambatte {
Tima::Tima() :
lastUpdate_(0),
tmatime_(DISABLED_TIME),
tima_(0),
tma_(0),
tac_(0)
{}
Tima::Tima()
: lastUpdate_(0)
, tmatime_(disabled_time)
, tima_(0)
, tma_(0)
, tac_(0)
{
}
void Tima::loadState(const SaveState &state, const TimaInterruptRequester timaIrq) {
void Tima::loadState(SaveState const &state, TimaInterruptRequester timaIrq) {
basetime_ = state.mem.timaBasetime;
lastUpdate_ = state.mem.timaLastUpdate;
tmatime_ = state.mem.tmatime;
tima_ = state.mem.ioamhram.get()[0x105];
tma_ = state.mem.ioamhram.get()[0x106];
tac_ = state.mem.ioamhram.get()[0x107];
timaIrq.setNextIrqEventTime((tac_ & 4)
?
(tmatime_ != DISABLED_TIME && tmatime_ > state.cpu.cycleCounter
? tmatime_
: lastUpdate_ + ((256u - tima_) << timaClock[tac_ & 3]) + 3)
:
static_cast<unsigned long>(DISABLED_TIME)
);
unsigned long nextIrqEventTime = disabled_time;
if (tac_ & 4) {
nextIrqEventTime = tmatime_ != disabled_time && tmatime_ > state.cpu.cycleCounter
? tmatime_
: lastUpdate_ + ((256u - tima_) << timaClock[tac_ & 3]) + 3;
}
timaIrq.setNextIrqEventTime(nextIrqEventTime);
}
void Tima::resetCc(const unsigned long oldCc, const unsigned long newCc, const TimaInterruptRequester timaIrq) {
const unsigned long dec = oldCc - newCc;
void Tima::resetCc(unsigned long const oldCc, unsigned long const newCc, TimaInterruptRequester timaIrq) {
if (tac_ & 0x04) {
updateIrq(oldCc, timaIrq);
updateTima(oldCc);
unsigned long const dec = oldCc - newCc;
lastUpdate_ -= dec;
timaIrq.setNextIrqEventTime(timaIrq.nextIrqEventTime() - dec);
if (tmatime_ != DISABLED_TIME)
if (tmatime_ != disabled_time)
tmatime_ -= dec;
}
}
void Tima::updateTima(const unsigned long cycleCounter) {
const unsigned long ticks = (cycleCounter - lastUpdate_) >> timaClock[tac_ & 3];
void Tima::updateTima(unsigned long const cc) {
unsigned long const ticks = (cc - lastUpdate_) >> timaClock[tac_ & 3];
lastUpdate_ += ticks << timaClock[tac_ & 3];
if (cycleCounter >= tmatime_) {
if (cycleCounter >= tmatime_ + 4)
tmatime_ = DISABLED_TIME;
if (cc >= tmatime_) {
if (cc >= tmatime_ + 4)
tmatime_ = disabled_time;
tima_ = tma_;
}
unsigned long tmp = tima_ + ticks;
while (tmp > 0x100)
tmp -= 0x100 - tma_;
@ -85,9 +83,9 @@ void Tima::updateTima(const unsigned long cycleCounter) {
tmp = 0;
tmatime_ = lastUpdate_ + 3;
if (cycleCounter >= tmatime_) {
if (cycleCounter >= tmatime_ + 4)
tmatime_ = DISABLED_TIME;
if (cc >= tmatime_) {
if (cc >= tmatime_ + 4)
tmatime_ = disabled_time;
tmp = tma_;
}
@ -96,86 +94,88 @@ void Tima::updateTima(const unsigned long cycleCounter) {
tima_ = tmp;
}
void Tima::setTima(const unsigned data, const unsigned long cycleCounter, const TimaInterruptRequester timaIrq) {
void Tima::setTima(unsigned const data, unsigned long const cc, TimaInterruptRequester timaIrq) {
if (tac_ & 0x04) {
updateIrq(cycleCounter, timaIrq);
updateTima(cycleCounter);
updateIrq(cc, timaIrq);
updateTima(cc);
if (tmatime_ - cycleCounter < 4)
tmatime_ = DISABLED_TIME;
if (tmatime_ - cc < 4)
tmatime_ = disabled_time;
timaIrq.setNextIrqEventTime(lastUpdate_ + ((256u - data) << timaClock[tac_ & 3]) + 3);
}
tima_ = data;
}
void Tima::setTma(const unsigned data, const unsigned long cycleCounter, const TimaInterruptRequester timaIrq) {
void Tima::setTma(unsigned const data, unsigned long const cc, TimaInterruptRequester timaIrq) {
if (tac_ & 0x04) {
updateIrq(cycleCounter, timaIrq);
updateTima(cycleCounter);
updateIrq(cc, timaIrq);
updateTima(cc);
}
tma_ = data;
}
void Tima::setTac(const unsigned data, const unsigned long cycleCounter, const TimaInterruptRequester timaIrq, bool gbIsCgb) {
void Tima::setTac(unsigned const data, unsigned long const cc, TimaInterruptRequester timaIrq, bool agbFlag) {
if (tac_ ^ data) {
unsigned long nextIrqEventTime = timaIrq.nextIrqEventTime();
if (tac_ & 0x04) {
updateIrq(cycleCounter, timaIrq);
updateTima(cycleCounter);
updateIrq(cc, timaIrq);
updateTima(cc);
lastUpdate_ -= (1u << (timaClock[tac_ & 3] - 1)) + 3;
tmatime_ -= (1u << (timaClock[tac_ & 3] - 1)) + 3;
nextIrqEventTime -= (1u << (timaClock[tac_ & 3] - 1)) + 3;
if (cycleCounter >= nextIrqEventTime)
timaIrq.flagIrq();
updateTima(cycleCounter);
tmatime_ = DISABLED_TIME;
nextIrqEventTime = DISABLED_TIME;
if (cc >= nextIrqEventTime)
timaIrq.flagIrq();
updateTima(cc);
tmatime_ = disabled_time;
nextIrqEventTime = disabled_time;
}
if (data & 4) {
lastUpdate_ = (cycleCounter >> timaClock[data & 3]) << timaClock[data & 3];
unsigned long diff = cycleCounter - basetime_;
if (gbIsCgb) {
unsigned long diff = cc - basetime_;
if (agbFlag) {
if (((diff >> (timaClock[tac_ & 3] - 1)) & 1) == 1 && ((diff >> (timaClock[data & 3] - 1)) & 1) == 0)
tima_++;
}
}
lastUpdate_ = basetime_ + ((diff >> timaClock[data & 3]) << timaClock[data & 3]);
nextIrqEventTime = lastUpdate_ + ((256u - tima_) << timaClock[data & 3]) + 3;
}
timaIrq.setNextIrqEventTime(nextIrqEventTime);
}
tac_ = data;
}
void Tima::resTac(unsigned long const cycleCounter, TimaInterruptRequester timaIrq) {
basetime_ = cycleCounter;
void Tima::resTac(unsigned long const cc, TimaInterruptRequester timaIrq) {
basetime_ = cc;
if (tac_ & 0x04) {
setTac(tac_ & ~0x04, cycleCounter, timaIrq, false);
setTac(tac_ | 0x04, cycleCounter, timaIrq, false);
setTac(tac_ & ~0x04, cc, timaIrq, false);
setTac(tac_ | 0x04, cc, timaIrq, false);
}
}
unsigned Tima::tima(unsigned long cycleCounter) {
unsigned Tima::tima(unsigned long cc) {
if (tac_ & 0x04)
updateTima(cycleCounter);
updateTima(cc);
return tima_;
}
void Tima::doIrqEvent(const TimaInterruptRequester timaIrq) {
void Tima::doIrqEvent(TimaInterruptRequester timaIrq) {
timaIrq.flagIrq();
timaIrq.setNextIrqEventTime(timaIrq.nextIrqEventTime() + ((256u - tma_) << timaClock[tac_ & 3]));
timaIrq.setNextIrqEventTime(timaIrq.nextIrqEventTime()
+ ((256u - tma_) << timaClock[tac_ & 3]));
}
SYNCFUNC(Tima)

84
libgambatte/src/tima.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef TIMA_H
#define TIMA_H
@ -24,44 +24,44 @@
namespace gambatte {
class TimaInterruptRequester {
InterruptRequester &intreq;
public:
explicit TimaInterruptRequester(InterruptRequester &intreq) : intreq(intreq) {}
void flagIrq() const { intreq.flagIrq(4); }
unsigned long nextIrqEventTime() const { return intreq.eventTime(TIMA); }
void setNextIrqEventTime(const unsigned long time) const { intreq.setEventTime<TIMA>(time); }
explicit TimaInterruptRequester(InterruptRequester &intreq) : intreq_(intreq) {}
void flagIrq() const { intreq_.flagIrq(4); }
unsigned long nextIrqEventTime() const { return intreq_.eventTime(intevent_tima); }
void setNextIrqEventTime(unsigned long time) const { intreq_.setEventTime<intevent_tima>(time); }
private:
InterruptRequester &intreq_;
};
class Tima {
unsigned long basetime_;
unsigned long lastUpdate_;
unsigned long tmatime_;
unsigned char tima_;
unsigned char tma_;
unsigned char tac_;
void updateIrq(const unsigned long cc, const TimaInterruptRequester timaIrq) {
while (cc >= timaIrq.nextIrqEventTime())
doIrqEvent(timaIrq);
}
void updateTima(unsigned long cc);
public:
Tima();
void loadState(const SaveState &, TimaInterruptRequester timaIrq);
void resetCc(unsigned long oldCc, unsigned long newCc, TimaInterruptRequester timaIrq);
void setTima(unsigned tima, unsigned long cc, TimaInterruptRequester timaIrq);
void setTma(unsigned tma, unsigned long cc, TimaInterruptRequester timaIrq);
void setTac(unsigned tac, unsigned long cc, TimaInterruptRequester timaIrq, bool gbIsCgb);
void setTac(unsigned tac, unsigned long cc, TimaInterruptRequester timaIrq, bool agbFlag);
void resTac(unsigned long cc, TimaInterruptRequester timaIrq);
unsigned tima(unsigned long cc);
void doIrqEvent(TimaInterruptRequester timaIrq);
private:
unsigned long basetime_;
unsigned long lastUpdate_;
unsigned long tmatime_;
unsigned char tima_;
unsigned char tma_;
unsigned char tac_;
void updateIrq(unsigned long const cc, TimaInterruptRequester timaIrq) {
while (cc >= timaIrq.nextIrqEventTime())
doIrqEvent(timaIrq);
}
void updateTima(unsigned long cc);
public:
template<bool isReader>void SyncState(NewState *ns);
};

1077
libgambatte/src/video.cpp
View File

File diff suppressed because it is too large Load Diff

369
libgambatte/src/video.h
View File

@ -1,220 +1,99 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef VIDEO_H
#define VIDEO_H
#include "video/ppu.h"
#include "video/lyc_irq.h"
#include "video/next_m0_time.h"
#include "interruptrequester.h"
#include "minkeeper.h"
#include <memory>
#include "video/lyc_irq.h"
#include "video/m0_irq.h"
#include "video/next_m0_time.h"
#include "video/ppu.h"
#include "newstate.h"
namespace gambatte {
class VideoInterruptRequester {
InterruptRequester * intreq;
public:
explicit VideoInterruptRequester(InterruptRequester * intreq) : intreq(intreq) {}
void flagHdmaReq() const { gambatte::flagHdmaReq(intreq); }
void flagIrq(const unsigned bit) const { intreq->flagIrq(bit); }
void setNextEventTime(const unsigned long time) const { intreq->setEventTime<VIDEO>(time); }
};
class M0Irq {
unsigned char statReg_;
unsigned char lycReg_;
public:
M0Irq() : statReg_(0), lycReg_(0) {}
void lcdReset(const unsigned statReg, const unsigned lycReg) {
statReg_ = statReg;
lycReg_ = lycReg;
}
void statRegChange(const unsigned statReg,
const unsigned long nextM0IrqTime, const unsigned long cc, const bool cgb) {
if (nextM0IrqTime - cc > cgb * 2U)
statReg_ = statReg;
}
void lycRegChange(const unsigned lycReg,
const unsigned long nextM0IrqTime, const unsigned long cc, const bool ds, const bool cgb) {
if (nextM0IrqTime - cc > cgb * 5 + 1U - ds)
lycReg_ = lycReg;
}
void doEvent(unsigned char *const ifreg, const unsigned ly, const unsigned statReg, const unsigned lycReg) {
if (((statReg_ | statReg) & 0x08) && (!(statReg_ & 0x40) || ly != lycReg_))
*ifreg |= 2;
statReg_ = statReg;
lycReg_ = lycReg;
}
void loadState(const SaveState &state) {
lycReg_ = state.ppu.m0lyc;
statReg_ = state.mem.ioamhram.get()[0x141];
}
unsigned statReg() const { return statReg_; }
template<bool isReader>
void SyncState(NewState *ns)
explicit VideoInterruptRequester(InterruptRequester &intreq)
: intreq_(intreq)
{
NSS(statReg_);
NSS(lycReg_);
}
void flagHdmaReq() const { gambatte::flagHdmaReq(intreq_); }
void flagIrq(unsigned bit) const { intreq_.flagIrq(bit); }
void setNextEventTime(unsigned long time) const { intreq_.setEventTime<intevent_video>(time); }
private:
InterruptRequester &intreq_;
};
class LCD {
enum Event { MEM_EVENT, LY_COUNT }; enum { NUM_EVENTS = LY_COUNT + 1 };
enum MemEvent { ONESHOT_LCDSTATIRQ, ONESHOT_UPDATEWY2, MODE1_IRQ, LYC_IRQ, SPRITE_MAP,
HDMA_REQ, MODE2_IRQ, MODE0_IRQ }; enum { NUM_MEM_EVENTS = MODE0_IRQ + 1 };
class EventTimes {
MinKeeper<NUM_EVENTS> eventMin_;
MinKeeper<NUM_MEM_EVENTS> memEventMin_;
VideoInterruptRequester memEventRequester_;
void setMemEvent() {
const unsigned long nmet = nextMemEventTime();
eventMin_.setValue<MEM_EVENT>(nmet);
memEventRequester_.setNextEventTime(nmet);
}
public:
explicit EventTimes(const VideoInterruptRequester memEventRequester) : memEventRequester_(memEventRequester) {}
Event nextEvent() const { return static_cast<Event>(eventMin_.min()); }
unsigned long nextEventTime() const { return eventMin_.minValue(); }
unsigned long operator()(const Event e) const { return eventMin_.value(e); }
template<Event e> void set(const unsigned long time) { eventMin_.setValue<e>(time); }
void set(const Event e, const unsigned long time) { eventMin_.setValue(e, time); }
MemEvent nextMemEvent() const { return static_cast<MemEvent>(memEventMin_.min()); }
unsigned long nextMemEventTime() const { return memEventMin_.minValue(); }
unsigned long operator()(const MemEvent e) const { return memEventMin_.value(e); }
template<MemEvent e> void setm(const unsigned long time) { memEventMin_.setValue<e>(time); setMemEvent(); }
void set(const MemEvent e, const unsigned long time) { memEventMin_.setValue(e, time); setMemEvent(); }
void flagIrq(const unsigned bit) { memEventRequester_.flagIrq(bit); }
void flagHdmaReq() { memEventRequester_.flagHdmaReq(); }
template<bool isReader>
void SyncState(NewState *ns)
{
SSS(eventMin_);
SSS(memEventMin_);
//SSS(memEventRequester_); // not needed
}
};
PPU ppu;
unsigned long dmgColorsRgb32[3 * 4];
unsigned long cgbColorsRgb32[32768];
unsigned char bgpData[8 * 8];
unsigned char objpData[8 * 8];
EventTimes eventTimes_;
M0Irq m0Irq_;
LycIrq lycIrq;
NextM0Time nextM0Time_;
unsigned char statReg;
unsigned char m2IrqStatReg_;
unsigned char m1IrqStatReg_;
static void setDmgPalette(unsigned long *palette, const unsigned long *dmgColors, unsigned data);
void setDmgPaletteColor(unsigned index, unsigned long rgb32);
unsigned long gbcToRgb32(const unsigned bgr15);
void doCgbColorChange(unsigned char *const pdata, unsigned long *const palette, unsigned index, const unsigned data);
void refreshPalettes();
void setDBuffer();
void doMode2IrqEvent();
void event();
unsigned long m0TimeOfCurrentLine(unsigned long cc);
bool cgbpAccessible(unsigned long cycleCounter);
void mode3CyclesChange();
void doCgbBgColorChange(unsigned index, unsigned data, unsigned long cycleCounter);
void doCgbSpColorChange(unsigned index, unsigned data, unsigned long cycleCounter);
void (*scanlinecallback)();
int scanlinecallbacksl;
public:
LCD(const unsigned char *oamram, const unsigned char *vram_in, VideoInterruptRequester memEventRequester);
void reset(const unsigned char *oamram, const unsigned char *vram, bool cgb);
LCD(unsigned char const *oamram, unsigned char const *vram,
VideoInterruptRequester memEventRequester);
void reset(unsigned char const *oamram, unsigned char const *vram, bool cgb);
void setStatePtrs(SaveState &state);
void loadState(const SaveState &state, const unsigned char *oamram);
void loadState(SaveState const &state, unsigned char const *oamram);
void setDmgPaletteColor(unsigned palNum, unsigned colorNum, unsigned long rgb32);
void setCgbPalette(unsigned *lut);
void setVideoBuffer(uint_least32_t *videoBuf, int pitch);
void setLayers(unsigned mask) { ppu.setLayers(mask); }
void setVideoBuffer(uint_least32_t *videoBuf, std::ptrdiff_t pitch);
void setLayers(unsigned mask) { ppu_.setLayers(mask); }
void setCgb(bool cgb);
void copyCgbPalettesToDmg();
void blackScreen();
int debugGetLY() const { return ppu.lyCounter().ly(); }
int debugGetLY() const { return ppu_.lyCounter().ly(); }
void dmgBgPaletteChange(const unsigned data, const unsigned long cycleCounter) {
void dmgBgPaletteChange(unsigned data, unsigned long cycleCounter) {
update(cycleCounter);
bgpData[0] = data;
setDmgPalette(ppu.bgPalette(), dmgColorsRgb32, data);
bgpData_[0] = data;
setDmgPalette(ppu_.bgPalette(), dmgColorsRgb32_, data);
}
void dmgSpPalette1Change(const unsigned data, const unsigned long cycleCounter) {
void dmgSpPalette1Change(unsigned data, unsigned long cycleCounter) {
update(cycleCounter);
objpData[0] = data;
setDmgPalette(ppu.spPalette(), dmgColorsRgb32 + 4, data);
objpData_[0] = data;
setDmgPalette(ppu_.spPalette(), dmgColorsRgb32_ + 4, data);
}
void dmgSpPalette2Change(const unsigned data, const unsigned long cycleCounter) {
void dmgSpPalette2Change(unsigned data, unsigned long cycleCounter) {
update(cycleCounter);
objpData[1] = data;
setDmgPalette(ppu.spPalette() + 4, dmgColorsRgb32 + 8, data);
objpData_[1] = data;
setDmgPalette(ppu_.spPalette() + 4, dmgColorsRgb32_ + 8, data);
}
void cgbBgColorChange(unsigned index, const unsigned data, const unsigned long cycleCounter) {
if (bgpData[index] != data)
void cgbBgColorChange(unsigned index, unsigned data, unsigned long cycleCounter) {
if (bgpData_[index] != data)
doCgbBgColorChange(index, data, cycleCounter);
}
void cgbSpColorChange(unsigned index, const unsigned data, const unsigned long cycleCounter) {
if (objpData[index] != data)
void cgbSpColorChange(unsigned index, unsigned data, unsigned long cycleCounter) {
if (objpData_[index] != data)
doCgbSpColorChange(index, data, cycleCounter);
}
unsigned cgbBgColorRead(const unsigned index, const unsigned long cycleCounter) {
return ppu.cgb() & cgbpAccessible(cycleCounter) ? bgpData[index] : 0xFF;
unsigned cgbBgColorRead(unsigned index, unsigned long cycleCounter) {
return ppu_.cgb() & cgbpAccessible(cycleCounter) ? bgpData_[index] : 0xFF;
}
unsigned cgbSpColorRead(const unsigned index, const unsigned long cycleCounter) {
return ppu.cgb() & cgbpAccessible(cycleCounter) ? objpData[index] : 0xFF;
unsigned cgbSpColorRead(unsigned index, unsigned long cycleCounter) {
return ppu_.cgb() & cgbpAccessible(cycleCounter) ? objpData_[index] : 0xFF;
}
void updateScreen(bool blanklcd, unsigned long cc);
@ -229,53 +108,149 @@ public:
void oamChange(const unsigned char *oamram, unsigned long cycleCounter);
void scxChange(unsigned newScx, unsigned long cycleCounter);
void scyChange(unsigned newValue, unsigned long cycleCounter);
void vramChange(const unsigned long cycleCounter) { update(cycleCounter); }
void vramChange(unsigned long cycleCounter) { update(cycleCounter); }
unsigned getStat(unsigned lycReg, unsigned long cycleCounter);
unsigned getLyReg(const unsigned long cycleCounter) {
unsigned getLyReg(unsigned long const cc) {
unsigned lyReg = 0;
if (ppu.lcdc() & 0x80) {
if (cycleCounter >= ppu.lyCounter().time())
update(cycleCounter);
if (ppu_.lcdc() & lcdc_en) {
if (cc >= ppu_.lyCounter().time())
update(cc);
lyReg = ppu_.lyCounter().ly();
lyReg = ppu.lyCounter().ly();
if (lyReg == 153) {
if (isDoubleSpeed()) {
if (ppu.lyCounter().time() - cycleCounter <= 456 * 2 - 8)
if (ppu_.lyCounter().time() - cc <= 456 * 2 - 8)
lyReg = 0;
} else
lyReg = 0;
} else if (ppu.lyCounter().time() - cycleCounter <= 4)
} else if (ppu_.lyCounter().time() - cc <= 4)
++lyReg;
}
return lyReg;
}
unsigned long nextMode1IrqTime() const { return eventTimes_(MODE1_IRQ); }
unsigned long nextMode1IrqTime() const { return eventTimes_(memevent_m1irq); }
void lcdcChange(unsigned data, unsigned long cycleCounter);
void lcdstatChange(unsigned data, unsigned long cycleCounter);
void lycRegChange(unsigned data, unsigned long cycleCounter);
void enableHdma(unsigned long cycleCounter);
void disableHdma(unsigned long cycleCounter);
bool hdmaIsEnabled() const { return eventTimes_(HDMA_REQ) != DISABLED_TIME; }
bool hdmaIsEnabled() const { return eventTimes_(memevent_hdma) != disabled_time; }
void update(unsigned long cycleCounter);
bool isCgb() const { return ppu.cgb(); }
bool isDoubleSpeed() const { return ppu.lyCounter().isDoubleSpeed(); }
bool isCgb() const { return ppu_.cgb(); }
bool isDoubleSpeed() const { return ppu_.lyCounter().isDoubleSpeed(); }
unsigned long *bgPalette() { return ppu.bgPalette(); }
unsigned long *spPalette() { return ppu.spPalette(); }
unsigned long *bgPalette() { return ppu_.bgPalette(); }
unsigned long *spPalette() { return ppu_.spPalette(); }
void setScanlineCallback(void (*callback)(), int sl) { scanlinecallback = callback; scanlinecallbacksl = sl; }
private:
enum Event { event_mem,
event_ly, event_last = event_ly };
enum MemEvent { memevent_oneshot_statirq,
memevent_oneshot_updatewy2,
memevent_m1irq,
memevent_lycirq,
memevent_spritemap,
memevent_hdma,
memevent_m2irq,
memevent_m0irq, memevent_last = memevent_m0irq };
enum { num_events = event_last + 1 };
enum { num_memevents = memevent_last + 1 };
class EventTimes {
public:
explicit EventTimes(VideoInterruptRequester memEventRequester)
: eventMin_(disabled_time)
, memEventMin_(disabled_time)
, memEventRequester_(memEventRequester)
{
}
Event nextEvent() const { return static_cast<Event>(eventMin_.min()); }
unsigned long nextEventTime() const { return eventMin_.minValue(); }
unsigned long operator()(Event e) const { return eventMin_.value(e); }
template<Event e> void set(unsigned long time) { eventMin_.setValue<e>(time); }
void set(Event e, unsigned long time) { eventMin_.setValue(e, time); }
MemEvent nextMemEvent() const { return static_cast<MemEvent>(memEventMin_.min()); }
unsigned long nextMemEventTime() const { return memEventMin_.minValue(); }
unsigned long operator()(MemEvent e) const { return memEventMin_.value(e); }
template<MemEvent e>
void setm(unsigned long time) { memEventMin_.setValue<e>(time); setMemEvent(); }
void set(MemEvent e, unsigned long time) { memEventMin_.setValue(e, time); setMemEvent(); }
void flagIrq(unsigned bit) { memEventRequester_.flagIrq(bit); }
void flagHdmaReq() { memEventRequester_.flagHdmaReq(); }
private:
MinKeeper<num_events> eventMin_;
MinKeeper<num_memevents> memEventMin_;
VideoInterruptRequester memEventRequester_;
void setMemEvent() {
unsigned long nmet = nextMemEventTime();
eventMin_.setValue<event_mem>(nmet);
memEventRequester_.setNextEventTime(nmet);
}
public:
template<bool isReader>
void SyncState(NewState *ns)
{
SSS(eventMin_);
SSS(memEventMin_);
}
};
PPU ppu_;
unsigned long dmgColorsRgb32_[3 * 4];
unsigned long cgbColorsRgb32_[32768];
unsigned char bgpData_[8 * 8];
unsigned char objpData_[8 * 8];
EventTimes eventTimes_;
M0Irq m0Irq_;
LycIrq lycIrq_;
NextM0Time nextM0Time_;
unsigned char statReg_;
unsigned char m2IrqStatReg_;
unsigned char m1IrqStatReg_;
static void setDmgPalette(unsigned long palette[],
unsigned long const dmgColors[],
unsigned data);
unsigned long gbcToRgb32(const unsigned bgr15);
void doCgbColorChange(unsigned char *const pdata, unsigned long *const palette, unsigned index, const unsigned data);
void refreshPalettes();
void setDBuffer();
void doMode2IrqEvent();
void event();
unsigned long m0TimeOfCurrentLine(unsigned long cc);
bool cgbpAccessible(unsigned long cycleCounter);
bool lycRegChangeStatTriggerBlockedByM0OrM1Irq(unsigned long cc);
bool lycRegChangeTriggersStatIrq(unsigned old, unsigned data, unsigned long cc);
bool statChangeTriggersM0LycOrM1StatIrqCgb(unsigned old, unsigned data, unsigned long cc);
bool statChangeTriggersStatIrqCgb(unsigned old, unsigned data, unsigned long cc);
bool statChangeTriggersStatIrqDmg(unsigned old, unsigned long cc);
bool statChangeTriggersStatIrq(unsigned old, unsigned data, unsigned long cc);
void mode3CyclesChange();
void doCgbBgColorChange(unsigned index, unsigned data, unsigned long cycleCounter);
void doCgbSpColorChange(unsigned index, unsigned data, unsigned long cycleCounter);
void (*scanlinecallback)();
int scanlinecallbacksl;
public:
template<bool isReader>void SyncState(NewState *ns);
};

21
libgambatte/src/video/lcddef.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef LCDDEF_H
#define LCDDEF_H
namespace gambatte {
enum { lcdc_bgen = 0x01,
lcdc_objen = 0x02,
lcdc_obj2x = 0x04,
lcdc_tdsel = 0x10,
lcdc_we = 0x20,
lcdc_en = 0x80 };
enum { lcdstat_lycflag = 0x04,
lcdstat_m0irqen = 0x08,
lcdstat_m1irqen = 0x10,
lcdstat_m2irqen = 0x20,
lcdstat_lycirqen = 0x40 };
}
#endif

74
libgambatte/src/video/ly_counter.cpp
View File

@ -1,28 +1,31 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "ly_counter.h"
#include "../savestate.h"
namespace gambatte {
LyCounter::LyCounter()
: time_(0), lineTime_(0), ly_(0), ds(false)
: time_(0)
, lineTime_(0)
, ly_(0)
, ds_(false)
{
setDoubleSpeed(false);
reset(0, 0);
@ -30,39 +33,36 @@ LyCounter::LyCounter()
void LyCounter::doEvent() {
++ly_;
if (ly_ == 154)
ly_ = 0;
time_ = time_ + lineTime_;
}
unsigned long LyCounter::nextLineCycle(const unsigned lineCycle, const unsigned long cycleCounter) const {
unsigned long tmp = time_ + (lineCycle << ds);
if (tmp - cycleCounter > lineTime_)
unsigned long LyCounter::nextLineCycle(unsigned const lineCycle, unsigned long const cc) const {
unsigned long tmp = time_ + (lineCycle << ds_);
if (tmp - cc > lineTime_)
tmp -= lineTime_;
return tmp;
}
unsigned long LyCounter::nextFrameCycle(const unsigned long frameCycle, const unsigned long cycleCounter) const {
unsigned long tmp = time_ + (((153U - ly()) * 456U + frameCycle) << ds);
if (tmp - cycleCounter > 70224U << ds)
tmp -= 70224U << ds;
unsigned long LyCounter::nextFrameCycle(unsigned long const frameCycle, unsigned long const cc) const {
unsigned long tmp = time_ + (((153U - ly()) * 456U + frameCycle) << ds_);
if (tmp - cc > 70224U << ds_)
tmp -= 70224U << ds_;
return tmp;
}
void LyCounter::reset(const unsigned long videoCycles, const unsigned long lastUpdate) {
void LyCounter::reset(unsigned long videoCycles, unsigned long lastUpdate) {
ly_ = videoCycles / 456;
time_ = lastUpdate + ((456 - (videoCycles - ly_ * 456ul)) << isDoubleSpeed());
}
void LyCounter::setDoubleSpeed(const bool ds_in) {
ds = ds_in;
lineTime_ = 456U << ds_in;
void LyCounter::setDoubleSpeed(bool ds) {
ds_ = ds;
lineTime_ = 456U << ds;
}
SYNCFUNC(LyCounter)
@ -70,7 +70,7 @@ SYNCFUNC(LyCounter)
NSS(time_);
NSS(lineTime_);
NSS(ly_);
NSS(ds);
NSS(ds_);
}
}

62
libgambatte/src/video/ly_counter.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef LY_COUNTER_H
#define LY_COUNTER_H
@ -26,32 +26,34 @@ namespace gambatte {
struct SaveState;
class LyCounter {
unsigned long time_;
unsigned short lineTime_;
unsigned char ly_;
bool ds;
public:
LyCounter();
void doEvent();
bool isDoubleSpeed() const { return ds; }
unsigned long frameCycles(const unsigned long cc) const {
bool isDoubleSpeed() const { return ds_; }
unsigned long frameCycles(unsigned long cc) const {
return ly_ * 456ul + lineCycles(cc);
}
unsigned lineCycles(const unsigned long cc) const {
unsigned lineCycles(unsigned long cc) const {
return 456u - ((time_ - cc) >> isDoubleSpeed());
}
unsigned lineTime() const { return lineTime_; }
unsigned ly() const { return ly_; }
unsigned long nextLineCycle(unsigned lineCycle, unsigned long cycleCounter) const;
unsigned long nextFrameCycle(unsigned long frameCycle, unsigned long cycleCounter) const;
void reset(unsigned long videoCycles, unsigned long lastUpdate);
void setDoubleSpeed(bool ds_in);
void setDoubleSpeed(bool ds);
unsigned long time() const { return time_; }
private:
unsigned long time_;
unsigned short lineTime_;
unsigned char ly_;
bool ds_;
public:
template<bool isReader>void SyncState(NewState *ns);
};

98
libgambatte/src/video/lyc_irq.cpp
View File

@ -1,91 +1,97 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "lyc_irq.h"
#include "counterdef.h"
#include "lcddef.h"
#include "ly_counter.h"
#include "savestate.h"
#include <algorithm>
namespace gambatte {
LycIrq::LycIrq() :
time_(DISABLED_TIME),
lycRegSrc_(0),
statRegSrc_(0),
lycReg_(0),
statReg_(0),
cgb_(false)
LycIrq::LycIrq()
: time_(disabled_time)
, lycRegSrc_(0)
, statRegSrc_(0)
, lycReg_(0)
, statReg_(0)
, cgb_(false)
{
}
static unsigned long schedule(const unsigned statReg, const unsigned lycReg, const LyCounter &lyCounter, const unsigned long cc) {
return (statReg & 0x40) && lycReg < 154
? lyCounter.nextFrameCycle(lycReg ? lycReg * 456 : 153 * 456 + 8, cc)
: static_cast<unsigned long>(DISABLED_TIME);
static unsigned long schedule(unsigned statReg,
unsigned lycReg, LyCounter const &lyCounter, unsigned long cc) {
return (statReg & lcdstat_lycirqen) && lycReg < 154
? lyCounter.nextFrameCycle(lycReg ? lycReg * 456 : 153 * 456 + 8, cc)
: static_cast<unsigned long>(disabled_time);
}
void LycIrq::regChange(const unsigned statReg, const unsigned lycReg, const LyCounter &lyCounter, const unsigned long cc) {
const unsigned long timeSrc = schedule(statReg, lycReg, lyCounter, cc);
void LycIrq::regChange(unsigned const statReg,
unsigned const lycReg, LyCounter const &lyCounter, unsigned long const cc) {
unsigned long const timeSrc = schedule(statReg, lycReg, lyCounter, cc);
statRegSrc_ = statReg;
lycRegSrc_ = lycReg;
time_ = std::min(time_, timeSrc);
if (cgb_) {
if (time_ - cc > 8 || (timeSrc != time_ && time_ - cc > 4U - lyCounter.isDoubleSpeed() * 4U))
lycReg_ = lycReg;
if (time_ - cc > 4U - lyCounter.isDoubleSpeed() * 4U)
statReg_ = statReg;
} else {
if (time_ - cc > 4 || timeSrc != time_)
lycReg_ = lycReg;
if (time_ - cc > 4 || lycReg_ != 0)
statReg_ = statReg;
statReg_ = (statReg_ & 0x40) | (statReg & ~0x40);
statReg_ = (statReg_ & lcdstat_lycirqen) | (statReg & ~lcdstat_lycirqen);
}
}
void LycIrq::doEvent(unsigned char *const ifreg, const LyCounter &lyCounter) {
if ((statReg_ | statRegSrc_) & 0x40) {
const unsigned cmpLy = lyCounter.time() - time_ < lyCounter.lineTime() ? 0 : lyCounter.ly();
if (lycReg_ == cmpLy &&
(lycReg_ - 1U < 144U - 1U ? !(statReg_ & 0x20) : !(statReg_ & 0x10))) {
static bool lycIrqBlockedByM2OrM1StatIrq(unsigned ly, unsigned statreg) {
return ly - 1u < 144u - 1u
? statreg & lcdstat_m2irqen
: statreg & lcdstat_m1irqen;
}
void LycIrq::doEvent(unsigned char *const ifreg, LyCounter const &lyCounter) {
if ((statReg_ | statRegSrc_) & lcdstat_lycirqen) {
unsigned cmpLy = lyCounter.time() - time_ < lyCounter.lineTime() ? 0 : lyCounter.ly();
if (lycReg_ == cmpLy && !lycIrqBlockedByM2OrM1StatIrq(lycReg_, statReg_))
*ifreg |= 2;
}
}
lycReg_ = lycRegSrc_;
statReg_ = statRegSrc_;
time_ = schedule(statReg_, lycReg_, lyCounter, time_);
}
void LycIrq::loadState(const SaveState &state) {
void LycIrq::loadState(SaveState const &state) {
lycRegSrc_ = state.mem.ioamhram.get()[0x145];
statRegSrc_ = state.mem.ioamhram.get()[0x141];
lycReg_ = state.ppu.lyc;
statReg_ = statRegSrc_;
}
void LycIrq::reschedule(const LyCounter & lyCounter, const unsigned long cc) {
void LycIrq::reschedule(LyCounter const &lyCounter, unsigned long cc) {
time_ = std::min(schedule(statReg_ , lycReg_ , lyCounter, cc),
schedule(statRegSrc_, lycRegSrc_, lyCounter, cc));
}

79
libgambatte/src/video/lyc_irq.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef VIDEO_LYC_IRQ_H
#define VIDEO_LYC_IRQ_H
@ -27,33 +27,36 @@ struct SaveState;
class LyCounter;
class LycIrq {
public:
LycIrq();
void doEvent(unsigned char *ifreg, LyCounter const &lyCounter);
unsigned lycReg() const { return lycRegSrc_; }
void loadState(SaveState const &state);
unsigned long time() const { return time_; }
void setCgb(bool cgb) { cgb_ = cgb; }
void lcdReset();
void reschedule(LyCounter const &lyCounter, unsigned long cc);
void statRegChange(unsigned statReg, LyCounter const &lyCounter, unsigned long cc) {
regChange(statReg, lycRegSrc_, lyCounter, cc);
}
void lycRegChange(unsigned lycReg, LyCounter const &lyCounter, unsigned long cc) {
regChange(statRegSrc_, lycReg, lyCounter, cc);
}
private:
unsigned long time_;
unsigned char lycRegSrc_;
unsigned char statRegSrc_;
unsigned char lycReg_;
unsigned char statReg_;
bool cgb_;
void regChange(unsigned statReg, unsigned lycReg, const LyCounter &lyCounter, unsigned long cc);
public:
LycIrq();
void doEvent(unsigned char *ifreg, const LyCounter &lyCounter);
unsigned lycReg() const { return lycRegSrc_; }
void loadState(const SaveState &state);
unsigned long time() const { return time_; }
void setCgb(const bool cgb) { cgb_ = cgb; }
void lcdReset();
void reschedule(const LyCounter & lyCounter, unsigned long cc);
void statRegChange(unsigned statReg, const LyCounter &lyCounter, unsigned long cc) {
regChange(statReg, lycRegSrc_, lyCounter, cc);
}
void lycRegChange(unsigned lycReg, const LyCounter &lyCounter, unsigned long cc) {
regChange(statRegSrc_, lycReg, lyCounter, cc);
}
void regChange(unsigned statReg, unsigned lycReg,
LyCounter const &lyCounter, unsigned long cc);
public:
template<bool isReader>void SyncState(NewState *ns);
};

68
libgambatte/src/video/m0_irq.h Normal file
View File

@ -0,0 +1,68 @@
#ifndef M0_IRQ_H
#define M0_IRQ_H
#include "lcddef.h"
#include "../savestate.h"
#include "../newstate.h"
namespace gambatte {
class M0Irq {
public:
M0Irq()
: statReg_(0)
, lycReg_(0)
{
}
void lcdReset(unsigned statReg, unsigned lycReg) {
statReg_ = statReg;
lycReg_ = lycReg;
}
void statRegChange(unsigned statReg,
unsigned long nextM0IrqTime, unsigned long cc, bool cgb) {
if (nextM0IrqTime - cc > cgb * 2U)
statReg_ = statReg;
}
void lycRegChange(unsigned lycReg,
unsigned long nextM0IrqTime, unsigned long cc,
bool ds, bool cgb) {
if (nextM0IrqTime - cc > cgb * 5 + 1U - ds)
lycReg_ = lycReg;
}
void doEvent(unsigned char *ifreg, unsigned ly, unsigned statReg, unsigned lycReg) {
if (((statReg_ | statReg) & lcdstat_m0irqen)
&& (!(statReg_ & lcdstat_lycirqen) || ly != lycReg_)) {
*ifreg |= 2;
}
statReg_ = statReg;
lycReg_ = lycReg;
}
void loadState(SaveState const &state) {
lycReg_ = state.ppu.m0lyc;
statReg_ = state.mem.ioamhram.get()[0x141];
}
unsigned statReg() const { return statReg_; }
private:
unsigned char statReg_;
unsigned char lycReg_;
public:
template<bool isReader>
void SyncState(NewState *ns)
{
NSS(statReg_);
NSS(lycReg_);
}
};
}
#endif

8
libgambatte/src/video/next_m0_time.cpp
View File

@ -1,15 +1,11 @@
#include "next_m0_time.h"
#include "ppu.h"
namespace gambatte {
void NextM0Time::predictNextM0Time(const PPU &ppu) {
void gambatte::NextM0Time::predictNextM0Time(PPU const &ppu) {
predictedNextM0Time_ = ppu.predictedNextXposTime(167);
}
SYNCFUNC(NextM0Time)
SYNCFUNC(gambatte::NextM0Time)
{
NSS(predictedNextM0Time_);
}
}

8
libgambatte/src/video/next_m0_time.h
View File

@ -6,14 +6,16 @@
namespace gambatte {
class NextM0Time {
unsigned predictedNextM0Time_;
public:
NextM0Time() : predictedNextM0Time_(0) {}
void predictNextM0Time(const class PPU &v);
void predictNextM0Time(class PPU const &v);
void invalidatePredictedNextM0Time() { predictedNextM0Time_ = 0; }
unsigned predictedNextM0Time() const { return predictedNextM0Time_; }
private:
unsigned predictedNextM0Time_;
public:
template<bool isReader>void SyncState(NewState *ns);
};

2670
libgambatte/src/video/ppu.cpp
View File

File diff suppressed because it is too large Load Diff

113
libgambatte/src/video/ppu.h
View File

@ -1,57 +1,61 @@
/***************************************************************************
* Copyright (C) 2010 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2010 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef PPU_H
#define PPU_H
#include "video/ly_counter.h"
#include "video/sprite_mapper.h"
#include "lcddef.h"
#include "ly_counter.h"
#include "sprite_mapper.h"
#include "gbint.h"
#include <cstddef>
#include "newstate.h"
namespace gambatte {
enum { LAYER_MASK_BG = 1, LAYER_MASK_OBJ = 2, LAYER_MASK_WINDOW = 4 };
enum { layer_mask_bg = 1, layer_mask_obj = 2, layer_mask_window = 4 };
class PPUFrameBuf {
uint_least32_t *buf_;
uint_least32_t *fbline_;
int pitch_;
static uint_least32_t * nullfbline() { static uint_least32_t nullfbline_[160]; return nullfbline_; }
public:
PPUFrameBuf() : buf_(0), fbline_(nullfbline()), pitch_(0) {}
uint_least32_t * fb() const { return buf_; }
uint_least32_t * fbline() const { return fbline_; }
int pitch() const { return pitch_; }
void setBuf(uint_least32_t *const buf, const int pitch) { buf_ = buf; pitch_ = pitch; fbline_ = nullfbline(); }
void setFbline(const unsigned ly) { fbline_ = buf_ ? buf_ + static_cast<long>(ly) * static_cast<long>(pitch_) : nullfbline(); }
std::ptrdiff_t pitch() const { return pitch_; }
void setBuf(uint_least32_t *buf, std::ptrdiff_t pitch) { buf_ = buf; pitch_ = pitch; fbline_ = nullfbline(); }
void setFbline(unsigned ly) { fbline_ = buf_ ? buf_ + std::ptrdiff_t(ly) * pitch_ : nullfbline(); }
private:
uint_least32_t *buf_;
uint_least32_t *fbline_;
std::ptrdiff_t pitch_;
static uint_least32_t * nullfbline() { static uint_least32_t nullfbline_[160]; return nullfbline_; }
};
struct PPUPriv;
struct PPUState {
void (*f)(struct PPUPriv &v);
unsigned (*predictCyclesUntilXpos_f)(const struct PPUPriv &v, int targetxpos, unsigned cycles);
void (*f)(PPUPriv &v);
unsigned (*predictCyclesUntilXpos_f)(PPUPriv const &v, int targetxpos, unsigned cycles);
unsigned char id;
};
// The PPU loop accesses a lot of state at once, so it's difficult to split this up much beyond grouping stuff into smaller structs.
struct PPUPriv {
unsigned long bgPalette[8 * 4];
unsigned long spPalette[8 * 4];
@ -61,8 +65,8 @@ struct PPUPriv {
unsigned char currentSprite;
unsigned layersMask;
const unsigned char *vram;
const PPUState *nextCallPtr;
unsigned char const *vram;
PPUState const *nextCallPtr;
unsigned long now;
unsigned long lastM0Time;
@ -93,41 +97,44 @@ struct PPUPriv {
bool cgb;
bool weMaster;
PPUPriv(NextM0Time &nextM0Time, const unsigned char *oamram, const unsigned char *vram);
PPUPriv(NextM0Time &nextM0Time, unsigned char const *oamram, unsigned char const *vram);
};
class PPU {
PPUPriv p_;
public:
PPU(NextM0Time &nextM0Time, const unsigned char *oamram, const unsigned char *vram)
PPU(NextM0Time &nextM0Time, unsigned char const *oamram, unsigned char const *vram)
: p_(nextM0Time, oamram, vram)
{
}
unsigned long * bgPalette() { return p_.bgPalette; }
bool cgb() const { return p_.cgb; }
void doLyCountEvent() { p_.lyCounter.doEvent(); }
unsigned long doSpriteMapEvent(unsigned long time) { return p_.spriteMapper.doEvent(time); }
const PPUFrameBuf & frameBuf() const { return p_.framebuf; }
bool inactivePeriodAfterDisplayEnable(unsigned long cc) const { return p_.spriteMapper.inactivePeriodAfterDisplayEnable(cc); }
PPUFrameBuf const & frameBuf() const { return p_.framebuf; }
bool inactivePeriodAfterDisplayEnable(unsigned long cc) const {
return p_.spriteMapper.inactivePeriodAfterDisplayEnable(cc);
}
unsigned long lastM0Time() const { return p_.lastM0Time; }
unsigned lcdc() const { return p_.lcdc; }
void loadState(const SaveState &state, const unsigned char *oamram);
const LyCounter & lyCounter() const { return p_.lyCounter; }
void loadState(SaveState const &state, unsigned char const *oamram);
LyCounter const & lyCounter() const { return p_.lyCounter; }
unsigned long now() const { return p_.now; }
void oamChange(unsigned long cc) { p_.spriteMapper.oamChange(cc); }
void oamChange(const unsigned char *oamram, unsigned long cc) { p_.spriteMapper.oamChange(oamram, cc); }
void oamChange(unsigned char const *oamram, unsigned long cc) { p_.spriteMapper.oamChange(oamram, cc); }
unsigned long predictedNextXposTime(unsigned xpos) const;
void reset(const unsigned char *oamram, const unsigned char *vram, bool cgb);
void reset(unsigned char const *oamram, unsigned char const *vram, bool cgb);
void resetCc(unsigned long oldCc, unsigned long newCc);
void setFrameBuf(uint_least32_t *buf, unsigned pitch) { p_.framebuf.setBuf(buf, pitch); }
void setFrameBuf(uint_least32_t *buf, std::ptrdiff_t pitch) { p_.framebuf.setBuf(buf, pitch); }
void setLcdc(unsigned lcdc, unsigned long cc);
void setScx(const unsigned scx) { p_.scx = scx; }
void setScy(const unsigned scy) { p_.scy = scy; }
void setScx(unsigned scx) { p_.scx = scx; }
void setScy(unsigned scy) { p_.scy = scy; }
void setStatePtrs(SaveState &ss) { p_.spriteMapper.setStatePtrs(ss); }
void setWx(const unsigned wx) { p_.wx = wx; }
void setWy(const unsigned wy) { p_.wy = wy; }
void setWx(unsigned wx) { p_.wx = wx; }
void setWy(unsigned wy) { p_.wy = wy; }
void updateWy2() { p_.wy2 = p_.wy; }
void speedChange(unsigned long cycleCounter);
unsigned long * spPalette() { return p_.spPalette; }
@ -135,6 +142,10 @@ public:
void setLayers(unsigned mask) { p_.layersMask = mask; }
void setCgb(bool cgb) { p_.cgb = cgb; }
private:
PPUPriv p_;
public:
template<bool isReader>void SyncState(NewState *ns);
};

206
libgambatte/src/video/sprite_mapper.cpp
View File

@ -1,81 +1,96 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#include "sprite_mapper.h"
#include "counterdef.h"
#include "next_m0_time.h"
#include "../insertion_sort.h"
#include <cstring>
#include <algorithm>
#include <cstring>
namespace {
class SpxLess {
public:
explicit SpxLess(unsigned char const *spxlut) : spxlut_(spxlut) {}
bool operator()(unsigned char lhs, unsigned char rhs) const {
return spxlut_[lhs] < spxlut_[rhs];
}
private:
unsigned char const *const spxlut_;
};
}
namespace gambatte {
SpriteMapper::OamReader::OamReader(const LyCounter &lyCounter, const unsigned char *oamram)
: lyCounter(lyCounter), oamram(oamram), cgb_(false) {
SpriteMapper::OamReader::OamReader(LyCounter const &lyCounter, unsigned char const *oamram)
: lyCounter_(lyCounter)
, oamram_(oamram)
, cgb_(false)
{
reset(oamram, false);
}
void SpriteMapper::OamReader::reset(const unsigned char *const oamram, const bool cgb) {
this->oamram = oamram;
this->cgb_ = cgb;
void SpriteMapper::OamReader::reset(unsigned char const *const oamram, bool const cgb) {
oamram_ = oamram;
cgb_ = cgb;
setLargeSpritesSrc(false);
lu = 0;
lastChange = 0xFF;
std::fill_n(szbuf, 40, largeSpritesSrc);
lu_ = 0;
lastChange_ = 0xFF;
std::fill(szbuf_, szbuf_ + 40, largeSpritesSrc_);
unsigned pos = 0;
unsigned distance = 80;
while (distance--) {
buf[pos] = oamram[((pos * 2) & ~3) | (pos & 1)];
buf_[pos] = oamram[((pos * 2) & ~3) | (pos & 1)];
++pos;
}
}
static unsigned toPosCycles(const unsigned long cc, const LyCounter &lyCounter) {
static unsigned toPosCycles(unsigned long const cc, LyCounter const &lyCounter) {
unsigned lc = lyCounter.lineCycles(cc) + 3 - lyCounter.isDoubleSpeed() * 3u;
if (lc >= 456)
lc -= 456;
return lc;
}
void SpriteMapper::OamReader::update(const unsigned long cc) {
if (cc > lu) {
void SpriteMapper::OamReader::update(unsigned long const cc) {
if (cc > lu_) {
if (changed()) {
const unsigned lulc = toPosCycles(lu, lyCounter);
unsigned const lulc = toPosCycles(lu_, lyCounter_);
unsigned pos = std::min(lulc, 80u);
unsigned distance = 80;
if ((cc - lu) >> lyCounter.isDoubleSpeed() < 456) {
const unsigned cclc = toPosCycles(cc, lyCounter);
if ((cc - lu_) >> lyCounter_.isDoubleSpeed() < 456) {
unsigned cclc = toPosCycles(cc, lyCounter_);
distance = std::min(cclc, 80u) - pos + (cclc < lulc ? 80 : 0);
}
{
const unsigned targetDistance = lastChange - pos + (lastChange <= pos ? 80 : 0);
unsigned targetDistance =
lastChange_ - pos + (lastChange_ <= pos ? 80 : 0);
if (targetDistance <= distance) {
distance = targetDistance;
lastChange = 0xFF;
lastChange_ = 0xFF;
}
}
@ -83,93 +98,92 @@ void SpriteMapper::OamReader::update(const unsigned long cc) {
if (!(pos & 1)) {
if (pos == 80)
pos = 0;
if (cgb_)
szbuf[pos >> 1] = largeSpritesSrc;
buf[pos ] = oamram[pos * 2 ];
buf[pos + 1] = oamram[pos * 2 + 1];
szbuf_[pos >> 1] = largeSpritesSrc_;
buf_[pos ] = oamram_[pos * 2 ];
buf_[pos + 1] = oamram_[pos * 2 + 1];
} else
szbuf[pos >> 1] = (szbuf[pos >> 1] & cgb_) | largeSpritesSrc;
szbuf_[pos >> 1] = (szbuf_[pos >> 1] & cgb_) | largeSpritesSrc_;
++pos;
}
}
lu = cc;
lu_ = cc;
}
}
void SpriteMapper::OamReader::change(const unsigned long cc) {
void SpriteMapper::OamReader::change(unsigned long cc) {
update(cc);
lastChange = std::min(toPosCycles(lu, lyCounter), 80u);
lastChange_ = std::min(toPosCycles(lu_, lyCounter_), 80u);
}
void SpriteMapper::OamReader::setStatePtrs(SaveState &state) {
state.ppu.oamReaderBuf.set(buf, sizeof buf);
state.ppu.oamReaderSzbuf.set(szbuf, sizeof(szbuf) / sizeof(bool));
state.ppu.oamReaderBuf.set(buf_, sizeof buf_);
state.ppu.oamReaderSzbuf.set(szbuf_, sizeof szbuf_ / sizeof *szbuf_);
}
void SpriteMapper::OamReader::loadState(const SaveState &ss, const unsigned char *const oamram) {
this->oamram = oamram;
largeSpritesSrc = ss.mem.ioamhram.get()[0x140] >> 2 & 1;
lu = ss.ppu.enableDisplayM0Time;
change(lu);
void SpriteMapper::OamReader::loadState(SaveState const &ss, unsigned char const *const oamram) {
oamram_ = oamram;
largeSpritesSrc_ = ss.mem.ioamhram.get()[0x140] >> 2 & 1;
lu_ = ss.ppu.enableDisplayM0Time;
change(lu_);
}
SYNCFUNC(SpriteMapper::OamReader)
{
NSS(buf);
NSS(szbuf);
NSS(buf_);
NSS(szbuf_);
NSS(lu);
NSS(lastChange);
NSS(largeSpritesSrc);
NSS(lu_);
NSS(lastChange_);
NSS(largeSpritesSrc_);
NSS(cgb_);
}
void SpriteMapper::OamReader::enableDisplay(const unsigned long cc) {
std::memset(buf, 0x00, sizeof(buf));
std::fill(szbuf, szbuf + 40, false);
lu = cc + (80 << lyCounter.isDoubleSpeed());
lastChange = 80;
void SpriteMapper::OamReader::enableDisplay(unsigned long cc) {
std::memset(buf_, 0x00, sizeof buf_);
std::fill(szbuf_, szbuf_ + 40, false);
lu_ = cc + (80 << lyCounter_.isDoubleSpeed());
lastChange_ = 80;
}
SpriteMapper::SpriteMapper(NextM0Time &nextM0Time,
const LyCounter &lyCounter,
const unsigned char *const oamram) :
nextM0Time_(nextM0Time),
oamReader(lyCounter, oamram)
LyCounter const &lyCounter,
unsigned char const *oamram)
: nextM0Time_(nextM0Time)
, oamReader_(lyCounter, oamram)
{
clearMap();
}
void SpriteMapper::reset(const unsigned char *const oamram, const bool cgb) {
oamReader.reset(oamram, cgb);
void SpriteMapper::reset(unsigned char const *oamram, bool cgb) {
oamReader_.reset(oamram, cgb);
clearMap();
}
void SpriteMapper::clearMap() {
std::memset(num, NEED_SORTING_MASK, sizeof num);
std::memset(num_, need_sorting_mask, sizeof num_);
}
void SpriteMapper::mapSprites() {
clearMap();
for (unsigned i = 0x00; i < 0x50; i += 2) {
const int spriteHeight = 8 << largeSprites(i >> 1);
const unsigned bottom_pos = posbuf()[i] - (17u - spriteHeight);
int const spriteHeight = 8 << largeSprites(i >> 1);
unsigned const bottomPos = posbuf()[i] - (17u - spriteHeight);
if (bottom_pos < 143u + spriteHeight) {
const unsigned startly = static_cast<int>(bottom_pos) + 1 - spriteHeight >= 0
? static_cast<int>(bottom_pos) + 1 - spriteHeight : 0;
unsigned char *map = spritemap + startly * 10;
unsigned char *n = num + startly;
unsigned char *const nend = num + (bottom_pos < 143 ? bottom_pos : 143) + 1;
if (bottomPos < 143u + spriteHeight) {
unsigned const startly = std::max(int(bottomPos) + 1 - spriteHeight, 0);
unsigned char *map = spritemap_ + startly * 10;
unsigned char *n = num_ + startly;
unsigned char *const nend = num_ + std::min(bottomPos, 143u) + 1;
do {
if (*n < NEED_SORTING_MASK + 10)
map[(*n)++ - NEED_SORTING_MASK] = i;
if (*n < need_sorting_mask + 10)
map[(*n)++ - need_sorting_mask] = i;
map += 10;
} while (++n != nend);
@ -179,24 +193,26 @@ void SpriteMapper::mapSprites() {
nextM0Time_.invalidatePredictedNextM0Time();
}
void SpriteMapper::sortLine(const unsigned ly) const {
num[ly] &= ~NEED_SORTING_MASK;
insertionSort(spritemap + ly * 10, spritemap + ly * 10 + num[ly], SpxLess(posbuf()));
void SpriteMapper::sortLine(unsigned const ly) const {
num_[ly] &= ~need_sorting_mask;
insertionSort(spritemap_ + ly * 10, spritemap_ + ly * 10 + num_[ly],
SpxLess(posbuf() + 1));
}
unsigned long SpriteMapper::doEvent(const unsigned long time) {
oamReader.update(time);
unsigned long SpriteMapper::doEvent(unsigned long const time) {
oamReader_.update(time);
mapSprites();
return oamReader.changed() ? time + oamReader.lyCounter.lineTime() : static_cast<unsigned long>(DISABLED_TIME);
return oamReader_.changed()
? time + oamReader_.lineTime()
: static_cast<unsigned long>(disabled_time);
}
SYNCFUNC(SpriteMapper)
{
NSS(spritemap);
NSS(num);
SSS(nextM0Time_);
SSS(oamReader);
NSS(spritemap_);
NSS(num_);
SSS(oamReader_);
}
}

189
libgambatte/src/video/sprite_mapper.h
View File

@ -1,21 +1,21 @@
/***************************************************************************
* Copyright (C) 2007 by Sindre Aamås *
* aamas@stud.ntnu.no *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License version 2 as *
* published by the Free Software Foundation. *
* *
* 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 version 2 for more details. *
* *
* You should have received a copy of the GNU General Public License *
* version 2 along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
//
// Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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 version 2 for more details.
//
// You should have received a copy of the GNU General Public License
// version 2 along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
#ifndef SPRITE_MAPPER_H
#define SPRITE_MAPPER_H
@ -24,106 +24,101 @@
#include "newstate.h"
namespace gambatte {
class NextM0Time;
class SpriteMapper {
class OamReader {
unsigned char buf[80];
bool szbuf[40];
public:
SpriteMapper(NextM0Time &nextM0Time,
LyCounter const &lyCounter,
unsigned char const *oamram);
void reset(unsigned char const *oamram, bool cgb);
unsigned long doEvent(unsigned long time);
bool largeSprites(unsigned spNo) const { return oamReader_.largeSprites(spNo); }
unsigned numSprites(unsigned ly) const { return num_[ly] & ~need_sorting_mask; }
void oamChange(unsigned long cc) { oamReader_.change(cc); }
void oamChange(unsigned char const *oamram, unsigned long cc) { oamReader_.change(oamram, cc); }
unsigned char const * oamram() const { return oamReader_.oam(); }
unsigned char const * posbuf() const { return oamReader_.spritePosBuf(); }
void preSpeedChange(unsigned long cc) { oamReader_.update(cc); }
void postSpeedChange(unsigned long cc) { oamReader_.change(cc); }
void resetCycleCounter(unsigned long oldCc, unsigned long newCc) {
oamReader_.update(oldCc);
oamReader_.resetCycleCounter(oldCc, newCc);
}
void setLargeSpritesSource(bool src) { oamReader_.setLargeSpritesSrc(src); }
unsigned char const * sprites(unsigned ly) const {
if (num_[ly] & need_sorting_mask)
sortLine(ly);
return spritemap_ + ly * 10;
}
void setStatePtrs(SaveState &state) { oamReader_.setStatePtrs(state); }
void enableDisplay(unsigned long cc) { oamReader_.enableDisplay(cc); }
void loadState(SaveState const &state, unsigned char const *oamram) {
oamReader_.loadState(state, oamram);
mapSprites();
}
bool inactivePeriodAfterDisplayEnable(unsigned long cc) const {
return oamReader_.inactivePeriodAfterDisplayEnable(cc);
}
static unsigned long schedule(LyCounter const &lyCounter, unsigned long cc) {
return lyCounter.nextLineCycle(80, cc);
}
private:
class OamReader {
public:
const LyCounter &lyCounter;
OamReader(LyCounter const &lyCounter, unsigned char const *oamram);
void reset(unsigned char const *oamram, bool cgb);
void change(unsigned long cc);
void change(unsigned char const *oamram, unsigned long cc) { change(cc); oamram_ = oamram; }
bool changed() const { return lastChange_ != 0xFF; }
bool largeSprites(unsigned spNo) const { return szbuf_[spNo]; }
unsigned char const * oam() const { return oamram_; }
void resetCycleCounter(unsigned long oldCc, unsigned long newCc) { lu_ -= oldCc - newCc; }
void setLargeSpritesSrc(bool src) { largeSpritesSrc_ = src; }
void update(unsigned long cc);
unsigned char const * spritePosBuf() const { return buf_; }
void setStatePtrs(SaveState &state);
void enableDisplay(unsigned long cc);
void loadState(SaveState const &ss, unsigned char const *oamram);
bool inactivePeriodAfterDisplayEnable(unsigned long cc) const { return cc < lu_; }
unsigned lineTime() const { return lyCounter_.lineTime(); }
private:
const unsigned char *oamram;
unsigned long lu;
unsigned char lastChange;
bool largeSpritesSrc;
unsigned char buf_[80];
bool szbuf_[40];
LyCounter const &lyCounter_;
unsigned char const *oamram_;
unsigned long lu_;
unsigned char lastChange_;
bool largeSpritesSrc_;
bool cgb_;
public:
OamReader(const LyCounter &lyCounter, const unsigned char *oamram);
void reset(const unsigned char *oamram, bool cgb);
void change(unsigned long cc);
void change(const unsigned char *oamram, unsigned long cc) { change(cc); this->oamram = oamram; }
bool changed() const { return lastChange != 0xFF; }
bool largeSprites(unsigned spNr) const { return szbuf[spNr]; }
const unsigned char *oam() const { return oamram; }
void resetCycleCounter(const unsigned long oldCc, const unsigned long newCc) { lu -= oldCc - newCc; }
void setLargeSpritesSrc(const bool src) { largeSpritesSrc = src; }
void update(unsigned long cc);
const unsigned char *spritePosBuf() const { return buf; }
void setStatePtrs(SaveState &state);
void enableDisplay(unsigned long cc);
void loadState(const SaveState &ss, const unsigned char *oamram);
bool inactivePeriodAfterDisplayEnable(const unsigned long cc) const { return cc < lu; }
template<bool isReader>void SyncState(NewState *ns);
};
enum { NEED_SORTING_MASK = 0x80 };
enum { need_sorting_mask = 0x80 };
public:
class SpxLess {
const unsigned char *const posbuf_plus1;
public:
explicit SpxLess(const unsigned char *const posbuf) : posbuf_plus1(posbuf + 1) {}
bool operator()(const unsigned char l, const unsigned char r) const {
return posbuf_plus1[l] < posbuf_plus1[r];
}
};
private:
mutable unsigned char spritemap[144*10];
mutable unsigned char num[144];
mutable unsigned char spritemap_[144 * 10];
mutable unsigned char num_[144];
NextM0Time &nextM0Time_;
OamReader oamReader;
OamReader oamReader_;
void clearMap();
void mapSprites();
void sortLine(unsigned ly) const;
public:
SpriteMapper(NextM0Time &nextM0Time,
const LyCounter &lyCounter,
const unsigned char *oamram_in);
void reset(const unsigned char *oamram, bool cgb);
unsigned long doEvent(unsigned long time);
bool largeSprites(unsigned spNr) const { return oamReader.largeSprites(spNr); }
unsigned numSprites(const unsigned ly) const { return num[ly] & ~NEED_SORTING_MASK; }
void oamChange(unsigned long cc) { oamReader.change(cc); }
void oamChange(const unsigned char *oamram, unsigned long cc) { oamReader.change(oamram, cc); }
const unsigned char *oamram() const { return oamReader.oam(); }
const unsigned char *posbuf() const { return oamReader.spritePosBuf(); }
void preSpeedChange(const unsigned long cc) { oamReader.update(cc); }
void postSpeedChange(const unsigned long cc) { oamReader.change(cc); }
void resetCycleCounter(const unsigned long oldCc, const unsigned long newCc) {
oamReader.update(oldCc);
oamReader.resetCycleCounter(oldCc, newCc);
}
static unsigned long schedule(const LyCounter &lyCounter, const unsigned long cycleCounter) {
return lyCounter.nextLineCycle(80, cycleCounter);
}
void setLargeSpritesSource(bool src) { oamReader.setLargeSpritesSrc(src); }
const unsigned char* sprites(const unsigned ly) const {
if (num[ly] & NEED_SORTING_MASK)
sortLine(ly);
return spritemap + ly * 10;
}
void setStatePtrs(SaveState &state) { oamReader.setStatePtrs(state); }
void enableDisplay(unsigned long cc) { oamReader.enableDisplay(cc); }
void loadState(const SaveState &state, const unsigned char *const oamram) { oamReader.loadState(state, oamram); mapSprites(); }
bool inactivePeriodAfterDisplayEnable(unsigned long cc) const { return oamReader.inactivePeriodAfterDisplayEnable(cc); }
template<bool isReader>void SyncState(NewState *ns);
};

BIN
output/dll/libgambatte.dll
View File

Binary file not shown.