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

Merge pull request #286 from retro-wertz/libretro_gb 

add GB/GBC core to libretro
This commit is contained in:
Zach Bacon 2018-07-22 10:27:25 -04:00 committed by GitHub
parent 0e60c34ab9 6ef938fc52
commit 5016fd6c0e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 1080 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

379
src/gb/GB.cpp
View File

@ -2852,6 +2852,7 @@ void gbReset()
gbCheatWrite(true); // Emulates GS codes.
}
#ifndef __LIBRETRO__
void gbWriteSaveMBC1(const char* name)
{
if (gbRam) {
@ -3335,6 +3336,7 @@ bool gbReadSaveMMM01(const char* name)
} else
return false;
}
#endif // !__LIBRETRO__
void gbInit()
{
@ -3343,11 +3345,16 @@ void gbInit()
gbMemory = (uint8_t*)malloc(65536);
#ifdef __LIBRETRO__
pix = (uint8_t*)calloc(1, 4 * 256 * 224);
#else
pix = (uint8_t*)calloc(1, 4 * 257 * 226);
#endif
gbLineBuffer = (uint16_t*)malloc(160 * sizeof(uint16_t));
}
#ifndef __LIBRETRO__
bool gbWriteBatteryFile(const char* file, bool extendedSave)
{
if (gbBattery) {
@ -3480,6 +3487,7 @@ bool gbReadBatteryFile(const char* file)
systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
return res;
}
#endif // !__LIBRETRO__
bool gbReadGSASnapshot(const char* fileName)
{
@ -3617,6 +3625,7 @@ variable_desc gbSaveGameStruct[] = {
{ NULL, 0 }
};
#ifndef __LIBRETRO__
static bool gbWriteSaveState(gzFile gzFile)
{
@ -4091,6 +4100,7 @@ bool gbReadSaveState(const char* name)
return res;
}
#endif // !__LIBRETRO__
bool gbWritePNGFile(const char* fileName)
{
@ -4457,8 +4467,13 @@ void gbDrawLine()
{
switch (systemColorDepth) {
case 16: {
#ifdef __LIBRETRO__
uint16_t* dest = (uint16_t*)pix + gbBorderLineSkip * (register_LY + gbBorderRowSkip)
+ gbBorderColumnSkip;
#else
uint16_t* dest = (uint16_t*)pix + (gbBorderLineSkip + 2) * (register_LY + gbBorderRowSkip + 1)
+ gbBorderColumnSkip;
#endif
for (int x = 0; x < 160;) {
*dest++ = systemColorMap16[gbLineMix[x++]];
*dest++ = systemColorMap16[gbLineMix[x++]];
@ -4482,7 +4497,9 @@ void gbDrawLine()
}
if (gbBorderOn)
dest += gbBorderColumnSkip;
#ifndef __LIBRETRO__
*dest++ = 0; // for filters that read one pixel more
#endif
} break;
case 24: {
@ -4527,8 +4544,13 @@ void gbDrawLine()
} break;
case 32: {
#ifdef __LIBRETRO__
uint32_t* dest = (uint32_t*)pix + gbBorderLineSkip * (register_LY + gbBorderRowSkip)
+ gbBorderColumnSkip;
#else
uint32_t* dest = (uint32_t*)pix + (gbBorderLineSkip + 1) * (register_LY + gbBorderRowSkip + 1)
+ gbBorderColumnSkip;
#endif
for (int x = 0; x < 160;) {
*dest++ = systemColorMap32[gbLineMix[x++]];
*dest++ = systemColorMap32[gbLineMix[x++]];
@ -5418,6 +5440,361 @@ void gbEmulate(int ticksToStop)
}
}
bool gbLoadRomData(const char* data, unsigned size)
{
gbRomSize = size;
if (gbRom != NULL) {
gbCleanUp();
}
systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
gbRom = (uint8_t*)calloc(1, gbRomSize);
if (gbRom == NULL) {
return 0;
}
memcpy(gbRom, data, gbRomSize);
gbBatteryError = false;
if (bios != NULL) {
free(bios);
bios = NULL;
}
bios = (uint8_t*)calloc(1, 0x900);
return gbUpdateSizes();
}
#ifdef __LIBRETRO__
#include <stddef.h>
unsigned int gbWriteSaveState(uint8_t* data, unsigned)
{
uint8_t* orig = data;
utilWriteIntMem(data, GBSAVE_GAME_VERSION);
utilWriteMem(data, &gbRom[0x134], 15);
utilWriteIntMem(data, useBios);
utilWriteIntMem(data, inBios);
utilWriteDataMem(data, gbSaveGameStruct);
utilWriteMem(data, &IFF, 2);
if (gbSgbMode) {
gbSgbSaveGame(data);
}
utilWriteMem(data, &gbDataMBC1, sizeof(gbDataMBC1));
utilWriteMem(data, &gbDataMBC2, sizeof(gbDataMBC2));
utilWriteMem(data, &gbDataMBC3, sizeof(gbDataMBC3));
utilWriteMem(data, &gbDataMBC5, sizeof(gbDataMBC5));
utilWriteMem(data, &gbDataHuC1, sizeof(gbDataHuC1));
utilWriteMem(data, &gbDataHuC3, sizeof(gbDataHuC3));
utilWriteMem(data, &gbDataTAMA5, sizeof(gbDataTAMA5));
if (gbTAMA5ram != NULL)
utilWriteMem(data, gbTAMA5ram, gbTAMA5ramSize);
utilWriteMem(data, &gbDataMMM01, sizeof(gbDataMMM01));
utilWriteMem(data, gbPalette, 128 * sizeof(uint16_t));
utilWriteMem(data, &gbMemory[0x8000], 0x8000);
if (gbRamSize && gbRam) {
utilWriteIntMem(data, gbRamSize);
utilWriteMem(data, gbRam, gbRamSize);
}
if (gbCgbMode) {
utilWriteMem(data, gbVram, 0x4000);
utilWriteMem(data, gbWram, 0x8000);
}
gbSoundSaveGame(data);
// We dont care about cheat saves
// gbCheatsSaveGame(data);
utilWriteIntMem(data, gbLcdModeDelayed);
utilWriteIntMem(data, gbLcdTicksDelayed);
utilWriteIntMem(data, gbLcdLYIncrementTicksDelayed);
utilWriteIntMem(data, gbSpritesTicks[299]);
utilWriteIntMem(data, gbTimerModeChange);
utilWriteIntMem(data, gbTimerOnChange);
utilWriteIntMem(data, gbHardware);
utilWriteIntMem(data, gbBlackScreen);
utilWriteIntMem(data, oldRegister_WY);
utilWriteIntMem(data, gbWindowLine);
utilWriteIntMem(data, inUseRegister_WY);
utilWriteIntMem(data, gbScreenOn);
utilWriteIntMem(data, 0x12345678); // end marker
return (ptrdiff_t)data - (ptrdiff_t)orig;
}
bool gbReadSaveState(const uint8_t* data, unsigned)
{
int version = utilReadIntMem(data);
if (version != GBSAVE_GAME_VERSION) {
systemMessage(MSG_UNSUPPORTED_VB_SGM,
N_("Unsupported VBA-M save game version %d"), version);
return false;
}
uint8_t romname[20];
utilReadMem(romname, data, 15);
if (memcmp(&gbRom[0x134], romname, 15) != 0) {
systemMessage(MSG_CANNOT_LOAD_SGM_FOR,
N_("Cannot load save game for %s. Playing %s"),
romname, &gbRom[0x134]);
return false;
}
bool ub = false;
bool ib = false;
ub = utilReadIntMem(data) ? true : false;
ib = utilReadIntMem(data) ? true : false;
if ((ub != useBios) && (ib)) {
if (useBios)
systemMessage(MSG_SAVE_GAME_NOT_USING_BIOS,
N_("Save game is not using the BIOS files"));
else
systemMessage(MSG_SAVE_GAME_USING_BIOS,
N_("Save game is using the BIOS file"));
return false;
}
gbReset();
inBios = ib;
utilReadDataMem(data, gbSaveGameStruct);
// Correct crash when loading color gameboy save in regular gameboy type.
if (!gbCgbMode) {
if (gbVram != NULL) {
free(gbVram);
gbVram = NULL;
}
if (gbWram != NULL) {
free(gbWram);
gbWram = NULL;
}
} else {
if (gbVram == NULL)
gbVram = (uint8_t*)malloc(0x4000);
if (gbWram == NULL)
gbWram = (uint8_t*)malloc(0x8000);
memset(gbVram, 0, 0x4000);
memset(gbPalette, 0, 2 * 128);
}
utilReadMem(&IFF, data, 2);
if (gbSgbMode) {
gbSgbReadGame(data, version);
} else {
gbSgbMask = 0; // loading a game at the wrong time causes no display
}
utilReadMem(&gbDataMBC1, data, sizeof(gbDataMBC1));
utilReadMem(&gbDataMBC2, data, sizeof(gbDataMBC2));
utilReadMem(&gbDataMBC3, data, sizeof(gbDataMBC3));
utilReadMem(&gbDataMBC5, data, sizeof(gbDataMBC5));
utilReadMem(&gbDataHuC1, data, sizeof(gbDataHuC1));
utilReadMem(&gbDataHuC3, data, sizeof(gbDataHuC3));
utilReadMem(&gbDataTAMA5, data, sizeof(gbDataTAMA5));
if (gbTAMA5ram != NULL) {
utilReadMem(gbTAMA5ram, data, gbTAMA5ramSize);
}
utilReadMem(&gbDataMMM01, data, sizeof(gbDataMMM01));
utilReadMem(gbPalette, data, 128 * sizeof(uint16_t));
utilReadMem(&gbMemory[0x8000], data, 0x8000);
if (gbRamSize && gbRam) {
int ramSize = utilReadIntMem(data);
utilReadMem(gbRam, data, (gbRamSize > ramSize) ? ramSize : gbRamSize); //read
/*if (ramSize > gbRamSize)
utilGzSeek(gzFile, ramSize - gbRamSize, SEEK_CUR);*/ // Libretro Note: ????
}
memset(gbSCYLine, register_SCY, sizeof(gbSCYLine));
memset(gbSCXLine, register_SCX, sizeof(gbSCXLine));
memset(gbBgpLine, (gbBgp[0] | (gbBgp[1] << 2) | (gbBgp[2] << 4) | (gbBgp[3] << 6)), sizeof(gbBgpLine));
memset(gbObp0Line, (gbObp0[0] | (gbObp0[1] << 2) | (gbObp0[2] << 4) | (gbObp0[3] << 6)), sizeof(gbObp0Line));
memset(gbObp1Line, (gbObp1[0] | (gbObp1[1] << 2) | (gbObp1[2] << 4) | (gbObp1[3] << 6)), sizeof(gbObp1Line));
memset(gbSpritesTicks, 0x0, sizeof(gbSpritesTicks));
if (inBios) {
gbMemoryMap[0x00] = &gbMemory[0x0000];
if (gbHardware & 5) {
memcpy((uint8_t*)(gbMemory), (uint8_t*)(gbRom), 0x1000);
memcpy((uint8_t*)(gbMemory), (uint8_t*)(bios), 0x100);
} else if (gbHardware & 2) {
memcpy((uint8_t*)(gbMemory), (uint8_t*)(bios), 0x900);
memcpy((uint8_t*)(gbMemory + 0x100), (uint8_t*)(gbRom + 0x100), 0x100);
}
} else {
gbMemoryMap[0x00] = &gbRom[0x0000];
}
gbMemoryMap[0x01] = &gbRom[0x1000];
gbMemoryMap[0x02] = &gbRom[0x2000];
gbMemoryMap[0x03] = &gbRom[0x3000];
gbMemoryMap[0x04] = &gbRom[0x4000];
gbMemoryMap[0x05] = &gbRom[0x5000];
gbMemoryMap[0x06] = &gbRom[0x6000];
gbMemoryMap[0x07] = &gbRom[0x7000];
gbMemoryMap[0x08] = &gbMemory[0x8000];
gbMemoryMap[0x09] = &gbMemory[0x9000];
gbMemoryMap[0x0a] = &gbMemory[0xa000];
gbMemoryMap[0x0b] = &gbMemory[0xb000];
gbMemoryMap[0x0c] = &gbMemory[0xc000];
gbMemoryMap[0x0d] = &gbMemory[0xd000];
gbMemoryMap[0x0e] = &gbMemory[0xe000];
gbMemoryMap[0x0f] = &gbMemory[0xf000];
switch (gbRomType) {
case 0x00:
case 0x01:
case 0x02:
case 0x03:
// MBC 1
memoryUpdateMapMBC1();
break;
case 0x05:
case 0x06:
// MBC2
memoryUpdateMapMBC2();
break;
case 0x0b:
case 0x0c:
case 0x0d:
// MMM01
memoryUpdateMapMMM01();
break;
case 0x0f:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
// MBC 3
memoryUpdateMapMBC3();
break;
case 0x19:
case 0x1a:
case 0x1b:
// MBC5
memoryUpdateMapMBC5();
break;
case 0x1c:
case 0x1d:
case 0x1e:
// MBC 5 Rumble
memoryUpdateMapMBC5();
break;
case 0x22:
// MBC 7
memoryUpdateMapMBC7();
break;
case 0x56:
// GS3
memoryUpdateMapGS3();
break;
case 0xfd:
// TAMA5
memoryUpdateMapTAMA5();
break;
case 0xfe:
// HuC3
memoryUpdateMapHuC3();
break;
case 0xff:
// HuC1
memoryUpdateMapHuC1();
break;
}
if (gbCgbMode) {
utilReadMem(gbVram, data, 0x4000);
utilReadMem(gbWram, data, 0x8000);
int value = register_SVBK;
if (value == 0)
value = 1;
gbMemoryMap[0x08] = &gbVram[register_VBK * 0x2000];
gbMemoryMap[0x09] = &gbVram[register_VBK * 0x2000 + 0x1000];
gbMemoryMap[0x0d] = &gbWram[value * 0x1000];
}
gbSoundReadGame(data, version);
if (gbCgbMode && gbSgbMode) {
gbSgbMode = 0;
}
if (gbBorderOn && !gbSgbMask) {
gbSgbRenderBorder();
}
gbLcdModeDelayed = utilReadIntMem(data);
gbLcdTicksDelayed = utilReadIntMem(data);
gbLcdLYIncrementTicksDelayed = utilReadIntMem(data);
gbSpritesTicks[299] = utilReadIntMem(data) & 0xff;
gbTimerModeChange = (utilReadIntMem(data) ? true : false);
gbTimerOnChange = (utilReadIntMem(data) ? true : false);
gbHardware = utilReadIntMem(data);
gbBlackScreen = (utilReadIntMem(data) ? true : false);
oldRegister_WY = utilReadIntMem(data);
gbWindowLine = utilReadIntMem(data);
inUseRegister_WY = utilReadIntMem(data);
gbScreenOn = (utilReadIntMem(data) ? true : false);
if (gbSpeed)
gbLine99Ticks *= 2;
systemSaveUpdateCounter = SYSTEM_SAVE_NOT_UPDATED;
if (version >= 12 && utilReadIntMem(data) != 0x12345678)
assert(false); // fails if something read too much/little from file
return true;
}
bool gbWriteMemSaveState(char*, int, long&)
{
return false;
}
bool gbReadMemSaveState(char*, int)
{
return false;
}
bool gbReadBatteryFile(const char*)
{
return false;
}
bool gbWriteBatteryFile(const char*)
{
return false;
}
#endif
struct EmulatedSystem GBSystem = {
// emuMain
gbEmulate,
@ -5445,7 +5822,7 @@ struct EmulatedSystem GBSystem = {
NULL,
// emuHasDebugger
false,
// emuCount
// emuCount
#ifdef FINAL_VERSION
70000 / 4,
#else

11
src/gb/gb.h
View File

@ -31,18 +31,25 @@ void gbGetHardwareType();
void gbReset();
void gbCleanUp();
void gbCPUInit(const char*, bool);
#ifdef __LIBRETRO__
unsigned int gbWriteSaveState(uint8_t*, unsigned);
bool gbReadSaveState(const uint8_t*, unsigned);
#else
bool gbWriteSaveState(const char*);
bool gbReadSaveState(const char*);
#endif
bool gbWriteBatteryFile(const char*);
bool gbWriteBatteryFile(const char*, bool);
bool gbReadBatteryFile(const char*);
bool gbWriteSaveState(const char*);
bool gbWriteMemSaveState(char*, int, long&);
bool gbReadSaveState(const char*);
bool gbReadMemSaveState(char*, int);
void gbSgbRenderBorder();
bool gbWritePNGFile(const char*);
bool gbWriteBMPFile(const char*);
bool gbReadGSASnapshot(const char*);
bool gbLoadRomData(const char* data, unsigned size);
extern int gbHardware;
extern struct EmulatedSystem GBSystem;

2
src/gb/gbCheats.cpp
View File

@ -30,6 +30,7 @@ void gbCheatUpdateMap()
}
}
#ifndef __LIBRETRO__
void gbCheatsSaveGame(gzFile gzFile)
{
utilWriteInt(gzFile, gbCheatNumber);
@ -98,6 +99,7 @@ void gbCheatsReadGameSkip(gzFile gzFile, int version)
}
}
}
#endif
void gbCheatsSaveCheatList(const char* file)
{

2
src/gb/gbCheats.h
View File

@ -19,9 +19,11 @@ struct gbCheat {
bool enabled;
};
#ifndef __LIBRETRO__
void gbCheatsSaveGame(gzFile);
void gbCheatsReadGame(gzFile, int);
void gbCheatsReadGameSkip(gzFile, int);
#endif
void gbCheatsSaveCheatList(const char*);
bool gbCheatsLoadCheatList(const char*);
bool gbCheatReadGSCodeFile(const char*);

54
src/gb/gbSGB.cpp
View File

@ -113,7 +113,11 @@ void gbSgbFillScreen(uint16_t color)
switch (systemColorDepth) {
case 16: {
for (int y = 0; y < 144; y++) {
#ifdef __LIBRETRO__
int yLine = (y + gbBorderRowSkip) * gbBorderLineSkip + gbBorderColumnSkip;
#else
int yLine = (y + gbBorderRowSkip + 1) * (gbBorderLineSkip + 2) + gbBorderColumnSkip;
#endif
uint16_t* dest = (uint16_t*)pix + yLine;
for (register int x = 0; x < 160; x++)
gbSgbDraw16Bit(dest++, color);
@ -131,7 +135,11 @@ void gbSgbFillScreen(uint16_t color)
} break;
case 32: {
for (int y = 0; y < 144; y++) {
#ifdef __LIBRETRO__
int yLine = (y + gbBorderRowSkip) * gbBorderLineSkip + gbBorderColumnSkip;
#else
int yLine = (y + gbBorderRowSkip + 1) * (gbBorderLineSkip + 1) + gbBorderColumnSkip;
#endif
uint32_t* dest = (uint32_t*)pix + yLine;
for (register int x = 0; x < 160; x++) {
gbSgbDraw32Bit(dest++, color);
@ -181,9 +189,14 @@ void gbSgbRenderScreenToBuffer()
void gbSgbDrawBorderTile(int x, int y, int tile, int attr)
{
#ifdef __LIBRETRO__
uint16_t* dest = (uint16_t*)pix + (y * 256) + x;
uint32_t* dest32 = (uint32_t*)pix + (y * 256) + x;
#else
uint16_t* dest = (uint16_t*)pix + ((y + 1) * (256 + 2)) + x;
uint32_t* dest32 = (uint32_t*)pix + ((y + 1) * (256 + 1)) + x;
#endif
uint8_t* dest8 = (uint8_t*)pix + ((y * 256) + x) * 3;
uint32_t* dest32 = (uint32_t*)pix + ((y + 1) * 257) + x;
uint8_t* tileAddress = &gbSgbBorderChar[tile * 32];
uint8_t* tileAddress2 = &gbSgbBorderChar[tile * 32 + 16];
@ -245,13 +258,21 @@ void gbSgbDrawBorderTile(int x, int y, int tile, int attr)
switch (systemColorDepth) {
case 16:
#ifdef __LIBRETRO__
gbSgbDraw16Bit(dest + yyy * 256 + xxx, cc);
#else
gbSgbDraw16Bit(dest + yyy * (256 + 2) + xxx, cc);
#endif
break;
case 24:
gbSgbDraw24Bit(dest8 + (yyy * 256 + xxx) * 3, cc);
break;
case 32:
#ifdef __LIBRETRO__
gbSgbDraw32Bit(dest32 + yyy * 256 + xxx, cc);
#else
gbSgbDraw32Bit(dest32 + yyy * (256 + 1) + xxx, cc);
#endif
break;
}
}
@ -860,6 +881,36 @@ variable_desc gbSgbSaveStructV3[] = {
{ NULL, 0 }
};
#ifdef __LIBRETRO__
void gbSgbSaveGame(uint8_t*& data)
{
utilWriteDataMem(data, gbSgbSaveStructV3);
utilWriteMem(data, gbSgbBorder, 2048);
utilWriteMem(data, gbSgbBorderChar, 32 * 256);
utilWriteMem(data, gbSgbPacket, 16 * 7);
utilWriteMem(data, gbSgbSCPPalette, 4 * 512 * sizeof(uint16_t));
utilWriteMem(data, gbSgbATF, 20 * 18);
utilWriteMem(data, gbSgbATFList, 45 * 20 * 18);
}
void gbSgbReadGame(const uint8_t*& data, int version)
{
utilReadDataMem(data, gbSgbSaveStructV3);
utilReadMem(gbSgbBorder, data, 2048);
utilReadMem(gbSgbBorderChar, data, 32 * 256);
utilReadMem(gbSgbPacket, data, 16 * 7);
utilReadMem(gbSgbSCPPalette, data, 4 * 512 * sizeof(uint16_t));
utilReadMem(gbSgbATF, data, 20 * 18);
utilReadMem(gbSgbATFList, data, 45 * 20 * 18);
}
#else // !__LIBRETRO__
void gbSgbSaveGame(gzFile gzFile)
{
utilWriteData(gzFile, gbSgbSaveStructV3);
@ -894,3 +945,4 @@ void gbSgbReadGame(gzFile gzFile, int version)
utilGzRead(gzFile, gbSgbATF, 20 * 18);
utilGzRead(gzFile, gbSgbATFList, 45 * 20 * 18);
}
#endif // !__LIBRETRO__

7
src/gb/gbSGB.h
View File

@ -7,9 +7,14 @@ void gbSgbCommand();
void gbSgbResetPacketState();
void gbSgbReset();
void gbSgbDoBitTransfer(uint8_t);
void gbSgbRenderBorder();
#ifdef __LIBRETRO__
void gbSgbSaveGame(uint8_t*&);
void gbSgbReadGame(const uint8_t*&, int);
#else
void gbSgbSaveGame(gzFile);
void gbSgbReadGame(gzFile, int version);
void gbSgbRenderBorder();
#endif
extern uint8_t gbSgbATF[20 * 18];
extern int gbSgbMode;

18
src/gb/gbSound.cpp
View File

@ -358,6 +358,7 @@ enum {
nr52
};
#ifndef __LIBRETRO__
static void gbSoundReadGameOld(int version, gzFile gzFile)
{
if (version == 11) {
@ -395,6 +396,7 @@ static void gbSoundReadGameOld(int version, gzFile gzFile)
memcpy(&s.regs[0x20], &gbMemory[0xFF30], 0x10); // wave
}
#endif
// New state format
@ -430,7 +432,11 @@ static variable_desc gb_state[] = {
{ NULL, 0 }
};
#ifdef __LIBRETRO__
void gbSoundSaveGame(uint8_t*& out)
#else
void gbSoundSaveGame(gzFile out)
#endif
{
gb_apu->save_state(&state.apu);
@ -438,19 +444,31 @@ void gbSoundSaveGame(gzFile out)
memset(dummy_state, 0, sizeof dummy_state);
state.version = 1;
#ifdef __LIBRETRO__
utilWriteDataMem(out, gb_state);
#else
utilWriteData(out, gb_state);
#endif
}
#ifdef __LIBRETRO__
void gbSoundReadGame(const uint8_t*& in, int version)
#else
void gbSoundReadGame(int version, gzFile in)
#endif
{
// Prepare APU and default state
reset_apu();
gb_apu->save_state(&state.apu);
if (version > 11)
#ifdef __LIBRETRO__
utilReadDataMem(in, gb_state);
#else
utilReadData(in, gb_state);
else
gbSoundReadGameOld(version, in);
#endif
gb_apu->load_state(state.apu);
}

5
src/gb/gbSound.h
View File

@ -68,7 +68,12 @@ extern int SOUND_CLOCK_TICKS; // Number of 16.8 MHz clocks between calls to gbSo
extern int soundTicks; // Number of 16.8 MHz clocks until gbSoundTick() will be called
// Saves/loads emulator state
#ifdef __LIBRETRO__
void gbSoundSaveGame(uint8_t*&);
void gbSoundReadGame(const uint8_t*&, int);
#else
void gbSoundSaveGame(gzFile out);
void gbSoundReadGame(int version, gzFile in);
#endif
#endif // GBSOUND_H

8
src/libretro/Makefile
View File

@ -1,5 +1,6 @@
TILED_RENDERING=0
STATIC_LINKING=0
FRONTEND_SUPPORTS_RGB565=1
SPACE :=
SPACE := $(SPACE) $(SPACE)
@ -226,7 +227,10 @@ include Makefile.common
OBJS := $(SOURCES_CXX:.cpp=.o)
VBA_DEFINES += -D__LIBRETRO__ -DFINAL_VERSION -DC_CORE -DNO_LINK -DNO_DEBUGGER
ifeq ($(FRONTEND_SUPPORTS_RGB565),1)
VBA_DEFINES += -DFRONTEND_SUPPORTS_RGB565
endif
ifneq ($(SANITIZER),)
CFLAGS += -fsanitize=$(SANITIZER)
@ -234,8 +238,8 @@ ifneq ($(SANITIZER),)
endif
ifeq ($(DEBUG), 1)
CFLAGS += -g
CXXFLAGS += -g
CFLAGS += -O0 -g
CXXFLAGS += -O0 -g
else
CFLAGS += -O2 -DNDEBUG
CXXFLAGS += -O2 -DNDEBUG

38
src/libretro/Makefile.common
View File

@ -1,6 +1,22 @@
INCFLAGS := -I$(CORE_DIR)
SOURCES_CXX :=
SOURCES_CXX := $(CORE_DIR)/gba/GBA-thumb.cpp \
SOURCES_CXX += \
$(CORE_DIR)/libretro/libretro.cpp \
$(CORE_DIR)/libretro/UtilRetro.cpp \
$(CORE_DIR)/libretro/SoundRetro.cpp \
$(CORE_DIR)/libretro/scrc32.cpp
SOURCES_CXX += \
$(CORE_DIR)/apu/Gb_Oscs.cpp \
$(CORE_DIR)/apu/Gb_Apu_State.cpp \
$(CORE_DIR)/apu/Blip_Buffer.cpp \
$(CORE_DIR)/apu/Multi_Buffer.cpp \
$(CORE_DIR)/apu/Effects_Buffer.cpp \
$(CORE_DIR)/apu/Gb_Apu.cpp
SOURCES_CXX += \
$(CORE_DIR)/gba/GBA-thumb.cpp \
$(CORE_DIR)/gba/Sound.cpp \
$(CORE_DIR)/gba/Mode1.cpp \
$(CORE_DIR)/gba/CheatSearch.cpp \
@ -20,13 +36,13 @@ SOURCES_CXX := $(CORE_DIR)/gba/GBA-thumb.cpp \
$(CORE_DIR)/gba/GBA.cpp \
$(CORE_DIR)/gba/EEprom.cpp \
$(CORE_DIR)/gba/RTC.cpp \
$(CORE_DIR)/gba/Sram.cpp \
$(CORE_DIR)/apu/Gb_Oscs.cpp \
$(CORE_DIR)/apu/Gb_Apu_State.cpp \
$(CORE_DIR)/apu/Blip_Buffer.cpp \
$(CORE_DIR)/apu/Multi_Buffer.cpp \
$(CORE_DIR)/apu/Gb_Apu.cpp \
$(CORE_DIR)/libretro/libretro.cpp \
$(CORE_DIR)/libretro/UtilRetro.cpp \
$(CORE_DIR)/libretro/SoundRetro.cpp \
$(CORE_DIR)/libretro/scrc32.cpp
$(CORE_DIR)/gba/Sram.cpp
SOURCES_CXX += \
$(CORE_DIR)/gb/gbCheats.cpp \
$(CORE_DIR)/gb/GB.cpp \
$(CORE_DIR)/gb/gbGfx.cpp \
$(CORE_DIR)/gb/gbGlobals.cpp \
$(CORE_DIR)/gb/gbMemory.cpp \
$(CORE_DIR)/gb/gbSGB.cpp \
$(CORE_DIR)/gb/gbSound.cpp

5
src/libretro/SoundRetro.cpp
View File

@ -18,7 +18,6 @@
#include "SoundRetro.h"
#include "libretro.h"
unsigned g_audio_frames;
extern retro_audio_sample_batch_t audio_batch_cb;
SoundRetro::SoundRetro()
@ -30,14 +29,10 @@ void SoundRetro::write(uint16_t* finalWave, int length)
const int16_t* wave = (const int16_t*)finalWave;
int frames = length >> 1;
audio_batch_cb(wave, frames);
g_audio_frames += frames;
}
bool SoundRetro::init(long sampleRate)
{
g_audio_frames = 0;
return true;
}

15
src/libretro/UtilRetro.cpp
View File

@ -108,6 +108,7 @@ bool utilIsGBAImage(const char* file)
bool utilIsGBImage(const char* file)
{
/*
FILE *fp;
bool ret = false;
char buffer[47];
@ -121,6 +122,20 @@ bool utilIsGBImage(const char* file)
}
fclose (fp);
return ret;
*/
if (strlen(file) > 4) {
const char *p = strrchr(file, '.');
if (p != NULL) {
if ((_stricmp(p, ".dmg") == 0) || (_stricmp(p, ".gb") == 0)
|| (_stricmp(p, ".gbc") == 0) || (_stricmp(p, ".cgb") == 0)
|| (_stricmp(p, ".sgb") == 0)) {
return true;
}
}
}
return false;
}
// strip .gz or .z off end

726
src/libretro/libretro.cpp
View File

File diff suppressed because it is too large Load Diff