src/platform/libretro/libretro.c (view raw)
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 "libretro.h"
7
8#include "util/common.h"
9
10#include "gba/cheats.h"
11#include "gba/renderers/video-software.h"
12#include "gba/serialize.h"
13#include "gba/context/context.h"
14#include "util/circle-buffer.h"
15#include "util/memory.h"
16#include "util/vfs.h"
17
18#define SAMPLES 1024
19#define RUMBLE_PWM 35
20
21static retro_environment_t environCallback;
22static retro_video_refresh_t videoCallback;
23static retro_audio_sample_batch_t audioCallback;
24static retro_input_poll_t inputPollCallback;
25static retro_input_state_t inputCallback;
26static retro_log_printf_t logCallback;
27static retro_set_rumble_state_t rumbleCallback;
28
29static void GBARetroLog(struct GBAThread* thread, enum GBALogLevel level, const char* format, va_list args);
30
31static void _postAudioBuffer(struct GBAAVStream*, struct GBAAudio* audio);
32static void _setRumble(struct mRumble* rumble, int enable);
33static uint8_t _readLux(struct GBALuminanceSource* lux);
34static void _updateLux(struct GBALuminanceSource* lux);
35
36static struct GBAContext context;
37static struct GBAVideoSoftwareRenderer renderer;
38static void* data;
39static size_t dataSize;
40static void* savedata;
41static struct GBAAVStream stream;
42static int rumbleLevel;
43static struct CircleBuffer rumbleHistory;
44static struct mRumble rumble;
45static struct GBALuminanceSource lux;
46static int luxLevel;
47static struct GBACheatDevice cheats;
48static struct GBACheatSet cheatSet;
49
50static void _reloadSettings(void) {
51 struct mCoreOptions opts = {
52 .useBios = true,
53 };
54
55 struct retro_variable var;
56
57 var.key = "mgba_use_bios";
58 var.value = 0;
59 if (environCallback(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
60 opts.useBios = strcmp(var.value, "ON") == 0;
61 }
62
63 var.key = "mgba_skip_bios";
64 var.value = 0;
65 if (environCallback(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
66 opts.skipBios = strcmp(var.value, "ON") == 0;
67 }
68
69 var.key = "mgba_idle_optimization";
70 var.value = 0;
71 if (environCallback(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
72 if (strcmp(var.value, "Don't Remove") == 0) {
73 mCoreConfigSetDefaultIntValue(&context.config, "idleOptimization", IDLE_LOOP_IGNORE);
74 } else if (strcmp(var.value, "Remove Known") == 0) {
75 mCoreConfigSetDefaultIntValue(&context.config, "idleOptimization", IDLE_LOOP_REMOVE);
76 } else if (strcmp(var.value, "Detect and Remove") == 0) {
77 mCoreConfigSetDefaultIntValue(&context.config, "idleOptimization", IDLE_LOOP_DETECT);
78 }
79 }
80
81 mCoreConfigLoadDefaults(&context.config, &opts);
82}
83
84unsigned retro_api_version(void) {
85 return RETRO_API_VERSION;
86}
87
88void retro_set_environment(retro_environment_t env) {
89 environCallback = env;
90
91 struct retro_variable vars[] = {
92 { "mgba_solar_sensor_level", "Solar sensor level; 0|1|2|3|4|5|6|7|8|9|10" },
93 { "mgba_allow_opposing_directions", "Allow opposing directional input; OFF|ON" },
94 { "mgba_use_bios", "Use BIOS file if found; ON|OFF" },
95 { "mgba_skip_bios", "Skip BIOS intro; OFF|ON" },
96 { "mgba_idle_optimization", "Idle loop removal; Remove Known|Detect and Remove|Don't Remove" },
97 { 0, 0 }
98 };
99
100 environCallback(RETRO_ENVIRONMENT_SET_VARIABLES, vars);
101}
102
103void retro_set_video_refresh(retro_video_refresh_t video) {
104 videoCallback = video;
105}
106
107void retro_set_audio_sample(retro_audio_sample_t audio) {
108 UNUSED(audio);
109}
110
111void retro_set_audio_sample_batch(retro_audio_sample_batch_t audioBatch) {
112 audioCallback = audioBatch;
113}
114
115void retro_set_input_poll(retro_input_poll_t inputPoll) {
116 inputPollCallback = inputPoll;
117}
118
119void retro_set_input_state(retro_input_state_t input) {
120 inputCallback = input;
121}
122
123void retro_get_system_info(struct retro_system_info* info) {
124 info->need_fullpath = false;
125 info->valid_extensions = "gba";
126 info->library_version = projectVersion;
127 info->library_name = projectName;
128 info->block_extract = false;
129}
130
131void retro_get_system_av_info(struct retro_system_av_info* info) {
132 info->geometry.base_width = VIDEO_HORIZONTAL_PIXELS;
133 info->geometry.base_height = VIDEO_VERTICAL_PIXELS;
134 info->geometry.max_width = VIDEO_HORIZONTAL_PIXELS;
135 info->geometry.max_height = VIDEO_VERTICAL_PIXELS;
136 info->geometry.aspect_ratio = 3.0 / 2.0;
137 info->timing.fps = GBA_ARM7TDMI_FREQUENCY / (float) VIDEO_TOTAL_LENGTH;
138 info->timing.sample_rate = 32768;
139}
140
141void retro_init(void) {
142 enum retro_pixel_format fmt;
143#ifdef COLOR_16_BIT
144#ifdef COLOR_5_6_5
145 fmt = RETRO_PIXEL_FORMAT_RGB565;
146#else
147#warning This pixel format is unsupported. Please use -DCOLOR_16-BIT -DCOLOR_5_6_5
148 fmt = RETRO_PIXEL_FORMAT_0RGB1555;
149#endif
150#else
151#warning This pixel format is unsupported. Please use -DCOLOR_16-BIT -DCOLOR_5_6_5
152 fmt = RETRO_PIXEL_FORMAT_XRGB8888;
153#endif
154 environCallback(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt);
155
156 struct retro_input_descriptor inputDescriptors[] = {
157 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "A" },
158 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B, "B" },
159 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select" },
160 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START, "Start" },
161 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
162 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
163 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "Up" },
164 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "Down" },
165 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R, "R" },
166 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L, "L" },
167 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3, "Brighten Solar Sensor" },
168 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3, "Darken Solar Sensor" }
169 };
170 environCallback(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, &inputDescriptors);
171
172 // TODO: RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME when BIOS booting is supported
173
174 struct retro_rumble_interface rumbleInterface;
175 if (environCallback(RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE, &rumbleInterface)) {
176 rumbleCallback = rumbleInterface.set_rumble_state;
177 CircleBufferInit(&rumbleHistory, RUMBLE_PWM);
178 rumble.setRumble = _setRumble;
179 } else {
180 rumbleCallback = 0;
181 }
182
183 luxLevel = 0;
184 lux.readLuminance = _readLux;
185 lux.sample = _updateLux;
186 _updateLux(&lux);
187
188 struct retro_log_callback log;
189 if (environCallback(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) {
190 logCallback = log.log;
191 } else {
192 logCallback = 0;
193 }
194
195 stream.postAudioFrame = 0;
196 stream.postAudioBuffer = _postAudioBuffer;
197 stream.postVideoFrame = 0;
198
199 GBAContextInit(&context, 0);
200 context.gba->logHandler = GBARetroLog;
201 context.gba->stream = &stream;
202 if (rumbleCallback) {
203 context.gba->rumble = &rumble;
204 }
205 context.gba->luminanceSource = &lux;
206
207 const char* sysDir = 0;
208 if (environCallback(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &sysDir)) {
209 char biosPath[PATH_MAX];
210 snprintf(biosPath, sizeof(biosPath), "%s%s%s", sysDir, PATH_SEP, "gba_bios.bin");
211 struct VFile* bios = VFileOpen(biosPath, O_RDONLY);
212 if (bios) {
213 GBAContextLoadBIOSFromVFile(&context, bios);
214 }
215 }
216
217 GBAVideoSoftwareRendererCreate(&renderer);
218 renderer.outputBuffer = malloc(256 * VIDEO_VERTICAL_PIXELS * BYTES_PER_PIXEL);
219 renderer.outputBufferStride = 256;
220 context.renderer = &renderer.d;
221
222 GBAAudioResizeBuffer(&context.gba->audio, SAMPLES);
223
224 blip_set_rates(context.gba->audio.psg.left, GBA_ARM7TDMI_FREQUENCY, 32768);
225 blip_set_rates(context.gba->audio.psg.right, GBA_ARM7TDMI_FREQUENCY, 32768);
226
227 GBACheatDeviceCreate(&cheats);
228 GBACheatAttachDevice(context.gba, &cheats);
229 GBACheatSetInit(&cheatSet, "libretro");
230 GBACheatAddSet(&cheats, &cheatSet);
231}
232
233void retro_deinit(void) {
234 GBAContextDeinit(&context);
235 GBACheatRemoveSet(&cheats, &cheatSet);
236 GBACheatDeviceDestroy(&cheats);
237 GBACheatSetDeinit(&cheatSet);
238 free(renderer.outputBuffer);
239}
240
241void retro_run(void) {
242 uint16_t keys;
243 inputPollCallback();
244
245 struct retro_variable var = {
246 .key = "mgba_allow_opposing_directions",
247 .value = 0
248 };
249
250 bool updated = false;
251 if (environCallback(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated) {
252 if (environCallback(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
253 context.gba->allowOpposingDirections = strcmp(var.value, "yes") == 0;
254 }
255 }
256
257 keys = 0;
258 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A)) << 0;
259 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B)) << 1;
260 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT)) << 2;
261 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START)) << 3;
262 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT)) << 4;
263 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT)) << 5;
264 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP)) << 6;
265 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN)) << 7;
266 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R)) << 8;
267 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L)) << 9;
268
269 static bool wasAdjustingLux = false;
270 if (wasAdjustingLux) {
271 wasAdjustingLux = inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3) ||
272 inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3);
273 } else {
274 if (inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3)) {
275 ++luxLevel;
276 if (luxLevel > 10) {
277 luxLevel = 10;
278 }
279 wasAdjustingLux = true;
280 } else if (inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3)) {
281 --luxLevel;
282 if (luxLevel < 0) {
283 luxLevel = 0;
284 }
285 wasAdjustingLux = true;
286 }
287 }
288
289 GBAContextFrame(&context, keys);
290 videoCallback(renderer.outputBuffer, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, BYTES_PER_PIXEL * renderer.outputBufferStride);
291}
292
293void retro_reset(void) {
294 ARMReset(context.cpu);
295
296 if (rumbleCallback) {
297 CircleBufferClear(&rumbleHistory);
298 }
299}
300
301bool retro_load_game(const struct retro_game_info* game) {
302 struct VFile* rom;
303 if (game->data) {
304 data = anonymousMemoryMap(game->size);
305 dataSize = game->size;
306 memcpy(data, game->data, game->size);
307 rom = VFileFromMemory(data, game->size);
308 } else {
309 data = 0;
310 rom = VFileOpen(game->path, O_RDONLY);
311 }
312 if (!rom) {
313 return false;
314 }
315 if (!GBAIsROM(rom)) {
316 rom->close(rom);
317 mappedMemoryFree(data, game->size);
318 return false;
319 }
320
321 savedata = anonymousMemoryMap(SIZE_CART_FLASH1M);
322 struct VFile* save = VFileFromMemory(savedata, SIZE_CART_FLASH1M);
323
324 _reloadSettings();
325 GBAContextLoadROMFromVFile(&context, rom, save);
326 GBAContextStart(&context);
327 return true;
328}
329
330void retro_unload_game(void) {
331 GBAContextStop(&context);
332 mappedMemoryFree(data, dataSize);
333 data = 0;
334 mappedMemoryFree(savedata, SIZE_CART_FLASH1M);
335 savedata = 0;
336 CircleBufferDeinit(&rumbleHistory);
337}
338
339size_t retro_serialize_size(void) {
340 return sizeof(struct GBASerializedState);
341}
342
343bool retro_serialize(void* data, size_t size) {
344 if (size != retro_serialize_size()) {
345 return false;
346 }
347 GBASerialize(context.gba, data);
348 return true;
349}
350
351bool retro_unserialize(const void* data, size_t size) {
352 if (size != retro_serialize_size()) {
353 return false;
354 }
355 GBADeserialize(context.gba, data);
356 return true;
357}
358
359void retro_cheat_reset(void) {
360 GBACheatSetDeinit(&cheatSet);
361 GBACheatSetInit(&cheatSet, "libretro");
362}
363
364void retro_cheat_set(unsigned index, bool enabled, const char* code) {
365 UNUSED(index);
366 UNUSED(enabled);
367 // Convert the super wonky unportable libretro format to something normal
368 char realCode[] = "XXXXXXXX XXXXXXXX";
369 size_t len = strlen(code) + 1; // Include null terminator
370 size_t i, pos;
371 for (i = 0, pos = 0; i < len; ++i) {
372 if (isspace((int) code[i]) || code[i] == '+') {
373 realCode[pos] = ' ';
374 } else {
375 realCode[pos] = code[i];
376 }
377 if ((pos == 13 && (realCode[pos] == ' ' || !realCode[pos])) || pos == 17) {
378 realCode[pos] = '\0';
379 GBACheatAddLine(&cheatSet, realCode);
380 pos = 0;
381 continue;
382 }
383 ++pos;
384 }
385}
386
387unsigned retro_get_region(void) {
388 return RETRO_REGION_NTSC; // TODO: This isn't strictly true
389}
390
391void retro_set_controller_port_device(unsigned port, unsigned device) {
392 UNUSED(port);
393 UNUSED(device);
394}
395
396bool retro_load_game_special(unsigned game_type, const struct retro_game_info* info, size_t num_info) {
397 UNUSED(game_type);
398 UNUSED(info);
399 UNUSED(num_info);
400 return false;
401}
402
403void* retro_get_memory_data(unsigned id) {
404 if (id != RETRO_MEMORY_SAVE_RAM) {
405 return 0;
406 }
407 return savedata;
408}
409
410size_t retro_get_memory_size(unsigned id) {
411 if (id != RETRO_MEMORY_SAVE_RAM) {
412 return 0;
413 }
414 switch (context.gba->memory.savedata.type) {
415 case SAVEDATA_AUTODETECT:
416 case SAVEDATA_FLASH1M:
417 return SIZE_CART_FLASH1M;
418 case SAVEDATA_FLASH512:
419 return SIZE_CART_FLASH512;
420 case SAVEDATA_EEPROM:
421 return SIZE_CART_EEPROM;
422 case SAVEDATA_SRAM:
423 return SIZE_CART_SRAM;
424 case SAVEDATA_FORCE_NONE:
425 return 0;
426 }
427 return 0;
428}
429
430void GBARetroLog(struct GBAThread* thread, enum GBALogLevel level, const char* format, va_list args) {
431 UNUSED(thread);
432 if (!logCallback) {
433 return;
434 }
435
436 char message[128];
437 vsnprintf(message, sizeof(message), format, args);
438
439 enum retro_log_level retroLevel = RETRO_LOG_INFO;
440 switch (level) {
441 case GBA_LOG_ALL:
442 case GBA_LOG_ERROR:
443 case GBA_LOG_FATAL:
444 retroLevel = RETRO_LOG_ERROR;
445 break;
446 case GBA_LOG_WARN:
447 retroLevel = RETRO_LOG_WARN;
448 break;
449 case GBA_LOG_INFO:
450 case GBA_LOG_GAME_ERROR:
451 case GBA_LOG_SWI:
452 case GBA_LOG_STATUS:
453 retroLevel = RETRO_LOG_INFO;
454 break;
455 case GBA_LOG_DEBUG:
456 case GBA_LOG_STUB:
457 case GBA_LOG_SIO:
458 retroLevel = RETRO_LOG_DEBUG;
459 break;
460 }
461 logCallback(retroLevel, "%s\n", message);
462}
463
464static void _postAudioBuffer(struct GBAAVStream* stream, struct GBAAudio* audio) {
465 UNUSED(stream);
466 int16_t samples[SAMPLES * 2];
467 blip_read_samples(audio->psg.left, samples, SAMPLES, true);
468 blip_read_samples(audio->psg.right, samples + 1, SAMPLES, true);
469 audioCallback(samples, SAMPLES);
470}
471
472static void _setRumble(struct mRumble* rumble, int enable) {
473 UNUSED(rumble);
474 if (!rumbleCallback) {
475 return;
476 }
477 rumbleLevel += enable;
478 if (CircleBufferSize(&rumbleHistory) == RUMBLE_PWM) {
479 int8_t oldLevel;
480 CircleBufferRead8(&rumbleHistory, &oldLevel);
481 rumbleLevel -= oldLevel;
482 }
483 CircleBufferWrite8(&rumbleHistory, enable);
484 rumbleCallback(0, RETRO_RUMBLE_STRONG, rumbleLevel * 0xFFFF / RUMBLE_PWM);
485 rumbleCallback(0, RETRO_RUMBLE_WEAK, rumbleLevel * 0xFFFF / RUMBLE_PWM);
486}
487
488static void _updateLux(struct GBALuminanceSource* lux) {
489 UNUSED(lux);
490 struct retro_variable var = {
491 .key = "mgba_solar_sensor_level",
492 .value = 0
493 };
494
495 bool updated = false;
496 if (!environCallback(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) || !updated) {
497 return;
498 }
499 if (!environCallback(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || !var.value) {
500 return;
501 }
502
503 char* end;
504 int newLuxLevel = strtol(var.value, &end, 10);
505 if (!*end) {
506 if (newLuxLevel > 10) {
507 luxLevel = 10;
508 } else if (newLuxLevel < 0) {
509 luxLevel = 0;
510 } else {
511 luxLevel = newLuxLevel;
512 }
513 }
514}
515
516static uint8_t _readLux(struct GBALuminanceSource* lux) {
517 UNUSED(lux);
518 int value = 0x16;
519 if (luxLevel > 0) {
520 value += GBA_LUX_LEVELS[luxLevel - 1];
521 }
522 return 0xFF - value;
523}