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 "gba/gba.h"
9#include "gba/renderers/video-software.h"
10#include "gba/serialize.h"
11#include "gba/supervisor/overrides.h"
12#include "gba/video.h"
13#include "util/vfs.h"
14
15#define SAMPLES 1024
16
17static retro_environment_t environCallback;
18static retro_video_refresh_t videoCallback;
19static retro_audio_sample_batch_t audioCallback;
20static retro_input_poll_t inputPollCallback;
21static retro_input_state_t inputCallback;
22static retro_log_printf_t logCallback;
23
24static void GBARetroLog(struct GBAThread* thread, enum GBALogLevel level, const char* format, va_list args);
25
26static void _postAudioBuffer(struct GBAAVStream*, struct GBAAudio* audio);
27static void _postVideoFrame(struct GBAAVStream*, struct GBAVideoRenderer* renderer);
28
29static struct GBA gba;
30static struct ARMCore cpu;
31static struct GBAVideoSoftwareRenderer renderer;
32static struct VFile* rom;
33static void* data;
34static struct VFile* save;
35static void* savedata;
36static struct GBAAVStream stream;
37
38unsigned retro_api_version(void) {
39 return RETRO_API_VERSION;
40}
41
42void retro_set_environment(retro_environment_t env) {
43 environCallback = env;
44}
45
46void retro_set_video_refresh(retro_video_refresh_t video) {
47 videoCallback = video;
48}
49
50void retro_set_audio_sample(retro_audio_sample_t audio) {
51 UNUSED(audio);
52}
53
54void retro_set_audio_sample_batch(retro_audio_sample_batch_t audioBatch) {
55 audioCallback = audioBatch;
56}
57
58void retro_set_input_poll(retro_input_poll_t inputPoll) {
59 inputPollCallback = inputPoll;
60}
61
62void retro_set_input_state(retro_input_state_t input) {
63 inputCallback = input;
64}
65
66void retro_get_system_info(struct retro_system_info* info) {
67 info->need_fullpath = false;
68 info->valid_extensions = "gba";
69 info->library_version = PROJECT_VERSION;
70 info->library_name = PROJECT_NAME;
71 info->block_extract = false;
72}
73
74void retro_get_system_av_info(struct retro_system_av_info* info) {
75 info->geometry.base_width = VIDEO_HORIZONTAL_PIXELS;
76 info->geometry.base_height = VIDEO_VERTICAL_PIXELS;
77 info->geometry.max_width = VIDEO_HORIZONTAL_PIXELS;
78 info->geometry.max_height = VIDEO_VERTICAL_PIXELS;
79 info->timing.fps = GBA_ARM7TDMI_FREQUENCY / (float) VIDEO_TOTAL_LENGTH;
80 info->timing.sample_rate = 32768;
81}
82
83void retro_init(void) {
84 enum retro_pixel_format fmt;
85#ifdef COLOR_16_BIT
86#ifdef COLOR_5_6_5
87 fmt = RETRO_PIXEL_FORMAT_RGB565;
88#else
89#warning This pixel format is unsupported. Please use -DCOLOR_16-BIT -DCOLOR_5_6_5
90 fmt = RETRO_PIXEL_FORMAT_0RGB1555;
91#endif
92#else
93#warning This pixel format is unsupported. Please use -DCOLOR_16-BIT -DCOLOR_5_6_5
94 fmt = RETRO_PIXEL_FORMAT_XRGB8888;
95#endif
96 environCallback(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt);
97
98 struct retro_input_descriptor inputDescriptors[] = {
99 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "A" },
100 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B, "B" },
101 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select" },
102 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START, "Start" },
103 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
104 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
105 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "Up" },
106 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "Down" },
107 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R, "R" },
108 { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L, "L" }
109 };
110 environCallback(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, &inputDescriptors);
111
112 // TODO: RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME when BIOS booting is supported
113 // TODO: RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE
114
115 struct retro_log_callback log;
116 if (environCallback(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) {
117 logCallback = log.log;
118 } else {
119 logCallback = 0;
120 }
121
122 stream.postAudioFrame = 0;
123 stream.postAudioBuffer = _postAudioBuffer;
124 stream.postVideoFrame = _postVideoFrame;
125
126 GBACreate(&gba);
127 ARMSetComponents(&cpu, &gba.d, 0, 0);
128 ARMInit(&cpu);
129 gba.logLevel = 0; // TODO: Settings
130 gba.logHandler = GBARetroLog;
131 gba.stream = &stream;
132 gba.idleOptimization = IDLE_LOOP_REMOVE; // TODO: Settings
133 rom = 0;
134
135 GBAVideoSoftwareRendererCreate(&renderer);
136 renderer.outputBuffer = malloc(256 * VIDEO_VERTICAL_PIXELS * BYTES_PER_PIXEL);
137 renderer.outputBufferStride = 256;
138 GBAVideoAssociateRenderer(&gba.video, &renderer.d);
139
140 GBAAudioResizeBuffer(&gba.audio, SAMPLES);
141
142#if RESAMPLE_LIBRARY == RESAMPLE_BLIP_BUF
143 blip_set_rates(gba.audio.left, GBA_ARM7TDMI_FREQUENCY, 32768);
144 blip_set_rates(gba.audio.right, GBA_ARM7TDMI_FREQUENCY, 32768);
145#endif
146}
147
148void retro_deinit(void) {
149 GBADestroy(&gba);
150}
151
152void retro_run(void) {
153 int keys;
154 gba.keySource = &keys;
155 inputPollCallback();
156
157 keys = 0;
158 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A)) << 0;
159 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B)) << 1;
160 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT)) << 2;
161 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START)) << 3;
162 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT)) << 4;
163 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT)) << 5;
164 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP)) << 6;
165 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN)) << 7;
166 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R)) << 8;
167 keys |= (!!inputCallback(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L)) << 9;
168
169 int frameCount = gba.video.frameCounter;
170 while (gba.video.frameCounter == frameCount) {
171 ARMRunLoop(&cpu);
172 }
173 videoCallback(renderer.outputBuffer, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, BYTES_PER_PIXEL * 256);
174}
175
176void retro_reset(void) {
177 ARMReset(&cpu);
178}
179
180bool retro_load_game(const struct retro_game_info* game) {
181 if (game->data) {
182 data = malloc(game->size);
183 memcpy(data, game->data, game->size);
184 rom = VFileFromMemory(data, game->size);
185 } else {
186 data = 0;
187 rom = VFileOpen(game->path, O_RDONLY);
188 }
189 if (!rom) {
190 return false;
191 }
192 if (!GBAIsROM(rom)) {
193 return false;
194 }
195
196 savedata = malloc(SIZE_CART_FLASH1M);
197 save = VFileFromMemory(savedata, SIZE_CART_FLASH1M);
198
199 GBALoadROM(&gba, rom, save, game->path);
200
201 struct GBACartridgeOverride override;
202 const struct GBACartridge* cart = (const struct GBACartridge*) gba.memory.rom;
203 memcpy(override.id, &cart->id, sizeof(override.id));
204 if (GBAOverrideFind(0, &override)) {
205 GBAOverrideApply(&gba, &override);
206 }
207
208 ARMReset(&cpu);
209 return true;
210}
211
212void retro_unload_game(void) {
213 rom->close(rom);
214 rom = 0;
215 free(data);
216 data = 0;
217 save->close(save);
218 save = 0;
219 free(savedata);
220 savedata = 0;
221}
222
223size_t retro_serialize_size(void) {
224 return sizeof(struct GBASerializedState);
225}
226
227bool retro_serialize(void* data, size_t size) {
228 if (size != retro_serialize_size()) {
229 return false;
230 }
231 GBASerialize(&gba, data);
232 return true;
233}
234
235bool retro_unserialize(const void* data, size_t size) {
236 if (size != retro_serialize_size()) {
237 return false;
238 }
239 GBADeserialize(&gba, data);
240 return true;
241}
242
243void retro_cheat_reset(void) {
244 // TODO: Cheats
245}
246
247void retro_cheat_set(unsigned index, bool enabled, const char* code) {
248 // TODO: Cheats
249 UNUSED(index);
250 UNUSED(enabled);
251 UNUSED(code);
252}
253
254unsigned retro_get_region(void) {
255 return RETRO_REGION_NTSC; // TODO: This isn't strictly true
256}
257
258void retro_set_controller_port_device(unsigned port, unsigned device) {
259 UNUSED(port);
260 UNUSED(device);
261}
262
263bool retro_load_game_special(unsigned game_type, const struct retro_game_info* info, size_t num_info) {
264 UNUSED(game_type);
265 UNUSED(info);
266 UNUSED(num_info);
267 return false;
268}
269
270void* retro_get_memory_data(unsigned id) {
271 if (id != RETRO_MEMORY_SAVE_RAM) {
272 return 0;
273 }
274 return savedata;
275}
276
277size_t retro_get_memory_size(unsigned id) {
278 if (id != RETRO_MEMORY_SAVE_RAM) {
279 return 0;
280 }
281 switch (gba.memory.savedata.type) {
282 case SAVEDATA_AUTODETECT:
283 case SAVEDATA_FLASH1M:
284 return SIZE_CART_FLASH1M;
285 case SAVEDATA_FLASH512:
286 return SIZE_CART_FLASH512;
287 case SAVEDATA_EEPROM:
288 return SIZE_CART_EEPROM;
289 case SAVEDATA_SRAM:
290 return SIZE_CART_SRAM;
291 case SAVEDATA_FORCE_NONE:
292 return 0;
293 }
294 return 0;
295}
296
297void GBARetroLog(struct GBAThread* thread, enum GBALogLevel level, const char* format, va_list args) {
298 UNUSED(thread);
299 if (!logCallback) {
300 return;
301 }
302
303 char message[128];
304 vsnprintf(message, sizeof(message), format, args);
305
306 enum retro_log_level retroLevel = RETRO_LOG_INFO;
307 switch (level) {
308 case GBA_LOG_ALL:
309 case GBA_LOG_ERROR:
310 case GBA_LOG_FATAL:
311 retroLevel = RETRO_LOG_ERROR;
312 break;
313 case GBA_LOG_WARN:
314 retroLevel = RETRO_LOG_WARN;
315 break;
316 case GBA_LOG_INFO:
317 case GBA_LOG_GAME_ERROR:
318 case GBA_LOG_SWI:
319 retroLevel = RETRO_LOG_INFO;
320 break;
321 case GBA_LOG_DEBUG:
322 case GBA_LOG_STUB:
323 retroLevel = RETRO_LOG_DEBUG;
324 break;
325 }
326 logCallback(retroLevel, "%s\n", message);
327}
328
329static void _postAudioBuffer(struct GBAAVStream* stream, struct GBAAudio* audio) {
330 UNUSED(stream);
331 int16_t samples[SAMPLES * 2];
332#if RESAMPLE_LIBRARY == RESAMPLE_BLIP_BUF
333 blip_read_samples(audio->left, samples, SAMPLES, true);
334 blip_read_samples(audio->right, samples + 1, SAMPLES, true);
335#else
336 int16_t samplesR[SAMPLES];
337 GBAAudioCopy(audio, &samples[SAMPLES], samplesR, SAMPLES);
338 size_t i;
339 for (i = 0; i < SAMPLES; ++i) {
340 samples[i * 2] = samples[SAMPLES + i];
341 samples[i * 2 + 1] = samplesR[i];
342 }
343#endif
344 audioCallback(samples, SAMPLES);
345}
346
347static void _postVideoFrame(struct GBAAVStream* stream, struct GBAVideoRenderer* renderer) {
348 UNUSED(stream);
349 void* pixels;
350 unsigned stride;
351 renderer->getPixels(renderer, &stride, &pixels);
352 videoCallback(pixels, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, BYTES_PER_PIXEL * stride);
353}