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

Reformat gambatte.cpp

This commit is contained in:
MrWint 2019-05-26 12:22:53 +02:00
parent a79febdef9
commit af42fbb714
12 changed files with 103 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
libgambatte/include/gambatte.h
View File

@ -64,10 +64,10 @@ public:
* @param flags ORed combination of LoadFlags. * @param flags ORed combination of LoadFlags.
* @return 0 on success, negative value on failure. * @return 0 on success, negative value on failure.
*/ */
LoadRes load(const char *romfiledata, unsigned romfilelength, std::uint32_t now, unsigned flags, unsigned div); LoadRes load(char const *romfiledata, unsigned romfilelength, std::uint32_t now, unsigned flags, unsigned div);
int loadGBCBios(const char* biosfiledata); int loadGBCBios(char const* biosfiledata);
int loadDMGBios(const char* biosfiledata); int loadDMGBios(char const* biosfiledata);
/** /**
* Emulates until at least 'samples' audio samples are produced in the * Emulates until at least 'samples' audio samples are produced in the
@ -136,7 +136,7 @@ public:
bool isLoaded() const; bool isLoaded() const;
/** Writes persistent cartridge data to disk. NOT Done implicitly on ROM close. */ /** Writes persistent cartridge data to disk. NOT Done implicitly on ROM close. */
void loadSavedata(const char *data); void loadSavedata(char const *data);
int saveSavedataLength(); int saveSavedataLength();
void saveSavedata(char *dest); void saveSavedata(char *dest);
@ -146,15 +146,15 @@ public:
/** ROM header title of currently loaded ROM image. */ /** ROM header title of currently loaded ROM image. */
const std::string romTitle() const; const std::string romTitle() const;
unsigned char ExternalRead(unsigned short addr); unsigned char externalRead(unsigned short addr);
void ExternalWrite(unsigned short addr, unsigned char val); 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); void setInterruptAddresses(int *addrs, int numAddrs);
int GetHitInterruptAddress(); int getHitInterruptAddress();
template<bool isReader>void SyncState(NewState *ns); template<bool isReader>void SyncState(NewState *ns);

22
libgambatte/src/cinterface.cpp
View File

@ -29,19 +29,19 @@ GBEXPORT void gambatte_destroy(GB *g)
delete g; delete g;
} }
GBEXPORT int gambatte_load(GB *g, const char *romfiledata, unsigned romfilelength, long long now, unsigned flags, unsigned div) GBEXPORT int gambatte_load(GB *g, char const *romfiledata, unsigned romfilelength, long long now, unsigned flags, unsigned div)
{ {
int ret = g->load(romfiledata, romfilelength, now, flags, div); int ret = g->load(romfiledata, romfilelength, now, flags, div);
return ret; return ret;
} }
GBEXPORT int gambatte_loadgbcbios(GB* g, const char* biosfiledata) GBEXPORT int gambatte_loadgbcbios(GB* g, char const* biosfiledata)
{ {
int ret = g->loadGBCBios(biosfiledata); int ret = g->loadGBCBios(biosfiledata);
return ret; return ret;
} }
GBEXPORT int gambatte_loaddmgbios(GB* g, const char* biosfiledata) GBEXPORT int gambatte_loaddmgbios(GB* g, char const* biosfiledata)
{ {
int ret = g->loadDMGBios(biosfiledata); int ret = g->loadDMGBios(biosfiledata);
return ret; return ret;
@ -141,7 +141,7 @@ GBEXPORT void gambatte_savesavedata(GB *g, char *dest)
g->saveSavedata(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); g->loadSavedata(data);
} }
@ -165,7 +165,7 @@ GBEXPORT int gambatte_newstatesave(GB *g, char *data, int len)
return !saver.Overflow() && saver.GetLength() == len; 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); NewStateExternalBuffer loader((char *)data, len);
g->SyncState<true>(&loader); g->SyncState<true>(&loader);
@ -196,30 +196,30 @@ GBEXPORT int gambatte_getmemoryarea(GB *g, int which, unsigned char **data, int
GBEXPORT unsigned char gambatte_cpuread(GB *g, unsigned short addr) GBEXPORT unsigned char gambatte_cpuread(GB *g, unsigned short addr)
{ {
return g->ExternalRead(addr); return g->externalRead(addr);
} }
GBEXPORT void gambatte_cpuwrite(GB *g, unsigned short addr, unsigned char val) GBEXPORT void gambatte_cpuwrite(GB *g, unsigned short addr, unsigned char val)
{ {
g->ExternalWrite(addr, val); g->externalWrite(addr, val);
} }
GBEXPORT int gambatte_linkstatus(GB *g, int which) GBEXPORT int gambatte_linkstatus(GB *g, int which)
{ {
return g->LinkStatus(which); return g->linkStatus(which);
} }
GBEXPORT void gambatte_getregs(GB *g, int *dest) GBEXPORT void gambatte_getregs(GB *g, int *dest)
{ {
g->GetRegs(dest); g->getRegs(dest);
} }
GBEXPORT void gambatte_setinterruptaddresses(GB *g, int *addrs, int numAddrs) GBEXPORT void gambatte_setinterruptaddresses(GB *g, int *addrs, int numAddrs)
{ {
g->SetInterruptAddresses(addrs, numAddrs); g->setInterruptAddresses(addrs, numAddrs);
} }
GBEXPORT int gambatte_gethitinterruptaddress(GB *g) GBEXPORT int gambatte_gethitinterruptaddress(GB *g)
{ {
return g->GetHitInterruptAddress(); return g->getHitInterruptAddress();
} }

4
libgambatte/src/counterdef.h
View File

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

4
libgambatte/src/cpu.h
View File

@ -31,7 +31,7 @@ public:
void setStatePtrs(SaveState &state); void setStatePtrs(SaveState &state);
void loadState(SaveState const &state); void loadState(SaveState const &state);
void setLayers(unsigned mask) { mem_.setLayers(mask); } void setLayers(unsigned mask) { mem_.setLayers(mask); }
void loadSavedata(const char *data) { mem_.loadSavedata(data); } void loadSavedata(char const *data) { mem_.loadSavedata(data); }
int saveSavedataLength() {return mem_.saveSavedataLength(); } int saveSavedataLength() {return mem_.saveSavedataLength(); }
void saveSavedata(char *dest) { mem_.saveSavedata(dest); } void saveSavedata(char *dest) { mem_.saveSavedata(dest); }
@ -105,7 +105,7 @@ public:
mem_.write_nocb(addr, val, cycleCounter_); mem_.write_nocb(addr, val, cycleCounter_);
} }
int LinkStatus(int which) { return mem_.LinkStatus(which); } int linkStatus(int which) { return mem_.linkStatus(which); }
void getRegs(int *dest); void getRegs(int *dest);
void setInterruptAddresses(int *addrs, int numAddrs); void setInterruptAddresses(int *addrs, int numAddrs);

90
libgambatte/src/gambatte.cpp
View File

@ -1,29 +1,30 @@
/*************************************************************************** //
* Copyright (C) 2007 by Sindre Aamås * // Copyright (C) 2007 by sinamas <sinamas at users.sourceforge.net>
* aamas@stud.ntnu.no * //
* * // This program is free software; you can redistribute it and/or modify
* 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
* it under the terms of the GNU General Public License version 2 as * // published by the Free Software Foundation.
* published by the Free Software Foundation. * //
* * // This program is distributed in the hope that it will be useful,
* This program is distributed in the hope that it will be useful, * // but WITHOUT ANY WARRANTY; without even the implied warranty of
* but WITHOUT ANY WARRANTY; without even the implied warranty of * // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * // GNU General Public License version 2 for more details.
* GNU General Public License version 2 for more details. * //
* * // You should have received a copy of the GNU General Public License
* You should have received a copy of the GNU General Public License * // version 2 along with this program; if not, write to the
* version 2 along with this program; if not, write to the * // Free Software Foundation, Inc.,
* Free Software Foundation, Inc., * // 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * //
***************************************************************************/
#include "gambatte.h" #include "gambatte.h"
#include "cpu.h" #include "cpu.h"
#include "savestate.h"
#include "initstate.h" #include "initstate.h"
#include <sstream> #include "savestate.h"
#include <cstring> #include <cstring>
#include <sstream>
namespace gambatte { namespace gambatte {
struct GB::Priv { struct GB::Priv {
CPU cpu; CPU cpu;
unsigned loadflags; unsigned loadflags;
@ -34,18 +35,11 @@ struct GB::Priv {
Priv() : loadflags(0), layersMask(LAYER_MASK_BG | LAYER_MASK_OBJ) Priv() : loadflags(0), layersMask(LAYER_MASK_BG | LAYER_MASK_OBJ)
{ {
} }
~Priv()
{
}
}; };
GB::GB() : p_(new Priv) {} GB::GB() : p_(new Priv) {}
GB::~GB() { GB::~GB() {
//if (p_->cpu.loaded())
// p_->cpu.saveSavedata();
delete p_; delete p_;
} }
@ -57,19 +51,19 @@ std::ptrdiff_t GB::runFor(gambatte::uint_least32_t *const soundBuf, std::size_t
p_->cpu.setVideoBuffer(p_->vbuff, 160); p_->cpu.setVideoBuffer(p_->vbuff, 160);
p_->cpu.setSoundBuffer(soundBuf); p_->cpu.setSoundBuffer(soundBuf);
const long cyclesSinceBlit = p_->cpu.runFor(samples * 2);
samples = p_->cpu.fillSoundBuffer();
return cyclesSinceBlit < 0 ? cyclesSinceBlit : static_cast<std::ptrdiff_t>(samples) - (cyclesSinceBlit >> 1); long const cyclesSinceBlit = p_->cpu.runFor(samples * 2);
samples = p_->cpu.fillSoundBuffer();
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); p_->cpu.setLayers(mask);
} }
void GB::blitTo(gambatte::uint_least32_t *videoBuf, std::ptrdiff_t pitch) void GB::blitTo(gambatte::uint_least32_t *videoBuf, std::ptrdiff_t pitch) {
{
gambatte::uint_least32_t *src = p_->vbuff; gambatte::uint_least32_t *src = p_->vbuff;
gambatte::uint_least32_t *dst = videoBuf; gambatte::uint_least32_t *dst = videoBuf;
@ -140,10 +134,7 @@ void GB::setLinkCallback(void(*callback)()) {
p_->cpu.setLinkCallback(callback); p_->cpu.setLinkCallback(callback);
} }
LoadRes GB::load(const char *romfiledata, unsigned romfilelength, const std::uint32_t now, unsigned const flags, const unsigned div) { LoadRes GB::load(char const *romfiledata, unsigned romfilelength, const std::uint32_t now, unsigned const flags, const unsigned div) {
//if (p_->cpu.loaded())
// p_->cpu.saveSavedata();
LoadRes const loadres = p_->cpu.load(romfiledata, romfilelength, flags & FORCE_DMG, flags & MULTICART_COMPAT); LoadRes const loadres = p_->cpu.load(romfiledata, romfilelength, flags & FORCE_DMG, flags & MULTICART_COMPAT);
if (loadres == LOADRES_OK) { if (loadres == LOADRES_OK) {
@ -152,18 +143,17 @@ LoadRes GB::load(const char *romfiledata, unsigned romfilelength, const std::uin
p_->loadflags = flags; p_->loadflags = flags;
setInitState(state, !(flags & FORCE_DMG), flags & GBA_CGB, now, div); setInitState(state, !(flags & FORCE_DMG), flags & GBA_CGB, now, div);
p_->cpu.loadState(state); p_->cpu.loadState(state);
//p_->cpu.loadSavedata();
} }
return loadres; return loadres;
} }
int GB::loadGBCBios(const char* biosfiledata) { int GB::loadGBCBios(char const* biosfiledata) {
memcpy(p_->cpu.cgbBiosBuffer(), biosfiledata, 0x900); memcpy(p_->cpu.cgbBiosBuffer(), biosfiledata, 0x900);
return 0; return 0;
} }
int GB::loadDMGBios(const char* biosfiledata) { int GB::loadDMGBios(char const* biosfiledata) {
memcpy(p_->cpu.dmgBiosBuffer(), biosfiledata, 0x100); memcpy(p_->cpu.dmgBiosBuffer(), biosfiledata, 0x100);
return 0; return 0;
} }
@ -180,7 +170,7 @@ void GB::saveSavedata(char *dest) {
if (p_->cpu.loaded()) if (p_->cpu.loaded())
p_->cpu.saveSavedata(dest); p_->cpu.saveSavedata(dest);
} }
void GB::loadSavedata(const char *data) { void GB::loadSavedata(char const *data) {
if (p_->cpu.loaded()) if (p_->cpu.loaded())
p_->cpu.loadSavedata(data); p_->cpu.loadSavedata(data);
} }
@ -198,14 +188,14 @@ bool GB::getMemoryArea(int which, unsigned char **data, int *length) {
return false; return false;
} }
unsigned char GB::ExternalRead(unsigned short addr) { unsigned char GB::externalRead(unsigned short addr) {
if (p_->cpu.loaded()) if (p_->cpu.loaded())
return p_->cpu.externalRead(addr); return p_->cpu.externalRead(addr);
else else
return 0; return 0;
} }
void GB::ExternalWrite(unsigned short addr, unsigned char val) { void GB::externalWrite(unsigned short addr, unsigned char val) {
if (p_->cpu.loaded()) if (p_->cpu.loaded())
p_->cpu.externalWrite(addr, val); p_->cpu.externalWrite(addr, val);
} }
@ -219,7 +209,7 @@ void GB::setCgbPalette(unsigned *lut) {
p_->cpu.setCgbPalette(lut); p_->cpu.setCgbPalette(lut);
} }
const std::string GB::romTitle() const { std::string const GB::romTitle() const {
if (p_->cpu.loaded()) { if (p_->cpu.loaded()) {
char title[0x11]; char title[0x11];
std::memcpy(title, p_->cpu.romTitle(), 0x10); std::memcpy(title, p_->cpu.romTitle(), 0x10);
@ -230,20 +220,20 @@ const std::string GB::romTitle() const {
return std::string(); return std::string();
} }
int GB::LinkStatus(int which) { int GB::linkStatus(int which) {
return p_->cpu.LinkStatus(which); return p_->cpu.linkStatus(which);
} }
void GB::GetRegs(int *dest) { void GB::getRegs(int *dest) {
p_->cpu.getRegs(dest); p_->cpu.getRegs(dest);
} }
void GB::SetInterruptAddresses(int *addrs, int numAddrs) void GB::setInterruptAddresses(int *addrs, int numAddrs)
{ {
p_->cpu.setInterruptAddresses(addrs, numAddrs); p_->cpu.setInterruptAddresses(addrs, numAddrs);
} }
int GB::GetHitInterruptAddress() int GB::getHitInterruptAddress()
{ {
return p_->cpu.getHitInterruptAddress(); return p_->cpu.getHitInterruptAddress();
} }

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

@ -572,7 +572,7 @@ static bool presumedMulti64Mbc1(unsigned char const header[], unsigned rombanks)
return header[0x147] == 1 && header[0x149] == 0 && rombanks == 64; return header[0x147] == 1 && header[0x149] == 0 && rombanks == 64;
} }
LoadRes Cartridge::loadROM(const char *romfiledata, unsigned romfilelength, bool const forceDmg, bool const multicartCompat) { LoadRes Cartridge::loadROM(char const *romfiledata, unsigned romfilelength, bool const forceDmg, bool const multicartCompat) {
//const std::auto_ptr<File> rom(newFileInstance(romfile)); //const std::auto_ptr<File> rom(newFileInstance(romfile));
//if (rom->fail()) //if (rom->fail())
@ -698,7 +698,7 @@ static bool hasBattery(unsigned char headerByte0x147) {
} }
} }
void Cartridge::loadSavedata(const char *data) { void Cartridge::loadSavedata(char const *data) {
if (hasBattery(memptrs_.romdata()[0x147])) { if (hasBattery(memptrs_.romdata()[0x147])) {
int length = memptrs_.rambankdataend() - memptrs_.rambankdata(); int length = memptrs_.rambankdataend() - memptrs_.rambankdata();
std::memcpy(memptrs_.rambankdata(), data, length); std::memcpy(memptrs_.rambankdata(), data, length);

4
libgambatte/src/memory.cpp
View File

@ -1058,7 +1058,7 @@ void Memory::nontrivial_write(const unsigned P, const unsigned data, const unsig
ioamhram[P - 0xFE00] = data; ioamhram[P - 0xFE00] = data;
} }
LoadRes Memory::loadROM(const char *romfiledata, unsigned romfilelength, const bool forceDmg, const bool multicartCompat) { LoadRes Memory::loadROM(char const *romfiledata, unsigned romfilelength, const bool forceDmg, const bool multicartCompat) {
if (LoadRes const fail = cart.loadROM(romfiledata, romfilelength, forceDmg, multicartCompat)) if (LoadRes const fail = cart.loadROM(romfiledata, romfilelength, forceDmg, multicartCompat))
return fail; return fail;
@ -1104,7 +1104,7 @@ bool Memory::getMemoryArea(int which, unsigned char **data, int *length) {
} }
} }
int Memory::LinkStatus(int which) int Memory::linkStatus(int which)
{ {
switch (which) switch (which)
{ {

8
libgambatte/src/memory.h
View File

@ -99,13 +99,13 @@ public:
bool loaded() const { return cart.loaded(); } bool loaded() const { return cart.loaded(); }
unsigned curRomBank() const { return cart.curRomBank(); } unsigned curRomBank() const { return cart.curRomBank(); }
const char * romTitle() const { return cart.romTitle(); } char const * romTitle() const { return cart.romTitle(); }
int debugGetLY() const { return display.debugGetLY(); } int debugGetLY() const { return display.debugGetLY(); }
void setStatePtrs(SaveState &state); void setStatePtrs(SaveState &state);
void loadState(const SaveState &state/*, unsigned long oldCc*/); void loadState(const SaveState &state/*, unsigned long oldCc*/);
void loadSavedata(const char *data) { cart.loadSavedata(data); } void loadSavedata(char const *data) { cart.loadSavedata(data); }
int saveSavedataLength() {return cart.saveSavedataLength(); } int saveSavedataLength() {return cart.saveSavedataLength(); }
void saveSavedata(char *dest) { cart.saveSavedata(dest); } void saveSavedata(char *dest) { cart.saveSavedata(dest); }
void updateInput(); void updateInput();
@ -295,7 +295,7 @@ public:
unsigned long event(unsigned long cycleCounter); unsigned long event(unsigned long cycleCounter);
unsigned long resetCounters(unsigned long cycleCounter); unsigned long resetCounters(unsigned long cycleCounter);
LoadRes 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)()) { void setInputGetter(unsigned (*getInput)()) {
this->getInput = getInput; this->getInput = getInput;
@ -346,7 +346,7 @@ public:
display.blackScreen(); display.blackScreen();
} }
int LinkStatus(int which); int linkStatus(int which);
template<bool isReader>void SyncState(NewState *ns); template<bool isReader>void SyncState(NewState *ns);
}; };

16
libgambatte/src/newstate.cpp
View File

@ -8,11 +8,11 @@ NewStateDummy::NewStateDummy()
:length(0) :length(0)
{ {
} }
void NewStateDummy::Save(const void *ptr, size_t size, const char *name) void NewStateDummy::Save(const void *ptr, size_t size, char const *name)
{ {
length += size; 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(const void *ptr, size_t size, char const *name)
{ {
if (maxlength - length >= (long)size) if (maxlength - length >= (long)size)
{ {
@ -30,7 +30,7 @@ void NewStateExternalBuffer::Save(const void *ptr, size_t size, const char *name
length += size; 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); char *dst = static_cast<char *>(ptr);
if (maxlength - length >= (long)size) 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(const void *ptr, size_t size, char const *name)
{ {
Save_(ptr, size, 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); Load_(ptr, size, name);
} }
void NewStateExternalFunctions::EnterSection(const char *name) void NewStateExternalFunctions::EnterSection(char const *name)
{ {
EnterSection_(name); EnterSection_(name);
} }
void NewStateExternalFunctions::ExitSection(const char *name) void NewStateExternalFunctions::ExitSection(char const *name)
{ {
ExitSection_(name); ExitSection_(name);
} }

40
libgambatte/src/newstate.h
View File

@ -9,10 +9,10 @@ namespace gambatte {
class NewState class NewState
{ {
public: public:
virtual void Save(const void *ptr, size_t size, const char *name) = 0; virtual void Save(const void *ptr, size_t size, char const *name) = 0;
virtual void Load(void *ptr, size_t size, const char *name) = 0; virtual void Load(void *ptr, size_t size, char const *name) = 0;
virtual void EnterSection(const char *name) { } virtual void EnterSection(char const *name) { }
virtual void ExitSection(const char *name) { } virtual void ExitSection(char const *name) { }
}; };
class NewStateDummy : public NewState class NewStateDummy : public NewState
@ -23,8 +23,8 @@ public:
NewStateDummy(); NewStateDummy();
long GetLength() { return length; } long GetLength() { return length; }
void Rewind() { length = 0; } void Rewind() { length = 0; }
virtual void Save(const void *ptr, size_t size, const char *name); virtual void Save(const void *ptr, size_t size, char const *name);
virtual void Load(void *ptr, size_t size, const char *name); virtual void Load(void *ptr, size_t size, char const *name);
}; };
class NewStateExternalBuffer : public NewState class NewStateExternalBuffer : public NewState
@ -38,31 +38,31 @@ public:
long GetLength() { return length; } long GetLength() { return length; }
void Rewind() { length = 0; } void Rewind() { length = 0; }
bool Overflow() { return length > maxlength; } bool Overflow() { return length > maxlength; }
virtual void Save(const void *ptr, size_t size, const char *name); virtual void Save(const void *ptr, size_t size, char const *name);
virtual void Load(void *ptr, size_t size, const char *name); virtual void Load(void *ptr, size_t size, char const *name);
}; };
struct FPtrs struct FPtrs
{ {
void (*Save_)(const void *ptr, size_t size, const char *name); void (*Save_)(const void *ptr, size_t size, char const *name);
void (*Load_)(void *ptr, size_t size, const char *name); void (*Load_)(void *ptr, size_t size, char const *name);
void (*EnterSection_)(const char *name); void (*EnterSection_)(char const *name);
void (*ExitSection_)(const char *name); void (*ExitSection_)(char const *name);
}; };
class NewStateExternalFunctions : public NewState class NewStateExternalFunctions : public NewState
{ {
private: private:
void (*Save_)(const void *ptr, size_t size, const char *name); void (*Save_)(const void *ptr, size_t size, char const *name);
void (*Load_)(void *ptr, size_t size, const char *name); void (*Load_)(void *ptr, size_t size, char const *name);
void (*EnterSection_)(const char *name); void (*EnterSection_)(char const *name);
void (*ExitSection_)(const char *name); void (*ExitSection_)(char const *name);
public: public:
NewStateExternalFunctions(const FPtrs *ff); NewStateExternalFunctions(const FPtrs *ff);
virtual void Save(const void *ptr, size_t size, const char *name); virtual void Save(const void *ptr, size_t size, char const *name);
virtual void Load(void *ptr, size_t size, const char *name); virtual void Load(void *ptr, size_t size, char const *name);
virtual void EnterSection(const char *name); virtual void EnterSection(char const *name);
virtual void ExitSection(const char *name); virtual void ExitSection(char const *name);
}; };
// defines and explicitly instantiates // defines and explicitly instantiates

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

@ -21,7 +21,7 @@
#include <algorithm> #include <algorithm>
#include <cstring> #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); return 0x800 - ((nr4 << 8 & 0x700) | nr3);
} }

BIN
output/dll/libgambatte.dll
View File

Binary file not shown.