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