src/gba/core.c (view raw)
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 <mgba/gba/core.h>
7
8#include <mgba/core/core.h>
9#include <mgba/core/log.h>
10#include <mgba/internal/arm/debugger/debugger.h>
11#include <mgba/internal/debugger/symbols.h>
12#include <mgba/internal/gba/cheats.h>
13#include <mgba/internal/gba/gba.h>
14#include <mgba/internal/gba/io.h>
15#include <mgba/internal/gba/extra/cli.h>
16#include <mgba/internal/gba/overrides.h>
17#ifndef DISABLE_THREADING
18#include <mgba/feature/thread-proxy.h>
19#endif
20#include <mgba/internal/gba/renderers/proxy.h>
21#include <mgba/internal/gba/renderers/video-software.h>
22#include <mgba/internal/gba/savedata.h>
23#include <mgba/internal/gba/serialize.h>
24#ifdef USE_ELF
25#include <mgba-util/elf-read.h>
26#endif
27#include <mgba-util/memory.h>
28#include <mgba-util/patch.h>
29#include <mgba-util/vfs.h>
30
31static const struct mCoreChannelInfo _GBAVideoLayers[] = {
32 { 0, "bg0", "Background 0", NULL },
33 { 1, "bg1", "Background 1", NULL },
34 { 2, "bg2", "Background 2", NULL },
35 { 3, "bg3", "Background 3", NULL },
36 { 4, "obj", "Objects", NULL },
37};
38
39static const struct mCoreChannelInfo _GBAAudioChannels[] = {
40 { 0, "ch1", "PSG Channel 1", "Square/Sweep" },
41 { 1, "ch2", "PSG Channel 2", "Square" },
42 { 2, "ch3", "PSG Channel 3", "PCM" },
43 { 3, "ch4", "PSG Channel 4", "Noise" },
44 { 4, "chA", "FIFO Channel A", NULL },
45 { 5, "chB", "FIFO Channel B", NULL },
46};
47
48static const struct mCoreMemoryBlock _GBAMemoryBlocks[] = {
49 { -1, "mem", "All", "All", 0, 0x10000000, 0x10000000, mCORE_MEMORY_VIRTUAL },
50 { REGION_BIOS, "bios", "BIOS", "BIOS (16kiB)", BASE_BIOS, SIZE_BIOS, SIZE_BIOS, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
51 { REGION_WORKING_RAM, "wram", "EWRAM", "Working RAM (256kiB)", BASE_WORKING_RAM, BASE_WORKING_RAM + SIZE_WORKING_RAM, SIZE_WORKING_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
52 { REGION_WORKING_IRAM, "iwram", "IWRAM", "Internal Working RAM (32kiB)", BASE_WORKING_IRAM, BASE_WORKING_IRAM + SIZE_WORKING_IRAM, SIZE_WORKING_IRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
53 { REGION_IO, "io", "MMIO", "Memory-Mapped I/O", BASE_IO, BASE_IO + SIZE_IO, SIZE_IO, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
54 { REGION_PALETTE_RAM, "palette", "Palette", "Palette RAM (1kiB)", BASE_PALETTE_RAM, BASE_PALETTE_RAM + SIZE_PALETTE_RAM, SIZE_PALETTE_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
55 { REGION_VRAM, "vram", "VRAM", "Video RAM (96kiB)", BASE_VRAM, BASE_VRAM + SIZE_VRAM, SIZE_VRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
56 { REGION_OAM, "oam", "OAM", "OBJ Attribute Memory (1kiB)", BASE_OAM, BASE_OAM + SIZE_OAM, SIZE_OAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
57 { REGION_CART0, "cart0", "ROM", "Game Pak (32MiB)", BASE_CART0, BASE_CART0 + SIZE_CART0, SIZE_CART0, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
58 { REGION_CART1, "cart1", "ROM WS1", "Game Pak (Waitstate 1)", BASE_CART1, BASE_CART1 + SIZE_CART1, SIZE_CART1, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
59 { REGION_CART2, "cart2", "ROM WS2", "Game Pak (Waitstate 2)", BASE_CART2, BASE_CART2 + SIZE_CART2, SIZE_CART2, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
60};
61
62static const struct mCoreMemoryBlock _GBAMemoryBlocksSRAM[] = {
63 { -1, "mem", "All", "All", 0, 0x10000000, 0x10000000, mCORE_MEMORY_VIRTUAL },
64 { REGION_BIOS, "bios", "BIOS", "BIOS (16kiB)", BASE_BIOS, SIZE_BIOS, SIZE_BIOS, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
65 { REGION_WORKING_RAM, "wram", "EWRAM", "Working RAM (256kiB)", BASE_WORKING_RAM, BASE_WORKING_RAM + SIZE_WORKING_RAM, SIZE_WORKING_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
66 { REGION_WORKING_IRAM, "iwram", "IWRAM", "Internal Working RAM (32kiB)", BASE_WORKING_IRAM, BASE_WORKING_IRAM + SIZE_WORKING_IRAM, SIZE_WORKING_IRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
67 { REGION_IO, "io", "MMIO", "Memory-Mapped I/O", BASE_IO, BASE_IO + SIZE_IO, SIZE_IO, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
68 { REGION_PALETTE_RAM, "palette", "Palette", "Palette RAM (1kiB)", BASE_PALETTE_RAM, BASE_PALETTE_RAM + SIZE_PALETTE_RAM, SIZE_PALETTE_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
69 { REGION_VRAM, "vram", "VRAM", "Video RAM (96kiB)", BASE_VRAM, BASE_VRAM + SIZE_VRAM, SIZE_VRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
70 { REGION_OAM, "oam", "OAM", "OBJ Attribute Memory (1kiB)", BASE_OAM, BASE_OAM + SIZE_OAM, SIZE_OAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
71 { REGION_CART0, "cart0", "ROM", "Game Pak (32MiB)", BASE_CART0, BASE_CART0 + SIZE_CART0, SIZE_CART0, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
72 { REGION_CART1, "cart1", "ROM WS1", "Game Pak (Waitstate 1)", BASE_CART1, BASE_CART1 + SIZE_CART1, SIZE_CART1, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
73 { REGION_CART2, "cart2", "ROM WS2", "Game Pak (Waitstate 2)", BASE_CART2, BASE_CART2 + SIZE_CART2, SIZE_CART2, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
74 { REGION_CART_SRAM, "sram", "SRAM", "Static RAM (64kiB)", BASE_CART_SRAM, BASE_CART_SRAM + SIZE_CART_SRAM, SIZE_CART_SRAM, true },
75};
76
77static const struct mCoreMemoryBlock _GBAMemoryBlocksFlash512[] = {
78 { -1, "mem", "All", "All", 0, 0x10000000, 0x10000000, mCORE_MEMORY_VIRTUAL },
79 { REGION_BIOS, "bios", "BIOS", "BIOS (16kiB)", BASE_BIOS, SIZE_BIOS, SIZE_BIOS, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
80 { REGION_WORKING_RAM, "wram", "EWRAM", "Working RAM (256kiB)", BASE_WORKING_RAM, BASE_WORKING_RAM + SIZE_WORKING_RAM, SIZE_WORKING_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
81 { REGION_WORKING_IRAM, "iwram", "IWRAM", "Internal Working RAM (32kiB)", BASE_WORKING_IRAM, BASE_WORKING_IRAM + SIZE_WORKING_IRAM, SIZE_WORKING_IRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
82 { REGION_IO, "io", "MMIO", "Memory-Mapped I/O", BASE_IO, BASE_IO + SIZE_IO, SIZE_IO, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
83 { REGION_PALETTE_RAM, "palette", "Palette", "Palette RAM (1kiB)", BASE_PALETTE_RAM, BASE_PALETTE_RAM + SIZE_PALETTE_RAM, SIZE_PALETTE_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
84 { REGION_VRAM, "vram", "VRAM", "Video RAM (96kiB)", BASE_VRAM, BASE_VRAM + SIZE_VRAM, SIZE_VRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
85 { REGION_OAM, "oam", "OAM", "OBJ Attribute Memory (1kiB)", BASE_OAM, BASE_OAM + SIZE_OAM, SIZE_OAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
86 { REGION_CART0, "cart0", "ROM", "Game Pak (32MiB)", BASE_CART0, BASE_CART0 + SIZE_CART0, SIZE_CART0, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
87 { REGION_CART1, "cart1", "ROM WS1", "Game Pak (Waitstate 1)", BASE_CART1, BASE_CART1 + SIZE_CART1, SIZE_CART1, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
88 { REGION_CART2, "cart2", "ROM WS2", "Game Pak (Waitstate 2)", BASE_CART2, BASE_CART2 + SIZE_CART2, SIZE_CART2, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
89 { REGION_CART_SRAM, "sram", "Flash", "Flash Memory (64kiB)", BASE_CART_SRAM, BASE_CART_SRAM + SIZE_CART_FLASH512, SIZE_CART_FLASH512, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
90};
91
92static const struct mCoreMemoryBlock _GBAMemoryBlocksFlash1M[] = {
93 { -1, "mem", "All", "All", 0, 0x10000000, 0x10000000, mCORE_MEMORY_VIRTUAL },
94 { REGION_BIOS, "bios", "BIOS", "BIOS (16kiB)", BASE_BIOS, SIZE_BIOS, SIZE_BIOS, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
95 { REGION_WORKING_RAM, "wram", "EWRAM", "Working RAM (256kiB)", BASE_WORKING_RAM, BASE_WORKING_RAM + SIZE_WORKING_RAM, SIZE_WORKING_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
96 { REGION_WORKING_IRAM, "iwram", "IWRAM", "Internal Working RAM (32kiB)", BASE_WORKING_IRAM, BASE_WORKING_IRAM + SIZE_WORKING_IRAM, SIZE_WORKING_IRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
97 { REGION_IO, "io", "MMIO", "Memory-Mapped I/O", BASE_IO, BASE_IO + SIZE_IO, SIZE_IO, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
98 { REGION_PALETTE_RAM, "palette", "Palette", "Palette RAM (1kiB)", BASE_PALETTE_RAM, BASE_PALETTE_RAM + SIZE_PALETTE_RAM, SIZE_PALETTE_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
99 { REGION_VRAM, "vram", "VRAM", "Video RAM (96kiB)", BASE_VRAM, BASE_VRAM + SIZE_VRAM, SIZE_VRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
100 { REGION_OAM, "oam", "OAM", "OBJ Attribute Memory (1kiB)", BASE_OAM, BASE_OAM + SIZE_OAM, SIZE_OAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
101 { REGION_CART0, "cart0", "ROM", "Game Pak (32MiB)", BASE_CART0, BASE_CART0 + SIZE_CART0, SIZE_CART0, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
102 { REGION_CART1, "cart1", "ROM WS1", "Game Pak (Waitstate 1)", BASE_CART1, BASE_CART1 + SIZE_CART1, SIZE_CART1, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
103 { REGION_CART2, "cart2", "ROM WS2", "Game Pak (Waitstate 2)", BASE_CART2, BASE_CART2 + SIZE_CART2, SIZE_CART2, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
104 { REGION_CART_SRAM, "sram", "Flash", "Flash Memory (64kiB)", BASE_CART_SRAM, BASE_CART_SRAM + SIZE_CART_FLASH512, SIZE_CART_FLASH1M, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED, 1 },
105};
106
107static const struct mCoreMemoryBlock _GBAMemoryBlocksEEPROM[] = {
108 { -1, "mem", "All", "All", 0, 0x10000000, 0x10000000, mCORE_MEMORY_VIRTUAL },
109 { REGION_BIOS, "bios", "BIOS", "BIOS (16kiB)", BASE_BIOS, SIZE_BIOS, SIZE_BIOS, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
110 { REGION_WORKING_RAM, "wram", "EWRAM", "Working RAM (256kiB)", BASE_WORKING_RAM, BASE_WORKING_RAM + SIZE_WORKING_RAM, SIZE_WORKING_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
111 { REGION_WORKING_IRAM, "iwram", "IWRAM", "Internal Working RAM (32kiB)", BASE_WORKING_IRAM, BASE_WORKING_IRAM + SIZE_WORKING_IRAM, SIZE_WORKING_IRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
112 { REGION_IO, "io", "MMIO", "Memory-Mapped I/O", BASE_IO, BASE_IO + SIZE_IO, SIZE_IO, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
113 { REGION_PALETTE_RAM, "palette", "Palette", "Palette RAM (1kiB)", BASE_PALETTE_RAM, BASE_PALETTE_RAM + SIZE_PALETTE_RAM, SIZE_PALETTE_RAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
114 { REGION_VRAM, "vram", "VRAM", "Video RAM (96kiB)", BASE_VRAM, BASE_VRAM + SIZE_VRAM, SIZE_VRAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
115 { REGION_OAM, "oam", "OAM", "OBJ Attribute Memory (1kiB)", BASE_OAM, BASE_OAM + SIZE_OAM, SIZE_OAM, mCORE_MEMORY_RW | mCORE_MEMORY_MAPPED },
116 { REGION_CART0, "cart0", "ROM", "Game Pak (32MiB)", BASE_CART0, BASE_CART0 + SIZE_CART0, SIZE_CART0, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
117 { REGION_CART1, "cart1", "ROM WS1", "Game Pak (Waitstate 1)", BASE_CART1, BASE_CART1 + SIZE_CART1, SIZE_CART1, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
118 { REGION_CART2, "cart2", "ROM WS2", "Game Pak (Waitstate 2)", BASE_CART2, BASE_CART2 + SIZE_CART2, SIZE_CART2, mCORE_MEMORY_READ | mCORE_MEMORY_MAPPED },
119 { REGION_CART_SRAM_MIRROR, "eeprom", "EEPROM", "EEPROM (8kiB)", 0, SIZE_CART_EEPROM, SIZE_CART_EEPROM, mCORE_MEMORY_RW },
120};
121
122struct mVideoLogContext;
123struct GBACore {
124 struct mCore d;
125 struct GBAVideoSoftwareRenderer renderer;
126 struct GBAVideoProxyRenderer proxyRenderer;
127 struct mVideoLogContext* logContext;
128 struct mCoreCallbacks logCallbacks;
129#ifndef DISABLE_THREADING
130 struct mVideoThreadProxy threadProxy;
131 int threadedVideo;
132#endif
133 int keys;
134 struct mCPUComponent* components[CPU_COMPONENT_MAX];
135 const struct Configuration* overrides;
136 struct mDebuggerPlatform* debuggerPlatform;
137 struct mCheatDevice* cheatDevice;
138};
139
140static bool _GBACoreInit(struct mCore* core) {
141 struct GBACore* gbacore = (struct GBACore*) core;
142
143 struct ARMCore* cpu = anonymousMemoryMap(sizeof(struct ARMCore));
144 struct GBA* gba = anonymousMemoryMap(sizeof(struct GBA));
145 if (!cpu || !gba) {
146 free(cpu);
147 free(gba);
148 return false;
149 }
150 core->cpu = cpu;
151 core->board = gba;
152 core->debugger = NULL;
153 core->symbolTable = NULL;
154 gbacore->overrides = NULL;
155 gbacore->debuggerPlatform = NULL;
156 gbacore->cheatDevice = NULL;
157 gbacore->logContext = NULL;
158
159 GBACreate(gba);
160 // TODO: Restore cheats
161 memset(gbacore->components, 0, sizeof(gbacore->components));
162 ARMSetComponents(cpu, &gba->d, CPU_COMPONENT_MAX, gbacore->components);
163 ARMInit(cpu);
164 mRTCGenericSourceInit(&core->rtc, core);
165 gba->rtcSource = &core->rtc.d;
166
167 GBAVideoSoftwareRendererCreate(&gbacore->renderer);
168 gbacore->renderer.outputBuffer = NULL;
169
170#ifndef DISABLE_THREADING
171 gbacore->threadedVideo = false;
172 mVideoThreadProxyCreate(&gbacore->threadProxy);
173#endif
174 gbacore->proxyRenderer.logger = NULL;
175
176 gbacore->keys = 0;
177 gba->keySource = &gbacore->keys;
178
179#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
180 mDirectorySetInit(&core->dirs);
181#endif
182
183 return true;
184}
185
186static void _GBACoreDeinit(struct mCore* core) {
187 ARMDeinit(core->cpu);
188 GBADestroy(core->board);
189 mappedMemoryFree(core->cpu, sizeof(struct ARMCore));
190 mappedMemoryFree(core->board, sizeof(struct GBA));
191#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
192 mDirectorySetDeinit(&core->dirs);
193#endif
194
195 struct GBACore* gbacore = (struct GBACore*) core;
196 free(gbacore->debuggerPlatform);
197 if (gbacore->cheatDevice) {
198 mCheatDeviceDestroy(gbacore->cheatDevice);
199 }
200 free(gbacore->cheatDevice);
201 mCoreConfigFreeOpts(&core->opts);
202 free(core);
203}
204
205static enum mPlatform _GBACorePlatform(const struct mCore* core) {
206 UNUSED(core);
207 return PLATFORM_GBA;
208}
209
210static void _GBACoreSetSync(struct mCore* core, struct mCoreSync* sync) {
211 struct GBA* gba = core->board;
212 gba->sync = sync;
213}
214
215static void _GBACoreLoadConfig(struct mCore* core, const struct mCoreConfig* config) {
216 struct GBA* gba = core->board;
217 if (core->opts.mute) {
218 gba->audio.masterVolume = 0;
219 } else {
220 gba->audio.masterVolume = core->opts.volume;
221 }
222 gba->video.frameskip = core->opts.frameskip;
223
224#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
225 struct GBACore* gbacore = (struct GBACore*) core;
226 gbacore->overrides = mCoreConfigGetOverridesConst(config);
227#endif
228
229 const char* idleOptimization = mCoreConfigGetValue(config, "idleOptimization");
230 if (idleOptimization) {
231 if (strcasecmp(idleOptimization, "ignore") == 0) {
232 gba->idleOptimization = IDLE_LOOP_IGNORE;
233 } else if (strcasecmp(idleOptimization, "remove") == 0) {
234 gba->idleOptimization = IDLE_LOOP_REMOVE;
235 } else if (strcasecmp(idleOptimization, "detect") == 0) {
236 if (gba->idleLoop == IDLE_LOOP_NONE) {
237 gba->idleOptimization = IDLE_LOOP_DETECT;
238 } else {
239 gba->idleOptimization = IDLE_LOOP_REMOVE;
240 }
241 }
242 }
243
244 mCoreConfigCopyValue(&core->config, config, "gba.bios");
245
246#ifndef DISABLE_THREADING
247 mCoreConfigGetIntValue(config, "threadedVideo", &gbacore->threadedVideo);
248#endif
249}
250
251static void _GBACoreDesiredVideoDimensions(struct mCore* core, unsigned* width, unsigned* height) {
252 UNUSED(core);
253 *width = VIDEO_HORIZONTAL_PIXELS;
254 *height = VIDEO_VERTICAL_PIXELS;
255}
256
257static void _GBACoreSetVideoBuffer(struct mCore* core, color_t* buffer, size_t stride) {
258 struct GBACore* gbacore = (struct GBACore*) core;
259 gbacore->renderer.outputBuffer = buffer;
260 gbacore->renderer.outputBufferStride = stride;
261 memset(gbacore->renderer.scanlineDirty, 0xFFFFFFFF, sizeof(gbacore->renderer.scanlineDirty));
262}
263
264static void _GBACoreGetPixels(struct mCore* core, const void** buffer, size_t* stride) {
265 struct GBACore* gbacore = (struct GBACore*) core;
266 gbacore->renderer.d.getPixels(&gbacore->renderer.d, stride, buffer);
267}
268
269static void _GBACorePutPixels(struct mCore* core, const void* buffer, size_t stride) {
270 struct GBACore* gbacore = (struct GBACore*) core;
271 gbacore->renderer.d.putPixels(&gbacore->renderer.d, stride, buffer);
272}
273
274static struct blip_t* _GBACoreGetAudioChannel(struct mCore* core, int ch) {
275 struct GBA* gba = core->board;
276 switch (ch) {
277 case 0:
278 return gba->audio.psg.left;
279 case 1:
280 return gba->audio.psg.right;
281 default:
282 return NULL;
283 }
284}
285
286static void _GBACoreSetAudioBufferSize(struct mCore* core, size_t samples) {
287 struct GBA* gba = core->board;
288 GBAAudioResizeBuffer(&gba->audio, samples);
289}
290
291static size_t _GBACoreGetAudioBufferSize(struct mCore* core) {
292 struct GBA* gba = core->board;
293 return gba->audio.samples;
294}
295
296static void _GBACoreAddCoreCallbacks(struct mCore* core, struct mCoreCallbacks* coreCallbacks) {
297 struct GBA* gba = core->board;
298 *mCoreCallbacksListAppend(&gba->coreCallbacks) = *coreCallbacks;
299}
300
301static void _GBACoreClearCoreCallbacks(struct mCore* core) {
302 struct GBA* gba = core->board;
303 mCoreCallbacksListClear(&gba->coreCallbacks);
304}
305
306static void _GBACoreSetAVStream(struct mCore* core, struct mAVStream* stream) {
307 struct GBA* gba = core->board;
308 gba->stream = stream;
309 if (stream && stream->videoDimensionsChanged) {
310 stream->videoDimensionsChanged(stream, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS);
311 }
312}
313
314static bool _GBACoreLoadROM(struct mCore* core, struct VFile* vf) {
315#ifdef USE_ELF
316 struct ELF* elf = ELFOpen(vf);
317 if (elf) {
318 GBALoadNull(core->board);
319 bool success = mCoreLoadELF(core, elf);
320 ELFClose(elf);
321 return success;
322 }
323#endif
324 if (GBAIsMB(vf)) {
325 return GBALoadMB(core->board, vf);
326 }
327 return GBALoadROM(core->board, vf);
328}
329
330static bool _GBACoreLoadBIOS(struct mCore* core, struct VFile* vf, int type) {
331 UNUSED(type);
332 if (!GBAIsBIOS(vf)) {
333 return false;
334 }
335 GBALoadBIOS(core->board, vf);
336 return true;
337}
338
339static bool _GBACoreLoadSave(struct mCore* core, struct VFile* vf) {
340 return GBALoadSave(core->board, vf);
341}
342
343static bool _GBACoreLoadTemporarySave(struct mCore* core, struct VFile* vf) {
344 struct GBA* gba = core->board;
345 GBASavedataMask(&gba->memory.savedata, vf, false);
346 return true; // TODO: Return a real value
347}
348
349static bool _GBACoreLoadPatch(struct mCore* core, struct VFile* vf) {
350 if (!vf) {
351 return false;
352 }
353 struct Patch patch;
354 if (!loadPatch(vf, &patch)) {
355 return false;
356 }
357 GBAApplyPatch(core->board, &patch);
358 return true;
359}
360
361static void _GBACoreUnloadROM(struct mCore* core) {
362 struct GBACore* gbacore = (struct GBACore*) core;
363 struct ARMCore* cpu = core->cpu;
364 if (gbacore->cheatDevice) {
365 ARMHotplugDetach(cpu, CPU_COMPONENT_CHEAT_DEVICE);
366 cpu->components[CPU_COMPONENT_CHEAT_DEVICE] = NULL;
367 mCheatDeviceDestroy(gbacore->cheatDevice);
368 gbacore->cheatDevice = NULL;
369 }
370 return GBAUnloadROM(core->board);
371}
372
373static void _GBACoreChecksum(const struct mCore* core, void* data, enum mCoreChecksumType type) {
374 struct GBA* gba = (struct GBA*) core->board;
375 switch (type) {
376 case CHECKSUM_CRC32:
377 memcpy(data, &gba->romCrc32, sizeof(gba->romCrc32));
378 break;
379 }
380 return;
381}
382
383static void _GBACoreReset(struct mCore* core) {
384 struct GBACore* gbacore = (struct GBACore*) core;
385 struct GBA* gba = (struct GBA*) core->board;
386 if (gbacore->renderer.outputBuffer) {
387 struct GBAVideoRenderer* renderer = &gbacore->renderer.d;
388#ifndef DISABLE_THREADING
389 if (gbacore->threadedVideo) {
390 gbacore->proxyRenderer.logger = &gbacore->threadProxy.d;
391 GBAVideoProxyRendererCreate(&gbacore->proxyRenderer, renderer);
392 renderer = &gbacore->proxyRenderer.d;
393 }
394#endif
395 GBAVideoAssociateRenderer(&gba->video, renderer);
396 }
397
398 GBAOverrideApplyDefaults(gba, gbacore->overrides);
399
400#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
401 if (!gba->biosVf && core->opts.useBios) {
402 struct VFile* bios = NULL;
403 bool found = false;
404 if (core->opts.bios) {
405 bios = VFileOpen(core->opts.bios, O_RDONLY);
406 if (bios && GBAIsBIOS(bios)) {
407 found = true;
408 } else if (bios) {
409 bios->close(bios);
410 bios = NULL;
411 }
412 }
413 if (!found) {
414 const char* configPath = mCoreConfigGetValue(&core->config, "gba.bios");
415 if (configPath) {
416 bios = VFileOpen(configPath, O_RDONLY);
417 }
418 if (bios && GBAIsBIOS(bios)) {
419 found = true;
420 } else if (bios) {
421 bios->close(bios);
422 bios = NULL;
423 }
424 }
425 if (!found) {
426 char path[PATH_MAX];
427 mCoreConfigDirectory(path, PATH_MAX);
428 strncat(path, PATH_SEP "gba_bios.bin", PATH_MAX - strlen(path));
429 bios = VFileOpen(path, O_RDONLY);
430 if (bios && GBAIsBIOS(bios)) {
431 found = true;
432 } else if (bios) {
433 bios->close(bios);
434 bios = NULL;
435 }
436 }
437 if (bios) {
438 GBALoadBIOS(gba, bios);
439 }
440 }
441#endif
442
443 ARMReset(core->cpu);
444 if (core->opts.skipBios && gba->isPristine) {
445 GBASkipBIOS(core->board);
446 }
447}
448
449static void _GBACoreRunFrame(struct mCore* core) {
450 struct GBA* gba = core->board;
451 int32_t frameCounter = gba->video.frameCounter;
452 while (gba->video.frameCounter == frameCounter) {
453 ARMRunLoop(core->cpu);
454 }
455}
456
457static void _GBACoreRunLoop(struct mCore* core) {
458 ARMRunLoop(core->cpu);
459}
460
461static void _GBACoreStep(struct mCore* core) {
462 ARMRun(core->cpu);
463}
464
465static size_t _GBACoreStateSize(struct mCore* core) {
466 UNUSED(core);
467 return sizeof(struct GBASerializedState);
468}
469
470static bool _GBACoreLoadState(struct mCore* core, const void* state) {
471 return GBADeserialize(core->board, state);
472}
473
474static bool _GBACoreSaveState(struct mCore* core, void* state) {
475 GBASerialize(core->board, state);
476 return true;
477}
478
479static void _GBACoreSetKeys(struct mCore* core, uint32_t keys) {
480 struct GBACore* gbacore = (struct GBACore*) core;
481 gbacore->keys = keys;
482 GBATestKeypadIRQ(core->board);
483}
484
485static void _GBACoreAddKeys(struct mCore* core, uint32_t keys) {
486 struct GBACore* gbacore = (struct GBACore*) core;
487 gbacore->keys |= keys;
488 GBATestKeypadIRQ(core->board);
489}
490
491static void _GBACoreClearKeys(struct mCore* core, uint32_t keys) {
492 struct GBACore* gbacore = (struct GBACore*) core;
493 gbacore->keys &= ~keys;
494}
495
496static int32_t _GBACoreFrameCounter(const struct mCore* core) {
497 const struct GBA* gba = core->board;
498 return gba->video.frameCounter;
499}
500
501static int32_t _GBACoreFrameCycles(const struct mCore* core) {
502 UNUSED(core);
503 return VIDEO_TOTAL_LENGTH;
504}
505
506static int32_t _GBACoreFrequency(const struct mCore* core) {
507 UNUSED(core);
508 return GBA_ARM7TDMI_FREQUENCY;
509}
510
511static void _GBACoreGetGameTitle(const struct mCore* core, char* title) {
512 GBAGetGameTitle(core->board, title);
513}
514
515static void _GBACoreGetGameCode(const struct mCore* core, char* title) {
516 GBAGetGameCode(core->board, title);
517}
518
519static void _GBACoreSetPeripheral(struct mCore* core, int type, void* periph) {
520 struct GBA* gba = core->board;
521 switch (type) {
522 case mPERIPH_ROTATION:
523 gba->rotationSource = periph;
524 break;
525 case mPERIPH_RUMBLE:
526 gba->rumble = periph;
527 break;
528 case mPERIPH_GBA_LUMINANCE:
529 gba->luminanceSource = periph;
530 break;
531 default:
532 return;
533 }
534}
535
536static uint32_t _GBACoreBusRead8(struct mCore* core, uint32_t address) {
537 struct ARMCore* cpu = core->cpu;
538 return cpu->memory.load8(cpu, address, 0);
539}
540
541static uint32_t _GBACoreBusRead16(struct mCore* core, uint32_t address) {
542 struct ARMCore* cpu = core->cpu;
543 return cpu->memory.load16(cpu, address, 0);
544
545}
546
547static uint32_t _GBACoreBusRead32(struct mCore* core, uint32_t address) {
548 struct ARMCore* cpu = core->cpu;
549 return cpu->memory.load32(cpu, address, 0);
550}
551
552static void _GBACoreBusWrite8(struct mCore* core, uint32_t address, uint8_t value) {
553 struct ARMCore* cpu = core->cpu;
554 cpu->memory.store8(cpu, address, value, 0);
555}
556
557static void _GBACoreBusWrite16(struct mCore* core, uint32_t address, uint16_t value) {
558 struct ARMCore* cpu = core->cpu;
559 cpu->memory.store16(cpu, address, value, 0);
560}
561
562static void _GBACoreBusWrite32(struct mCore* core, uint32_t address, uint32_t value) {
563 struct ARMCore* cpu = core->cpu;
564 cpu->memory.store32(cpu, address, value, 0);
565}
566
567static uint32_t _GBACoreRawRead8(struct mCore* core, uint32_t address, int segment) {
568 UNUSED(segment);
569 struct ARMCore* cpu = core->cpu;
570 return GBAView8(cpu, address);
571}
572
573static uint32_t _GBACoreRawRead16(struct mCore* core, uint32_t address, int segment) {
574 UNUSED(segment);
575 struct ARMCore* cpu = core->cpu;
576 return GBAView16(cpu, address);
577}
578
579static uint32_t _GBACoreRawRead32(struct mCore* core, uint32_t address, int segment) {
580 UNUSED(segment);
581 struct ARMCore* cpu = core->cpu;
582 return GBAView32(cpu, address);
583}
584
585static void _GBACoreRawWrite8(struct mCore* core, uint32_t address, int segment, uint8_t value) {
586 UNUSED(segment);
587 struct ARMCore* cpu = core->cpu;
588 GBAPatch8(cpu, address, value, NULL);
589}
590
591static void _GBACoreRawWrite16(struct mCore* core, uint32_t address, int segment, uint16_t value) {
592 UNUSED(segment);
593 struct ARMCore* cpu = core->cpu;
594 GBAPatch16(cpu, address, value, NULL);
595}
596
597static void _GBACoreRawWrite32(struct mCore* core, uint32_t address, int segment, uint32_t value) {
598 UNUSED(segment);
599 struct ARMCore* cpu = core->cpu;
600 GBAPatch32(cpu, address, value, NULL);
601}
602
603size_t _GBAListMemoryBlocks(const struct mCore* core, const struct mCoreMemoryBlock** blocks) {
604 const struct GBA* gba = core->board;
605 switch (gba->memory.savedata.type) {
606 case SAVEDATA_SRAM:
607 *blocks = _GBAMemoryBlocksSRAM;
608 return sizeof(_GBAMemoryBlocksSRAM) / sizeof(*_GBAMemoryBlocksSRAM);
609 case SAVEDATA_FLASH512:
610 *blocks = _GBAMemoryBlocksFlash512;
611 return sizeof(_GBAMemoryBlocksFlash512) / sizeof(*_GBAMemoryBlocksFlash512);
612 case SAVEDATA_FLASH1M:
613 *blocks = _GBAMemoryBlocksFlash1M;
614 return sizeof(_GBAMemoryBlocksFlash1M) / sizeof(*_GBAMemoryBlocksFlash1M);
615 case SAVEDATA_EEPROM:
616 *blocks = _GBAMemoryBlocksEEPROM;
617 return sizeof(_GBAMemoryBlocksEEPROM) / sizeof(*_GBAMemoryBlocksEEPROM);
618 default:
619 *blocks = _GBAMemoryBlocks;
620 return sizeof(_GBAMemoryBlocks) / sizeof(*_GBAMemoryBlocks);
621 }
622}
623
624void* _GBAGetMemoryBlock(struct mCore* core, size_t id, size_t* sizeOut) {
625 struct GBA* gba = core->board;
626 switch (id) {
627 default:
628 return NULL;
629 case REGION_BIOS:
630 *sizeOut = SIZE_BIOS;
631 return gba->memory.bios;
632 case REGION_WORKING_RAM:
633 *sizeOut = SIZE_WORKING_RAM;
634 return gba->memory.wram;
635 case REGION_WORKING_IRAM:
636 *sizeOut = SIZE_WORKING_IRAM;
637 return gba->memory.iwram;
638 case REGION_PALETTE_RAM:
639 *sizeOut = SIZE_PALETTE_RAM;
640 return gba->video.palette;
641 case REGION_VRAM:
642 *sizeOut = SIZE_VRAM;
643 return gba->video.vram;
644 case REGION_OAM:
645 *sizeOut = SIZE_OAM;
646 return gba->video.oam.raw;
647 case REGION_CART0:
648 case REGION_CART1:
649 case REGION_CART2:
650 *sizeOut = gba->memory.romSize;
651 return gba->memory.rom;
652 case REGION_CART_SRAM:
653 if (gba->memory.savedata.type == SAVEDATA_FLASH1M) {
654 *sizeOut = SIZE_CART_FLASH1M;
655 return gba->memory.savedata.currentBank;
656 }
657 // Fall through
658 case REGION_CART_SRAM_MIRROR:
659 *sizeOut = GBASavedataSize(&gba->memory.savedata);
660 return gba->memory.savedata.data;
661 }
662}
663
664#ifdef USE_DEBUGGERS
665static bool _GBACoreSupportsDebuggerType(struct mCore* core, enum mDebuggerType type) {
666 UNUSED(core);
667 switch (type) {
668 case DEBUGGER_CLI:
669 return true;
670#ifdef USE_GDB_STUB
671 case DEBUGGER_GDB:
672 return true;
673#endif
674 default:
675 return false;
676 }
677}
678
679static struct mDebuggerPlatform* _GBACoreDebuggerPlatform(struct mCore* core) {
680 struct GBACore* gbacore = (struct GBACore*) core;
681 if (!gbacore->debuggerPlatform) {
682 gbacore->debuggerPlatform = ARMDebuggerPlatformCreate();
683 }
684 return gbacore->debuggerPlatform;
685}
686
687static struct CLIDebuggerSystem* _GBACoreCliDebuggerSystem(struct mCore* core) {
688 return &GBACLIDebuggerCreate(core)->d;
689}
690
691static void _GBACoreAttachDebugger(struct mCore* core, struct mDebugger* debugger) {
692 if (core->debugger) {
693 GBADetachDebugger(core->board);
694 }
695 GBAAttachDebugger(core->board, debugger);
696 core->debugger = debugger;
697}
698
699static void _GBACoreDetachDebugger(struct mCore* core) {
700 GBADetachDebugger(core->board);
701 core->debugger = NULL;
702}
703
704static void _GBACoreLoadSymbols(struct mCore* core, struct VFile* vf) {
705#ifdef USE_ELF
706 bool closeAfter = false;
707 core->symbolTable = mDebuggerSymbolTableCreate();
708#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
709 if (!vf) {
710 closeAfter = true;
711 vf = mDirectorySetOpenSuffix(&core->dirs, core->dirs.base, ".elf", O_RDONLY);
712 }
713#endif
714 if (!vf) {
715 return;
716 }
717 struct ELF* elf = ELFOpen(vf);
718 if (elf) {
719#ifdef USE_DEBUGGERS
720 mCoreLoadELFSymbols(core->symbolTable, elf);
721#endif
722 ELFClose(elf);
723 }
724 if (closeAfter) {
725 vf->close(vf);
726 }
727#endif
728}
729
730static bool _GBACoreLookupIdentifier(struct mCore* core, const char* name, int32_t* value, int* segment) {
731 UNUSED(core);
732 *segment = -1;
733 int i;
734 for (i = 0; i < REG_MAX; i += 2) {
735 const char* reg = GBAIORegisterNames[i >> 1];
736 if (reg && strcasecmp(reg, name) == 0) {
737 *value = BASE_IO | i;
738 return true;
739 }
740 }
741 return false;
742}
743#endif
744
745static struct mCheatDevice* _GBACoreCheatDevice(struct mCore* core) {
746 struct GBACore* gbacore = (struct GBACore*) core;
747 if (!gbacore->cheatDevice) {
748 gbacore->cheatDevice = GBACheatDeviceCreate();
749 ((struct ARMCore*) core->cpu)->components[CPU_COMPONENT_CHEAT_DEVICE] = &gbacore->cheatDevice->d;
750 ARMHotplugAttach(core->cpu, CPU_COMPONENT_CHEAT_DEVICE);
751 gbacore->cheatDevice->p = core;
752 }
753 return gbacore->cheatDevice;
754}
755
756static size_t _GBACoreSavedataClone(struct mCore* core, void** sram) {
757 struct GBA* gba = core->board;
758 size_t size = GBASavedataSize(&gba->memory.savedata);
759 if (!size) {
760 *sram = NULL;
761 return 0;
762 }
763 *sram = malloc(size);
764 struct VFile* vf = VFileFromMemory(*sram, size);
765 if (!vf) {
766 free(*sram);
767 *sram = NULL;
768 return 0;
769 }
770 bool success = GBASavedataClone(&gba->memory.savedata, vf);
771 vf->close(vf);
772 if (!success) {
773 free(*sram);
774 *sram = NULL;
775 return 0;
776 }
777 return size;
778}
779
780static bool _GBACoreSavedataRestore(struct mCore* core, const void* sram, size_t size, bool writeback) {
781 struct VFile* vf = VFileMemChunk(sram, size);
782 if (!vf) {
783 return false;
784 }
785 struct GBA* gba = core->board;
786 bool success = true;
787 if (writeback) {
788 success = GBASavedataLoad(&gba->memory.savedata, vf);
789 vf->close(vf);
790 } else {
791 GBASavedataMask(&gba->memory.savedata, vf, true);
792 }
793 return success;
794}
795
796static size_t _GBACoreListVideoLayers(const struct mCore* core, const struct mCoreChannelInfo** info) {
797 UNUSED(core);
798 if (info) {
799 *info = _GBAVideoLayers;
800 }
801 return sizeof(_GBAVideoLayers) / sizeof(*_GBAVideoLayers);
802}
803
804static size_t _GBACoreListAudioChannels(const struct mCore* core, const struct mCoreChannelInfo** info) {
805 UNUSED(core);
806 if (info) {
807 *info = _GBAAudioChannels;
808 }
809 return sizeof(_GBAAudioChannels) / sizeof(*_GBAAudioChannels);
810}
811
812static void _GBACoreEnableVideoLayer(struct mCore* core, size_t id, bool enable) {
813 struct GBA* gba = core->board;
814 switch (id) {
815 case 0:
816 case 1:
817 case 2:
818 case 3:
819 gba->video.renderer->disableBG[id] = !enable;
820 break;
821 case 4:
822 gba->video.renderer->disableOBJ = !enable;
823 break;
824 default:
825 break;
826 }
827}
828
829static void _GBACoreEnableAudioChannel(struct mCore* core, size_t id, bool enable) {
830 struct GBA* gba = core->board;
831 switch (id) {
832 case 0:
833 case 1:
834 case 2:
835 case 3:
836 gba->audio.psg.forceDisableCh[id] = !enable;
837 break;
838 case 4:
839 gba->audio.forceDisableChA = !enable;
840 case 5:
841 gba->audio.forceDisableChB = !enable;
842 break;
843 default:
844 break;
845 }
846}
847
848static void _GBACoreAdjustVideoLayer(struct mCore* core, size_t id, int32_t x, int32_t y) {
849 struct GBACore* gbacore = (struct GBACore*) core;
850 switch (id) {
851 case 0:
852 case 1:
853 case 2:
854 case 3:
855 gbacore->renderer.bg[id].offsetX = x;
856 gbacore->renderer.bg[id].offsetY = y;
857 break;
858 case 4:
859 gbacore->renderer.objOffsetX = x;
860 gbacore->renderer.objOffsetY = y;
861 gbacore->renderer.oamDirty = 1;
862 break;
863 default:
864 return;
865 }
866 memset(gbacore->renderer.scanlineDirty, 0xFFFFFFFF, sizeof(gbacore->renderer.scanlineDirty));
867}
868
869#ifndef MINIMAL_CORE
870static void _GBACoreStartVideoLog(struct mCore* core, struct mVideoLogContext* context) {
871 struct GBACore* gbacore = (struct GBACore*) core;
872 struct GBA* gba = core->board;
873 gbacore->logContext = context;
874
875 struct GBASerializedState* state = mVideoLogContextInitialState(context, NULL);
876 state->id = 0;
877 state->cpu.gprs[ARM_PC] = BASE_WORKING_RAM;
878
879 int channelId = mVideoLoggerAddChannel(context);
880 gbacore->proxyRenderer.logger = malloc(sizeof(struct mVideoLogger));
881 mVideoLoggerRendererCreate(gbacore->proxyRenderer.logger, false);
882 mVideoLoggerAttachChannel(gbacore->proxyRenderer.logger, context, channelId);
883 gbacore->proxyRenderer.logger->block = false;
884
885 GBAVideoProxyRendererCreate(&gbacore->proxyRenderer, &gbacore->renderer.d);
886 GBAVideoProxyRendererShim(&gba->video, &gbacore->proxyRenderer);
887}
888
889static void _GBACoreEndVideoLog(struct mCore* core) {
890 struct GBACore* gbacore = (struct GBACore*) core;
891 struct GBA* gba = core->board;
892 GBAVideoProxyRendererUnshim(&gba->video, &gbacore->proxyRenderer);
893 free(gbacore->proxyRenderer.logger);
894 gbacore->proxyRenderer.logger = NULL;
895}
896#endif
897
898struct mCore* GBACoreCreate(void) {
899 struct GBACore* gbacore = malloc(sizeof(*gbacore));
900 struct mCore* core = &gbacore->d;
901 memset(&core->opts, 0, sizeof(core->opts));
902 core->cpu = NULL;
903 core->board = NULL;
904 core->debugger = NULL;
905 core->init = _GBACoreInit;
906 core->deinit = _GBACoreDeinit;
907 core->platform = _GBACorePlatform;
908 core->setSync = _GBACoreSetSync;
909 core->loadConfig = _GBACoreLoadConfig;
910 core->desiredVideoDimensions = _GBACoreDesiredVideoDimensions;
911 core->setVideoBuffer = _GBACoreSetVideoBuffer;
912 core->getPixels = _GBACoreGetPixels;
913 core->putPixels = _GBACorePutPixels;
914 core->getAudioChannel = _GBACoreGetAudioChannel;
915 core->setAudioBufferSize = _GBACoreSetAudioBufferSize;
916 core->getAudioBufferSize = _GBACoreGetAudioBufferSize;
917 core->addCoreCallbacks = _GBACoreAddCoreCallbacks;
918 core->clearCoreCallbacks = _GBACoreClearCoreCallbacks;
919 core->setAVStream = _GBACoreSetAVStream;
920 core->isROM = GBAIsROM;
921 core->loadROM = _GBACoreLoadROM;
922 core->loadBIOS = _GBACoreLoadBIOS;
923 core->loadSave = _GBACoreLoadSave;
924 core->loadTemporarySave = _GBACoreLoadTemporarySave;
925 core->loadPatch = _GBACoreLoadPatch;
926 core->unloadROM = _GBACoreUnloadROM;
927 core->checksum = _GBACoreChecksum;
928 core->reset = _GBACoreReset;
929 core->runFrame = _GBACoreRunFrame;
930 core->runLoop = _GBACoreRunLoop;
931 core->step = _GBACoreStep;
932 core->stateSize = _GBACoreStateSize;
933 core->loadState = _GBACoreLoadState;
934 core->saveState = _GBACoreSaveState;
935 core->setKeys = _GBACoreSetKeys;
936 core->addKeys = _GBACoreAddKeys;
937 core->clearKeys = _GBACoreClearKeys;
938 core->frameCounter = _GBACoreFrameCounter;
939 core->frameCycles = _GBACoreFrameCycles;
940 core->frequency = _GBACoreFrequency;
941 core->getGameTitle = _GBACoreGetGameTitle;
942 core->getGameCode = _GBACoreGetGameCode;
943 core->setPeripheral = _GBACoreSetPeripheral;
944 core->busRead8 = _GBACoreBusRead8;
945 core->busRead16 = _GBACoreBusRead16;
946 core->busRead32 = _GBACoreBusRead32;
947 core->busWrite8 = _GBACoreBusWrite8;
948 core->busWrite16 = _GBACoreBusWrite16;
949 core->busWrite32 = _GBACoreBusWrite32;
950 core->rawRead8 = _GBACoreRawRead8;
951 core->rawRead16 = _GBACoreRawRead16;
952 core->rawRead32 = _GBACoreRawRead32;
953 core->rawWrite8 = _GBACoreRawWrite8;
954 core->rawWrite16 = _GBACoreRawWrite16;
955 core->rawWrite32 = _GBACoreRawWrite32;
956 core->listMemoryBlocks = _GBAListMemoryBlocks;
957 core->getMemoryBlock = _GBAGetMemoryBlock;
958#ifdef USE_DEBUGGERS
959 core->supportsDebuggerType = _GBACoreSupportsDebuggerType;
960 core->debuggerPlatform = _GBACoreDebuggerPlatform;
961 core->cliDebuggerSystem = _GBACoreCliDebuggerSystem;
962 core->attachDebugger = _GBACoreAttachDebugger;
963 core->detachDebugger = _GBACoreDetachDebugger;
964 core->loadSymbols = _GBACoreLoadSymbols;
965 core->lookupIdentifier = _GBACoreLookupIdentifier;
966#endif
967 core->cheatDevice = _GBACoreCheatDevice;
968 core->savedataClone = _GBACoreSavedataClone;
969 core->savedataRestore = _GBACoreSavedataRestore;
970 core->listVideoLayers = _GBACoreListVideoLayers;
971 core->listAudioChannels = _GBACoreListAudioChannels;
972 core->enableVideoLayer = _GBACoreEnableVideoLayer;
973 core->enableAudioChannel = _GBACoreEnableAudioChannel;
974 core->adjustVideoLayer = _GBACoreAdjustVideoLayer;
975#ifndef MINIMAL_CORE
976 core->startVideoLog = _GBACoreStartVideoLog;
977 core->endVideoLog = _GBACoreEndVideoLog;
978#endif
979 return core;
980}
981
982#ifndef MINIMAL_CORE
983static void _GBAVLPStartFrameCallback(void *context) {
984 struct mCore* core = context;
985 struct GBACore* gbacore = (struct GBACore*) core;
986 struct GBA* gba = core->board;
987
988 if (!mVideoLoggerRendererRun(gbacore->proxyRenderer.logger, true)) {
989 GBAVideoProxyRendererUnshim(&gba->video, &gbacore->proxyRenderer);
990 mVideoLogContextRewind(gbacore->logContext, core);
991 GBAVideoProxyRendererShim(&gba->video, &gbacore->proxyRenderer);
992 }
993}
994
995static bool _GBAVLPInit(struct mCore* core) {
996 struct GBACore* gbacore = (struct GBACore*) core;
997 if (!_GBACoreInit(core)) {
998 return false;
999 }
1000 gbacore->proxyRenderer.logger = malloc(sizeof(struct mVideoLogger));
1001 mVideoLoggerRendererCreate(gbacore->proxyRenderer.logger, true);
1002 GBAVideoProxyRendererCreate(&gbacore->proxyRenderer, NULL);
1003 memset(&gbacore->logCallbacks, 0, sizeof(gbacore->logCallbacks));
1004 gbacore->logCallbacks.videoFrameStarted = _GBAVLPStartFrameCallback;
1005 gbacore->logCallbacks.context = core;
1006 core->addCoreCallbacks(core, &gbacore->logCallbacks);
1007 return true;
1008}
1009
1010static void _GBAVLPDeinit(struct mCore* core) {
1011 struct GBACore* gbacore = (struct GBACore*) core;
1012 if (gbacore->logContext) {
1013 mVideoLogContextDestroy(core, gbacore->logContext);
1014 }
1015 _GBACoreDeinit(core);
1016}
1017
1018static void _GBAVLPReset(struct mCore* core) {
1019 struct GBACore* gbacore = (struct GBACore*) core;
1020 struct GBA* gba = (struct GBA*) core->board;
1021 if (gba->video.renderer == &gbacore->proxyRenderer.d) {
1022 GBAVideoProxyRendererUnshim(&gba->video, &gbacore->proxyRenderer);
1023 } else if (gbacore->renderer.outputBuffer) {
1024 struct GBAVideoRenderer* renderer = &gbacore->renderer.d;
1025 GBAVideoAssociateRenderer(&gba->video, renderer);
1026 }
1027
1028 ARMReset(core->cpu);
1029 mVideoLogContextRewind(gbacore->logContext, core);
1030 GBAVideoProxyRendererShim(&gba->video, &gbacore->proxyRenderer);
1031
1032 // Make sure CPU loop never spins
1033 GBAHalt(gba);
1034 gba->cpu->memory.store16(gba->cpu, BASE_IO | REG_IME, 0, NULL);
1035 gba->cpu->memory.store16(gba->cpu, BASE_IO | REG_IE, 0, NULL);
1036}
1037
1038static bool _GBAVLPLoadROM(struct mCore* core, struct VFile* vf) {
1039 struct GBACore* gbacore = (struct GBACore*) core;
1040 gbacore->logContext = mVideoLogContextCreate(NULL);
1041 if (!mVideoLogContextLoad(gbacore->logContext, vf)) {
1042 mVideoLogContextDestroy(core, gbacore->logContext);
1043 gbacore->logContext = NULL;
1044 return false;
1045 }
1046 mVideoLoggerAttachChannel(gbacore->proxyRenderer.logger, gbacore->logContext, 0);
1047 return true;
1048}
1049
1050static bool _GBAVLPLoadState(struct mCore* core, const void* state) {
1051 struct GBA* gba = (struct GBA*) core->board;
1052
1053 gba->timing.root = NULL;
1054 gba->cpu->gprs[ARM_PC] = BASE_WORKING_RAM;
1055 gba->cpu->memory.setActiveRegion(gba->cpu, gba->cpu->gprs[ARM_PC]);
1056
1057 // Make sure CPU loop never spins
1058 GBAHalt(gba);
1059 gba->cpu->memory.store16(gba->cpu, BASE_IO | REG_IME, 0, NULL);
1060 gba->cpu->memory.store16(gba->cpu, BASE_IO | REG_IE, 0, NULL);
1061 GBAVideoDeserialize(&gba->video, state);
1062 GBAIODeserialize(gba, state);
1063 GBAAudioReset(&gba->audio);
1064
1065 return true;
1066}
1067
1068static bool _returnTrue(struct VFile* vf) {
1069 UNUSED(vf);
1070 return true;
1071}
1072
1073struct mCore* GBAVideoLogPlayerCreate(void) {
1074 struct mCore* core = GBACoreCreate();
1075 core->init = _GBAVLPInit;
1076 core->deinit = _GBAVLPDeinit;
1077 core->reset = _GBAVLPReset;
1078 core->loadROM = _GBAVLPLoadROM;
1079 core->loadState = _GBAVLPLoadState;
1080 core->isROM = _returnTrue;
1081 return core;
1082}
1083#else
1084struct mCore* GBAVideoLogPlayerCreate(void) {
1085 return false;
1086}
1087#endif