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