all repos — mgba @ d84cee4700a11825259d6396d0b519b0b997f641

mGBA Game Boy Advance Emulator

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/gba/cheats.h>
 12#include <mgba/internal/gba/gba.h>
 13#include <mgba/internal/gba/extra/cli.h>
 14#include <mgba/internal/gba/overrides.h>
 15#ifndef DISABLE_THREADING
 16#include <mgba/internal/gba/renderers/thread-proxy.h>
 17#endif
 18#include <mgba/internal/gba/renderers/video-software.h>
 19#include <mgba/internal/gba/savedata.h>
 20#include <mgba/internal/gba/serialize.h>
 21#include <mgba-util/memory.h>
 22#include <mgba-util/patch.h>
 23#include <mgba-util/vfs.h>
 24
 25const static struct mCoreChannelInfo _GBAVideoLayers[] = {
 26	{ 0, "bg0", "Background 0", NULL },
 27	{ 1, "bg1", "Background 1", NULL },
 28	{ 2, "bg2", "Background 2", NULL },
 29	{ 3, "bg3", "Background 3", NULL },
 30	{ 4, "obj", "Objects", NULL },
 31};
 32
 33const static struct mCoreChannelInfo _GBAAudioChannels[] = {
 34	{ 0, "ch0", "PSG Channel 0", "Square/Sweep" },
 35	{ 1, "ch1", "PSG Channel 1", "Square" },
 36	{ 2, "ch2", "PSG Channel 2", "PCM" },
 37	{ 3, "ch3", "PSG Channel 3", "Noise" },
 38	{ 4, "chA", "FIFO Channel A", NULL },
 39	{ 5, "chB", "FIFO Channel B", NULL },
 40};
 41
 42struct GBACore {
 43	struct mCore d;
 44	struct GBAVideoSoftwareRenderer renderer;
 45#ifndef DISABLE_THREADING
 46	struct GBAVideoThreadProxyRenderer threadProxy;
 47	int threadedVideo;
 48#endif
 49	int keys;
 50	struct mCPUComponent* components[CPU_COMPONENT_MAX];
 51	const struct Configuration* overrides;
 52	struct mDebuggerPlatform* debuggerPlatform;
 53	struct mCheatDevice* cheatDevice;
 54};
 55
 56static bool _GBACoreInit(struct mCore* core) {
 57	struct GBACore* gbacore = (struct GBACore*) core;
 58
 59	struct ARMCore* cpu = anonymousMemoryMap(sizeof(struct ARMCore));
 60	struct GBA* gba = anonymousMemoryMap(sizeof(struct GBA));
 61	if (!cpu || !gba) {
 62		free(cpu);
 63		free(gba);
 64		return false;
 65	}
 66	core->cpu = cpu;
 67	core->board = gba;
 68	core->debugger = NULL;
 69	gbacore->overrides = NULL;
 70	gbacore->debuggerPlatform = NULL;
 71	gbacore->cheatDevice = NULL;
 72
 73	GBACreate(gba);
 74	// TODO: Restore cheats
 75	memset(gbacore->components, 0, sizeof(gbacore->components));
 76	ARMSetComponents(cpu, &gba->d, CPU_COMPONENT_MAX, gbacore->components);
 77	ARMInit(cpu);
 78	mRTCGenericSourceInit(&core->rtc, core);
 79	gba->rtcSource = &core->rtc.d;
 80
 81	GBAVideoSoftwareRendererCreate(&gbacore->renderer);
 82	gbacore->renderer.outputBuffer = NULL;
 83
 84#ifndef DISABLE_THREADING
 85	gbacore->threadedVideo = false;
 86	GBAVideoThreadProxyRendererCreate(&gbacore->threadProxy, &gbacore->renderer.d);
 87#endif
 88
 89	gbacore->keys = 0;
 90	gba->keySource = &gbacore->keys;
 91
 92#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
 93	mDirectorySetInit(&core->dirs);
 94#endif
 95	
 96	return true;
 97}
 98
 99static void _GBACoreDeinit(struct mCore* core) {
100	ARMDeinit(core->cpu);
101	GBADestroy(core->board);
102	mappedMemoryFree(core->cpu, sizeof(struct ARMCore));
103	mappedMemoryFree(core->board, sizeof(struct GBA));
104#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
105	mDirectorySetDeinit(&core->dirs);
106#endif
107
108	struct GBACore* gbacore = (struct GBACore*) core;
109	free(gbacore->debuggerPlatform);
110	if (gbacore->cheatDevice) {
111		mCheatDeviceDestroy(gbacore->cheatDevice);
112	}
113	free(gbacore->cheatDevice);
114	mCoreConfigFreeOpts(&core->opts);
115	free(core);
116}
117
118static enum mPlatform _GBACorePlatform(const struct mCore* core) {
119	UNUSED(core);
120	return PLATFORM_GBA;
121}
122
123static void _GBACoreSetSync(struct mCore* core, struct mCoreSync* sync) {
124	struct GBA* gba = core->board;
125	gba->sync = sync;
126}
127
128static void _GBACoreLoadConfig(struct mCore* core, const struct mCoreConfig* config) {
129	struct GBA* gba = core->board;
130	if (core->opts.mute) {
131		gba->audio.masterVolume = 0;
132	} else {
133		gba->audio.masterVolume = core->opts.volume;
134	}
135	gba->video.frameskip = core->opts.frameskip;
136
137#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
138	struct GBACore* gbacore = (struct GBACore*) core;
139	gbacore->overrides = mCoreConfigGetOverridesConst(config);
140#endif
141
142	const char* idleOptimization = mCoreConfigGetValue(config, "idleOptimization");
143	if (idleOptimization) {
144		if (strcasecmp(idleOptimization, "ignore") == 0) {
145			gba->idleOptimization = IDLE_LOOP_IGNORE;
146		} else if (strcasecmp(idleOptimization, "remove") == 0) {
147			gba->idleOptimization = IDLE_LOOP_REMOVE;
148		} else if (strcasecmp(idleOptimization, "detect") == 0) {
149			if (gba->idleLoop == IDLE_LOOP_NONE) {
150				gba->idleOptimization = IDLE_LOOP_DETECT;
151			} else {
152				gba->idleOptimization = IDLE_LOOP_REMOVE;
153			}
154		}
155	}
156
157	mCoreConfigCopyValue(&core->config, config, "gba.bios");
158
159#ifndef DISABLE_THREADING
160	mCoreConfigGetIntValue(config, "threadedVideo", &gbacore->threadedVideo);
161#endif
162}
163
164static void _GBACoreDesiredVideoDimensions(struct mCore* core, unsigned* width, unsigned* height) {
165	UNUSED(core);
166	*width = VIDEO_HORIZONTAL_PIXELS;
167	*height = VIDEO_VERTICAL_PIXELS;
168}
169
170static void _GBACoreSetVideoBuffer(struct mCore* core, color_t* buffer, size_t stride) {
171	struct GBACore* gbacore = (struct GBACore*) core;
172	gbacore->renderer.outputBuffer = buffer;
173	gbacore->renderer.outputBufferStride = stride;
174}
175
176static void _GBACoreGetPixels(struct mCore* core, const void** buffer, size_t* stride) {
177	struct GBACore* gbacore = (struct GBACore*) core;
178	gbacore->renderer.d.getPixels(&gbacore->renderer.d, stride, buffer);
179}
180
181static void _GBACorePutPixels(struct mCore* core, const void* buffer, size_t stride) {
182	struct GBACore* gbacore = (struct GBACore*) core;
183	gbacore->renderer.d.putPixels(&gbacore->renderer.d, stride, buffer);
184}
185
186static struct blip_t* _GBACoreGetAudioChannel(struct mCore* core, int ch) {
187	struct GBA* gba = core->board;
188	switch (ch) {
189	case 0:
190		return gba->audio.psg.left;
191	case 1:
192		return gba->audio.psg.right;
193	default:
194		return NULL;
195	}
196}
197
198static void _GBACoreSetAudioBufferSize(struct mCore* core, size_t samples) {
199	struct GBA* gba = core->board;
200	GBAAudioResizeBuffer(&gba->audio, samples);
201}
202
203static size_t _GBACoreGetAudioBufferSize(struct mCore* core) {
204	struct GBA* gba = core->board;
205	return gba->audio.samples;
206}
207
208static void _GBACoreAddCoreCallbacks(struct mCore* core, struct mCoreCallbacks* coreCallbacks) {
209	struct GBA* gba = core->board;
210	*mCoreCallbacksListAppend(&gba->coreCallbacks) = *coreCallbacks;
211}
212
213static void _GBACoreClearCoreCallbacks(struct mCore* core) {
214	struct GBA* gba = core->board;
215	mCoreCallbacksListClear(&gba->coreCallbacks);
216}
217
218static void _GBACoreSetAVStream(struct mCore* core, struct mAVStream* stream) {
219	struct GBA* gba = core->board;
220	gba->stream = stream;
221	if (stream && stream->videoDimensionsChanged) {
222		stream->videoDimensionsChanged(stream, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS);
223	}
224}
225
226static bool _GBACoreLoadROM(struct mCore* core, struct VFile* vf) {
227	if (GBAIsMB(vf)) {
228		return GBALoadMB(core->board, vf);
229	}
230	return GBALoadROM(core->board, vf);
231}
232
233static bool _GBACoreLoadBIOS(struct mCore* core, struct VFile* vf, int type) {
234	UNUSED(type);
235	if (!GBAIsBIOS(vf)) {
236		return false;
237	}
238	GBALoadBIOS(core->board, vf);
239	return true;
240}
241
242static bool _GBACoreLoadSave(struct mCore* core, struct VFile* vf) {
243	return GBALoadSave(core->board, vf);
244}
245
246static bool _GBACoreLoadTemporarySave(struct mCore* core, struct VFile* vf) {
247	struct GBA* gba = core->board;
248	GBASavedataMask(&gba->memory.savedata, vf, false);
249	return true; // TODO: Return a real value
250}
251
252static bool _GBACoreLoadPatch(struct mCore* core, struct VFile* vf) {
253	if (!vf) {
254		return false;
255	}
256	struct Patch patch;
257	if (!loadPatch(vf, &patch)) {
258		return false;
259	}
260	GBAApplyPatch(core->board, &patch);
261	return true;
262}
263
264static void _GBACoreUnloadROM(struct mCore* core) {
265	struct GBACore* gbacore = (struct GBACore*) core;
266	struct ARMCore* cpu = core->cpu;
267	if (gbacore->cheatDevice) {
268		ARMHotplugDetach(cpu, CPU_COMPONENT_CHEAT_DEVICE);
269		cpu->components[CPU_COMPONENT_CHEAT_DEVICE] = NULL;
270		mCheatDeviceDestroy(gbacore->cheatDevice);
271		gbacore->cheatDevice = NULL;
272	}
273	return GBAUnloadROM(core->board);
274}
275
276static void _GBACoreChecksum(const struct mCore* core, void* data, enum mCoreChecksumType type) {
277	struct GBA* gba = (struct GBA*) core->board;
278	switch (type) {
279	case CHECKSUM_CRC32:
280		memcpy(data, &gba->romCrc32, sizeof(gba->romCrc32));
281		break;
282	}
283	return;
284}
285
286static void _GBACoreReset(struct mCore* core) {
287	struct GBACore* gbacore = (struct GBACore*) core;
288	struct GBA* gba = (struct GBA*) core->board;
289	if (gbacore->renderer.outputBuffer) {
290		struct GBAVideoRenderer* renderer = &gbacore->renderer.d;
291#ifndef DISABLE_THREADING
292		if (gbacore->threadedVideo) {
293			renderer = &gbacore->threadProxy.d;
294		}
295#endif
296		GBAVideoAssociateRenderer(&gba->video, renderer);
297	}
298
299	struct GBACartridgeOverride override;
300	const struct GBACartridge* cart = (const struct GBACartridge*) gba->memory.rom;
301	if (cart) {
302		memcpy(override.id, &cart->id, sizeof(override.id));
303		if (GBAOverrideFind(gbacore->overrides, &override)) {
304			GBAOverrideApply(gba, &override);
305		}
306	}
307
308#if !defined(MINIMAL_CORE) || MINIMAL_CORE < 2
309	if (!gba->biosVf && core->opts.useBios) {
310		struct VFile* bios = NULL;
311		bool found = false;
312		if (core->opts.bios) {
313			bios = VFileOpen(core->opts.bios, O_RDONLY);
314			if (bios && GBAIsBIOS(bios)) {
315				found = true;
316			} else if (bios) {
317				bios->close(bios);
318				bios = NULL;
319			}
320		}
321		if (!found) {
322			const char* configPath = mCoreConfigGetValue(&core->config, "gba.bios");
323			if (configPath) {
324				bios = VFileOpen(configPath, O_RDONLY);
325			}
326			if (bios && GBAIsBIOS(bios)) {
327				found = true;
328			} else if (bios) {
329				bios->close(bios);
330				bios = NULL;
331			}
332		}
333		if (!found) {
334			char path[PATH_MAX];
335			mCoreConfigDirectory(path, PATH_MAX);
336			strncat(path, PATH_SEP "gba_bios.bin", PATH_MAX - strlen(path));
337			bios = VFileOpen(path, O_RDONLY);
338			if (bios && GBIsBIOS(bios)) {
339				found = true;
340			} else if (bios) {
341				bios->close(bios);
342				bios = NULL;
343			}
344		}
345		if (bios) {
346			GBALoadBIOS(gba, bios);
347		}
348	}
349#endif
350
351	ARMReset(core->cpu);
352	if (core->opts.skipBios && gba->isPristine) {
353		GBASkipBIOS(core->board);
354	}
355}
356
357static void _GBACoreRunFrame(struct mCore* core) {
358	struct GBA* gba = core->board;
359	int32_t frameCounter = gba->video.frameCounter;
360	while (gba->video.frameCounter == frameCounter) {
361		ARMRunLoop(core->cpu);
362	}
363}
364
365static void _GBACoreRunLoop(struct mCore* core) {
366	ARMRunLoop(core->cpu);
367}
368
369static void _GBACoreStep(struct mCore* core) {
370	ARMRun(core->cpu);
371}
372
373static size_t _GBACoreStateSize(struct mCore* core) {
374	UNUSED(core);
375	return sizeof(struct GBASerializedState);
376}
377
378static bool _GBACoreLoadState(struct mCore* core, const void* state) {
379	return GBADeserialize(core->board, state);
380}
381
382static bool _GBACoreSaveState(struct mCore* core, void* state) {
383	GBASerialize(core->board, state);
384	return true;
385}
386
387static void _GBACoreSetKeys(struct mCore* core, uint32_t keys) {
388	struct GBACore* gbacore = (struct GBACore*) core;
389	gbacore->keys = keys;
390}
391
392static void _GBACoreAddKeys(struct mCore* core, uint32_t keys) {
393	struct GBACore* gbacore = (struct GBACore*) core;
394	gbacore->keys |= keys;
395}
396
397static void _GBACoreClearKeys(struct mCore* core, uint32_t keys) {
398	struct GBACore* gbacore = (struct GBACore*) core;
399	gbacore->keys &= ~keys;
400}
401
402static int32_t _GBACoreFrameCounter(const struct mCore* core) {
403	const struct GBA* gba = core->board;
404	return gba->video.frameCounter;
405}
406
407static int32_t _GBACoreFrameCycles(const struct mCore* core) {
408	UNUSED(core);
409	return VIDEO_TOTAL_LENGTH;
410}
411
412static int32_t _GBACoreFrequency(const struct mCore* core) {
413	UNUSED(core);
414	return GBA_ARM7TDMI_FREQUENCY;
415}
416
417static void _GBACoreGetGameTitle(const struct mCore* core, char* title) {
418	GBAGetGameTitle(core->board, title);
419}
420
421static void _GBACoreGetGameCode(const struct mCore* core, char* title) {
422	GBAGetGameCode(core->board, title);
423}
424
425static void _GBACoreSetPeripheral(struct mCore* core, int type, void* periph) {
426	struct GBA* gba = core->board;
427	switch (type) {
428	case mPERIPH_ROTATION:
429		gba->rotationSource = periph;
430		break;
431	case mPERIPH_RUMBLE:
432		gba->rumble = periph;
433		break;
434	case mPERIPH_GBA_LUMINANCE:
435		gba->luminanceSource = periph;
436		break;
437	default:
438		return;
439	}
440}
441
442static uint32_t _GBACoreBusRead8(struct mCore* core, uint32_t address) {
443	struct ARMCore* cpu = core->cpu;
444	return cpu->memory.load8(cpu, address, 0);
445}
446
447static uint32_t _GBACoreBusRead16(struct mCore* core, uint32_t address) {
448	struct ARMCore* cpu = core->cpu;
449	return cpu->memory.load16(cpu, address, 0);
450
451}
452
453static uint32_t _GBACoreBusRead32(struct mCore* core, uint32_t address) {
454	struct ARMCore* cpu = core->cpu;
455	return cpu->memory.load32(cpu, address, 0);
456}
457
458static void _GBACoreBusWrite8(struct mCore* core, uint32_t address, uint8_t value) {
459	struct ARMCore* cpu = core->cpu;
460	cpu->memory.store8(cpu, address, value, 0);
461}
462
463static void _GBACoreBusWrite16(struct mCore* core, uint32_t address, uint16_t value) {
464	struct ARMCore* cpu = core->cpu;
465	cpu->memory.store16(cpu, address, value, 0);
466}
467
468static void _GBACoreBusWrite32(struct mCore* core, uint32_t address, uint32_t value) {
469	struct ARMCore* cpu = core->cpu;
470	cpu->memory.store32(cpu, address, value, 0);
471}
472
473static uint32_t _GBACoreRawRead8(struct mCore* core, uint32_t address, int segment) {
474	UNUSED(segment);
475	struct ARMCore* cpu = core->cpu;
476	return GBAView8(cpu, address);
477}
478
479static uint32_t _GBACoreRawRead16(struct mCore* core, uint32_t address, int segment) {
480	UNUSED(segment);
481	struct ARMCore* cpu = core->cpu;
482	return GBAView16(cpu, address);
483}
484
485static uint32_t _GBACoreRawRead32(struct mCore* core, uint32_t address, int segment) {
486	UNUSED(segment);
487	struct ARMCore* cpu = core->cpu;
488	return GBAView32(cpu, address);
489}
490
491static void _GBACoreRawWrite8(struct mCore* core, uint32_t address, int segment, uint8_t value) {
492	UNUSED(segment);
493	struct ARMCore* cpu = core->cpu;
494	GBAPatch8(cpu, address, value, NULL);
495}
496
497static void _GBACoreRawWrite16(struct mCore* core, uint32_t address, int segment, uint16_t value) {
498	UNUSED(segment);
499	struct ARMCore* cpu = core->cpu;
500	GBAPatch16(cpu, address, value, NULL);
501}
502
503static void _GBACoreRawWrite32(struct mCore* core, uint32_t address, int segment, uint32_t value) {
504	UNUSED(segment);
505	struct ARMCore* cpu = core->cpu;
506	GBAPatch32(cpu, address, value, NULL);
507}
508
509#ifdef USE_DEBUGGERS
510static bool _GBACoreSupportsDebuggerType(struct mCore* core, enum mDebuggerType type) {
511	UNUSED(core);
512	switch (type) {
513	case DEBUGGER_CLI:
514		return true;
515#ifdef USE_GDB_STUB
516	case DEBUGGER_GDB:
517		return true;
518#endif
519	default:
520		return false;
521	}
522}
523
524static struct mDebuggerPlatform* _GBACoreDebuggerPlatform(struct mCore* core) {
525	struct GBACore* gbacore = (struct GBACore*) core;
526	if (!gbacore->debuggerPlatform) {
527		gbacore->debuggerPlatform = ARMDebuggerPlatformCreate();
528	}
529	return gbacore->debuggerPlatform;
530}
531
532static struct CLIDebuggerSystem* _GBACoreCliDebuggerSystem(struct mCore* core) {
533	return &GBACLIDebuggerCreate(core)->d;
534}
535
536static void _GBACoreAttachDebugger(struct mCore* core, struct mDebugger* debugger) {
537	if (core->debugger) {
538		GBADetachDebugger(core->board);
539	}
540	GBAAttachDebugger(core->board, debugger);
541	core->debugger = debugger;
542}
543
544static void _GBACoreDetachDebugger(struct mCore* core) {
545	GBADetachDebugger(core->board);
546	core->debugger = NULL;
547}
548#endif
549
550static struct mCheatDevice* _GBACoreCheatDevice(struct mCore* core) {
551	struct GBACore* gbacore = (struct GBACore*) core;
552	if (!gbacore->cheatDevice) {
553		gbacore->cheatDevice = GBACheatDeviceCreate();
554		((struct ARMCore*) core->cpu)->components[CPU_COMPONENT_CHEAT_DEVICE] = &gbacore->cheatDevice->d;
555		ARMHotplugAttach(core->cpu, CPU_COMPONENT_CHEAT_DEVICE);
556		gbacore->cheatDevice->p = core;
557	}
558	return gbacore->cheatDevice;
559}
560
561static size_t _GBACoreSavedataClone(struct mCore* core, void** sram) {
562	struct GBA* gba = core->board;
563	size_t size = GBASavedataSize(&gba->memory.savedata);
564	if (!size) {
565		*sram = NULL;
566		return 0;
567	}
568	*sram = malloc(size);
569	struct VFile* vf = VFileFromMemory(*sram, size);
570	if (!vf) {
571		free(*sram);
572		*sram = NULL;
573		return 0;
574	}
575	bool success = GBASavedataClone(&gba->memory.savedata, vf);
576	vf->close(vf);
577	if (!success) {
578		free(*sram);
579		*sram = NULL;
580		return 0;
581	}
582	return size;
583}
584
585static bool _GBACoreSavedataRestore(struct mCore* core, const void* sram, size_t size, bool writeback) {
586	struct VFile* vf = VFileMemChunk(sram, size);
587	if (!vf) {
588		return false;
589	}
590	struct GBA* gba = core->board;
591	bool success = true;
592	if (writeback) {
593		success = GBASavedataLoad(&gba->memory.savedata, vf);
594		vf->close(vf);
595	} else {
596		GBASavedataMask(&gba->memory.savedata, vf, true);
597	}
598	return success;
599}
600
601static size_t _GBACoreListVideoLayers(const struct mCore* core, const struct mCoreChannelInfo** info) {
602	UNUSED(core);
603	*info = _GBAVideoLayers;
604	return sizeof(_GBAVideoLayers) / sizeof(*_GBAVideoLayers);
605}
606
607static size_t _GBACoreListAudioChannels(const struct mCore* core, const struct mCoreChannelInfo** info) {
608	UNUSED(core);
609	*info = _GBAAudioChannels;
610	return sizeof(_GBAAudioChannels) / sizeof(*_GBAAudioChannels);
611}
612
613static void _GBACoreEnableVideoLayer(struct mCore* core, size_t id, bool enable) {
614	struct GBA* gba = core->board;
615	switch (id) {
616	case 0:
617	case 1:
618	case 2:
619	case 3:
620		gba->video.renderer->disableBG[id] = !enable;
621		break;
622	case 4:
623		gba->video.renderer->disableOBJ = !enable;
624		break;
625	default:
626		break;
627	}
628}
629
630static void _GBACoreEnableAudioChannel(struct mCore* core, size_t id, bool enable) {
631	struct GBA* gba = core->board;
632	switch (id) {
633	case 0:
634	case 1:
635	case 2:
636	case 3:
637		gba->audio.psg.forceDisableCh[id] = !enable;
638		break;
639	case 4:
640		gba->audio.forceDisableChA = !enable;
641	case 5:
642		gba->audio.forceDisableChB = !enable;
643		break;
644	default:
645		break;
646	}
647}
648
649struct mCore* GBACoreCreate(void) {
650	struct GBACore* gbacore = malloc(sizeof(*gbacore));
651	struct mCore* core = &gbacore->d;
652	memset(&core->opts, 0, sizeof(core->opts));
653	core->cpu = NULL;
654	core->board = NULL;
655	core->debugger = NULL;
656	core->init = _GBACoreInit;
657	core->deinit = _GBACoreDeinit;
658	core->platform = _GBACorePlatform;
659	core->setSync = _GBACoreSetSync;
660	core->loadConfig = _GBACoreLoadConfig;
661	core->desiredVideoDimensions = _GBACoreDesiredVideoDimensions;
662	core->setVideoBuffer = _GBACoreSetVideoBuffer;
663	core->getPixels = _GBACoreGetPixels;
664	core->putPixels = _GBACorePutPixels;
665	core->getAudioChannel = _GBACoreGetAudioChannel;
666	core->setAudioBufferSize = _GBACoreSetAudioBufferSize;
667	core->getAudioBufferSize = _GBACoreGetAudioBufferSize;
668	core->addCoreCallbacks = _GBACoreAddCoreCallbacks;
669	core->clearCoreCallbacks = _GBACoreClearCoreCallbacks;
670	core->setAVStream = _GBACoreSetAVStream;
671	core->isROM = GBAIsROM;
672	core->loadROM = _GBACoreLoadROM;
673	core->loadBIOS = _GBACoreLoadBIOS;
674	core->loadSave = _GBACoreLoadSave;
675	core->loadTemporarySave = _GBACoreLoadTemporarySave;
676	core->loadPatch = _GBACoreLoadPatch;
677	core->unloadROM = _GBACoreUnloadROM;
678	core->checksum = _GBACoreChecksum;
679	core->reset = _GBACoreReset;
680	core->runFrame = _GBACoreRunFrame;
681	core->runLoop = _GBACoreRunLoop;
682	core->step = _GBACoreStep;
683	core->stateSize = _GBACoreStateSize;
684	core->loadState = _GBACoreLoadState;
685	core->saveState = _GBACoreSaveState;
686	core->setKeys = _GBACoreSetKeys;
687	core->addKeys = _GBACoreAddKeys;
688	core->clearKeys = _GBACoreClearKeys;
689	core->frameCounter = _GBACoreFrameCounter;
690	core->frameCycles = _GBACoreFrameCycles;
691	core->frequency = _GBACoreFrequency;
692	core->getGameTitle = _GBACoreGetGameTitle;
693	core->getGameCode = _GBACoreGetGameCode;
694	core->setPeripheral = _GBACoreSetPeripheral;
695	core->busRead8 = _GBACoreBusRead8;
696	core->busRead16 = _GBACoreBusRead16;
697	core->busRead32 = _GBACoreBusRead32;
698	core->busWrite8 = _GBACoreBusWrite8;
699	core->busWrite16 = _GBACoreBusWrite16;
700	core->busWrite32 = _GBACoreBusWrite32;
701	core->rawRead8 = _GBACoreRawRead8;
702	core->rawRead16 = _GBACoreRawRead16;
703	core->rawRead32 = _GBACoreRawRead32;
704	core->rawWrite8 = _GBACoreRawWrite8;
705	core->rawWrite16 = _GBACoreRawWrite16;
706	core->rawWrite32 = _GBACoreRawWrite32;
707#ifdef USE_DEBUGGERS
708	core->supportsDebuggerType = _GBACoreSupportsDebuggerType;
709	core->debuggerPlatform = _GBACoreDebuggerPlatform;
710	core->cliDebuggerSystem = _GBACoreCliDebuggerSystem;
711	core->attachDebugger = _GBACoreAttachDebugger;
712	core->detachDebugger = _GBACoreDetachDebugger;
713#endif
714	core->cheatDevice = _GBACoreCheatDevice;
715	core->savedataClone = _GBACoreSavedataClone;
716	core->savedataRestore = _GBACoreSavedataRestore;
717	core->listVideoLayers = _GBACoreListVideoLayers;
718	core->listAudioChannels = _GBACoreListAudioChannels;
719	core->enableVideoLayer = _GBACoreEnableVideoLayer;
720	core->enableAudioChannel = _GBACoreEnableAudioChannel;
721	return core;
722}