int main(int argc, char** argv) {
struct mSDLRenderer renderer = {};
struct mCoreOptions opts = {
.useBios = true,
.rewindEnable = true,
.audioBuffers = 512,
.videoSync = false,
.audioSync = true,
.volume = 0x100,
};
struct mArguments args;
struct mGraphicsOpts graphicsOpts;
struct mSubParser subparser;
initParserForGraphics(&subparser, &graphicsOpts);
bool parsed = parseArguments(&args, argc, argv, &subparser);
if (!parsed || args.showHelp) {
usage(argv[0], subparser.usage);
freeArguments(&args);
return !parsed;
}
if (args.showVersion) {
version(argv[0]);
freeArguments(&args);
return 0;
}
renderer.core = mCoreFind(args.fname);
if (!renderer.core) {
printf("Could not run game. Are you sure the file exists and is a compatible game?\n");
freeArguments(&args);
return 1;
}
renderer.core->desiredVideoDimensions(renderer.core, &renderer.width, &renderer.height);
#ifdef BUILD_GL
mSDLGLCreate(&renderer);
#elif defined(BUILD_GLES2) || defined(USE_EPOXY)
mSDLGLES2Create(&renderer);
#else
mSDLSWCreate(&renderer);
#endif
renderer.ratio = graphicsOpts.multiplier;
if (renderer.ratio == 0) {
renderer.ratio = 1;
}
opts.width = renderer.width * renderer.ratio;
opts.height = renderer.height * renderer.ratio;
if (!renderer.core->init(renderer.core)) {
freeArguments(&args);
return 1;
}
mInputMapInit(&renderer.core->inputMap, &GBAInputInfo);
mCoreInitConfig(renderer.core, PORT);
applyArguments(&args, &subparser, &renderer.core->config);
mCoreConfigLoadDefaults(&renderer.core->config, &opts);
mCoreLoadConfig(renderer.core);
renderer.viewportWidth = renderer.core->opts.width;
renderer.viewportHeight = renderer.core->opts.height;
#if SDL_VERSION_ATLEAST(2, 0, 0)
renderer.player.fullscreen = renderer.core->opts.fullscreen;
renderer.player.windowUpdated = 0;
#else
renderer.fullscreen = renderer.core->opts.fullscreen;
#endif
renderer.lockAspectRatio = renderer.core->opts.lockAspectRatio;
renderer.filter = renderer.core->opts.resampleVideo;
if (!mSDLInit(&renderer)) {
freeArguments(&args);
renderer.core->deinit(renderer.core);
return 1;
}
renderer.player.bindings = &renderer.core->inputMap;
mSDLInitBindingsGBA(&renderer.core->inputMap);
mSDLInitEvents(&renderer.events);
mSDLEventsLoadConfig(&renderer.events, mCoreConfigGetInput(&renderer.core->config));
mSDLAttachPlayer(&renderer.events, &renderer.player);
mSDLPlayerLoadConfig(&renderer.player, mCoreConfigGetInput(&renderer.core->config));
int ret;
// TODO: Use opts and config
ret = mSDLRun(&renderer, &args);
mSDLDetachPlayer(&renderer.events, &renderer.player);
mInputMapDeinit(&renderer.core->inputMap);
mSDLDeinit(&renderer);
freeArguments(&args);
mCoreConfigFreeOpts(&opts);
mCoreConfigDeinit(&renderer.core->config);
renderer.core->deinit(renderer.core);
return ret;
}
int mSDLRun(struct mSDLRenderer* renderer, struct mArguments* args) {
struct mCoreThread thread = {
.core = renderer->core
};
if (!mCoreLoadFile(renderer->core, args->fname)) {
return 1;
}
mCoreAutoloadSave(renderer->core);
struct mDebugger* debugger = mDebuggerCreate(args->debuggerType, renderer->core);
if (debugger) {
mDebuggerAttach(debugger, renderer->core);
mDebuggerEnter(debugger, DEBUGGER_ENTER_MANUAL, NULL);
}
if (args->patch) {
struct VFile* patch = VFileOpen(args->patch, O_RDONLY);
if (patch) {
renderer->core->loadPatch(renderer->core, patch);
}
} else {
mCoreAutoloadPatch(renderer->core);
}
renderer->audio.samples = renderer->core->opts.audioBuffers;
renderer->audio.sampleRate = 44100;
bool didFail = !mSDLInitAudio(&renderer->audio, &thread);
if (!didFail) {
#if SDL_VERSION_ATLEAST(2, 0, 0)
mSDLSetScreensaverSuspendable(&renderer->events, renderer->core->opts.suspendScreensaver);
mSDLSuspendScreensaver(&renderer->events);
#endif
if (mCoreThreadStart(&thread)) {
renderer->runloop(renderer, &thread);
mSDLPauseAudio(&renderer->audio);
mCoreThreadJoin(&thread);
} else {
didFail = true;
printf("Could not run game. Are you sure the file exists and is a compatible game?\n");
}
#if SDL_VERSION_ATLEAST(2, 0, 0)
mSDLResumeScreensaver(&renderer->events);
mSDLSetScreensaverSuspendable(&renderer->events, false);
#endif
if (mCoreThreadHasCrashed(&thread)) {
didFail = true;
printf("The game crashed!\n");
}
}
renderer->core->unloadROM(renderer->core);
return didFail;
}
static bool mSDLInit(struct mSDLRenderer* renderer) {
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("Could not initialize video: %s\n", SDL_GetError());
return false;
}
return renderer->init(renderer);
}
static void mSDLDeinit(struct mSDLRenderer* renderer) {
mSDLDeinitEvents(&renderer->events);
mSDLDeinitAudio(&renderer->audio);
#if SDL_VERSION_ATLEAST(2, 0, 0)
SDL_DestroyWindow(renderer->window);
#endif
renderer->deinit(renderer);
SDL_Quit();
}
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;
}
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;
}
