1 /* Copyright (c) 2013-2016 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 "gui-runner.h"
7
8 #include <mgba/core/core.h>
9 #include <mgba/core/serialize.h>
10 #include "feature/gui/gui-config.h"
11 #include <mgba/internal/gba/gba.h>
12 #include <mgba/internal/gba/input.h>
13 #include <mgba/gba/interface.h>
14 #include <mgba-util/gui/file-select.h>
15 #include <mgba-util/gui/font.h>
16 #include <mgba-util/gui/menu.h>
17 #include <mgba-util/memory.h>
18 #include <mgba-util/png-io.h>
19 #include <mgba-util/vfs.h>
20
21 #include <sys/time.h>
22
23 mLOG_DECLARE_CATEGORY(GUI_RUNNER);
24 mLOG_DEFINE_CATEGORY(GUI_RUNNER, "GUI Runner", "gui.runner");
25
26 #define AUTOSAVE_GRANULARITY 600
27 #define FPS_GRANULARITY 120
28 #define FPS_BUFFER_SIZE 3
29
30 enum {
31 RUNNER_CONTINUE = 1,
32 RUNNER_EXIT,
33 RUNNER_SAVE_STATE,
34 RUNNER_LOAD_STATE,
35 RUNNER_SCREENSHOT,
36 RUNNER_CONFIG,
37 RUNNER_RESET,
38 RUNNER_COMMAND_MASK = 0xFFFF
39 };
40
41 #define RUNNER_STATE(X) ((X) << 16)
42
43 enum {
44 SCREENSHOT_VALID = 0x10000,
45 SCREENSHOT_INVALID = 0x20000,
46 };
47
48 static const struct mInputPlatformInfo _mGUIKeyInfo = {
49 .platformName = "gui",
50 .keyId = (const char*[GUI_INPUT_MAX]) {
51 "Select",
52 "Back",
53 "Cancel",
54 "Up",
55 "Down",
56 "Left",
57 "Right",
58 [mGUI_INPUT_INCREASE_BRIGHTNESS] = "Increase solar brightness",
59 [mGUI_INPUT_DECREASE_BRIGHTNESS] = "Decrease solar brightness",
60 [mGUI_INPUT_SCREEN_MODE] = "Screen mode",
61 [mGUI_INPUT_SCREENSHOT] = "Take screenshot",
62 [mGUI_INPUT_FAST_FORWARD_HELD] = "Fast forward (held)",
63 [mGUI_INPUT_FAST_FORWARD_TOGGLE] = "Fast forward (toggle)",
64 [mGUI_INPUT_MUTE_TOGGLE] = "Mute (toggle)",
65 },
66 .nKeys = GUI_INPUT_MAX
67 };
68
69 static void _log(struct mLogger*, int category, enum mLogLevel level, const char* format, va_list args);
70
71 static struct mGUILogger {
72 struct mLogger d;
73 struct VFile* vf;
74 int logLevel;
75 } logger = {
76 .d = {
77 .log = _log
78 },
79 .vf = NULL,
80 .logLevel = 0
81 };
82
_testExtensions(const char * name)83 static bool _testExtensions(const char* name) {
84 char ext[PATH_MAX] = {};
85 separatePath(name, NULL, NULL, ext);
86
87 if (!strncmp(ext, "sav", PATH_MAX)) {
88 return false;
89 }
90 if (!strncmp(ext, "png", PATH_MAX)) {
91 return false;
92 }
93 if (!strncmp(ext, "ini", PATH_MAX)) {
94 return false;
95 }
96 if (!strncmp(ext, "ss", 2)) {
97 return false;
98 }
99
100 return true;
101 }
102
_drawBackground(struct GUIBackground * background,void * context)103 static void _drawBackground(struct GUIBackground* background, void* context) {
104 UNUSED(context);
105 struct mGUIBackground* gbaBackground = (struct mGUIBackground*) background;
106 if (gbaBackground->p->drawFrame) {
107 gbaBackground->p->drawFrame(gbaBackground->p, true);
108 }
109 }
110
_drawState(struct GUIBackground * background,void * id)111 static void _drawState(struct GUIBackground* background, void* id) {
112 struct mGUIBackground* gbaBackground = (struct mGUIBackground*) background;
113 unsigned stateId = ((uint32_t) id) >> 16;
114 if (gbaBackground->p->drawScreenshot) {
115 unsigned w, h;
116 gbaBackground->p->core->desiredVideoDimensions(gbaBackground->p->core, &w, &h);
117 size_t size = w * h * BYTES_PER_PIXEL;
118 if (size != gbaBackground->imageSize) {
119 mappedMemoryFree(gbaBackground->image, gbaBackground->imageSize);
120 gbaBackground->image = NULL;
121 }
122 if (gbaBackground->image && gbaBackground->screenshotId == (stateId | SCREENSHOT_VALID)) {
123 gbaBackground->p->drawScreenshot(gbaBackground->p, gbaBackground->image, w, h, true);
124 return;
125 } else if (gbaBackground->screenshotId != (stateId | SCREENSHOT_INVALID)) {
126 struct VFile* vf = mCoreGetState(gbaBackground->p->core, stateId, false);
127 color_t* pixels = gbaBackground->image;
128 if (!pixels) {
129 pixels = anonymousMemoryMap(size);
130 gbaBackground->image = pixels;
131 gbaBackground->imageSize = size;
132 }
133 bool success = false;
134 if (vf && isPNG(vf) && pixels) {
135 png_structp png = PNGReadOpen(vf, PNG_HEADER_BYTES);
136 png_infop info = png_create_info_struct(png);
137 png_infop end = png_create_info_struct(png);
138 if (png && info && end) {
139 success = PNGReadHeader(png, info);
140 success = success && PNGReadPixels(png, info, pixels, w, h, w);
141 success = success && PNGReadFooter(png, end);
142 }
143 PNGReadClose(png, info, end);
144 }
145 if (vf) {
146 vf->close(vf);
147 }
148 if (success) {
149 gbaBackground->p->drawScreenshot(gbaBackground->p, pixels, w, h, true);
150 gbaBackground->screenshotId = stateId | SCREENSHOT_VALID;
151 } else {
152 gbaBackground->screenshotId = stateId | SCREENSHOT_INVALID;
153 }
154 }
155 if (gbaBackground->p->drawFrame && gbaBackground->screenshotId == (stateId | SCREENSHOT_INVALID)) {
156 gbaBackground->p->drawFrame(gbaBackground->p, true);
157 }
158 }
159 }
160
_updateLux(struct GBALuminanceSource * lux)161 static void _updateLux(struct GBALuminanceSource* lux) {
162 UNUSED(lux);
163 }
164
_readLux(struct GBALuminanceSource * lux)165 static uint8_t _readLux(struct GBALuminanceSource* lux) {
166 struct mGUIRunnerLux* runnerLux = (struct mGUIRunnerLux*) lux;
167 int value = 0x16;
168 if (runnerLux->luxLevel > 0) {
169 value += GBA_LUX_LEVELS[runnerLux->luxLevel - 1];
170 }
171 return 0xFF - value;
172 }
173
_tryAutosave(struct mGUIRunner * runner)174 static void _tryAutosave(struct mGUIRunner* runner) {
175 int autosave = false;
176 mCoreConfigGetIntValue(&runner->config, "autosave", &autosave);
177 if (!autosave) {
178 return;
179 }
180
181 #ifdef DISABLE_THREADING
182 mCoreSaveState(runner->core, 0, SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
183 #else
184 if (!runner->autosave.buffer) {
185 runner->autosave.buffer = VFileMemChunk(NULL, 0);
186 }
187 MutexLock(&runner->autosave.mutex);
188 runner->autosave.core = runner->core;
189 mCoreSaveStateNamed(runner->core, runner->autosave.buffer, SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
190 ConditionWake(&runner->autosave.cond);
191 MutexUnlock(&runner->autosave.mutex);
192 #endif
193 }
194
mGUIInit(struct mGUIRunner * runner,const char * port)195 void mGUIInit(struct mGUIRunner* runner, const char* port) {
196 GUIInit(&runner->params);
197 runner->port = port;
198 runner->core = NULL;
199 runner->luminanceSource.d.readLuminance = _readLux;
200 runner->luminanceSource.d.sample = _updateLux;
201 runner->luminanceSource.luxLevel = 0;
202 runner->background.d.draw = _drawBackground;
203 runner->background.p = runner;
204 runner->fps = 0;
205 runner->lastFpsCheck = 0;
206 runner->totalDelta = 0;
207 CircleBufferInit(&runner->fpsBuffer, FPS_BUFFER_SIZE * sizeof(uint32_t));
208
209 mInputMapInit(&runner->params.keyMap, &_mGUIKeyInfo);
210 mCoreConfigInit(&runner->config, runner->port);
211 // TODO: Do we need to load more defaults?
212 mCoreConfigSetDefaultIntValue(&runner->config, "volume", 0x100);
213 mCoreConfigSetDefaultValue(&runner->config, "idleOptimization", "detect");
214 mCoreConfigSetDefaultIntValue(&runner->config, "autoload", true);
215 #ifdef DISABLE_THREADING
216 mCoreConfigSetDefaultIntValue(&runner->config, "autosave", false);
217 #else
218 mCoreConfigSetDefaultIntValue(&runner->config, "autosave", true);
219 #endif
220 mCoreConfigSetDefaultIntValue(&runner->config, "showOSD", true);
221 mCoreConfigLoad(&runner->config);
222 mCoreConfigGetIntValue(&runner->config, "logLevel", &logger.logLevel);
223
224 char path[PATH_MAX];
225 mCoreConfigDirectory(path, PATH_MAX);
226 strncat(path, PATH_SEP "log", PATH_MAX - strlen(path));
227 logger.vf = VFileOpen(path, O_CREAT | O_WRONLY | O_APPEND);
228 mLogSetDefaultLogger(&logger.d);
229
230 const char* lastPath = mCoreConfigGetValue(&runner->config, "lastDirectory");
231 if (lastPath) {
232 struct VDir* dir = VDirOpen(lastPath);
233 if (dir) {
234 dir->close(dir);
235 strncpy(runner->params.currentPath, lastPath, PATH_MAX - 1);
236 runner->params.currentPath[PATH_MAX - 1] = '\0';
237 }
238 }
239
240 #ifndef DISABLE_THREADING
241 if (!runner->autosave.running) {
242 runner->autosave.running = true;
243 runner->autosave.core = NULL;
244 MutexInit(&runner->autosave.mutex);
245 ConditionInit(&runner->autosave.cond);
246 ThreadCreate(&runner->autosave.thread, mGUIAutosaveThread, &runner->autosave);
247 }
248 #endif
249 }
250
mGUIDeinit(struct mGUIRunner * runner)251 void mGUIDeinit(struct mGUIRunner* runner) {
252 #ifndef DISABLE_THREADING
253 MutexLock(&runner->autosave.mutex);
254 runner->autosave.running = false;
255 ConditionWake(&runner->autosave.cond);
256 MutexUnlock(&runner->autosave.mutex);
257
258 ThreadJoin(&runner->autosave.thread);
259
260 ConditionDeinit(&runner->autosave.cond);
261 MutexDeinit(&runner->autosave.mutex);
262
263 if (runner->autosave.buffer) {
264 runner->autosave.buffer->close(runner->autosave.buffer);
265 }
266 #endif
267
268 if (runner->teardown) {
269 runner->teardown(runner);
270 }
271 CircleBufferDeinit(&runner->fpsBuffer);
272 mInputMapDeinit(&runner->params.keyMap);
273 mCoreConfigDeinit(&runner->config);
274 if (logger.vf) {
275 logger.vf->close(logger.vf);
276 logger.vf = NULL;
277 }
278 }
279
_log(struct mLogger * logger,int category,enum mLogLevel level,const char * format,va_list args)280 static void _log(struct mLogger* logger, int category, enum mLogLevel level, const char* format, va_list args) {
281 struct mGUILogger* guiLogger = (struct mGUILogger*) logger;
282 if (!guiLogger->vf) {
283 return;
284 }
285 if (!(guiLogger->logLevel & level)) {
286 return;
287 }
288
289 char log[256] = {0};
290 vsnprintf(log, sizeof(log) - 1, format, args);
291 char log2[256] = {0};
292 size_t len = snprintf(log2, sizeof(log2) - 1, "%s: %s\n", mLogCategoryName(category), log);
293 if (len >= sizeof(log2)) {
294 len = sizeof(log2) - 1;
295 }
296 if (guiLogger->vf->write(guiLogger->vf, log2, len) < 0) {
297 char path[PATH_MAX];
298 mCoreConfigDirectory(path, PATH_MAX);
299 strncat(path, PATH_SEP "log", PATH_MAX - strlen(path));
300 guiLogger->vf->close(guiLogger->vf);
301 guiLogger->vf = VFileOpen(path, O_CREAT | O_WRONLY | O_APPEND);
302 if (guiLogger->vf->write(guiLogger->vf, log2, len) < 0) {
303 guiLogger->vf->close(guiLogger->vf);
304 guiLogger->vf = NULL;
305 }
306 }
307 #ifdef GEKKO
308 puts(log2);
309 #endif
310 }
311
_updateLoading(size_t read,size_t size,void * context)312 static void _updateLoading(size_t read, size_t size, void* context) {
313 struct mGUIRunner* runner = context;
314 runner->params.drawStart();
315 if (runner->params.guiPrepare) {
316 runner->params.guiPrepare();
317 }
318 GUIFontPrintf(runner->params.font, runner->params.width / 2, (GUIFontHeight(runner->params.font) + runner->params.height) / 2, GUI_ALIGN_HCENTER, 0xFFFFFFFF, "Loading...%i%%", 100 * read / size);
319 if (runner->params.guiFinish) {
320 runner->params.guiFinish();
321 }
322 runner->params.drawEnd();
323 }
324
mGUIRun(struct mGUIRunner * runner,const char * path)325 void mGUIRun(struct mGUIRunner* runner, const char* path) {
326 struct mGUIBackground drawState = {
327 .d = {
328 .draw = _drawState
329 },
330 .p = runner,
331 .image = 0,
332 .screenshotId = 0
333 };
334 struct GUIMenu pauseMenu = {
335 .title = "Game Paused",
336 .index = 0,
337 .background = &runner->background.d
338 };
339 struct GUIMenu stateSaveMenu = {
340 .title = "Save state",
341 .index = 0,
342 .background = &drawState.d
343 };
344 struct GUIMenu stateLoadMenu = {
345 .title = "Load state",
346 .index = 0,
347 .background = &drawState.d
348 };
349 GUIMenuItemListInit(&pauseMenu.items, 0);
350 GUIMenuItemListInit(&stateSaveMenu.items, 9);
351 GUIMenuItemListInit(&stateLoadMenu.items, 9);
352 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Unpause", .data = (void*) RUNNER_CONTINUE };
353 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Save state", .submenu = &stateSaveMenu };
354 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Load state", .submenu = &stateLoadMenu };
355
356 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(1)) };
357 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(2)) };
358 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(3)) };
359 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(4)) };
360 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(5)) };
361 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(6)) };
362 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(7)) };
363 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(8)) };
364 *GUIMenuItemListAppend(&stateSaveMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_SAVE_STATE | RUNNER_STATE(9)) };
365
366 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "Autosave", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(0)) };
367 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 1", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(1)) };
368 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 2", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(2)) };
369 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 3", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(3)) };
370 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 4", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(4)) };
371 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 5", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(5)) };
372 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 6", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(6)) };
373 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 7", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(7)) };
374 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 8", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(8)) };
375 *GUIMenuItemListAppend(&stateLoadMenu.items) = (struct GUIMenuItem) { .title = "State 9", .data = (void*) (RUNNER_LOAD_STATE | RUNNER_STATE(9)) };
376
377 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Take screenshot", .data = (void*) RUNNER_SCREENSHOT };
378 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Configure", .data = (void*) RUNNER_CONFIG };
379 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Reset game", .data = (void*) RUNNER_RESET };
380 *GUIMenuItemListAppend(&pauseMenu.items) = (struct GUIMenuItem) { .title = "Exit game", .data = (void*) RUNNER_EXIT };
381
382 runner->params.drawStart();
383 if (runner->params.guiPrepare) {
384 runner->params.guiPrepare();
385 }
386 GUIFontPrint(runner->params.font, runner->params.width / 2, (GUIFontHeight(runner->params.font) + runner->params.height) / 2, GUI_ALIGN_HCENTER, 0xFFFFFFFF, "Loading...");
387 if (runner->params.guiFinish) {
388 runner->params.guiFinish();
389 }
390 runner->params.drawEnd();
391
392 bool found = false;
393 mLOG(GUI_RUNNER, INFO, "Attempting to load %s", path);
394 runner->core = mCoreFind(path);
395 if (runner->core) {
396 mLOG(GUI_RUNNER, INFO, "Found core");
397 runner->core->init(runner->core);
398 mCoreInitConfig(runner->core, runner->port);
399 mInputMapInit(&runner->core->inputMap, &GBAInputInfo);
400
401 struct VFile* rom = mDirectorySetOpenPath(&runner->core->dirs, path, runner->core->isROM);
402 if (runner->setFrameLimiter) {
403 runner->setFrameLimiter(runner, false);
404 }
405 found = mCorePreloadVFCB(runner->core, rom, _updateLoading, runner);
406 if (runner->setFrameLimiter) {
407 runner->setFrameLimiter(runner, true);
408 }
409
410 #ifdef FIXED_ROM_BUFFER
411 extern size_t romBufferSize;
412 if (!found && rom && (size_t) rom->size(rom) > romBufferSize) {
413 found = runner->core->loadROM(runner->core, rom);
414 }
415 #endif
416 if (!found) {
417 if (rom) {
418 rom->close(rom);
419 }
420 mLOG(GUI_RUNNER, WARN, "Failed to load %s!", path);
421 mCoreConfigDeinit(&runner->core->config);
422 runner->core->deinit(runner->core);
423 }
424 }
425
426 if (!found) {
427 mLOG(GUI_RUNNER, WARN, "Failed to find core for %s!", path);
428 GUIShowMessageBox(&runner->params, GUI_MESSAGE_BOX_OK, 240, "Load failed!");
429 return;
430 }
431 if (runner->core->platform(runner->core) == mPLATFORM_GBA) {
432 runner->core->setPeripheral(runner->core, mPERIPH_GBA_LUMINANCE, &runner->luminanceSource.d);
433 }
434 mLOG(GUI_RUNNER, DEBUG, "Loading config...");
435 mCoreLoadForeignConfig(runner->core, &runner->config);
436
437 mLOG(GUI_RUNNER, DEBUG, "Loading save...");
438 mCoreAutoloadSave(runner->core);
439 mCoreAutoloadCheats(runner->core);
440 if (runner->setup) {
441 mLOG(GUI_RUNNER, DEBUG, "Setting up runner...");
442 runner->setup(runner);
443 }
444 if (runner->config.port && runner->keySources) {
445 mLOG(GUI_RUNNER, DEBUG, "Loading key sources for %s...", runner->config.port);
446 size_t i;
447 for (i = 0; runner->keySources[i].id; ++i) {
448 mInputMapLoad(&runner->core->inputMap, runner->keySources[i].id, mCoreConfigGetInput(&runner->config));
449 }
450 }
451 mLOG(GUI_RUNNER, DEBUG, "Reseting...");
452 runner->core->reset(runner->core);
453 mLOG(GUI_RUNNER, DEBUG, "Reset!");
454
455
456 int autoload = false;
457 mCoreConfigGetIntValue(&runner->config, "autoload", &autoload);
458 if (autoload) {
459 mCoreLoadState(runner->core, 0, SAVESTATE_SCREENSHOT | SAVESTATE_RTC);
460 }
461
462 int showOSD = true;
463 mCoreConfigGetIntValue(&runner->config, "showOSD", &showOSD);
464
465 int drawFps = false;
466 mCoreConfigGetIntValue(&runner->config, "fpsCounter", &drawFps);
467
468 bool running = true;
469
470 #ifndef DISABLE_THREADING
471 MutexLock(&runner->autosave.mutex);
472 runner->autosave.core = runner->core;
473 MutexUnlock(&runner->autosave.mutex);
474 #endif
475
476 if (runner->gameLoaded) {
477 runner->gameLoaded(runner);
478 }
479 mLOG(GUI_RUNNER, INFO, "Game starting");
480 while (running) {
481 CircleBufferClear(&runner->fpsBuffer);
482 runner->totalDelta = 0;
483 runner->fps = 0;
484 struct timeval tv;
485 gettimeofday(&tv, 0);
486 runner->lastFpsCheck = 1000000LL * tv.tv_sec + tv.tv_usec;
487
488 int frame = 0;
489 bool fastForward = false;
490 while (running) {
491 if (runner->running) {
492 running = runner->running(runner);
493 if (!running) {
494 break;
495 }
496 }
497 uint32_t guiKeys;
498 uint32_t heldKeys;
499 GUIPollInput(&runner->params, &guiKeys, &heldKeys);
500 if (guiKeys & (1 << GUI_INPUT_CANCEL)) {
501 break;
502 }
503 if (guiKeys & (1 << mGUI_INPUT_INCREASE_BRIGHTNESS)) {
504 if (runner->luminanceSource.luxLevel < 10) {
505 ++runner->luminanceSource.luxLevel;
506 }
507 }
508 if (guiKeys & (1 << mGUI_INPUT_DECREASE_BRIGHTNESS)) {
509 if (runner->luminanceSource.luxLevel > 0) {
510 --runner->luminanceSource.luxLevel;
511 }
512 }
513 if (guiKeys & (1 << mGUI_INPUT_SCREEN_MODE) && runner->incrementScreenMode) {
514 runner->incrementScreenMode(runner);
515 }
516 if (guiKeys & (1 << mGUI_INPUT_SCREENSHOT)) {
517 mCoreTakeScreenshot(runner->core);
518 }
519 if (runner->setFrameLimiter) {
520 if (guiKeys & (1 << mGUI_INPUT_FAST_FORWARD_TOGGLE)) {
521 fastForward = !fastForward;
522 }
523 if (fastForward || (heldKeys & (1 << mGUI_INPUT_FAST_FORWARD_HELD))) {
524 runner->setFrameLimiter(runner, false);
525 } else {
526 runner->setFrameLimiter(runner, true);
527 }
528 }
529 if (guiKeys & (1 << mGUI_INPUT_MUTE_TOGGLE)) {
530 int mute = !runner->core->opts.mute;
531 mCoreConfigSetUIntValue(&runner->config, "mute", mute);
532 runner->core->reloadConfigOption(runner->core, "mute", &runner->config);
533 }
534 uint16_t keys = runner->pollGameInput(runner);
535 if (runner->prepareForFrame) {
536 runner->prepareForFrame(runner);
537 }
538 runner->core->setKeys(runner->core, keys);
539 runner->core->runFrame(runner->core);
540 if (runner->drawFrame) {
541 runner->params.drawStart();
542 runner->drawFrame(runner, false);
543 if (showOSD || drawFps) {
544 if (runner->params.guiPrepare) {
545 runner->params.guiPrepare();
546 }
547 if (drawFps) {
548 GUIFontPrintf(runner->params.font, 0, GUIFontHeight(runner->params.font), GUI_ALIGN_LEFT, 0x7FFFFFFF, "%.2f fps", runner->fps);
549 }
550 if (showOSD) {
551 unsigned origin = runner->params.width - GUIFontHeight(runner->params.font) / 2;
552 unsigned w;
553 if (fastForward || (heldKeys & (1 << mGUI_INPUT_FAST_FORWARD_HELD))) {
554 GUIFontDrawIcon(runner->params.font, origin, GUIFontHeight(runner->params.font) / 2, GUI_ALIGN_RIGHT, 0, 0x7FFFFFFF, GUI_ICON_STATUS_FAST_FORWARD);
555 GUIFontIconMetrics(runner->params.font, GUI_ICON_STATUS_FAST_FORWARD, &w, NULL);
556 origin -= w + GUIFontHeight(runner->params.font) / 2;
557 }
558 if (runner->core->opts.mute) {
559 GUIFontDrawIcon(runner->params.font, origin, GUIFontHeight(runner->params.font) / 2, GUI_ALIGN_RIGHT, 0, 0x7FFFFFFF, GUI_ICON_STATUS_MUTE);
560 GUIFontIconMetrics(runner->params.font, GUI_ICON_STATUS_MUTE, &w, NULL);
561 origin -= w + GUIFontHeight(runner->params.font) / 2;
562 }
563 }
564 if (runner->params.guiFinish) {
565 runner->params.guiFinish();
566 }
567 }
568 runner->params.drawEnd();
569
570 if (runner->core->frameCounter(runner->core) % FPS_GRANULARITY == 0) {
571 if (drawFps) {
572 struct timeval tv;
573 gettimeofday(&tv, 0);
574 uint64_t t = 1000000LL * tv.tv_sec + tv.tv_usec;
575 uint64_t delta = t - runner->lastFpsCheck;
576 runner->lastFpsCheck = t;
577 if (delta > 0x7FFFFFFFLL) {
578 CircleBufferClear(&runner->fpsBuffer);
579 runner->fps = 0;
580 }
581 if (CircleBufferSize(&runner->fpsBuffer) == CircleBufferCapacity(&runner->fpsBuffer)) {
582 int32_t last;
583 CircleBufferRead32(&runner->fpsBuffer, &last);
584 runner->totalDelta -= last;
585 }
586 CircleBufferWrite32(&runner->fpsBuffer, delta);
587 runner->totalDelta += delta;
588 runner->fps = (CircleBufferSize(&runner->fpsBuffer) * FPS_GRANULARITY * 1000000.0f) / (runner->totalDelta * sizeof(uint32_t));
589 }
590 }
591 if (frame == AUTOSAVE_GRANULARITY) {
592 frame = 0;
593 _tryAutosave(runner);
594 }
595 ++frame;
596 }
597 }
598 if (!running) {
599 break;
600 }
601
602 if (runner->paused) {
603 runner->paused(runner);
604 }
605 if (runner->setFrameLimiter) {
606 runner->setFrameLimiter(runner, true);
607 }
608
609 GUIInvalidateKeys(&runner->params);
610 uint32_t keys = 0xFFFFFFFF; // Huge hack to avoid an extra variable!
611 struct GUIMenuItem* item;
612 enum GUIMenuExitReason reason = GUIShowMenu(&runner->params, &pauseMenu, &item);
613 if (reason == GUI_MENU_EXIT_ACCEPT) {
614 switch (((int) item->data) & RUNNER_COMMAND_MASK) {
615 case RUNNER_EXIT:
616 running = false;
617 keys = 0;
618 break;
619 case RUNNER_RESET:
620 runner->core->reset(runner->core);
621 break;
622 case RUNNER_SAVE_STATE:
623 mCoreSaveState(runner->core, ((uint32_t) item->data) >> 16, SAVESTATE_SCREENSHOT | SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
624 break;
625 case RUNNER_LOAD_STATE:
626 mCoreLoadState(runner->core, ((uint32_t) item->data) >> 16, SAVESTATE_SCREENSHOT | SAVESTATE_RTC);
627 break;
628 case RUNNER_SCREENSHOT:
629 mCoreTakeScreenshot(runner->core);
630 break;
631 case RUNNER_CONFIG:
632 mGUIShowConfig(runner, runner->configExtra, runner->nConfigExtra);
633 break;
634 case RUNNER_CONTINUE:
635 break;
636 }
637 }
638 int frames = 0;
639 GUIPollInput(&runner->params, 0, &keys);
640 while (keys && frames < 30) {
641 #ifdef _3DS
642 if (!frames) {
643 #endif
644 runner->params.drawStart();
645 runner->drawFrame(runner, true);
646 runner->params.drawEnd();
647 #ifdef _3DS
648 } else {
649 // XXX: Why does this fix #1294?
650 usleep(15000);
651 }
652 #endif
653 ++frames;
654 GUIPollInput(&runner->params, 0, &keys);
655 }
656 if (runner->unpaused) {
657 runner->unpaused(runner);
658 }
659 mCoreConfigGetIntValue(&runner->config, "fpsCounter", &drawFps);
660 mCoreConfigGetIntValue(&runner->config, "showOSD", &showOSD);
661 }
662 mLOG(GUI_RUNNER, DEBUG, "Shutting down...");
663 if (runner->gameUnloaded) {
664 runner->gameUnloaded(runner);
665 }
666 #ifndef DISABLE_THREADING
667 MutexLock(&runner->autosave.mutex);
668 runner->autosave.core = NULL;
669 MutexUnlock(&runner->autosave.mutex);
670 #endif
671
672 int autosave = false;
673 mCoreConfigGetIntValue(&runner->config, "autosave", &autosave);
674 if (autosave) {
675 mCoreSaveState(runner->core, 0, SAVESTATE_SAVEDATA | SAVESTATE_RTC | SAVESTATE_METADATA);
676 }
677
678 mLOG(GUI_RUNNER, DEBUG, "Unloading game...");
679 runner->core->unloadROM(runner->core);
680 drawState.screenshotId = 0;
681 if (drawState.image) {
682 mappedMemoryFree(drawState.image, drawState.imageSize);
683 }
684
685 if (runner->config.port) {
686 mLOG(GUI_RUNNER, DEBUG, "Saving key sources...");
687 if (runner->keySources) {
688 size_t i;
689 for (i = 0; runner->keySources[i].id; ++i) {
690 mInputMapSave(&runner->core->inputMap, runner->keySources[i].id, mCoreConfigGetInput(&runner->config));
691 mInputMapSave(&runner->params.keyMap, runner->keySources[i].id, mCoreConfigGetInput(&runner->config));
692 }
693 }
694 mCoreConfigSave(&runner->config);
695 }
696 mInputMapDeinit(&runner->core->inputMap);
697 mLOG(GUI_RUNNER, DEBUG, "Deinitializing core...");
698 mCoreConfigDeinit(&runner->core->config);
699 runner->core->deinit(runner->core);
700 runner->core = NULL;
701
702 GUIMenuItemListDeinit(&pauseMenu.items);
703 GUIMenuItemListDeinit(&stateSaveMenu.items);
704 GUIMenuItemListDeinit(&stateLoadMenu.items);
705 mLOG(GUI_RUNNER, INFO, "Game stopped!");
706 }
707
mGUIRunloop(struct mGUIRunner * runner)708 void mGUIRunloop(struct mGUIRunner* runner) {
709 if (runner->keySources) {
710 mLOG(GUI_RUNNER, DEBUG, "Loading key sources for %s...", runner->config.port);
711 size_t i;
712 for (i = 0; runner->keySources[i].id; ++i) {
713 mInputMapLoad(&runner->params.keyMap, runner->keySources[i].id, mCoreConfigGetInput(&runner->config));
714 }
715 }
716 while (!runner->running || runner->running(runner)) {
717 char path[PATH_MAX];
718 const char* preselect = mCoreConfigGetValue(&runner->config, "lastGame");
719 if (preselect) {
720 preselect = strrchr(preselect, '/');
721 }
722 if (preselect) {
723 ++preselect;
724 }
725 if (!GUISelectFile(&runner->params, path, sizeof(path), _testExtensions, NULL, preselect)) {
726 break;
727 }
728 mCoreConfigSetValue(&runner->config, "lastDirectory", runner->params.currentPath);
729 mCoreConfigSetValue(&runner->config, "lastGame", path);
730 mCoreConfigSave(&runner->config);
731 mGUIRun(runner, path);
732 }
733 }
734
735 #ifndef DISABLE_THREADING
mGUIAutosaveThread(void * context)736 THREAD_ENTRY mGUIAutosaveThread(void* context) {
737 struct mGUIAutosaveContext* autosave = context;
738 MutexLock(&autosave->mutex);
739 while (autosave->running) {
740 ConditionWait(&autosave->cond, &autosave->mutex);
741 if (autosave->running && autosave->core) {
742 struct VFile* vf = mCoreGetState(autosave->core, 0, true);
743 void* mem = autosave->buffer->map(autosave->buffer, autosave->buffer->size(autosave->buffer), MAP_READ);
744 vf->write(vf, mem, autosave->buffer->size(autosave->buffer));
745 autosave->buffer->unmap(autosave->buffer, mem, autosave->buffer->size(autosave->buffer));
746 vf->close(vf);
747 }
748 }
749 MutexUnlock(&autosave->mutex);
750 }
751 #endif
752