1/* Copyright (c) 2013-2015 Jeffrey Pfau
  2 *
  3 * This Source Code Form is subject to the terms of the Mozilla Public
  4 * License, v. 2.0. If a copy of the MPL was not distributed with this
  5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  6#include "main.h"
  7
  8#include <mgba/internal/debugger/cli-debugger.h>
  9
 10#ifdef USE_GDB_STUB
 11#include <mgba/internal/debugger/gdb-stub.h>
 12#endif
 13#ifdef USE_EDITLINE
 14#include "feature/editline/cli-el-backend.h"
 15#endif
 16#ifdef ENABLE_SCRIPTING
 17#include <mgba/core/scripting.h>
 18
 19#ifdef ENABLE_PYTHON
 20#include "platform/python/engine.h"
 21#endif
 22#endif
 23
 24#include <mgba/core/cheats.h>
 25#include <mgba/core/core.h>
 26#include <mgba/core/config.h>
 27#include <mgba/core/input.h>
 28#include <mgba/core/serialize.h>
 29#include <mgba/core/thread.h>
 30#include <mgba/internal/gba/input.h>
 31
 32#include <mgba/feature/commandline.h>
 33#include <mgba-util/vfs.h>
 34
 35#include <SDL.h>
 36
 37#include <errno.h>
 38#include <signal.h>
 39
 40#define PORT "sdl"
 41
 42static void mSDLDeinit(struct mSDLRenderer* renderer);
 43
 44static int mSDLRun(struct mSDLRenderer* renderer, struct mArguments* args);
 45
 46static struct VFile* _state = NULL;
 47
 48static void _loadState(struct mCoreThread* thread) {
 49	mCoreLoadStateNamed(thread->core, _state, SAVESTATE_RTC);
 50}
 51
 52int main(int argc, char** argv) {
 53	struct mSDLRenderer renderer = {0};
 54
 55	struct mCoreOptions opts = {
 56		.useBios = true,
 57		.rewindEnable = true,
 58		.rewindBufferCapacity = 600,
 59		.audioBuffers = 1024,
 60		.videoSync = false,
 61		.audioSync = true,
 62		.volume = 0x100,
 63	};
 64
 65	struct mArguments args;
 66	struct mGraphicsOpts graphicsOpts;
 67
 68	struct mSubParser subparser;
 69
 70	initParserForGraphics(&subparser, &graphicsOpts);
 71	bool parsed = parseArguments(&args, argc, argv, &subparser);
 72	if (!args.fname && !args.showVersion) {
 73		parsed = false;
 74	}
 75	if (!parsed || args.showHelp) {
 76		usage(argv[0], subparser.usage);
 77		freeArguments(&args);
 78		return !parsed;
 79	}
 80	if (args.showVersion) {
 81		version(argv[0]);
 82		freeArguments(&args);
 83		return 0;
 84	}
 85
 86	if (SDL_Init(SDL_INIT_VIDEO) < 0) {
 87		printf("Could not initialize video: %s\n", SDL_GetError());
 88		freeArguments(&args);
 89		return 1;
 90	}
 91
 92	renderer.core = mCoreFind(args.fname);
 93	if (!renderer.core) {
 94		printf("Could not run game. Are you sure the file exists and is a compatible game?\n");
 95		freeArguments(&args);
 96		return 1;
 97	}
 98
 99	if (!renderer.core->init(renderer.core)) {
100		freeArguments(&args);
101		return 1;
102	}
103
104	renderer.core->desiredVideoDimensions(renderer.core, &renderer.width, &renderer.height);
105	renderer.ratio = graphicsOpts.multiplier;
106	if (renderer.ratio == 0) {
107		renderer.ratio = 1;
108	}
109	opts.width = renderer.width * renderer.ratio;
110	opts.height = renderer.height * renderer.ratio;
111
112	struct mCheatDevice* device = NULL;
113	if (args.cheatsFile && (device = renderer.core->cheatDevice(renderer.core))) {
114		struct VFile* vf = VFileOpen(args.cheatsFile, O_RDONLY);
115		if (vf) {
116			mCheatDeviceClear(device);
117			mCheatParseFile(device, vf);
118			vf->close(vf);
119		}
120	}
121
122	mInputMapInit(&renderer.core->inputMap, &GBAInputInfo);
123	mCoreInitConfig(renderer.core, PORT);
124	applyArguments(&args, &subparser, &renderer.core->config);
125
126	mCoreConfigLoadDefaults(&renderer.core->config, &opts);
127	mCoreLoadConfig(renderer.core);
128
129	renderer.viewportWidth = renderer.core->opts.width;
130	renderer.viewportHeight = renderer.core->opts.height;
131	renderer.player.fullscreen = renderer.core->opts.fullscreen;
132	renderer.player.windowUpdated = 0;
133
134	renderer.lockAspectRatio = renderer.core->opts.lockAspectRatio;
135	renderer.lockIntegerScaling = renderer.core->opts.lockIntegerScaling;
136	renderer.interframeBlending = renderer.core->opts.interframeBlending;
137	renderer.filter = renderer.core->opts.resampleVideo;
138
139#ifdef BUILD_GL
140	if (mSDLGLCommonInit(&renderer)) {
141		mSDLGLCreate(&renderer);
142	} else
143#elif defined(BUILD_GLES2) || defined(USE_EPOXY)
144#ifdef BUILD_RASPI
145	mRPIGLCommonInit(&renderer);
146#else
147	if (mSDLGLCommonInit(&renderer))
148#endif
149	{
150		mSDLGLES2Create(&renderer);
151	} else
152#endif
153	{
154		mSDLSWCreate(&renderer);
155	}
156
157	if (!renderer.init(&renderer)) {
158		freeArguments(&args);
159		mCoreConfigDeinit(&renderer.core->config);
160		renderer.core->deinit(renderer.core);
161		return 1;
162	}
163
164	renderer.player.bindings = &renderer.core->inputMap;
165	mSDLInitBindingsGBA(&renderer.core->inputMap);
166	mSDLInitEvents(&renderer.events);
167	mSDLEventsLoadConfig(&renderer.events, mCoreConfigGetInput(&renderer.core->config));
168	mSDLAttachPlayer(&renderer.events, &renderer.player);
169	mSDLPlayerLoadConfig(&renderer.player, mCoreConfigGetInput(&renderer.core->config));
170
171#if SDL_VERSION_ATLEAST(2, 0, 0)
172	renderer.core->setPeripheral(renderer.core, mPERIPH_RUMBLE, &renderer.player.rumble.d);
173#endif
174
175	int ret;
176
177	// TODO: Use opts and config
178	ret = mSDLRun(&renderer, &args);
179	mSDLDetachPlayer(&renderer.events, &renderer.player);
180	mInputMapDeinit(&renderer.core->inputMap);
181
182	if (device) {
183		mCheatDeviceDestroy(device);
184	}
185
186	mSDLDeinit(&renderer);
187
188	freeArguments(&args);
189	mCoreConfigFreeOpts(&opts);
190	mCoreConfigDeinit(&renderer.core->config);
191	renderer.core->deinit(renderer.core);
192
193	return ret;
194}
195
196#if defined(_WIN32) && !defined(_UNICODE)
197#include <mgba-util/string.h>
198
199int wmain(int argc, wchar_t** argv) {
200	char** argv8 = malloc(sizeof(char*) * argc);
201	int i;
202	for (i = 0; i < argc; ++i) {
203		argv8[i] = utf16to8((uint16_t*) argv[i], wcslen(argv[i]) * 2);
204	}
205	int ret = main(argc, argv8);
206	for (i = 0; i < argc; ++i) {
207		free(argv8[i]);
208	}
209	free(argv8);
210	return ret;
211}
212#endif
213
214int mSDLRun(struct mSDLRenderer* renderer, struct mArguments* args) {
215	struct mCoreThread thread = {
216		.core = renderer->core
217	};
218	if (!mCoreLoadFile(renderer->core, args->fname)) {
219		return 1;
220	}
221	mCoreAutoloadSave(renderer->core);
222	mCoreAutoloadCheats(renderer->core);
223#ifdef ENABLE_SCRIPTING
224	struct mScriptBridge* bridge = mScriptBridgeCreate();
225#ifdef ENABLE_PYTHON
226	mPythonSetup(bridge);
227#endif
228#ifdef USE_DEBUGGERS
229	CLIDebuggerScriptEngineInstall(bridge);
230#endif
231#endif
232
233#ifdef USE_DEBUGGERS
234	struct mDebugger* debugger = mDebuggerCreate(args->debuggerType, renderer->core);
235	if (debugger) {
236#ifdef USE_EDITLINE
237		if (args->debuggerType == DEBUGGER_CLI) {
238			struct CLIDebugger* cliDebugger = (struct CLIDebugger*) debugger;
239			CLIDebuggerAttachBackend(cliDebugger, CLIDebuggerEditLineBackendCreate());
240		}
241#endif
242		mDebuggerAttach(debugger, renderer->core);
243		mDebuggerEnter(debugger, DEBUGGER_ENTER_MANUAL, NULL);
244#ifdef ENABLE_SCRIPTING
245		mScriptBridgeSetDebugger(bridge, debugger);
246#endif
247	}
248#endif
249
250	if (args->patch) {
251		struct VFile* patch = VFileOpen(args->patch, O_RDONLY);
252		if (patch) {
253			renderer->core->loadPatch(renderer->core, patch);
254		}
255	} else {
256		mCoreAutoloadPatch(renderer->core);
257	}
258
259	renderer->audio.samples = renderer->core->opts.audioBuffers;
260	renderer->audio.sampleRate = 44100;
261
262	bool didFail = !mCoreThreadStart(&thread);
263	if (!didFail) {
264#if SDL_VERSION_ATLEAST(2, 0, 0)
265		renderer->core->desiredVideoDimensions(renderer->core, &renderer->width, &renderer->height);
266		unsigned width = renderer->width * renderer->ratio;
267		unsigned height = renderer->height * renderer->ratio;
268		if (width != (unsigned) renderer->viewportWidth && height != (unsigned) renderer->viewportHeight) {
269			SDL_SetWindowSize(renderer->window, width, height);
270			renderer->player.windowUpdated = 1;
271		}
272		mSDLSetScreensaverSuspendable(&renderer->events, renderer->core->opts.suspendScreensaver);
273		mSDLSuspendScreensaver(&renderer->events);
274#endif
275		if (mSDLInitAudio(&renderer->audio, &thread)) {
276			if (args->savestate) {
277				struct VFile* state = VFileOpen(args->savestate, O_RDONLY);
278				if (state) {
279					_state = state;
280					mCoreThreadRunFunction(&thread, _loadState);
281					_state = NULL;
282					state->close(state);
283				}
284			}
285			renderer->runloop(renderer, &thread);
286			mSDLPauseAudio(&renderer->audio);
287			if (mCoreThreadHasCrashed(&thread)) {
288				didFail = true;
289				printf("The game crashed!\n");
290			}
291		} else {
292			didFail = true;
293			printf("Could not initialize audio.\n");
294		}
295#if SDL_VERSION_ATLEAST(2, 0, 0)
296		mSDLResumeScreensaver(&renderer->events);
297		mSDLSetScreensaverSuspendable(&renderer->events, false);
298#endif
299
300		mCoreThreadJoin(&thread);
301	} else {
302		printf("Could not run game. Are you sure the file exists and is a compatible game?\n");
303	}
304	renderer->core->unloadROM(renderer->core);
305
306#ifdef ENABLE_SCRIPTING
307	mScriptBridgeDestroy(bridge);
308#endif
309
310	return didFail;
311}
312
313static void mSDLDeinit(struct mSDLRenderer* renderer) {
314	mSDLDeinitEvents(&renderer->events);
315	mSDLDeinitAudio(&renderer->audio);
316#if SDL_VERSION_ATLEAST(2, 0, 0)
317	SDL_DestroyWindow(renderer->window);
318#endif
319
320	renderer->deinit(renderer);
321
322	SDL_Quit();
323}