void GBVideoReset(struct GBVideo* video) {
video->ly = 0;
video->x = 0;
video->mode = 1;
video->stat = 1;
video->frameCounter = 0;
video->frameskipCounter = 0;
GBVideoSwitchBank(video, 0);
video->renderer->vram = video->vram;
memset(&video->oam, 0, sizeof(video->oam));
video->renderer->oam = &video->oam;
memset(&video->palette, 0, sizeof(video->palette));
if (video->p->model & GB_MODEL_SGB) {
video->renderer->sgbCharRam = anonymousMemoryMap(SGB_SIZE_CHAR_RAM);
video->renderer->sgbMapRam = anonymousMemoryMap(SGB_SIZE_MAP_RAM);
video->renderer->sgbPalRam = anonymousMemoryMap(SGB_SIZE_PAL_RAM);
video->renderer->sgbAttributeFiles = anonymousMemoryMap(SGB_SIZE_ATF_RAM);
video->renderer->sgbAttributes = malloc(90 * 45);
memset(video->renderer->sgbAttributes, 0, 90 * 45);
video->sgbCommandHeader = 0;
video->sgbBufferIndex = 0;
}
video->palette[0] = video->dmgPalette[0];
video->palette[1] = video->dmgPalette[1];
video->palette[2] = video->dmgPalette[2];
video->palette[3] = video->dmgPalette[3];
video->palette[8 * 4 + 0] = video->dmgPalette[4];
video->palette[8 * 4 + 1] = video->dmgPalette[5];
video->palette[8 * 4 + 2] = video->dmgPalette[6];
video->palette[8 * 4 + 3] = video->dmgPalette[7];
video->palette[9 * 4 + 0] = video->dmgPalette[8];
video->palette[9 * 4 + 1] = video->dmgPalette[9];
video->palette[9 * 4 + 2] = video->dmgPalette[10];
video->palette[9 * 4 + 3] = video->dmgPalette[11];
video->renderer->deinit(video->renderer);
video->renderer->init(video->renderer, video->p->model, video->sgbBorders);
video->renderer->writePalette(video->renderer, 0, video->palette[0]);
video->renderer->writePalette(video->renderer, 1, video->palette[1]);
video->renderer->writePalette(video->renderer, 2, video->palette[2]);
video->renderer->writePalette(video->renderer, 3, video->palette[3]);
video->renderer->writePalette(video->renderer, 8 * 4 + 0, video->palette[8 * 4 + 0]);
video->renderer->writePalette(video->renderer, 8 * 4 + 1, video->palette[8 * 4 + 1]);
video->renderer->writePalette(video->renderer, 8 * 4 + 2, video->palette[8 * 4 + 2]);
video->renderer->writePalette(video->renderer, 8 * 4 + 3, video->palette[8 * 4 + 3]);
video->renderer->writePalette(video->renderer, 9 * 4 + 0, video->palette[9 * 4 + 0]);
video->renderer->writePalette(video->renderer, 9 * 4 + 1, video->palette[9 * 4 + 1]);
video->renderer->writePalette(video->renderer, 9 * 4 + 2, video->palette[9 * 4 + 2]);
video->renderer->writePalette(video->renderer, 9 * 4 + 3, video->palette[9 * 4 + 3]);
}
void GBASavedataInitEEPROM(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_EEPROM512;
} else if (savedata->type != SAVEDATA_EEPROM512 && savedata->type != SAVEDATA_EEPROM) {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
}
int32_t eepromSize = SIZE_CART_EEPROM512;
if (savedata->type == SAVEDATA_EEPROM) {
eepromSize = SIZE_CART_EEPROM;
}
off_t end;
if (!savedata->vf) {
end = 0;
savedata->data = anonymousMemoryMap(SIZE_CART_EEPROM);
} else {
end = savedata->vf->size(savedata->vf);
if (end < eepromSize) {
savedata->vf->truncate(savedata->vf, eepromSize);
} else if (end >= SIZE_CART_EEPROM) {
eepromSize = SIZE_CART_EEPROM;
savedata->type = SAVEDATA_EEPROM;
}
savedata->data = savedata->vf->map(savedata->vf, eepromSize, savedata->mapMode);
}
if (end < SIZE_CART_EEPROM512) {
memset(&savedata->data[end], 0xFF, SIZE_CART_EEPROM512 - end);
}
}
void GBASavedataInitFlash(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_FLASH512;
}
if (savedata->type != SAVEDATA_FLASH512 && savedata->type != SAVEDATA_FLASH1M) {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
}
int32_t flashSize = SIZE_CART_FLASH512;
if (savedata->type == SAVEDATA_FLASH1M) {
flashSize = SIZE_CART_FLASH1M;
}
off_t end;
if (!savedata->vf) {
end = 0;
savedata->data = anonymousMemoryMap(SIZE_CART_FLASH1M);
} else {
end = savedata->vf->size(savedata->vf);
if (end < flashSize) {
savedata->vf->truncate(savedata->vf, flashSize);
} else if (end >= SIZE_CART_FLASH1M) {
flashSize = SIZE_CART_FLASH1M;
savedata->type = SAVEDATA_FLASH1M;
}
savedata->data = savedata->vf->map(savedata->vf, flashSize, savedata->mapMode);
}
savedata->currentBank = savedata->data;
if (end < SIZE_CART_FLASH512) {
memset(&savedata->data[end], 0xFF, flashSize - end);
}
}
struct VFile* VFileMemChunk(const void* mem, size_t size) {
struct VFileMem* vfm = malloc(sizeof(struct VFileMem));
if (!vfm) {
return 0;
}
vfm->size = size;
vfm->bufferSize = toPow2(size);
if (size) {
vfm->mem = anonymousMemoryMap(vfm->bufferSize);
if (mem) {
memcpy(vfm->mem, mem, size);
}
} else {
vfm->mem = 0;
}
vfm->offset = 0;
vfm->d.close = _vfmCloseFree;
vfm->d.seek = _vfmSeekExpanding;
vfm->d.read = _vfmRead;
vfm->d.readline = VFileReadline;
vfm->d.write = _vfmWriteExpanding;
vfm->d.map = _vfmMap;
vfm->d.unmap = _vfmUnmap;
vfm->d.truncate = _vfmTruncate;
vfm->d.size = _vfmSize;
vfm->d.sync = _vfmSync;
return &vfm->d;
}
void* _vfzMap(struct VFile* vf, size_t size, int flags) {
struct VFileZip* vfz = (struct VFileZip*) vf;
// TODO
UNUSED(flags);
off_t pos = vf->seek(vf, 0, SEEK_CUR);
if (pos < 0) {
return 0;
}
vfz->buffer = anonymousMemoryMap(size);
if (!vfz->buffer) {
return 0;
}
unzCloseCurrentFile(vfz->z);
unzOpenCurrentFile(vfz->z);
vf->read(vf, vfz->buffer, size);
unzCloseCurrentFile(vfz->z);
unzOpenCurrentFile(vfz->z);
vf->seek(vf, pos, SEEK_SET);
vfz->bufferSize = size;
return vfz->buffer;
}
void GBVideoReset(struct GBVideo* video) {
video->ly = 0;
video->mode = 1;
video->stat = 1;
video->nextEvent = INT_MAX;
video->eventDiff = 0;
video->nextMode = INT_MAX;
video->dotCounter = INT_MIN;
video->nextFrame = INT_MAX;
video->frameCounter = 0;
video->frameskipCounter = 0;
if (video->vram) {
mappedMemoryFree(video->vram, GB_SIZE_VRAM);
}
video->vram = anonymousMemoryMap(GB_SIZE_VRAM);
GBVideoSwitchBank(video, 0);
video->renderer->vram = video->vram;
memset(&video->oam, 0, sizeof(video->oam));
video->renderer->oam = &video->oam;
memset(&video->palette, 0, sizeof(video->palette));
video->renderer->deinit(video->renderer);
video->renderer->init(video->renderer, video->p->model);
}
void GBResizeSram(struct GB* gb, size_t size) {
if (gb->memory.sram && size <= gb->sramSize) {
return;
}
mLOG(GB, INFO, "Resizing SRAM to %"PRIz"u bytes", size);
struct VFile* vf = gb->sramVf;
if (vf) {
if (vf == gb->sramRealVf) {
ssize_t vfSize = vf->size(vf);
if (vfSize >= 0 && (size_t) vfSize < size) {
uint8_t extdataBuffer[0x100];
if (vfSize & 0xFF) {
vf->seek(vf, -(vfSize & 0xFF), SEEK_END);
vf->read(vf, extdataBuffer, vfSize & 0xFF);
}
if (gb->memory.sram) {
vf->unmap(vf, gb->memory.sram, gb->sramSize);
}
vf->truncate(vf, size + (vfSize & 0xFF));
if (vfSize & 0xFF) {
vf->seek(vf, size, SEEK_SET);
vf->write(vf, extdataBuffer, vfSize & 0xFF);
}
gb->memory.sram = vf->map(vf, size, MAP_WRITE);
memset(&gb->memory.sram[gb->sramSize], 0xFF, size - gb->sramSize);
} else if (size > gb->sramSize || !gb->memory.sram) {
if (gb->memory.sram) {
vf->unmap(vf, gb->memory.sram, gb->sramSize);
}
gb->memory.sram = vf->map(vf, size, MAP_WRITE);
}
} else {
if (gb->memory.sram) {
vf->unmap(vf, gb->memory.sram, gb->sramSize);
}
gb->memory.sram = vf->map(vf, size, MAP_READ);
}
if (gb->memory.sram == (void*) -1) {
gb->memory.sram = NULL;
}
} else {
uint8_t* newSram = anonymousMemoryMap(size);
if (gb->memory.sram) {
if (size > gb->sramSize) {
memcpy(newSram, gb->memory.sram, gb->sramSize);
memset(&newSram[gb->sramSize], 0xFF, size - gb->sramSize);
} else {
memcpy(newSram, gb->memory.sram, size);
}
mappedMemoryFree(gb->memory.sram, gb->sramSize);
} else {
memset(newSram, 0xFF, size);
}
gb->memory.sram = newSram;
}
if (gb->sramSize < size) {
gb->sramSize = size;
}
}
static void* _vf3dMap(struct VFile* vf, size_t size, int flags) {
struct VFile3DS* vf3d = (struct VFile3DS*) vf;
UNUSED(flags);
void* buffer = anonymousMemoryMap(size);
if (buffer) {
u32 sizeRead;
FSFILE_Read(vf3d->handle, &sizeRead, 0, buffer, size);
}
return buffer;
}
static void* _vfsceMap(struct VFile* vf, size_t size, int flags) {
struct VFileSce* vfsce = (struct VFileSce*) vf;
UNUSED(flags);
void* buffer = anonymousMemoryMap(size);
if (buffer) {
SceOff cur = sceIoLseek(vfsce->fd, 0, SEEK_CUR);
sceIoLseek(vfsce->fd, 0, SEEK_SET);
sceIoRead(vfsce->fd, buffer, size);
sceIoLseek(vfsce->fd, cur, SEEK_SET);
}
return buffer;
}
void GBMemoryReset(struct GB* gb) {
if (gb->memory.wram) {
mappedMemoryFree(gb->memory.wram, GB_SIZE_WORKING_RAM);
}
gb->memory.wram = anonymousMemoryMap(GB_SIZE_WORKING_RAM);
if (gb->model >= GB_MODEL_CGB) {
uint32_t* base = (uint32_t*) gb->memory.wram;
size_t i;
uint32_t pattern = 0;
for (i = 0; i < GB_SIZE_WORKING_RAM / 4; i += 4) {
if ((i & 0x1FF) == 0) {
pattern = ~pattern;
}
base[i + 0] = pattern;
base[i + 1] = pattern;
base[i + 2] = ~pattern;
base[i + 3] = ~pattern;
}
}
GBMemorySwitchWramBank(&gb->memory, 1);
gb->memory.romBank = &gb->memory.rom[GB_SIZE_CART_BANK0];
gb->memory.currentBank = 1;
gb->memory.sramCurrentBank = 0;
gb->memory.ime = false;
gb->memory.ie = 0;
gb->memory.dmaNext = INT_MAX;
gb->memory.dmaRemaining = 0;
gb->memory.dmaSource = 0;
gb->memory.dmaDest = 0;
gb->memory.hdmaNext = INT_MAX;
gb->memory.hdmaRemaining = 0;
gb->memory.hdmaSource = 0;
gb->memory.hdmaDest = 0;
gb->memory.isHdma = false;
gb->memory.sramAccess = false;
gb->memory.rtcAccess = false;
gb->memory.activeRtcReg = 0;
gb->memory.rtcLatched = false;
memset(&gb->memory.rtcRegs, 0, sizeof(gb->memory.rtcRegs));
memset(&gb->memory.hram, 0, sizeof(gb->memory.hram));
memset(&gb->memory.mbcState, 0, sizeof(gb->memory.mbcState));
GBMBCInit(gb);
gb->memory.sramBank = gb->memory.sram;
if (!gb->memory.wram) {
GBMemoryDeinit(gb);
}
}
static void* _vffMap(struct VFile* vf, size_t size, int flags) {
UNUSED(flags);
struct VFileFILE* vff = (struct VFileFILE*) vf;
void* mem = anonymousMemoryMap(size);
if (!mem) {
return 0;
}
long pos = ftell(vff->file);
fseek(vff->file, 0, SEEK_SET);
fread(mem, size, 1, vff->file);
fseek(vff->file, pos, SEEK_SET);
return mem;
}
void GBSGBDeserialize(struct GB* gb, const struct GBSerializedState* state) {
gb->video.sgbCommandHeader = state->sgb.command;
gb->sgbBit = state->sgb.bits;
GBSerializedSGBFlags flags;
LOAD_32LE(flags, 0, &state->sgb.flags);
gb->currentSgbBits = GBSerializedSGBFlagsGetP1Bits(flags);
gb->video.renderer->sgbRenderMode = GBSerializedSGBFlagsGetRenderMode(flags);
gb->video.sgbBufferIndex = GBSerializedSGBFlagsGetBufferIndex(flags);
gb->sgbControllers = GBSerializedSGBFlagsGetReqControllers(flags);
gb->sgbCurrentController = GBSerializedSGBFlagsGetCurrentController(flags);
memcpy(gb->video.sgbPacketBuffer, state->sgb.packet, sizeof(state->sgb.packet));
memcpy(gb->sgbPacket, state->sgb.inProgressPacket, sizeof(state->sgb.inProgressPacket));
if (!gb->video.renderer->sgbCharRam) {
gb->video.renderer->sgbCharRam = anonymousMemoryMap(SGB_SIZE_CHAR_RAM);
}
if (!gb->video.renderer->sgbMapRam) {
gb->video.renderer->sgbMapRam = anonymousMemoryMap(SGB_SIZE_MAP_RAM);
}
if (!gb->video.renderer->sgbPalRam) {
gb->video.renderer->sgbPalRam = anonymousMemoryMap(SGB_SIZE_PAL_RAM);
}
if (!gb->video.renderer->sgbAttributeFiles) {
gb->video.renderer->sgbAttributeFiles = anonymousMemoryMap(SGB_SIZE_ATF_RAM);
}
if (!gb->video.renderer->sgbAttributes) {
gb->video.renderer->sgbAttributes = malloc(90 * 45);
}
memcpy(gb->video.renderer->sgbCharRam, state->sgb.charRam, sizeof(state->sgb.charRam));
memcpy(gb->video.renderer->sgbMapRam, state->sgb.mapRam, sizeof(state->sgb.mapRam));
memcpy(gb->video.renderer->sgbPalRam, state->sgb.palRam, sizeof(state->sgb.palRam));
memcpy(gb->video.renderer->sgbAttributeFiles, state->sgb.atfRam, sizeof(state->sgb.atfRam));
memcpy(gb->video.renderer->sgbAttributes, state->sgb.attributes, sizeof(state->sgb.attributes));
GBVideoWriteSGBPacket(&gb->video, (uint8_t[16]) { (SGB_ATRC_EN << 3) | 1, 0 });
}
void GBApplyPatch(struct GB* gb, struct Patch* patch) {
size_t patchedSize = patch->outputSize(patch, gb->memory.romSize);
if (!patchedSize) {
return;
}
if (patchedSize > GB_SIZE_CART_MAX) {
patchedSize = GB_SIZE_CART_MAX;
}
gb->memory.rom = anonymousMemoryMap(GB_SIZE_CART_MAX);
if (!patch->applyPatch(patch, gb->pristineRom, gb->pristineRomSize, gb->memory.rom, patchedSize)) {
mappedMemoryFree(gb->memory.rom, patchedSize);
gb->memory.rom = gb->pristineRom;
return;
}
gb->memory.romSize = patchedSize;
gb->romCrc32 = doCrc32(gb->memory.rom, gb->memory.romSize);
}
void _vfmExpand(struct VFileMem* vfm, size_t newSize) {
size_t alignedSize = toPow2(newSize);
if (alignedSize > vfm->bufferSize) {
void* oldBuf = vfm->mem;
vfm->mem = anonymousMemoryMap(alignedSize);
if (oldBuf) {
if (newSize < vfm->size) {
memcpy(vfm->mem, oldBuf, newSize);
} else {
memcpy(vfm->mem, oldBuf, vfm->size);
}
mappedMemoryFree(oldBuf, vfm->bufferSize);
}
vfm->bufferSize = alignedSize;
}
vfm->size = newSize;
}
void GBASavedataInitSRAM(struct GBASavedata* savedata) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_SRAM;
} else {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
}
off_t end;
if (!savedata->vf) {
end = 0;
savedata->data = anonymousMemoryMap(SIZE_CART_SRAM);
} else {
end = savedata->vf->size(savedata->vf);
if (end < SIZE_CART_SRAM) {
savedata->vf->truncate(savedata->vf, SIZE_CART_SRAM);
}
savedata->data = savedata->vf->map(savedata->vf, SIZE_CART_SRAM, savedata->mapMode);
}
if (end < SIZE_CART_SRAM) {
memset(&savedata->data[end], 0xFF, SIZE_CART_SRAM - end);
}
}
void GBVideoInit(struct GBVideo* video) {
video->renderer = &dummyRenderer;
video->renderer->cache = NULL;
video->renderer->sgbRenderMode = 0;
video->vram = anonymousMemoryMap(GB_SIZE_VRAM);
video->frameskip = 0;
video->modeEvent.context = video;
video->modeEvent.name = "GB Video Mode";
video->modeEvent.callback = NULL;
video->modeEvent.priority = 8;
video->frameEvent.context = video;
video->frameEvent.name = "GB Video Frame";
video->frameEvent.callback = _updateFrameCount;
video->frameEvent.priority = 9;
video->dmgPalette[0] = 0x7FFF;
video->dmgPalette[1] = 0x56B5;
video->dmgPalette[2] = 0x294A;
video->dmgPalette[3] = 0x0000;
video->dmgPalette[4] = 0x7FFF;
video->dmgPalette[5] = 0x56B5;
video->dmgPalette[6] = 0x294A;
video->dmgPalette[7] = 0x0000;
video->dmgPalette[8] = 0x7FFF;
video->dmgPalette[9] = 0x56B5;
video->dmgPalette[10] = 0x294A;
video->dmgPalette[11] = 0x0000;
video->sgbBorders = true;
video->renderer->sgbCharRam = NULL;
video->renderer->sgbMapRam = NULL;
video->renderer->sgbPalRam = NULL;
video->renderer->sgbAttributes = NULL;
video->renderer->sgbAttributeFiles = NULL;
}
void GBASavedataInitEEPROM(struct GBASavedata* savedata, bool realisticTiming) {
if (savedata->type == SAVEDATA_AUTODETECT) {
savedata->type = SAVEDATA_EEPROM;
} else {
mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
return;
}
off_t end;
if (!savedata->vf) {
end = 0;
savedata->data = anonymousMemoryMap(SIZE_CART_EEPROM);
} else {
end = savedata->vf->size(savedata->vf);
if (end < SIZE_CART_EEPROM) {
savedata->vf->truncate(savedata->vf, SIZE_CART_EEPROM);
}
savedata->data = savedata->vf->map(savedata->vf, SIZE_CART_EEPROM, savedata->mapMode);
}
savedata->dust = 0;
savedata->realisticTiming = realisticTiming;
if (end < SIZE_CART_EEPROM) {
memset(&savedata->data[end], 0xFF, SIZE_CART_EEPROM - end);
}
}
bool retro_load_game(const struct retro_game_info* game) {
struct VFile* rom;
if (game->data) {
data = anonymousMemoryMap(game->size);
dataSize = game->size;
memcpy(data, game->data, game->size);
rom = VFileFromMemory(data, game->size);
} else {
data = 0;
rom = VFileOpen(game->path, O_RDONLY);
}
if (!rom) {
return false;
}
core = mCoreFindVF(rom);
if (!core) {
rom->close(rom);
mappedMemoryFree(data, game->size);
return false;
}
mCoreInitConfig(core, NULL);
core->init(core);
core->setAVStream(core, &stream);
size_t size = 256 * 224 * BYTES_PER_PIXEL;
outputBuffer = malloc(size);
memset(outputBuffer, 0xFF, size);
core->setVideoBuffer(core, outputBuffer, 256);
core->setAudioBufferSize(core, SAMPLES);
blip_set_rates(core->getAudioChannel(core, 0), core->frequency(core), 32768);
blip_set_rates(core->getAudioChannel(core, 1), core->frequency(core), 32768);
core->setPeripheral(core, mPERIPH_RUMBLE, &rumble);
savedata = anonymousMemoryMap(SIZE_CART_FLASH1M);
struct VFile* save = VFileFromMemory(savedata, SIZE_CART_FLASH1M);
_reloadSettings();
core->loadROM(core, rom);
core->loadSave(core, save);
const char* sysDir = 0;
const char* biosName = 0;
char biosPath[PATH_MAX];
environCallback(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &sysDir);
#ifdef M_CORE_GBA
if (core->platform(core) == PLATFORM_GBA) {
core->setPeripheral(core, mPERIPH_GBA_LUMINANCE, &lux);
biosName = "gba_bios.bin";
}
#endif
#ifdef M_CORE_GB
if (core->platform(core) == PLATFORM_GB) {
memset(&cam, 0, sizeof(cam));
cam.height = GBCAM_HEIGHT;
cam.width = GBCAM_WIDTH;
cam.caps = 1 << RETRO_CAMERA_BUFFER_RAW_FRAMEBUFFER;
cam.frame_raw_framebuffer = _updateCamera;
core->setPeripheral(core, mPERIPH_IMAGE_SOURCE, &imageSource);
environCallback(RETRO_ENVIRONMENT_GET_CAMERA_INTERFACE, &cam);
const char* modelName = mCoreConfigGetValue(&core->config, "gb.model");
struct GB* gb = core->board;
if (modelName) {
gb->model = GBNameToModel(modelName);
} else {
GBDetectModel(gb);
}
switch (gb->model) {
case GB_MODEL_AGB:
case GB_MODEL_CGB:
biosName = "gbc_bios.bin";
break;
case GB_MODEL_SGB:
biosName = "sgb_bios.bin";
break;
case GB_MODEL_DMG:
default:
biosName = "gb_bios.bin";
break;
}
}
#endif
if (core->opts.useBios && sysDir && biosName) {
snprintf(biosPath, sizeof(biosPath), "%s%s%s", sysDir, PATH_SEP, biosName);
struct VFile* bios = VFileOpen(biosPath, O_RDONLY);
if (bios) {
core->loadBIOS(core, bios, 0);
}
}
core->reset(core);
_setupMaps(core);
return true;
}
void GBMemoryReset(struct GB* gb) {
if (gb->memory.wram) {
mappedMemoryFree(gb->memory.wram, GB_SIZE_WORKING_RAM);
}
gb->memory.wram = anonymousMemoryMap(GB_SIZE_WORKING_RAM);
if (gb->model >= GB_MODEL_CGB) {
uint32_t* base = (uint32_t*) gb->memory.wram;
size_t i;
uint32_t pattern = 0;
for (i = 0; i < GB_SIZE_WORKING_RAM / 4; i += 4) {
if ((i & 0x1FF) == 0) {
pattern = ~pattern;
}
base[i + 0] = pattern;
base[i + 1] = pattern;
base[i + 2] = ~pattern;
base[i + 3] = ~pattern;
}
}
GBMemorySwitchWramBank(&gb->memory, 1);
gb->memory.romBank = &gb->memory.rom[GB_SIZE_CART_BANK0];
gb->memory.currentBank = 1;
gb->memory.sramCurrentBank = 0;
gb->memory.ime = false;
gb->memory.ie = 0;
gb->memory.dmaRemaining = 0;
gb->memory.dmaSource = 0;
gb->memory.dmaDest = 0;
gb->memory.hdmaRemaining = 0;
gb->memory.hdmaSource = 0;
gb->memory.hdmaDest = 0;
gb->memory.isHdma = false;
gb->memory.dmaEvent.context = gb;
gb->memory.dmaEvent.name = "GB DMA";
gb->memory.dmaEvent.callback = _GBMemoryDMAService;
gb->memory.dmaEvent.priority = 0x40;
gb->memory.hdmaEvent.context = gb;
gb->memory.hdmaEvent.name = "GB HDMA";
gb->memory.hdmaEvent.callback = _GBMemoryHDMAService;
gb->memory.hdmaEvent.priority = 0x41;
memset(&gb->memory.hram, 0, sizeof(gb->memory.hram));
switch (gb->memory.mbcType) {
case GB_MBC1:
gb->memory.mbcState.mbc1.mode = 0;
break;
default:
memset(&gb->memory.mbcState, 0, sizeof(gb->memory.mbcState));
}
GBMBCInit(gb);
gb->memory.sramBank = gb->memory.sram;
if (!gb->memory.wram) {
GBMemoryDeinit(gb);
}
}
bool retro_load_game(const struct retro_game_info* game) {
struct VFile* rom;
if (game->data) {
data = anonymousMemoryMap(game->size);
dataSize = game->size;
memcpy(data, game->data, game->size);
rom = VFileFromMemory(data, game->size);
} else {
data = 0;
rom = VFileOpen(game->path, O_RDONLY);
}
if (!rom) {
return false;
}
core = NULL;
#ifdef M_CORE_GBA
if (!core && GBAIsROM(rom)) {
core = GBACoreCreate();
}
#endif
#ifdef M_CORE_GB
if (!core && GBIsROM(rom)) {
core = GBCoreCreate();
}
#endif
if (!core) {
rom->close(rom);
mappedMemoryFree(data, game->size);
return false;
}
mCoreInitConfig(core, NULL);
core->init(core);
core->setAVStream(core, &stream);
outputBuffer = malloc(256 * VIDEO_VERTICAL_PIXELS * BYTES_PER_PIXEL);
core->setVideoBuffer(core, outputBuffer, 256);
core->setAudioBufferSize(core, SAMPLES);
blip_set_rates(core->getAudioChannel(core, 0), core->frequency(core), 32768);
blip_set_rates(core->getAudioChannel(core, 1), core->frequency(core), 32768);
core->setRumble(core, &rumble);
#ifdef M_CORE_GBA
if (core->platform(core) == PLATFORM_GBA) {
struct GBA* gba = core->board;
gba->luminanceSource = &lux;
const char* sysDir = 0;
if (environCallback(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &sysDir)) {
char biosPath[PATH_MAX];
snprintf(biosPath, sizeof(biosPath), "%s%s%s", sysDir, PATH_SEP, "gba_bios.bin");
struct VFile* bios = VFileOpen(biosPath, O_RDONLY);
if (bios) {
core->loadBIOS(core, bios, 0);
}
}
GBACheatDeviceCreate(&cheats);
GBACheatAttachDevice(gba, &cheats);
GBACheatSetInit(&cheatSet, "libretro");
GBACheatAddSet(&cheats, &cheatSet);
}
#endif
savedata = anonymousMemoryMap(SIZE_CART_FLASH1M);
struct VFile* save = VFileFromMemory(savedata, SIZE_CART_FLASH1M);
_reloadSettings();
core->loadROM(core, rom);
core->loadSave(core, save);
core->reset(core);
return true;
}
void RingFIFOInit(struct RingFIFO* buffer, size_t capacity) {
buffer->data = anonymousMemoryMap(capacity);
buffer->capacity = capacity;
RingFIFOClear(buffer);
}
struct GBASerializedState* GBAAllocateState(void) {
return anonymousMemoryMap(sizeof(struct GBASerializedState));
}
