@@ -15,6 +15,8 @@
 DEFINE_VECTOR(DebugBreakpointList, struct DebugBreakpoint);
 DEFINE_VECTOR(DebugWatchpointList, struct DebugWatchpoint);
 
+mLOG_DEFINE_CATEGORY(DEBUGGER, "Debugger");
+
 static struct DebugBreakpoint* _lookupBreakpoint(struct DebugBreakpointList* breakpoints, uint32_t address) {
 	size_t i;
 	for (i = 0; i < DebugBreakpointListSize(breakpoints); ++i) {

@@ -9,7 +9,10 @@
 #include "util/common.h"
 
 #include "arm/arm.h"
+#include "core/log.h"
 #include "util/vector.h"
+
+mLOG_DECLARE_CATEGORY(DEBUGGER);
 
 extern const uint32_t DEBUGGER_ID;
 
@@ -105,9 +108,6 @@ void (*custom)(struct Debugger*);
 
 	bool (*setSoftwareBreakpoint)(struct Debugger*, uint32_t address, enum ExecutionMode mode, uint32_t* opcode);
 	bool (*clearSoftwareBreakpoint)(struct Debugger*, uint32_t address, enum ExecutionMode mode, uint32_t opcode);
-
-	ATTRIBUTE_FORMAT(printf, 3, 4)
-	void (*log)(struct Debugger*, enum DebuggerLogLevel, const char* format, ...);
 };
 
 void DebuggerCreate(struct Debugger*);

@@ -100,9 +100,7 @@ }
 
 static void _nak(struct GDBStub* stub) {
 	char nak = '-';
-	if (stub->d.log) {
-		stub->d.log(&stub->d, DEBUGGER_LOG_WARN, "Packet error");
-	}
+	mLOG(DEBUGGER, WARN, "Packet error");
 	SocketSend(stub->connection, &nak, 1);
 }
 
@@ -181,9 +179,7 @@ }
 	stub->outgoing[i] = '#';
 	_int2hex8(checksum, &stub->outgoing[i + 1]);
 	stub->outgoing[i + 3] = 0;
-	if (stub->d.log) {
-		stub->d.log(&stub->d, DEBUGGER_LOG_DEBUG, "> %s", stub->outgoing);
-	}
+	mLOG(DEBUGGER, DEBUG, "> %s", stub->outgoing);
 	SocketSend(stub->connection, stub->outgoing, i + 3);
 }
 
@@ -408,9 +404,7 @@ }
 	parsed += 2;
 	int networkChecksum = _hex2int(&message[i], 2);
 	if (networkChecksum != checksum) {
-		if (stub->d.log) {
-			stub->d.log(&stub->d, DEBUGGER_LOG_WARN, "Checksum error: expected %02x, got %02x", checksum, networkChecksum);
-		}
+		mLOG(DEBUGGER, WARN, "Checksum error: expected %02x, got %02x", checksum, networkChecksum);
 		_nak(stub);
 		return parsed;
 	}
@@ -476,7 +470,6 @@ stub->d.deinit = _gdbStubDeinit;
 	stub->d.paused = _gdbStubWait;
 	stub->d.entered = _gdbStubEntered;
 	stub->d.custom = _gdbStubPoll;
-	stub->d.log = 0;
 	stub->untilPoll = GDB_STUB_INTERVAL;
 	stub->lineAck = GDB_ACK_PENDING;
 	stub->shouldBlock = false;
@@ -488,9 +481,7 @@ GDBStubShutdown(stub);
 	}
 	stub->socket = SocketOpenTCP(port, bindAddress);
 	if (SOCKET_FAILED(stub->socket)) {
-		if (stub->d.log) {
-			stub->d.log(&stub->d, DEBUGGER_LOG_ERROR, "Couldn't open socket");
-		}
+		mLOG(DEBUGGER, ERROR, "Couldn't open socket");
 		return false;
 	}
 	if (!SocketSetBlocking(stub->socket, false)) {
@@ -504,9 +495,7 @@
 	return true;
 
 cleanup:
-	if (stub->d.log) {
-		stub->d.log(&stub->d, DEBUGGER_LOG_ERROR, "Couldn't listen on port");
-	}
+	mLOG(DEBUGGER, ERROR, "Couldn't listen on port");
 	SocketClose(stub->socket);
 	stub->socket = INVALID_SOCKET;
 	return false;
@@ -570,9 +559,7 @@ }
 			goto connectionLost;
 		}
 		stub->line[messageLen] = '\0';
-		if (stub->d.log) {
-			stub->d.log(&stub->d, DEBUGGER_LOG_DEBUG, "< %s", stub->line);
-		}
+		mLOG(DEBUGGER, DEBUG, "< %s", stub->line);
 		ssize_t position = 0;
 		while (position < messageLen) {
 			position += _parseGDBMessage(stub, &stub->line[position]);
@@ -580,8 +567,6 @@ }
 	}
 
 connectionLost:
-	if (stub->d.log) {
-		stub->d.log(&stub->d, DEBUGGER_LOG_INFO, "Connection lost");
-	}
+	mLOG(DEBUGGER, WARN, "Connection lost");
 	GDBStubHangup(stub);
 }

@@ -11,6 +11,8 @@ #include "gba/io.h"
 #include "gba/serialize.h"
 #include "gba/video.h"
 
+mLOG_DEFINE_CATEGORY(GBA_AUDIO, "GBA Audio");
+
 const unsigned GBA_AUDIO_SAMPLES = 2048;
 const unsigned GBA_AUDIO_FIFO_SIZE = 8 * sizeof(int32_t);
 const int GBA_AUDIO_VOLUME_MAX = 0x100;
@@ -118,7 +120,7 @@ case BASE_IO | REG_FIFO_B_LO:
 		audio->chB.dmaSource = number;
 		break;
 	default:
-		GBALog(audio->p, GBA_LOG_GAME_ERROR, "Invalid FIFO destination: 0x%08X", info->dest);
+		mLOG(GBA_AUDIO, GAME_ERROR, "Invalid FIFO destination: 0x%08X", info->dest);
 		return;
 	}
 	info->reg = GBADMARegisterSetDestControl(info->reg, DMA_FIXED);
@@ -220,7 +222,7 @@ case REG_FIFO_B_LO:
 		fifo = &audio->chB.fifo;
 		break;
 	default:
-		GBALog(audio->p, GBA_LOG_ERROR, "Bad FIFO write to address 0x%03x", address);
+		mLOG(GBA_AUDIO, ERROR, "Bad FIFO write to address 0x%03x", address);
 		return;
 	}
 	int i;
@@ -239,7 +241,7 @@ channel = &audio->chA;
 	} else if (fifoId == 1) {
 		channel = &audio->chB;
 	} else {
-		GBALog(audio->p, GBA_LOG_ERROR, "Bad FIFO write to address 0x%03x", fifoId);
+		mLOG(GBA_AUDIO, ERROR, "Bad FIFO write to address 0x%03x", fifoId);
 		return;
 	}
 	if (CircleBufferSize(&channel->fifo) <= 4 * sizeof(int32_t) && channel->dmaSource > 0) {

@@ -9,8 +9,11 @@
 #include "util/common.h"
 #include "macros.h"
 
+#include "core/log.h"
 #include "gb/audio.h"
 #include "util/circle-buffer.h"
+
+mLOG_DECLARE_CATEGORY(GBA_AUDIO);
 
 struct GBADMA;
 

@@ -508,11 +508,11 @@ uint32_t header = cpu->memory.load32(cpu, source, 0);
 	int remaining = header >> 8;
 	int bits = header & 0xF;
 	if (bits == 0) {
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Invalid Huffman bits");
+		mLOG(GBA_BIOS, GAME_ERROR, "Invalid Huffman bits");
 		bits = 8;
 	}
 	if (32 % bits || bits == 1) {
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented unaligned Huffman");
+		mLOG(GBA_BIOS, STUB, "Unimplemented unaligned Huffman");
 		return;
 	}
 	// We assume the signature byte (0x20) is correct

@@ -15,6 +15,8 @@ #define MAX_LINE_LENGTH 128
 
 const uint32_t GBA_CHEAT_DEVICE_ID = 0xABADC0DE;
 
+mLOG_DEFINE_CATEGORY(CHEATS, "Cheats");
+
 DEFINE_VECTOR(GBACheatList, struct GBACheat);
 DEFINE_VECTOR(GBACheatSets, struct GBACheatSet*);
 DEFINE_VECTOR(StringList, char*);

@@ -8,7 +8,8 @@ #define GBA_CHEATS_H
 
 #include "util/common.h"
 
-#include "arm.h"
+#include "arm/arm.h"
+#include "core/log.h"
 #include "util/vector.h"
 
 #define MAX_ROM_PATCHES 4
@@ -150,6 +151,8 @@ uint32_t patchedOpcode;
 	size_t refs;
 	size_t reentries;
 };
+
+mLOG_DECLARE_CATEGORY(CHEATS);
 
 DECLARE_VECTOR(GBACheatList, struct GBACheat);
 DECLARE_VECTOR(StringList, char*);

@@ -57,7 +57,7 @@ cheat->width = 2;
 		cheats->incompleteCheat = cheat;
 		break;
 	case CB_FILL_8:
-		GBALog(0, GBA_LOG_STUB, "[Cheat] CodeBreaker code %08X %04X not supported", op1, op2);
+		mLOG(CHEATS, STUB, "CodeBreaker code %08X %04X not supported", op1, op2);
 		return false;
 	case CB_AND_2:
 		cheat = GBACheatListAppend(&cheats->list);
@@ -75,7 +75,7 @@ cheat->type = CHEAT_ASSIGN;
 		cheat->width = 2;
 		break;
 	case CB_ENCRYPT:
-		GBALog(0, GBA_LOG_STUB, "[Cheat] CodeBreaker encryption not supported");
+		mLOG(CHEATS, STUB, "CodeBreaker encryption not supported");
 		return false;
 	case CB_IF_NE:
 		cheat = GBACheatListAppend(&cheats->list);
@@ -103,7 +103,7 @@ cheat->operand = op2;
 			cheat->repeat = 1;
 			return true;
 		default:
-			GBALog(0, GBA_LOG_STUB, "[Cheat] CodeBreaker code %08X %04X not supported", op1, op2);
+			mLOG(CHEATS, STUB, "CodeBreaker code %08X %04X not supported", op1, op2);
 			return false;
 		}
 	case CB_ADD_2:

@@ -152,7 +152,7 @@ cheats->romPatches[0].exists = true;
 		return true;
 	case GSA_BUTTON:
 		// TODO: Implement button
-		GBALog(0, GBA_LOG_STUB, "GameShark button unimplemented");
+		mLOG(CHEATS, STUB, "GameShark button unimplemented");
 		return false;
 	case GSA_IF_EQ:
 		if (op1 == 0xDEADFACE) {

@@ -109,7 +109,7 @@
 	switch (condition) {
 	case PAR3_COND_OTHER:
 		// We shouldn't be able to get here
-		GBALog(0, GBA_LOG_ERROR, "Unexpectedly created 'other' PARv3 code");
+		mLOG(CHEATS, ERROR, "Unexpectedly created 'other' PARv3 code");
 		cheat->type = CHEAT_IF_LAND;
 		cheat->operand = 0;
 		break;
@@ -148,7 +148,7 @@ case PAR3_OTHER_BUTTON_1:
 	case PAR3_OTHER_BUTTON_2:
 	case PAR3_OTHER_BUTTON_4:
 		// TODO: Button
-		GBALog(0, GBA_LOG_STUB, "GameShark button unimplemented");
+		mLOG(CHEATS, STUB, "GameShark button unimplemented");
 		return false;
 	// TODO: Fix overriding existing patches
 	case PAR3_OTHER_PATCH_1:

@@ -225,7 +225,7 @@ int32_t nextEvent = INT_MAX;
 		int32_t testEvent;
 #ifndef NDEBUG
 		if (cycles < 0) {
-			GBALog(gba, GBA_LOG_FATAL, "Negative cycles passed: %i", cycles);
+			mLOG(GBA, FATAL, "Negative cycles passed: %i", cycles);
 		}
 #endif
 
@@ -434,7 +434,7 @@ #else
 	gba->pristineRom = vf->map(vf, gba->pristineRomSize, MAP_READ);
 #endif
 	if (!gba->pristineRom) {
-		GBALog(gba, GBA_LOG_WARN, "Couldn't map ROM");
+		mLOG(GBA, WARN, "Couldn't map ROM");
 		return false;
 	}
 	gba->yankedRomSize = 0;
@@ -463,7 +463,7 @@ #else
 	gba->pristineRom = vf->map(vf, gba->pristineRomSize, MAP_READ);
 #endif
 	if (!gba->pristineRom) {
-		GBALog(gba, GBA_LOG_WARN, "Couldn't map ROM");
+		mLOG(GBA, WARN, "Couldn't map ROM");
 		return false;
 	}
 	gba->yankedRomSize = 0;
@@ -476,15 +476,6 @@ // TODO: error check
 	return true;
 }
 
-bool GBALoadROM(struct GBA* gba, struct VFile* vf, struct VFile* sav, const char* fname) {
-	if (!GBALoadROM2(gba, vf)) {
-		return false;
-	}
-	gba->activeFile = fname;
-	GBALoadSave(gba, sav);
-	return true;
-}
-
 bool GBALoadSave(struct GBA* gba, struct VFile* sav) {
 	GBASavedataInit(&gba->memory.savedata, sav);
 	return true;
@@ -501,19 +492,19 @@ void GBALoadBIOS(struct GBA* gba, struct VFile* vf) {
 	gba->biosVf = vf;
 	uint32_t* bios = vf->map(vf, SIZE_BIOS, MAP_READ);
 	if (!bios) {
-		GBALog(gba, GBA_LOG_WARN, "Couldn't map BIOS");
+		mLOG(GBA, WARN, "Couldn't map BIOS");
 		return;
 	}
 	gba->memory.bios = bios;
 	gba->memory.fullBios = 1;
 	uint32_t checksum = GBAChecksum(gba->memory.bios, SIZE_BIOS);
-	GBALog(gba, GBA_LOG_DEBUG, "BIOS Checksum: 0x%X", checksum);
+	mLOG(GBA, DEBUG, "BIOS Checksum: 0x%X", checksum);
 	if (checksum == GBA_BIOS_CHECKSUM) {
-		GBALog(gba, GBA_LOG_INFO, "Official GBA BIOS detected");
+		mLOG(GBA, INFO, "Official GBA BIOS detected");
 	} else if (checksum == GBA_DS_BIOS_CHECKSUM) {
-		GBALog(gba, GBA_LOG_INFO, "Official GBA (DS) BIOS detected");
+		mLOG(GBA, INFO, "Official GBA (DS) BIOS detected");
 	} else {
-		GBALog(gba, GBA_LOG_WARN, "BIOS checksum incorrect");
+		mLOG(GBA, WARN, "BIOS checksum incorrect");
 	}
 	gba->biosChecksum = checksum;
 	if (gba->memory.activeRegion == REGION_BIOS) {
@@ -606,7 +597,7 @@ };
 
 void GBAWriteIE(struct GBA* gba, uint16_t value) {
 	if (value & (1 << IRQ_KEYPAD)) {
-		GBALog(gba, GBA_LOG_STUB, "Keypad interrupts not implemented");
+		mLOG(GBA, STUB, "Keypad interrupts not implemented");
 	}
 
 	if (gba->memory.io[REG_IME >> 1] && value & gba->memory.io[REG_IF >> 1]) {
@@ -650,14 +641,6 @@ gba->cpu->nextEvent = gba->cpu->cycles;
 	gba->stopCallback->stop(gba->stopCallback);
 }
 
-void GBALog(struct GBA* gba, enum GBALogLevel level, const char* format, ...) {
-	// TODO: Kill GBALog
-}
-
-void GBADebuggerLogShim(struct Debugger* debugger, enum DebuggerLogLevel level, const char* format, ...) {
-	// TODO: Kill GBADebuggerLogShim
-}
-
 bool GBAIsROM(struct VFile* vf) {
 	if (vf->seek(vf, GBA_ROM_MAGIC_OFFSET, SEEK_SET) < 0) {
 		return false;
@@ -744,22 +727,22 @@ }
 
 void GBAHitStub(struct ARMCore* cpu, uint32_t opcode) {
 	struct GBA* gba = (struct GBA*) cpu->master;
-	enum GBALogLevel level = GBA_LOG_ERROR;
 	if (gba->debugger) {
-		level = GBA_LOG_STUB;
 		struct DebuggerEntryInfo info = {
 			.address = _ARMPCAddress(cpu),
 			.opcode = opcode
 		};
 		DebuggerEnter(gba->debugger, DEBUGGER_ENTER_ILLEGAL_OP, &info);
 	}
-	GBALog(gba, level, "Stub opcode: %08x", opcode);
+	// TODO: More sensible category?
+	mLOG(GBA, ERROR, "Stub opcode: %08x", opcode);
 }
 
 void GBAIllegal(struct ARMCore* cpu, uint32_t opcode) {
 	struct GBA* gba = (struct GBA*) cpu->master;
 	if (!gba->yankedRomSize) {
-		GBALog(gba, GBA_LOG_WARN, "Illegal opcode: %08x", opcode);
+		// TODO: More sensible category?
+		mLOG(GBA, WARN, "Illegal opcode: %08x", opcode);
 	}
 	if (gba->debugger) {
 		struct DebuggerEntryInfo info = {

@@ -170,7 +170,6 @@ void GBASetBreakpoint(struct GBA* gba, struct mCPUComponent* component, uint32_t address, enum ExecutionMode mode,
                       uint32_t* opcode);
 void GBAClearBreakpoint(struct GBA* gba, uint32_t address, enum ExecutionMode mode, uint32_t opcode);
 
-bool GBALoadROM(struct GBA* gba, struct VFile* vf, struct VFile* sav, const char* fname);
 bool GBALoadROM2(struct GBA* gba, struct VFile* vf);
 bool GBALoadSave(struct GBA* gba, struct VFile* sav);
 void GBAYankROM(struct GBA* gba);
@@ -188,11 +187,5 @@ void GBAGetGameTitle(struct GBA* gba, char* out);
 
 void GBAFrameStarted(struct GBA* gba);
 void GBAFrameEnded(struct GBA* gba);
-
-ATTRIBUTE_FORMAT(printf, 3, 4)
-void GBALog(struct GBA* gba, enum GBALogLevel level, const char* format, ...);
-
-ATTRIBUTE_FORMAT(printf, 3, 4)
-void GBADebuggerLogShim(struct Debugger* debugger, enum DebuggerLogLevel level, const char* format, ...);
 
 #endif

@@ -10,6 +10,8 @@ #include "gba/serialize.h"
 #include "util/formatting.h"
 #include "util/hash.h"
 
+mLOG_DEFINE_CATEGORY(GBA_HW, "GBA Pak Hardware");
+
 const int GBA_LUX_LEVELS[10] = { 5, 11, 18, 27, 42, 62, 84, 109, 139, 183 };
 
 static void _readPins(struct GBACartridgeHardware* hw);
@@ -84,7 +86,7 @@ case GPIO_REG_CONTROL:
 		hw->readWrite = value;
 		break;
 	default:
-		GBALog(hw->p, GBA_LOG_WARN, "Invalid GPIO address");
+		mLOG(GBA_HW, WARN, "Invalid GPIO address");
 	}
 	if (hw->readWrite) {
 		uint16_t old;
@@ -173,7 +175,7 @@ if (hw->pinState & 4) {
 				// GPIO direction should always != reading
 				if (hw->direction & 2) {
 					if (RTCCommandDataIsReading(hw->rtc.command)) {
-						GBALog(hw->p, GBA_LOG_GAME_ERROR, "Attempting to write to RTC while in read mode");
+						mLOG(GBA_HW, GAME_ERROR, "Attempting to write to RTC while in read mode");
 					}
 					++hw->rtc.bitsRead;
 					if (hw->rtc.bitsRead == 8) {
@@ -226,7 +228,7 @@ case RTC_CONTROL:
 				break;
 			}
 		} else {
-			GBALog(hw->p, GBA_LOG_WARN, "Invalid RTC command byte: %02X", hw->rtc.bits);
+			mLOG(GBA_HW, WARN, "Invalid RTC command byte: %02X", hw->rtc.bits);
 		}
 	} else {
 		switch (RTCCommandDataGetCommand(hw->rtc.command)) {
@@ -234,7 +236,7 @@ case RTC_CONTROL:
 			hw->rtc.control = hw->rtc.bits;
 			break;
 		case RTC_FORCE_IRQ:
-			GBALog(hw->p, GBA_LOG_STUB, "Unimplemented RTC command %u", RTCCommandDataGetCommand(hw->rtc.command));
+			mLOG(GBA_HW, STUB, "Unimplemented RTC command %u", RTCCommandDataGetCommand(hw->rtc.command));
 			break;
 		case RTC_RESET:
 		case RTC_DATETIME:
@@ -388,7 +390,7 @@ return;
 	}
 	if (hw->pinState & 2) {
 		struct GBALuminanceSource* lux = hw->p->luminanceSource;
-		GBALog(hw->p, GBA_LOG_DEBUG, "[SOLAR] Got reset");
+		mLOG(GBA_HW, DEBUG, "[SOLAR] Got reset");
 		hw->lightCounter = 0;
 		if (lux) {
 			lux->sample(lux);
@@ -404,7 +406,7 @@ hw->lightEdge = !(hw->pinState & 1);
 
 	bool sendBit = hw->lightCounter >= hw->lightSample;
 	_outputPins(hw, sendBit << 3);
-	GBALog(hw->p, GBA_LOG_DEBUG, "[SOLAR] Output %u with pins %u", hw->lightCounter, hw->pinState);
+	mLOG(GBA_HW, DEBUG, "[SOLAR] Output %u with pins %u", hw->lightCounter, hw->pinState);
 }
 
 // == Tilt
@@ -422,7 +424,7 @@ case 0x8000:
 		if (value == 0x55) {
 			hw->tiltState = 1;
 		} else {
-			GBALog(hw->p, GBA_LOG_GAME_ERROR, "Tilt sensor wrote wrong byte to %04x: %02x", address, value);
+			mLOG(GBA_HW, GAME_ERROR, "Tilt sensor wrote wrong byte to %04x: %02x", address, value);
 		}
 		break;
 	case 0x8100:
@@ -441,11 +443,11 @@ // Normalize to ~12 bits, focused on 0x3A0
 			hw->tiltX = (x >> 21) + 0x3A0; // Crop off an extra bit so that we can't go negative
 			hw->tiltY = (y >> 21) + 0x3A0;
 		} else {
-			GBALog(hw->p, GBA_LOG_GAME_ERROR, "Tilt sensor wrote wrong byte to %04x: %02x", address, value);
+			mLOG(GBA_HW, GAME_ERROR, "Tilt sensor wrote wrong byte to %04x: %02x", address, value);
 		}
 		break;
 	default:
-		GBALog(hw->p, GBA_LOG_GAME_ERROR, "Invalid tilt sensor write to %04x: %02x", address, value);
+		mLOG(GBA_HW, GAME_ERROR, "Invalid tilt sensor write to %04x: %02x", address, value);
 		break;
 	}
 }
@@ -461,7 +463,7 @@ return hw->tiltY & 0xFF;
 	case 0x8500:
 		return (hw->tiltY >> 8) & 0xF;
 	default:
-		GBALog(hw->p, GBA_LOG_GAME_ERROR, "Invalid tilt sensor read from %04x", address);
+		mLOG(GBA_HW, GAME_ERROR, "Invalid tilt sensor read from %04x", address);
 		break;
 	}
 	return 0xFF;

@@ -7,11 +7,15 @@ #ifndef GBA_HARDWARE_H
 #define GBA_HARDWARE_H
 
 #include "util/common.h"
+
+#include "core/log.h"
 #include "gba/interface.h"
 
 #include "macros.h"
 
 #include <time.h>
+
+mLOG_DECLARE_CATEGORY(GBA_HW);
 
 #define IS_GPIO_REGISTER(reg) ((reg) == GPIO_REG_DATA || (reg) == GPIO_REG_DIRECTION || (reg) == GPIO_REG_CONTROL)
 

@@ -10,21 +10,6 @@ #include "util/common.h"
 
 #include "core/interface.h"
 
-enum GBALogLevel {
-	GBA_LOG_FATAL = 0x01,
-	GBA_LOG_ERROR = 0x02,
-	GBA_LOG_WARN = 0x04,
-	GBA_LOG_INFO = 0x08,
-	GBA_LOG_DEBUG = 0x10,
-	GBA_LOG_STUB = 0x20,
-
-	GBA_LOG_GAME_ERROR = 0x100,
-	GBA_LOG_STATUS = 0x400,
-	GBA_LOG_SIO = 0x800,
-
-	GBA_LOG_ALL = 0xF3F,
-};
-
 enum GBASIOMode {
 	SIO_NORMAL_8 = 0,
 	SIO_NORMAL_32 = 1,

@@ -10,6 +10,8 @@ #include "gba/serialize.h"
 #include "gba/sio.h"
 #include "gba/video.h"
 
+mLOG_DEFINE_CATEGORY(GBA_IO, "GBA I/O");
+
 const char* GBAIORegisterNames[] = {
 	// Video
 	"DISPCNT",
@@ -533,9 +535,9 @@ case REG_MAX:
 			// Some bad interrupt libraries will write to this
 			break;
 		default:
-			GBALog(gba, GBA_LOG_STUB, "Stub I/O register write: %03X", address);
+			mLOG(GBA_IO, STUB, "Stub I/O register write: %03X", address);
 			if (address >= REG_MAX) {
-				GBALog(gba, GBA_LOG_GAME_ERROR, "Write to unused I/O register: %03X", address);
+				mLOG(GBA_IO, GAME_ERROR, "Write to unused I/O register: %03X", address);
 				return;
 			}
 			break;
@@ -751,7 +753,7 @@ case REG_DMA3DAD_LO:
 	case REG_DMA3DAD_HI:
 	case REG_DMA3CNT_LO:
 		// Write-only register
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Read from write-only I/O register: %03X", address);
+		mLOG(GBA_IO, GAME_ERROR, "Read from write-only I/O register: %03X", address);
 		return GBALoadBad(gba->cpu);
 
 	case REG_SOUNDBIAS:
@@ -760,7 +762,7 @@ case REG_JOY_RECV:
 	case REG_JOY_TRANS:
 	case REG_KEYCNT:
 	case REG_POSTFLG:
-		GBALog(gba, GBA_LOG_STUB, "Stub I/O register read: %03x", address);
+		mLOG(GBA_IO, STUB, "Stub I/O register read: %03x", address);
 		break;
 	case REG_SOUND1CNT_LO:
 	case REG_SOUND1CNT_HI:
@@ -822,7 +824,7 @@ case REG_MAX:
 		// Some bad interrupt libraries will read from this
 		break;
 	default:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Read from unused I/O register: %03X", address);
+		mLOG(GBA_IO, GAME_ERROR, "Read from unused I/O register: %03X", address);
 		return GBALoadBad(gba->cpu);
 	}
 	return gba->memory.io[address >> 1];

@@ -151,6 +151,8 @@ REG_POSTFLG = 0x300,
 	REG_HALTCNT = 0x301
 };
 
+mLOG_DECLARE_CATEGORY(GBA_IO);
+
 extern const char* GBAIORegisterNames[];
 
 void GBAIOInit(struct GBA* gba);

@@ -17,6 +17,8 @@ #include "util/memory.h"
 
 #define IDLE_LOOP_THRESHOLD 10000
 
+mLOG_DEFINE_CATEGORY(GBA_MEM, "GBA Memory");
+
 static void _pristineCow(struct GBA* gba);
 static uint32_t _deadbeef[1] = { 0xE710B710 }; // Illegal instruction on both ARM and Thumb
 
@@ -123,7 +125,7 @@ gba->memory.lastPrefetchedPc = 0;
 
 	if (!gba->memory.wram || !gba->memory.iwram) {
 		GBAMemoryDeinit(gba);
-		GBALog(gba, GBA_LOG_FATAL, "Could not map memory");
+		mLOG(GBA_MEM, FATAL, "Could not map memory");
 	}
 }
 
@@ -291,11 +293,11 @@ default:
 		memory->activeRegion = -1;
 		cpu->memory.activeRegion = _deadbeef;
 		cpu->memory.activeMask = 0;
-		enum GBALogLevel errorLevel = GBA_LOG_FATAL;
 		if (gba->yankedRomSize || !gba->hardCrash) {
-			errorLevel = GBA_LOG_GAME_ERROR;
+			mLOG(GBA_MEM, GAME_ERROR, "Jumped to invalid address: %08X", address);
+		} else {
+			mLOG(GBA_MEM, FATAL, "Jumped to invalid address: %08X", address);
 		}
-		GBALog(gba, errorLevel, "Jumped to invalid address: %08X", address);
 		return;
 	}
 	cpu->memory.activeSeqCycles32 = memory->waitstatesSeq32[memory->activeRegion];
@@ -337,11 +339,11 @@ if (address < SIZE_BIOS) { \
 		if (memory->activeRegion == REGION_BIOS) { \
 			LOAD_32(value, address, memory->bios); \
 		} else { \
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Bad BIOS Load32: 0x%08X", address); \
+			mLOG(GBA_MEM, GAME_ERROR, "Bad BIOS Load32: 0x%08X", address); \
 			value = memory->biosPrefetch; \
 		} \
 	} else { \
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load32: 0x%08X", address); \
+		mLOG(GBA_MEM, GAME_ERROR, "Bad memory Load32: 0x%08X", address); \
 		LOAD_BAD; \
 	}
 
@@ -371,7 +373,7 @@ wait += waitstatesRegion[address >> BASE_OFFSET]; \
 	if ((address & (SIZE_CART0 - 1)) < memory->romSize) { \
 		LOAD_32(value, address & (SIZE_CART0 - 4), memory->rom); \
 	} else { \
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Out of bounds ROM Load32: 0x%08X", address); \
+		mLOG(GBA_MEM, GAME_ERROR, "Out of bounds ROM Load32: 0x%08X", address); \
 		value = ((address & ~3) >> 1) & 0xFFFF; \
 		value |= (((address & ~3) + 2) >> 1) << 16; \
 	}
@@ -431,7 +433,7 @@ case REGION_CART_SRAM_MIRROR:
 		LOAD_SRAM;
 		break;
 	default:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load32: 0x%08X", address);
+		mLOG(GBA_MEM, GAME_ERROR, "Bad memory Load32: 0x%08X", address);
 		LOAD_BAD;
 		break;
 	}
@@ -460,11 +462,11 @@ if (address < SIZE_BIOS) {
 			if (memory->activeRegion == REGION_BIOS) {
 				LOAD_16(value, address, memory->bios);
 			} else {
-				GBALog(gba, GBA_LOG_GAME_ERROR, "Bad BIOS Load16: 0x%08X", address);
+				mLOG(GBA_MEM, GAME_ERROR, "Bad BIOS Load16: 0x%08X", address);
 				value = (memory->biosPrefetch >> ((address & 2) * 8)) & 0xFFFF;
 			}
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load16: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Bad memory Load16: 0x%08X", address);
 			LOAD_BAD;
 			value = (value >> ((address & 2) * 8)) & 0xFFFF;
 		}
@@ -501,7 +503,7 @@ wait = memory->waitstatesNonseq16[address >> BASE_OFFSET];
 		if ((address & (SIZE_CART0 - 1)) < memory->romSize) {
 			LOAD_16(value, address & (SIZE_CART0 - 2), memory->rom);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Out of bounds ROM Load16: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Out of bounds ROM Load16: 0x%08X", address);
 			value = (address >> 1) & 0xFFFF;
 		}
 		break;
@@ -512,7 +514,7 @@ value = GBASavedataReadEEPROM(&memory->savedata);
 		} else if ((address & (SIZE_CART0 - 1)) < memory->romSize) {
 			LOAD_16(value, address & (SIZE_CART0 - 2), memory->rom);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Out of bounds ROM Load16: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Out of bounds ROM Load16: 0x%08X", address);
 			value = (address >> 1) & 0xFFFF;
 		}
 		break;
@@ -523,7 +525,7 @@ value = GBALoad8(cpu, address, 0);
 		value |= value << 8;
 		break;
 	default:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load16: 0x%08X", address);
+		mLOG(GBA_MEM, GAME_ERROR, "Bad memory Load16: 0x%08X", address);
 		LOAD_BAD;
 		value = (value >> ((address & 2) * 8)) & 0xFFFF;
 		break;
@@ -553,11 +555,11 @@ if (address < SIZE_BIOS) {
 			if (memory->activeRegion == REGION_BIOS) {
 				value = ((uint8_t*) memory->bios)[address];
 			} else {
-				GBALog(gba, GBA_LOG_GAME_ERROR, "Bad BIOS Load8: 0x%08X", address);
+				mLOG(GBA_MEM, GAME_ERROR, "Bad BIOS Load8: 0x%08X", address);
 				value = (memory->biosPrefetch >> ((address & 3) * 8)) & 0xFF;
 			}
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load8: 0x%08x", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Bad memory Load8: 0x%08x", address);
 			LOAD_BAD;
 			value = (value >> ((address & 3) * 8)) & 0xFF;
 		}
@@ -595,7 +597,7 @@ wait = memory->waitstatesNonseq16[address >> BASE_OFFSET];
 		if ((address & (SIZE_CART0 - 1)) < memory->romSize) {
 			value = ((uint8_t*) memory->rom)[address & (SIZE_CART0 - 1)];
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Out of bounds ROM Load8: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Out of bounds ROM Load8: 0x%08X", address);
 			value = (address >> 1) & 0xFF;
 		}
 		break;
@@ -603,7 +605,7 @@ case REGION_CART_SRAM:
 	case REGION_CART_SRAM_MIRROR:
 		wait = memory->waitstatesNonseq16[address >> BASE_OFFSET];
 		if (memory->savedata.type == SAVEDATA_AUTODETECT) {
-			GBALog(gba, GBA_LOG_INFO, "Detected SRAM savegame");
+			mLOG(GBA_MEM, INFO, "Detected SRAM savegame");
 			GBASavedataInitSRAM(&memory->savedata);
 		}
 		if (gba->performingDMA == 1) {
@@ -616,13 +618,13 @@ value = GBASavedataReadFlash(&memory->savedata, address);
 		} else if (memory->hw.devices & HW_TILT) {
 			value = GBAHardwareTiltRead(&memory->hw, address & OFFSET_MASK);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Reading from non-existent SRAM: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Reading from non-existent SRAM: 0x%08X", address);
 			value = 0xFF;
 		}
 		value &= 0xFF;
 		break;
 	default:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Load8: 0x%08x", address);
+		mLOG(GBA_MEM, GAME_ERROR, "Bad memory Load8: 0x%08x", address);
 		LOAD_BAD;
 		value = (value >> ((address & 3) * 8)) & 0xFF;
 		break;
@@ -673,11 +675,11 @@ gba->video.renderer->writeOAM(gba->video.renderer, ((address & (SIZE_OAM - 4)) >> 1) + 1);
 
 #define STORE_CART \
 	wait += waitstatesRegion[address >> BASE_OFFSET]; \
-	GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Store32: 0x%08X", address);
+	mLOG(GBA_MEM, STUB, "Unimplemented memory Store32: 0x%08X", address);
 
 #define STORE_SRAM \
 	if (address & 0x3) { \
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Unaligned SRAM Store32: 0x%08X", address); \
+		mLOG(GBA_MEM, GAME_ERROR, "Unaligned SRAM Store32: 0x%08X", address); \
 		value = 0; \
 	} \
 	GBAStore8(cpu, address & ~0x3, value, cycleCounter); \
@@ -686,7 +688,7 @@ GBAStore8(cpu, (address & ~0x3) | 2, value, cycleCounter); \
 	GBAStore8(cpu, (address & ~0x3) | 3, value, cycleCounter);
 
 #define STORE_BAD \
-	GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Store32: 0x%08X", address);
+	mLOG(GBA_MEM, GAME_ERROR, "Bad memory Store32: 0x%08X", address);
 
 void GBAStore32(struct ARMCore* cpu, uint32_t address, int32_t value, int* cycleCounter) {
 	struct GBA* gba = (struct GBA*) cpu->master;
@@ -777,12 +779,12 @@ if (memory->hw.devices != HW_NONE && IS_GPIO_REGISTER(address & 0xFFFFFE)) {
 			uint32_t reg = address & 0xFFFFFE;
 			GBAHardwareGPIOWrite(&memory->hw, reg, value);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Bad cartridge Store16: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Bad cartridge Store16: 0x%08X", address);
 		}
 		break;
 	case REGION_CART2_EX:
 		if (memory->savedata.type == SAVEDATA_AUTODETECT) {
-			GBALog(gba, GBA_LOG_INFO, "Detected EEPROM savegame");
+			mLOG(GBA_MEM, INFO, "Detected EEPROM savegame");
 			GBASavedataInitEEPROM(&memory->savedata);
 		}
 		GBASavedataWriteEEPROM(&memory->savedata, value, 1);
@@ -793,7 +795,7 @@ GBAStore8(cpu, (address & ~0x1), value, cycleCounter);
 		GBAStore8(cpu, (address & ~0x1) | 1, value, cycleCounter);
 		break;
 	default:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Store16: 0x%08X", address);
+		mLOG(GBA_MEM, GAME_ERROR, "Bad memory Store16: 0x%08X", address);
 		break;
 	}
 
@@ -828,26 +830,26 @@ break;
 	case REGION_VRAM:
 		if ((address & 0x0001FFFF) >= ((GBARegisterDISPCNTGetMode(gba->memory.io[REG_DISPCNT >> 1]) == 4) ? 0x00014000 : 0x00010000)) {
 			// TODO: check BG mode
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Cannot Store8 to OBJ: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Cannot Store8 to OBJ: 0x%08X", address);
 			break;
 		}
 		gba->video.renderer->vram[(address & 0x1FFFE) >> 1] = ((uint8_t) value) | (value << 8);
 		gba->video.renderer->writeVRAM(gba->video.renderer, address & 0x0001FFFE);
 		break;
 	case REGION_OAM:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Cannot Store8 to OAM: 0x%08X", address);
+		mLOG(GBA_MEM, GAME_ERROR, "Cannot Store8 to OAM: 0x%08X", address);
 		break;
 	case REGION_CART0:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Store8: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Store8: 0x%08X", address);
 		break;
 	case REGION_CART_SRAM:
 	case REGION_CART_SRAM_MIRROR:
 		if (memory->savedata.type == SAVEDATA_AUTODETECT) {
 			if (address == SAVEDATA_FLASH_BASE) {
-				GBALog(gba, GBA_LOG_INFO, "Detected Flash savegame");
+				mLOG(GBA_MEM, INFO, "Detected Flash savegame");
 				GBASavedataInitFlash(&memory->savedata, gba->realisticTiming);
 			} else {
-				GBALog(gba, GBA_LOG_INFO, "Detected SRAM savegame");
+				mLOG(GBA_MEM, INFO, "Detected SRAM savegame");
 				GBASavedataInitSRAM(&memory->savedata);
 			}
 		}
@@ -859,12 +861,12 @@ memory->savedata.dirty |= SAVEDATA_DIRT_NEW;
 		} else if (memory->hw.devices & HW_TILT) {
 			GBAHardwareTiltWrite(&memory->hw, address & OFFSET_MASK, value);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
 		}
 		wait = memory->waitstatesNonseq16[REGION_CART_SRAM];
 		break;
 	default:
-		GBALog(gba, GBA_LOG_GAME_ERROR, "Bad memory Store8: 0x%08X", address);
+		mLOG(GBA_MEM, GAME_ERROR, "Bad memory Store8: 0x%08X", address);
 		break;
 	}
 
@@ -1003,7 +1005,7 @@ LOAD_32(oldValue, address & (SIZE_WORKING_IRAM - 4), memory->iwram);
 		STORE_32(value, address & (SIZE_WORKING_IRAM - 4), memory->iwram);
 		break;
 	case REGION_IO:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Patch32: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Patch32: 0x%08X", address);
 		break;
 	case REGION_PALETTE_RAM:
 		LOAD_32(oldValue, address & (SIZE_PALETTE_RAM - 1), gba->video.palette);
@@ -1046,11 +1048,11 @@ if (memory->savedata.type == SAVEDATA_SRAM) {
 			LOAD_32(oldValue, address & (SIZE_CART_SRAM - 4), memory->savedata.data);
 			STORE_32(value, address & (SIZE_CART_SRAM - 4), memory->savedata.data);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
 		}
 		break;
 	default:
-		GBALog(gba, GBA_LOG_WARN, "Bad memory Patch16: 0x%08X", address);
+		mLOG(GBA_MEM, WARN, "Bad memory Patch16: 0x%08X", address);
 		break;
 	}
 	if (old) {
@@ -1073,7 +1075,7 @@ LOAD_16(oldValue, address & (SIZE_WORKING_IRAM - 2), memory->iwram);
 		STORE_16(value, address & (SIZE_WORKING_IRAM - 2), memory->iwram);
 		break;
 	case REGION_IO:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Patch16: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Patch16: 0x%08X", address);
 		break;
 	case REGION_PALETTE_RAM:
 		LOAD_16(oldValue, address & (SIZE_PALETTE_RAM - 2), gba->video.palette);
@@ -1114,11 +1116,11 @@ if (memory->savedata.type == SAVEDATA_SRAM) {
 			LOAD_16(oldValue, address & (SIZE_CART_SRAM - 2), memory->savedata.data);
 			STORE_16(value, address & (SIZE_CART_SRAM - 2), memory->savedata.data);
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
 		}
 		break;
 	default:
-		GBALog(gba, GBA_LOG_WARN, "Bad memory Patch16: 0x%08X", address);
+		mLOG(GBA_MEM, WARN, "Bad memory Patch16: 0x%08X", address);
 		break;
 	}
 	if (old) {
@@ -1141,16 +1143,16 @@ oldValue = ((int8_t*) memory->iwram)[address & (SIZE_WORKING_IRAM - 1)];
 		((int8_t*) memory->iwram)[address & (SIZE_WORKING_IRAM - 1)] = value;
 		break;
 	case REGION_IO:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Patch8: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Patch8: 0x%08X", address);
 		break;
 	case REGION_PALETTE_RAM:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Patch8: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Patch8: 0x%08X", address);
 		break;
 	case REGION_VRAM:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Patch8: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Patch8: 0x%08X", address);
 		break;
 	case REGION_OAM:
-		GBALog(gba, GBA_LOG_STUB, "Unimplemented memory Patch8: 0x%08X", address);
+		mLOG(GBA_MEM, STUB, "Unimplemented memory Patch8: 0x%08X", address);
 		break;
 	case REGION_CART0:
 	case REGION_CART0_EX:
@@ -1172,11 +1174,11 @@ if (memory->savedata.type == SAVEDATA_SRAM) {
 			oldValue = ((int8_t*) memory->savedata.data)[address & (SIZE_CART_SRAM - 1)];
 			((int8_t*) memory->savedata.data)[address & (SIZE_CART_SRAM - 1)] = value;
 		} else {
-			GBALog(gba, GBA_LOG_GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
+			mLOG(GBA_MEM, GAME_ERROR, "Writing to non-existent SRAM: 0x%08X", address);
 		}
 		break;
 	default:
-		GBALog(gba, GBA_LOG_WARN, "Bad memory Patch8: 0x%08X", address);
+		mLOG(GBA_MEM, WARN, "Bad memory Patch8: 0x%08X", address);
 		break;
 	}
 	if (old) {
@@ -1498,7 +1500,7 @@ }
 	currentDma->reg = control;
 
 	if (GBADMARegisterIsDRQ(currentDma->reg)) {
-		GBALog(gba, GBA_LOG_STUB, "DRQ not implemented");
+		mLOG(GBA_MEM, STUB, "DRQ not implemented");
 	}
 
 	if (!wasEnabled && GBADMARegisterIsEnable(currentDma->reg)) {
@@ -1530,7 +1532,7 @@ case DMA_TIMING_CUSTOM:
 		info->nextEvent = INT_MAX;
 		switch (number) {
 		case 0:
-			GBALog(gba, GBA_LOG_WARN, "Discarding invalid DMA0 scheduling");
+			mLOG(GBA_MEM, WARN, "Discarding invalid DMA0 scheduling");
 			break;
 		case 1:
 		case 2:
@@ -1657,7 +1659,7 @@ dest += destOffset;
 			--wordsRemaining;
 		} else if (destRegion == REGION_CART2_EX) {
 			if (memory->savedata.type == SAVEDATA_AUTODETECT) {
-				GBALog(gba, GBA_LOG_INFO, "Detected EEPROM savegame");
+				mLOG(GBA_MEM, INFO, "Detected EEPROM savegame");
 				GBASavedataInitEEPROM(&memory->savedata);
 			}
 			word = cpu->memory.load16(cpu, source, 0);

@@ -86,6 +86,8 @@ DMA_TIMING_HBLANK = 2,
 	DMA_TIMING_CUSTOM = 3
 };
 
+mLOG_DECLARE_CATEGORY(GBA_MEM);
+
 DECL_BITFIELD(GBADMARegister, uint16_t);
 DECL_BITS(GBADMARegister, DestControl, 5, 2);
 DECL_BITS(GBADMARegister, SrcControl, 7, 2);

@@ -406,7 +406,7 @@ if (UNLIKELY(end == outX)) { \
 			return; \
 		} \
 		if (UNLIKELY(end < outX)) { \
-			GBALog(0, GBA_LOG_FATAL, "Out of bounds background draw!"); \
+			mLOG(GBA_VIDEO, FATAL, "Out of bounds background draw!"); \
 			return; \
 		} \
 		DRAW_BACKGROUND_MODE_0_TILE_SUFFIX_ ## BPP (BLEND, OBJWIN) \
@@ -414,7 +414,7 @@ outX = end; \
 		if (tileX < tileEnd) { \
 			++tileX; \
 		} else if (VIDEO_CHECKS && UNLIKELY(tileX > tileEnd)) { \
-			GBALog(0, GBA_LOG_FATAL, "Invariant doesn't hold in background draw! tileX (%u) > tileEnd (%u)", tileX, tileEnd); \
+			mLOG(GBA_VIDEO, FATAL, "Invariant doesn't hold in background draw! tileX (%u) > tileEnd (%u)", tileX, tileEnd); \
 			return; \
 		} \
 		length -= end - renderer->start; \
@@ -423,7 +423,7 @@ /*! TODO: Make sure these lines can be removed */ \
 	/*!*/ pixel = &renderer->row[outX]; \
 	outX += (tileEnd - tileX) * 8; \
 	/*!*/ if (VIDEO_CHECKS &&  UNLIKELY(outX > VIDEO_HORIZONTAL_PIXELS)) { \
-	/*!*/	GBALog(0, GBA_LOG_FATAL, "Out of bounds background draw would occur!"); \
+	/*!*/	mLOG(GBA_VIDEO, FATAL, "Out of bounds background draw would occur!"); \
 	/*!*/	return; \
 	/*!*/ } \
 	DRAW_BACKGROUND_MODE_0_TILES_ ## BPP (BLEND, OBJWIN) \
@@ -432,16 +432,16 @@ BACKGROUND_TEXT_SELECT_CHARACTER; \
 		\
 		int mod8 = length & 0x7; \
 		if (VIDEO_CHECKS && UNLIKELY(outX + mod8 != renderer->end)) { \
-			GBALog(0, GBA_LOG_FATAL, "Invariant doesn't hold in background draw!"); \
+			mLOG(GBA_VIDEO, FATAL, "Invariant doesn't hold in background draw!"); \
 			return; \
 		} \
 		DRAW_BACKGROUND_MODE_0_TILE_PREFIX_ ## BPP (BLEND, OBJWIN) \
 	} \
 	if (VIDEO_CHECKS && UNLIKELY(&renderer->row[outX] != pixel)) { \
-		GBALog(0, GBA_LOG_FATAL, "Background draw ended in the wrong place! Diff: %" PRIXPTR, &renderer->row[outX] - pixel); \
+		mLOG(GBA_VIDEO, FATAL, "Background draw ended in the wrong place! Diff: %" PRIXPTR, &renderer->row[outX] - pixel); \
 	} \
 	if (VIDEO_CHECKS && UNLIKELY(outX > VIDEO_HORIZONTAL_PIXELS)) { \
-		GBALog(0, GBA_LOG_FATAL, "Out of bounds background draw occurred!"); \
+		mLOG(GBA_VIDEO, FATAL, "Out of bounds background draw occurred!"); \
 		return; \
 	}
 

@@ -328,10 +328,10 @@ case REG_MOSAIC:
 		softwareRenderer->mosaic = value;
 		break;
 	case REG_GREENSWP:
-		GBALog(0, GBA_LOG_STUB, "Stub video register write: 0x%03X", address);
+		mLOG(GBA_VIDEO, STUB, "Stub video register write: 0x%03X", address);
 		break;
 	default:
-		GBALog(0, GBA_LOG_GAME_ERROR, "Invalid video register: 0x%03X", address);
+		mLOG(GBA_VIDEO, GAME_ERROR, "Invalid video register: 0x%03X", address);
 	}
 	return value;
 }
@@ -418,7 +418,7 @@ if (win->h.end >= oldWindow.endX) {
 					// Trim off extra windows we've overwritten
 					for (++activeWindow; softwareRenderer->nWindows > activeWindow + 1 && win->h.end >= softwareRenderer->windows[activeWindow].endX; ++activeWindow) {
 						if (VIDEO_CHECKS && activeWindow >= MAX_WINDOW) {
-							GBALog(0, GBA_LOG_FATAL, "Out of bounds window write will occur");
+							mLOG(GBA_VIDEO, FATAL, "Out of bounds window write will occur");
 							return;
 						}
 						softwareRenderer->windows[activeWindow] = softwareRenderer->windows[activeWindow + 1];
@@ -440,7 +440,7 @@ }
 	}
 #ifdef DEBUG
 	if (softwareRenderer->nWindows > MAX_WINDOW) {
-		GBALog(0, GBA_LOG_FATAL, "Out of bounds window write occurred!");
+		mLOG(GBA_VIDEO, FATAL, "Out of bounds window write occurred!");
 	}
 #endif
 }

@@ -157,7 +157,7 @@ if (!mgm->movieStream || !_verifyMagic(mgm, mgm->movieStream) || !_seekTag(mgm, mgm->movieStream, TAG_BEGIN)) {
 			mgm->d.stopPlaying(&mgm->d);
 		}
 	}
-	GBALog(0, GBA_LOG_DEBUG, "[RR] Loading segment: %u", streamId);
+	mLOG(GBA_RR, DEBUG, "Loading segment: %u", streamId);
 	mgm->d.frames = 0;
 	mgm->d.lagFrames = 0;
 	return true;
@@ -174,7 +174,7 @@ }
 	if (!_loadStream(mgm, newStreamId)) {
 		return false;
 	}
-	GBALog(0, GBA_LOG_DEBUG, "[RR] New segment: %u", newStreamId);
+	mLOG(GBA_RR, DEBUG, "New segment: %u", newStreamId);
 	_emitMagic(mgm, mgm->movieStream);
 	mgm->maxStreamId = newStreamId;
 	_emitTag(mgm, mgm->movieStream, TAG_PREVIOUSLY);
@@ -264,21 +264,21 @@ struct GBAMGMContext* mgm = (struct GBAMGMContext*) rr;
 	if (rr->isPlaying(rr)) {
 		while (mgm->peekedTag == TAG_INPUT) {
 			_readTag(mgm, mgm->movieStream);
-			GBALog(0, GBA_LOG_WARN, "[RR] Desync detected!");
+			mLOG(GBA_RR, WARN, "Desync detected!");
 		}
 		if (mgm->peekedTag == TAG_LAG) {
-			GBALog(0, GBA_LOG_DEBUG, "[RR] Lag frame marked in stream");
+			mLOG(GBA_RR, DEBUG, "Lag frame marked in stream");
 			if (mgm->inputThisFrame) {
-				GBALog(0, GBA_LOG_WARN, "[RR] Lag frame in stream does not match movie");
+				mLOG(GBA_RR, WARN, "Lag frame in stream does not match movie");
 			}
 		}
 	}
 
 	++mgm->d.frames;
-	GBALog(0, GBA_LOG_DEBUG, "[RR] Frame: %u", mgm->d.frames);
+	mLOG(GBA_RR, DEBUG, "Frame: %u", mgm->d.frames);
 	if (!mgm->inputThisFrame) {
 		++mgm->d.lagFrames;
-		GBALog(0, GBA_LOG_DEBUG, "[RR] Lag frame: %u", mgm->d.lagFrames);
+		mLOG(GBA_RR, DEBUG, "Lag frame: %u", mgm->d.lagFrames);
 	}
 
 	if (rr->isRecording(rr)) {
@@ -305,7 +305,7 @@ _emitTag(mgm, mgm->movieStream, TAG_INPUT);
 		mgm->movieStream->write(mgm->movieStream, &keys, sizeof(keys));
 		mgm->currentInput = keys;
 	}
-	GBALog(0, GBA_LOG_DEBUG, "[RR] Input log: %03X", mgm->currentInput);
+	mLOG(GBA_RR, DEBUG, "Input log: %03X", mgm->currentInput);
 	mgm->inputThisFrame = true;
 }
 
@@ -320,9 +320,9 @@ _readTag(mgm, mgm->movieStream);
 	}
 	mgm->inputThisFrame = true;
 	if (mgm->currentInput == INVALID_INPUT) {
-		GBALog(0, GBA_LOG_WARN, "[RR] Stream did not specify input");
+		mLOG(GBA_RR, WARN, "Stream did not specify input");
 	}
-	GBALog(0, GBA_LOG_DEBUG, "[RR] Input replay: %03X", mgm->currentInput);
+	mLOG(GBA_RR, DEBUG, "Input replay: %03X", mgm->currentInput);
 	return mgm->currentInput;
 }
 

@@ -7,6 +7,8 @@ #include "rr.h"
 
 #include "util/vfs.h"
 
+mLOG_DEFINE_CATEGORY(GBA_RR, "GBA RR");
+
 void GBARRInitRecord(struct GBA* gba) {
 	if (!gba || !gba->rr) {
 		return;

@@ -8,9 +8,12 @@ #define GBA_RR_H
 
 #include "util/common.h"
 
+#include "core/log.h"
 #include "gba/serialize.h"
 
 struct VFile;
+
+mLOG_DECLARE_CATEGORY(GBA_RR);
 
 enum GBARRInitFrom {
 	INIT_EX_NIHILO = 0,

@@ -22,6 +22,8 @@ // An average estimation is as follows.
 #define FLASH_SETTLE_CYCLES 18000
 #define CLEANUP_THRESHOLD 15
 
+mLOG_DEFINE_CATEGORY(GBA_SAVE, "GBA Savedata");
+
 static void _flashSwitchBank(struct GBASavedata* savedata, int bank);
 static void _flashErase(struct GBASavedata* savedata);
 static void _flashEraseSector(struct GBASavedata* savedata, uint16_t sectorStart);
@@ -181,7 +183,7 @@ if (savedata->type == SAVEDATA_AUTODETECT) {
 		savedata->type = SAVEDATA_FLASH512;
 	}
 	if (savedata->type != SAVEDATA_FLASH512 && savedata->type != SAVEDATA_FLASH1M) {
-		GBALog(0, GBA_LOG_WARN, "Can't re-initialize savedata");
+		mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
 		return;
 	}
 	int32_t flashSize = SIZE_CART_FLASH512;
@@ -213,7 +215,7 @@ void GBASavedataInitEEPROM(struct GBASavedata* savedata) {
 	if (savedata->type == SAVEDATA_AUTODETECT) {
 		savedata->type = SAVEDATA_EEPROM;
 	} else {
-		GBALog(0, GBA_LOG_WARN, "Can't re-initialize savedata");
+		mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
 		return;
 	}
 	off_t end;
@@ -236,7 +238,7 @@ void GBASavedataInitSRAM(struct GBASavedata* savedata) {
 	if (savedata->type == SAVEDATA_AUTODETECT) {
 		savedata->type = SAVEDATA_SRAM;
 	} else {
-		GBALog(0, GBA_LOG_WARN, "Can't re-initialize savedata");
+		mLOG(GBA_SAVE, WARN, "Can't re-initialize savedata");
 		return;
 	}
 	off_t end;
@@ -290,7 +292,7 @@ case FLASH_COMMAND_SWITCH_BANK:
 			if (address == 0 && value < 2) {
 				_flashSwitchBank(savedata, value);
 			} else {
-				GBALog(0, GBA_LOG_GAME_ERROR, "Bad flash bank switch");
+				mLOG(GBA_SAVE, GAME_ERROR, "Bad flash bank switch");
 				savedata->command = FLASH_COMMAND_NONE;
 			}
 			savedata->command = FLASH_COMMAND_NONE;
@@ -299,7 +301,7 @@ default:
 			if (address == FLASH_BASE_HI && value == FLASH_COMMAND_START) {
 				savedata->flashState = FLASH_STATE_START;
 			} else {
-				GBALog(0, GBA_LOG_GAME_ERROR, "Bad flash write: %#04x = %#02x", address, value);
+				mLOG(GBA_SAVE, GAME_ERROR, "Bad flash write: %#04x = %#02x", address, value);
 			}
 			break;
 		}
@@ -308,7 +310,7 @@ case FLASH_STATE_START:
 		if (address == FLASH_BASE_LO && value == FLASH_COMMAND_CONTINUE) {
 			savedata->flashState = FLASH_STATE_CONTINUE;
 		} else {
-			GBALog(0, GBA_LOG_GAME_ERROR, "Bad flash write: %#04x = %#02x", address, value);
+			mLOG(GBA_SAVE, GAME_ERROR, "Bad flash write: %#04x = %#02x", address, value);
 			savedata->flashState = FLASH_STATE_RAW;
 		}
 		break;
@@ -325,7 +327,7 @@ case FLASH_COMMAND_SWITCH_BANK:
 					savedata->command = value;
 					break;
 				default:
-					GBALog(0, GBA_LOG_GAME_ERROR, "Unsupported flash operation: %#02x", value);
+					mLOG(GBA_SAVE, GAME_ERROR, "Unsupported flash operation: %#02x", value);
 					break;
 				}
 				break;
@@ -335,7 +337,7 @@ case FLASH_COMMAND_ERASE_CHIP:
 					_flashErase(savedata);
 					break;
 				default:
-					GBALog(0, GBA_LOG_GAME_ERROR, "Unsupported flash erase operation: %#02x", value);
+					mLOG(GBA_SAVE, GAME_ERROR, "Unsupported flash erase operation: %#02x", value);
 					break;
 				}
 				savedata->command = FLASH_COMMAND_NONE;
@@ -346,7 +348,7 @@ savedata->command = FLASH_COMMAND_NONE;
 				}
 				break;
 			default:
-				GBALog(0, GBA_LOG_ERROR, "Flash entered bad state: %#02x", savedata->command);
+				mLOG(GBA_SAVE, ERROR, "Flash entered bad state: %#02x", savedata->command);
 				savedata->command = FLASH_COMMAND_NONE;
 				break;
 			}
@@ -355,7 +357,7 @@ if (value == FLASH_COMMAND_ERASE_SECTOR) {
 				_flashEraseSector(savedata, address);
 				savedata->command = FLASH_COMMAND_NONE;
 			} else {
-				GBALog(0, GBA_LOG_GAME_ERROR, "Unsupported flash erase operation: %#02x", value);
+				mLOG(GBA_SAVE, GAME_ERROR, "Unsupported flash erase operation: %#02x", value);
 			}
 		}
 		break;
@@ -394,7 +396,7 @@ savedata->dirty |= SAVEDATA_DIRT_NEW;
 			savedata->data[savedata->writeAddress >> 3] = current;
 			++savedata->writeAddress;
 		} else {
-			GBALog(0, GBA_LOG_GAME_ERROR, "Writing beyond end of EEPROM: %08X", (savedata->writeAddress >> 3));
+			mLOG(GBA_SAVE, GAME_ERROR, "Writing beyond end of EEPROM: %08X", (savedata->writeAddress >> 3));
 		}
 		break;
 	case EEPROM_COMMAND_READ_PENDING:
@@ -421,7 +423,7 @@ if (savedata->readBitsRemaining < 64) {
 		int step = 63 - savedata->readBitsRemaining;
 		uint32_t address = (savedata->readAddress + step) >> 3;
 		if (address >= SIZE_CART_EEPROM) {
-			GBALog(0, GBA_LOG_GAME_ERROR, "Reading beyond end of EEPROM: %08X", address);
+			mLOG(GBA_SAVE, GAME_ERROR, "Reading beyond end of EEPROM: %08X", address);
 			return 0xFF;
 		}
 		uint8_t data = savedata->data[address] >> (0x7 - (step & 0x7));
@@ -464,7 +466,7 @@ break;
 		}
 		savedata->vf->sync(savedata->vf, savedata->data, size);
 		savedata->dirty = 0;
-		GBALog(0, GBA_LOG_INFO, "Savedata synced");
+		mLOG(GBA_SAVE, INFO, "Savedata synced");
 	}
 }
 
@@ -504,7 +506,7 @@ }
 }
 
 void _flashSwitchBank(struct GBASavedata* savedata, int bank) {
-	GBALog(0, GBA_LOG_DEBUG, "Performing flash bank switch to bank %i", bank);
+	mLOG(GBA_SAVE, DEBUG, "Performing flash bank switch to bank %i", bank);
 	savedata->currentBank = &savedata->data[bank << 16];
 	if (bank > 0 && savedata->type == SAVEDATA_FLASH512) {
 		savedata->type = SAVEDATA_FLASH1M;
@@ -516,7 +518,7 @@ }
 }
 
 void _flashErase(struct GBASavedata* savedata) {
-	GBALog(0, GBA_LOG_DEBUG, "Performing flash chip erase");
+	mLOG(GBA_SAVE, DEBUG, "Performing flash chip erase");
 	savedata->dirty |= SAVEDATA_DIRT_NEW;
 	size_t size = SIZE_CART_FLASH512;
 	if (savedata->type == SAVEDATA_FLASH1M) {
@@ -526,11 +528,11 @@ memset(savedata->data, 0xFF, size);
 }
 
 void _flashEraseSector(struct GBASavedata* savedata, uint16_t sectorStart) {
-	GBALog(0, GBA_LOG_DEBUG, "Performing flash sector erase at 0x%04x", sectorStart);
+	mLOG(GBA_SAVE, DEBUG, "Performing flash sector erase at 0x%04x", sectorStart);
 	savedata->dirty |= SAVEDATA_DIRT_NEW;
 	size_t size = 0x1000;
 	if (savedata->type == SAVEDATA_FLASH1M) {
-		GBALog(0, GBA_LOG_DEBUG, "Performing unknown sector-size erase at 0x%04x", sectorStart);
+		mLOG(GBA_SAVE, DEBUG, "Performing unknown sector-size erase at 0x%04x", sectorStart);
 	}
 	savedata->settling = sectorStart >> 12;
 	if (savedata->realisticTiming) {

@@ -8,6 +8,10 @@ #define GBA_SAVEDATA_H
 
 #include "util/common.h"
 
+#include "core/log.h"
+
+mLOG_DECLARE_CATEGORY(GBA_SAVE);
+
 struct VFile;
 
 enum SavedataType {

@@ -26,6 +26,8 @@ #endif
 
 const uint32_t GBA_SAVESTATE_MAGIC = 0x01000000;
 
+mLOG_DEFINE_CATEGORY(GBA_STATE, "GBA Savestate");
+
 struct GBABundledState {
 	struct GBASerializedState* state;
 	struct GBAExtdata* extdata;
@@ -96,12 +98,12 @@ int32_t check;
 	uint32_t ucheck;
 	LOAD_32(ucheck, 0, &state->versionMagic);
 	if (ucheck != GBA_SAVESTATE_MAGIC) {
-		GBALog(gba, GBA_LOG_WARN, "Invalid or too new savestate: expected %08X, got %08X", GBA_SAVESTATE_MAGIC, ucheck);
+		mLOG(GBA_STATE, WARN, "Invalid or too new savestate: expected %08X, got %08X", GBA_SAVESTATE_MAGIC, ucheck);
 		error = true;
 	}
 	LOAD_32(ucheck, 0, &state->biosChecksum);
 	if (ucheck != gba->biosChecksum) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate created using a different version of the BIOS: expected %08X, got %08X", gba->biosChecksum, ucheck);
+		mLOG(GBA_STATE, WARN, "Savestate created using a different version of the BIOS: expected %08X, got %08X", gba->biosChecksum, ucheck);
 		uint32_t pc;
 		LOAD_32(pc, ARM_PC * sizeof(state->cpu.gprs[0]), state->cpu.gprs);
 		if (pc < SIZE_BIOS && pc >= 0x20) {
@@ -109,34 +111,34 @@ error = true;
 		}
 	}
 	if (gba->memory.rom && (state->id != ((struct GBACartridge*) gba->memory.rom)->id || memcmp(state->title, ((struct GBACartridge*) gba->memory.rom)->title, sizeof(state->title)))) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate is for a different game");
+		mLOG(GBA_STATE, WARN, "Savestate is for a different game");
 		error = true;
 	} else if (!gba->memory.rom && state->id != 0) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate is for a game, but no game loaded");
+		mLOG(GBA_STATE, WARN, "Savestate is for a game, but no game loaded");
 		error = true;
 	}
 	LOAD_32(ucheck, 0, &state->romCrc32);
 	if (ucheck != gba->romCrc32) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate is for a different version of the game");
+		mLOG(GBA_STATE, WARN, "Savestate is for a different version of the game");
 	}
 	LOAD_32(check, 0, &state->cpu.cycles);
 	if (check < 0) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate is corrupted: CPU cycles are negative");
+		mLOG(GBA_STATE, WARN, "Savestate is corrupted: CPU cycles are negative");
 		error = true;
 	}
 	if (check >= (int32_t) GBA_ARM7TDMI_FREQUENCY) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate is corrupted: CPU cycles are too high");
+		mLOG(GBA_STATE, WARN, "Savestate is corrupted: CPU cycles are too high");
 		error = true;
 	}
 	LOAD_32(check, 0, &state->video.eventDiff);
 	if (check < 0) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate is corrupted: video eventDiff is negative");
+		mLOG(GBA_STATE, WARN, "Savestate is corrupted: video eventDiff is negative");
 		error = true;
 	}
 	LOAD_32(check, ARM_PC * sizeof(state->cpu.gprs[0]), state->cpu.gprs);
 	int region = (check >> BASE_OFFSET);
 	if ((region == REGION_CART0 || region == REGION_CART1 || region == REGION_CART2) && ((check - WORD_SIZE_ARM) & SIZE_CART0) >= gba->memory.romSize - WORD_SIZE_ARM) {
-		GBALog(gba, GBA_LOG_WARN, "Savestate created using a differently sized version of the ROM");
+		mLOG(GBA_STATE, WARN, "Savestate created using a differently sized version of the ROM");
 		error = true;
 	}
 	if (error) {
@@ -461,7 +463,7 @@ if (item.size >= VIDEO_HORIZONTAL_PIXELS * VIDEO_VERTICAL_PIXELS * 4) {
 			gba->video.renderer->putPixels(gba->video.renderer, VIDEO_HORIZONTAL_PIXELS, item.data);
 			mCoreSyncForceFrame(gba->sync);
 		} else {
-			GBALog(gba, GBA_LOG_WARN, "Savestate includes invalid screenshot");
+			mLOG(GBA_STATE, WARN, "Savestate includes invalid screenshot");
 		}
 	}
 	if (flags & SAVESTATE_SAVEDATA && GBAExtdataGet(&extdata, EXTDATA_SAVEDATA, &item)) {
@@ -630,11 +632,11 @@ PNGWriteClose(png, info);
 		vf->close(vf);
 	}
 	if (success) {
-		GBALog(gba, GBA_LOG_STATUS, "Screenshot saved");
+		mLOG(STATUS, INFO, "Screenshot saved");
 		return;
 	}
 #else
 	UNUSED(dir);
 #endif
-	GBALog(gba, GBA_LOG_STATUS, "Failed to take screenshot");
+	mLOG(STATUS, WARN, "Failed to take screenshot");
 }

@@ -8,9 +8,12 @@ #define GBA_SERIALIZE_H
 
 #include "util/common.h"
 
+#include "core/core.h"
 #include "gba/gba.h"
 
 extern const uint32_t GBA_SAVESTATE_MAGIC;
+
+mLOG_DECLARE_CATEGORY(GBA_STATE);
 
 /* Savestate format:
  * 0x00000 - 0x00003: Version Magic (0x01000000)

@@ -7,6 +7,8 @@ #include "sio.h"
 
 #include "gba/io.h"
 
+mLOG_DEFINE_CATEGORY(GBA_SIO, "GBA Serial I/O");
+
 const int GBASIOCyclesPerTransfer[4][MAX_GBAS] = {
 	{ 38326, 73003, 107680, 142356 },
 	{ 9582, 18251, 26920, 35589 },
@@ -98,7 +100,7 @@ case SIO_JOYBUS:
 		driverLoc = &sio->drivers.joybus;
 		break;
 	default:
-		GBALog(sio->p, GBA_LOG_ERROR, "Setting an unsupported SIO driver: %x", mode);
+		mLOG(GBA_SIO, ERROR, "Setting an unsupported SIO driver: %x", mode);
 		return;
 	}
 	if (*driverLoc) {
@@ -115,7 +117,7 @@
 		if (driver->init) {
 			if (!driver->init(driver)) {
 				driver->deinit(driver);
-				GBALog(sio->p, GBA_LOG_ERROR, "Could not initialize SIO driver");
+				mLOG(GBA_SIO, ERROR, "Could not initialize SIO driver");
 				return;
 			}
 		}

@@ -8,11 +8,14 @@ #define GBA_SIO_H
 
 #include "util/common.h"
 
+#include "core/log.h"
 #include "gba/interface.h"
 
 #define MAX_GBAS 4
 
 extern const int GBASIOCyclesPerTransfer[4][MAX_GBAS];
+
+mLOG_DECLARE_CATEGORY(GBA_SIO);
 
 enum {
 	RCNT_INITIAL = 0x8000

@@ -85,7 +85,7 @@ bool GBASIOLockstepNodeInit(struct GBASIODriver* driver) {
 	struct GBASIOLockstepNode* node = (struct GBASIOLockstepNode*) driver;
 	node->nextEvent = LOCKSTEP_INCREMENT;
 	node->d.p->multiplayerControl.slave = node->id > 0;
-	GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: Node init", node->id);
+	mLOG(GBA_SIO, DEBUG, "Lockstep %i: Node init", node->id);
 	return true;
 }
 
@@ -142,10 +142,10 @@
 static uint16_t GBASIOLockstepNodeMultiWriteRegister(struct GBASIODriver* driver, uint32_t address, uint16_t value) {
 	struct GBASIOLockstepNode* node = (struct GBASIOLockstepNode*) driver;
 	if (address == REG_SIOCNT) {
-		GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: SIOCNT <- %04x", node->id, value);
+		mLOG(GBA_SIO, DEBUG, "Lockstep %i: SIOCNT <- %04x", node->id, value);
 		if (value & 0x0080) {
 			if (!node->id) {
-				GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: Transfer initiated", node->id);
+				mLOG(GBA_SIO, DEBUG, "Lockstep %i: Transfer initiated", node->id);
 				MutexLock(&node->p->mutex);
 				node->p->transferActive = true;
 				node->p->transferCycles = GBASIOCyclesPerTransfer[node->d.p->multiplayerControl.baud][node->p->attached - 1];
@@ -158,7 +158,7 @@ }
 		value &= 0xFF83;
 		value |= driver->p->siocnt & 0x00FC;
 	} else if (address == REG_SIOMLT_SEND) {
-		GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: SIOMLT_SEND <- %04x", node->id, value);
+		mLOG(GBA_SIO, DEBUG, "Lockstep %i: SIOMLT_SEND <- %04x", node->id, value);
 	}
 	return value;
 }
@@ -195,7 +195,7 @@ node->p->waiting = 0;
 			ConditionWake(&node->p->barrier);
 		}
 		if (node->state == LOCKSTEP_FINISHED) {
-			GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: Finishing transfer: %04x %04x %04x %04x", node->id, node->p->multiRecv[0], node->p->multiRecv[1], node->p->multiRecv[2], node->p->multiRecv[3]);
+			mLOG(GBA_SIO, DEBUG, "Lockstep %i: Finishing transfer: %04x %04x %04x %04x", node->id, node->p->multiRecv[0], node->p->multiRecv[1], node->p->multiRecv[2], node->p->multiRecv[3]);
 			node->d.p->p->memory.io[REG_SIOMULTI0 >> 1] = node->p->multiRecv[0];
 			node->d.p->p->memory.io[REG_SIOMULTI1 >> 1] = node->p->multiRecv[1];
 			node->d.p->p->memory.io[REG_SIOMULTI2 >> 1] = node->p->multiRecv[2];
@@ -229,7 +229,7 @@
 static uint16_t GBASIOLockstepNodeNormalWriteRegister(struct GBASIODriver* driver, uint32_t address, uint16_t value) {
 	struct GBASIOLockstepNode* node = (struct GBASIOLockstepNode*) driver;
 	if (address == REG_SIOCNT) {
-		GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: SIOCNT <- %04x", node->id, value);
+		mLOG(GBA_SIO, DEBUG, "Lockstep %i: SIOCNT <- %04x", node->id, value);
 		value &= 0xFF8B;
 		MutexLock(&node->p->mutex);
 		if (value & 0x0080) {
@@ -251,9 +251,9 @@ }
 		}
 		MutexUnlock(&node->p->mutex);
 	} else if (address == REG_SIODATA32_LO) {
-		GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: SIODATA32_LO <- %04x", node->id, value);
+		mLOG(GBA_SIO, DEBUG, "Lockstep %i: SIODATA32_LO <- %04x", node->id, value);
 	} else if (address == REG_SIODATA32_HI) {
-		GBALog(node->d.p->p, GBA_LOG_SIO, "Lockstep %i: SIODATA32_HI <- %04x", node->id, value);
+		mLOG(GBA_SIO, DEBUG, "Lockstep %i: SIODATA32_HI <- %04x", node->id, value);
 	}
 	return value;
 }

@@ -13,6 +13,8 @@ #include "gba/serialize.h"
 
 #include "util/memory.h"
 
+mLOG_DEFINE_CATEGORY(GBA_VIDEO, "GBA Video");
+
 static void GBAVideoDummyRendererInit(struct GBAVideoRenderer* renderer);
 static void GBAVideoDummyRendererReset(struct GBAVideoRenderer* renderer);
 static void GBAVideoDummyRendererDeinit(struct GBAVideoRenderer* renderer);

@@ -20,6 +20,8 @@ #define GBA_R8(X) (((X) << 3) & 0xF8)
 #define GBA_G8(X) (((X) >> 2) & 0xF8)
 #define GBA_B8(X) (((X) >> 7) & 0xF8)
 
+mLOG_DECLARE_CATEGORY(GBA_VIDEO);
+
 enum {
 	VIDEO_HORIZONTAL_PIXELS = 240,
 	VIDEO_HBLANK_PIXELS = 68,

@@ -110,7 +110,7 @@ m_opts.fpsTarget = 60;
 	m_opts.audioBuffers = 1536;
 	m_opts.sampleRate = 44100;
 	m_opts.volume = 0x100;
-	m_opts.logLevel = GBA_LOG_WARN | GBA_LOG_ERROR | GBA_LOG_FATAL | GBA_LOG_STATUS;
+	m_opts.logLevel = mLOG_WARN | mLOG_ERROR | mLOG_FATAL;
 	m_opts.rewindEnable = false;
 	m_opts.rewindBufferInterval = 0;
 	m_opts.rewindBufferCapacity = 0;

@@ -12,11 +12,13 @@ #include "third-party/blip_buf/blip_buf.h"
 
 #define BUFFER_SIZE (GBA_AUDIO_SAMPLES >> 2)
 
+mLOG_DEFINE_CATEGORY(SDL_AUDIO, "SDL Audio");
+
 static void _mSDLAudioCallback(void* context, Uint8* data, int len);
 
 bool mSDLInitAudio(struct mSDLAudio* context, struct mCoreThread* threadContext) {
 	if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
-		GBALog(0, GBA_LOG_ERROR, "Could not initialize SDL sound system: %s", SDL_GetError());
+		mLOG(SDL_AUDIO, ERROR, "Could not initialize SDL sound system: %s", SDL_GetError());
 		return false;
 	}
 
@@ -33,7 +35,7 @@ if (context->deviceId == 0) {
 #else
 	if (SDL_OpenAudio(&context->desiredSpec, &context->obtainedSpec) < 0) {
 #endif
-		GBALog(0, GBA_LOG_ERROR, "Could not open SDL sound system");
+		mLOG(SDL_AUDIO, ERROR, "Could not open SDL sound system");
 		return false;
 	}
 	context->samples = context->obtainedSpec.samples;

@@ -8,7 +8,11 @@ #define SDL_AUDIO_H
 
 #include "util/common.h"
 
+#include "core/log.h"
+
 #include <SDL.h>
+
+mLOG_DECLARE_CATEGORY(SDL_AUDIO);
 
 struct mSDLAudio {
 	// Input

@@ -27,6 +27,8 @@
 #define GYRO_STEPS 100
 #define RUMBLE_PWM 20
 
+mLOG_DEFINE_CATEGORY(SDL_EVENTS, "SDL Events");
+
 DEFINE_VECTOR(SDL_JoystickList, struct SDL_JoystickCombo);
 
 #if SDL_VERSION_ATLEAST(2, 0, 0)
@@ -42,16 +44,16 @@ #if SDL_VERSION_ATLEAST(2, 0, 4)
 	SDL_SetHint(SDL_HINT_NO_SIGNAL_HANDLERS, "1");
 #endif
 	if (SDL_InitSubSystem(SDL_INIT_JOYSTICK) < 0) {
-		GBALog(0, GBA_LOG_ERROR, "SDL joystick initialization failed: %s", SDL_GetError());
+		mLOG(SDL_EVENTS, ERROR, "SDL joystick initialization failed: %s", SDL_GetError());
 	}
 
 #if SDL_VERSION_ATLEAST(2, 0, 0)
 	SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1");
 	if (SDL_InitSubSystem(SDL_INIT_HAPTIC) < 0) {
-		GBALog(0, GBA_LOG_ERROR, "SDL haptic initialization failed: %s", SDL_GetError());
+		mLOG(SDL_EVENTS, ERROR, "SDL haptic initialization failed: %s", SDL_GetError());
 	}
 	if (SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
-		GBALog(0, GBA_LOG_ERROR, "SDL video initialization failed: %s", SDL_GetError());
+		mLOG(SDL_EVENTS, ERROR, "SDL video initialization failed: %s", SDL_GetError());
 	}
 #endif
 

@@ -9,10 +9,13 @@
 #include "util/common.h"
 
 #include "core/interface.h"
+#include "core/log.h"
 #include "util/circle-buffer.h"
 #include "util/vector.h"
 
 #include <SDL.h>
+
+mLOG_DECLARE_CATEGORY(SDL_EVENTS);
 
 #define SDL_BINDING_KEY 0x53444C4BU
 #define SDL_BINDING_BUTTON 0x53444C42U