mirror of
https://github.com/libretro/Mesen.git
synced 2024-11-24 01:29:41 +00:00
375 lines
8.6 KiB
C++
375 lines
8.6 KiB
C++
#pragma once
|
|
|
|
#include "stdafx.h"
|
|
#include "Snapshotable.h"
|
|
#include "IMemoryHandler.h"
|
|
#include "ROMLoader.h"
|
|
#include <assert.h>
|
|
#include "../Utilities/FolderUtilities.h"
|
|
#include "CheatManager.h"
|
|
#include "MessageManager.h"
|
|
|
|
class BaseMapper : public IMemoryHandler, public Snapshotable, public INotificationListener
|
|
{
|
|
protected:
|
|
const int ExpansionRAMSize = 0x2000;
|
|
const int SRAMSize = 0x2000;
|
|
|
|
uint8_t* _prgRAM;
|
|
uint8_t* _originalPrgRam;
|
|
uint8_t* _chrRAM;
|
|
uint32_t _prgSize;
|
|
uint32_t _chrSize;
|
|
|
|
uint8_t* _SRAM;
|
|
uint8_t* _expansionRAM;
|
|
bool _hasExpansionRAM;
|
|
|
|
bool _hasCHRRAM;
|
|
bool _hasBattery;
|
|
string _romFilename;
|
|
|
|
MirroringType _mirroringType;
|
|
|
|
vector<uint8_t*> _prgPages;
|
|
vector<uint8_t*> _chrPages;
|
|
|
|
uint32_t* _prgSlotPages;
|
|
uint32_t* _chrSlotPages;
|
|
|
|
uint32_t _chrShift = -1;
|
|
uint32_t _chrSlotMaxIndex = -1;
|
|
uint32_t _prgShift = -1;
|
|
uint32_t _prgSlotMaxIndex = -1;
|
|
|
|
uint32_t _chrPageMask = -1;
|
|
uint32_t _prgPageMask = -1;
|
|
|
|
virtual void InitMapper() = 0;
|
|
|
|
public:
|
|
const static int PRGSize = 0x8000;
|
|
const static int CHRSize = 0x2000;
|
|
const static int PRGRAMSize = 0x2000;
|
|
|
|
protected:
|
|
virtual uint32_t GetPRGPageSize() = 0;
|
|
virtual uint32_t GetCHRPageSize() = 0;
|
|
|
|
void SelectPRGPage(uint32_t slot, uint32_t page)
|
|
{
|
|
//std::cout << std::dec << "PRG Slot " << (short)slot << ": " << (short)(page & (GetPRGPageCount() - 1)) << std::endl;
|
|
_prgPages[slot] = &_prgRAM[(page % GetPRGPageCount()) * GetPRGPageSize()];
|
|
_prgSlotPages[slot] = page;
|
|
}
|
|
|
|
void SelectCHRPage(uint32_t slot, uint32_t page)
|
|
{
|
|
//std::cout << std::dec << "CHR Slot " << (short)slot << ": " << (short)page << std::endl;
|
|
_chrPages[slot] = &_chrRAM[(page % GetCHRPageCount()) * GetCHRPageSize()];
|
|
_chrSlotPages[slot] = page;
|
|
}
|
|
|
|
uint32_t GetPRGSlotCount()
|
|
{
|
|
return BaseMapper::PRGSize / GetPRGPageSize();
|
|
}
|
|
|
|
uint32_t GetCHRSlotCount()
|
|
{
|
|
return BaseMapper::CHRSize / GetCHRPageSize();
|
|
}
|
|
|
|
uint32_t GetPRGPageCount()
|
|
{
|
|
return _prgSize / GetPRGPageSize();
|
|
}
|
|
|
|
uint32_t GetCHRPageCount()
|
|
{
|
|
return _chrSize / GetCHRPageSize();
|
|
}
|
|
|
|
uint32_t log2(uint32_t value)
|
|
{
|
|
uint32_t counter = 0;
|
|
while(value >>= 1) {
|
|
counter++;
|
|
}
|
|
return counter;
|
|
}
|
|
|
|
uint32_t AddrToPRGSlot(uint16_t addr)
|
|
{
|
|
return (addr >> _prgShift) & _prgSlotMaxIndex;
|
|
}
|
|
|
|
uint32_t AddrToCHRSlot(uint16_t addr)
|
|
{
|
|
return (addr >> _chrShift) & _chrSlotMaxIndex;
|
|
}
|
|
|
|
string GetBatteryFilename()
|
|
{
|
|
return FolderUtilities::GetSaveFolder() + _romFilename + ".sav";
|
|
}
|
|
|
|
void RestoreOriginalPrgRam()
|
|
{
|
|
memcpy(_prgRAM, _originalPrgRam, GetPRGSize());
|
|
}
|
|
|
|
protected:
|
|
virtual void StreamState(bool saving)
|
|
{
|
|
StreamArray<uint32_t>(_prgSlotPages, GetPRGSlotCount());
|
|
StreamArray<uint32_t>(_chrSlotPages, GetCHRSlotCount());
|
|
|
|
Stream<bool>(_hasCHRRAM);
|
|
if(_hasCHRRAM) {
|
|
StreamArray<uint8_t>(_chrRAM, BaseMapper::CHRSize);
|
|
}
|
|
|
|
Stream<MirroringType>(_mirroringType);
|
|
|
|
if(!saving) {
|
|
for(int i = GetPRGSlotCount() - 1; i >= 0; i--) {
|
|
SelectPRGPage(i, _prgSlotPages[i]);
|
|
}
|
|
|
|
for(int i = GetCHRSlotCount() - 1; i >= 0; i--) {
|
|
SelectCHRPage(i, _chrSlotPages[i]);
|
|
}
|
|
}
|
|
|
|
Stream<bool>(_hasExpansionRAM);
|
|
if(_hasExpansionRAM) {
|
|
StreamArray<uint8_t>(_expansionRAM, BaseMapper::ExpansionRAMSize);
|
|
}
|
|
StreamArray<uint8_t>(_SRAM, BaseMapper::SRAMSize);
|
|
}
|
|
|
|
public:
|
|
void Initialize(ROMLoader &romLoader)
|
|
{
|
|
_mirroringType = romLoader.GetMirroringType();
|
|
romLoader.GetPRGRam(&_prgRAM);
|
|
romLoader.GetPRGRam(&_originalPrgRam);
|
|
romLoader.GetCHRRam(&_chrRAM);
|
|
_prgSize = romLoader.GetPRGSize();
|
|
_chrSize = romLoader.GetCHRSize();
|
|
_hasBattery = romLoader.HasBattery();
|
|
_romFilename = romLoader.GetFilename();
|
|
|
|
_hasExpansionRAM = false;
|
|
_SRAM = new uint8_t[SRAMSize];
|
|
_expansionRAM = new uint8_t[ExpansionRAMSize];
|
|
|
|
memset(_SRAM, 0, SRAMSize);
|
|
memset(_expansionRAM, 0, ExpansionRAMSize);
|
|
|
|
//Load battery data if present
|
|
if(HasBattery()) {
|
|
LoadBattery();
|
|
}
|
|
|
|
if(_chrSize == 0) {
|
|
_hasCHRRAM = true;
|
|
_chrRAM = new uint8_t[BaseMapper::CHRSize];
|
|
_chrSize = BaseMapper::CHRSize;
|
|
}
|
|
|
|
for(int i = GetPRGSlotCount(); i > 0; i--) {
|
|
_prgPages.push_back(nullptr);
|
|
}
|
|
|
|
for(int i = GetCHRSlotCount(); i > 0; i--) {
|
|
_chrPages.push_back(nullptr);
|
|
}
|
|
|
|
_prgSlotPages = new uint32_t[GetPRGSlotCount()];
|
|
_chrSlotPages = new uint32_t[GetCHRSlotCount()];
|
|
|
|
_prgShift = 15 - this->log2(GetPRGSlotCount());
|
|
_prgSlotMaxIndex = GetPRGSlotCount() - 1;
|
|
_chrShift = 13 - this->log2(GetCHRSlotCount());
|
|
_chrSlotMaxIndex = GetCHRSlotCount() - 1;
|
|
|
|
_chrPageMask = GetCHRPageSize() - 1;
|
|
_prgPageMask = GetPRGPageSize() - 1;
|
|
|
|
InitMapper();
|
|
|
|
MessageManager::RegisterNotificationListener(this);
|
|
|
|
ApplyCheats();
|
|
}
|
|
|
|
virtual ~BaseMapper()
|
|
{
|
|
if(HasBattery()) {
|
|
SaveBattery();
|
|
}
|
|
delete[] _prgRAM;
|
|
delete[] _chrRAM;
|
|
delete[] _originalPrgRam;
|
|
delete[] _prgSlotPages;
|
|
delete[] _chrSlotPages;
|
|
|
|
delete[] _SRAM;
|
|
delete[] _expansionRAM;
|
|
|
|
MessageManager::UnregisterNotificationListener(this);
|
|
}
|
|
|
|
void ProcessNotification(ConsoleNotificationType type)
|
|
{
|
|
switch(type) {
|
|
case ConsoleNotificationType::CheatAdded:
|
|
case ConsoleNotificationType::CheatRemoved:
|
|
ApplyCheats();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ApplyCheats()
|
|
{
|
|
RestoreOriginalPrgRam();
|
|
CheatManager::ApplyPrgCodes(_prgRAM, GetPRGSize());
|
|
}
|
|
|
|
void GetMemoryRanges(MemoryRanges &ranges)
|
|
{
|
|
ranges.AddHandler(MemoryType::RAM, MemoryOperation::Read, 0x4018, 0xFFFF);
|
|
ranges.AddHandler(MemoryType::RAM, MemoryOperation::Write, 0x4018, 0xFFFF);
|
|
|
|
ranges.AddHandler(MemoryType::VRAM, MemoryOperation::Read, 0x0000, 0x1FFF);
|
|
ranges.AddHandler(MemoryType::VRAM, MemoryOperation::Write, 0x0000, 0x1FFF);
|
|
}
|
|
|
|
bool HasBattery()
|
|
{
|
|
return _hasBattery;
|
|
}
|
|
|
|
MirroringType GetMirroringType()
|
|
{
|
|
return _mirroringType;
|
|
}
|
|
|
|
void LoadBattery()
|
|
{
|
|
ifstream batteryFile(GetBatteryFilename(), ios::in | ios::binary);
|
|
|
|
if(batteryFile) {
|
|
batteryFile.read((char*)_SRAM, BaseMapper::PRGRAMSize);
|
|
|
|
batteryFile.close();
|
|
}
|
|
}
|
|
|
|
void SaveBattery()
|
|
{
|
|
ofstream batteryFile(GetBatteryFilename(), ios::out | ios::binary);
|
|
|
|
if(batteryFile) {
|
|
batteryFile.write((char*)_SRAM, BaseMapper::PRGRAMSize);
|
|
|
|
batteryFile.close();
|
|
}
|
|
}
|
|
|
|
virtual uint8_t ReadRAM(uint16_t addr)
|
|
{
|
|
if(addr >= 0x8000) {
|
|
return _prgPages[AddrToPRGSlot(addr)][addr & _prgPageMask];
|
|
} else if(addr >= 0x6000) {
|
|
return _SRAM[addr & 0x1FFF];
|
|
} else if(addr >= 0x4000) {
|
|
return _expansionRAM[addr & 0x1FFF];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8_t* GetPRGCopy()
|
|
{
|
|
uint8_t* prgCopy = new uint8_t[_prgSize];
|
|
memcpy(prgCopy, _prgRAM, _prgSize);
|
|
return prgCopy;
|
|
}
|
|
|
|
uint32_t GetPRGSize()
|
|
{
|
|
return _prgSize;
|
|
}
|
|
|
|
uint32_t ToAbsoluteAddress(uint16_t addr)
|
|
{
|
|
return GetPRGPageSize() * (_prgSlotPages[AddrToPRGSlot(addr)] % GetPRGPageCount()) + (addr & _prgPageMask);
|
|
}
|
|
|
|
int32_t FromAbsoluteAddress(uint32_t addr)
|
|
{
|
|
uint32_t page = addr / GetPRGPageSize();
|
|
for(int i = 0, len = GetPRGSlotCount(); i < len; i++) {
|
|
if((_prgSlotPages[i] % GetPRGPageCount()) == page) {
|
|
uint32_t offset = addr - (page * GetPRGPageSize());
|
|
return GetPRGPageSize() * i + offset + 0x8000;
|
|
}
|
|
}
|
|
|
|
//Address is currently not mapped
|
|
return -1;
|
|
}
|
|
|
|
vector<uint32_t> GetPRGRanges()
|
|
{
|
|
vector<uint32_t> memoryRanges;
|
|
uint32_t slotCount = GetPRGSlotCount();
|
|
|
|
for(uint32_t i = 0; i < slotCount; i++) {
|
|
uint32_t page = _prgSlotPages[i] % GetPRGPageCount();
|
|
uint32_t pageStart = page * GetPRGPageSize();
|
|
uint32_t pageEnd = (page + 1) * GetPRGPageSize();
|
|
memoryRanges.push_back(pageStart);
|
|
memoryRanges.push_back(pageEnd);
|
|
}
|
|
|
|
return memoryRanges;
|
|
}
|
|
|
|
virtual uint16_t RegisterStartAddress() { return 0x8000; }
|
|
virtual uint16_t RegisterEndAddress() { return 0xFFFF; }
|
|
virtual void WriteRegister(uint16_t addr, uint8_t value) { }
|
|
|
|
virtual void WriteRAM(uint16_t addr, uint8_t value)
|
|
{
|
|
if(addr >= RegisterStartAddress() && addr <= RegisterEndAddress()) {
|
|
WriteRegister(addr, value);
|
|
} else if(addr >= 0x6000) {
|
|
_SRAM[addr & 0x1FFF] = value;
|
|
} else if(addr >= 0x4000) {
|
|
_hasExpansionRAM = true;
|
|
_expansionRAM[addr & 0x1FFF] = value;
|
|
}
|
|
}
|
|
|
|
virtual uint8_t ReadVRAM(uint16_t addr)
|
|
{
|
|
return _chrPages[AddrToCHRSlot(addr)][addr & _chrPageMask];
|
|
}
|
|
|
|
virtual void WriteVRAM(uint16_t addr, uint8_t value)
|
|
{
|
|
if(_hasCHRRAM) {
|
|
_chrPages[AddrToCHRSlot(addr)][addr & _chrPageMask] = value;
|
|
} else {
|
|
//assert(false);
|
|
}
|
|
}
|
|
|
|
virtual void NotifyVRAMAddressChange(uint16_t addr)
|
|
{
|
|
//Used for MMC3 IRQ counter
|
|
}
|
|
}; |