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/internal/gb/renderers/software.h>
   7
   8#include <mgba/core/cache-set.h>
   9#include <mgba/internal/gb/io.h>
  10#include <mgba/internal/gb/renderers/cache-set.h>
  11#include <mgba-util/math.h>
  12#include <mgba-util/memory.h>
  13
  14static void GBVideoSoftwareRendererInit(struct GBVideoRenderer* renderer, enum GBModel model, bool borders);
  15static void GBVideoSoftwareRendererDeinit(struct GBVideoRenderer* renderer);
  16static uint8_t GBVideoSoftwareRendererWriteVideoRegister(struct GBVideoRenderer* renderer, uint16_t address, uint8_t value);
  17static void GBVideoSoftwareRendererWriteSGBPacket(struct GBVideoRenderer* renderer, uint8_t* data);
  18static void GBVideoSoftwareRendererWritePalette(struct GBVideoRenderer* renderer, int index, uint16_t value);
  19static void GBVideoSoftwareRendererWriteVRAM(struct GBVideoRenderer* renderer, uint16_t address);
  20static void GBVideoSoftwareRendererWriteOAM(struct GBVideoRenderer* renderer, uint16_t oam);
  21static void GBVideoSoftwareRendererDrawRange(struct GBVideoRenderer* renderer, int startX, int endX, int y);
  22static void GBVideoSoftwareRendererFinishScanline(struct GBVideoRenderer* renderer, int y);
  23static void GBVideoSoftwareRendererFinishFrame(struct GBVideoRenderer* renderer);
  24static void GBVideoSoftwareRendererEnableSGBBorder(struct GBVideoRenderer* renderer, bool enable);
  25static void GBVideoSoftwareRendererGetPixels(struct GBVideoRenderer* renderer, size_t* stride, const void** pixels);
  26static void GBVideoSoftwareRendererPutPixels(struct GBVideoRenderer* renderer, size_t stride, const void* pixels);
  27
  28static void GBVideoSoftwareRendererDrawBackground(struct GBVideoSoftwareRenderer* renderer, uint8_t* maps, int startX, int endX, int sx, int sy);
  29static void GBVideoSoftwareRendererDrawObj(struct GBVideoSoftwareRenderer* renderer, struct GBObj* obj, int startX, int endX, int y);
  30
  31static void _clearScreen(struct GBVideoSoftwareRenderer* renderer) {
  32	size_t sgbOffset = 0;
  33	if (renderer->model & GB_MODEL_SGB) {
  34		return;
  35	}
  36	int y;
  37	for (y = 0; y < GB_VIDEO_VERTICAL_PIXELS; ++y) {
  38		color_t* row = &renderer->outputBuffer[renderer->outputBufferStride * y + sgbOffset];
  39		int x;
  40		for (x = 0; x < GB_VIDEO_HORIZONTAL_PIXELS; x += 4) {
  41			row[x + 0] = renderer->palette[0];
  42			row[x + 1] = renderer->palette[0];
  43			row[x + 2] = renderer->palette[0];
  44			row[x + 3] = renderer->palette[0];
  45		}
  46	}
  47}
  48
  49static void _regenerateSGBBorder(struct GBVideoSoftwareRenderer* renderer) {
  50	int i;
  51	for (i = 0; i < 0x40; ++i) {
  52		uint16_t color;
  53		LOAD_16LE(color, 0x800 + i * 2, renderer->d.sgbMapRam);
  54		renderer->d.writePalette(&renderer->d, i + 0x40, color);
  55	}
  56	int x, y;
  57	for (y = 0; y < 224; ++y) {
  58		for (x = 0; x < 256; x += 8) {
  59			if (x >= 48 && x < 208 && y >= 40 && y < 184) {
  60				continue;
  61			}
  62			uint16_t mapData;
  63			LOAD_16LE(mapData, (x >> 2) + (y & ~7) * 8, renderer->d.sgbMapRam);
  64			if (UNLIKELY(SGBBgAttributesGetTile(mapData) >= 0x100)) {
  65				continue;
  66			}
  67
  68			int localY = y & 0x7;
  69			if (SGBBgAttributesIsYFlip(mapData)) {
  70				localY = 7 - localY;
  71			}
  72			uint8_t tileData[4];
  73			tileData[0] = renderer->d.sgbCharRam[(SGBBgAttributesGetTile(mapData) * 16 + localY) * 2 + 0x00];
  74			tileData[1] = renderer->d.sgbCharRam[(SGBBgAttributesGetTile(mapData) * 16 + localY) * 2 + 0x01];
  75			tileData[2] = renderer->d.sgbCharRam[(SGBBgAttributesGetTile(mapData) * 16 + localY) * 2 + 0x10];
  76			tileData[3] = renderer->d.sgbCharRam[(SGBBgAttributesGetTile(mapData) * 16 + localY) * 2 + 0x11];
  77
  78			size_t base = y * renderer->outputBufferStride + x;
  79			int paletteBase = SGBBgAttributesGetPalette(mapData) * 0x10;
  80			int colorSelector;
  81
  82			int flip = 0;
  83			if (SGBBgAttributesIsXFlip(mapData)) {
  84				flip = 7;
  85			}
  86			for (i = 7; i >= 0; --i) {
  87				colorSelector = (tileData[0] >> i & 0x1) << 0 | (tileData[1] >> i & 0x1) << 1 | (tileData[2] >> i & 0x1) << 2 | (tileData[3] >> i & 0x1) << 3;
  88				renderer->outputBuffer[(base + 7 - i) ^ flip] = renderer->palette[paletteBase | colorSelector];
  89			}
  90		}
  91	}
  92}
  93
  94static inline void _setAttribute(uint8_t* sgbAttributes, unsigned x, unsigned y, int palette) {
  95	int p = sgbAttributes[(x >> 2) + 5 * y];
  96	p &= ~(3 << (2 * (3 - (x & 3))));
  97	p |= palette << (2 * (3 - (x & 3)));
  98	sgbAttributes[(x >> 2) + 5 * y] = p;
  99}
 100
 101static void _parseAttrBlock(struct GBVideoSoftwareRenderer* renderer, int start) {
 102	uint8_t block[6];
 103	memcpy(block, &renderer->sgbPacket[start], 6);
 104	unsigned x0 = block[2];
 105	unsigned x1 = block[4];
 106	unsigned y0 = block[3];
 107	unsigned y1 = block[5];
 108	unsigned x, y;
 109	int pIn = block[1] & 3;
 110	int pPerim = (block[1] >> 2) & 3;
 111	int pOut = (block[1] >> 4) & 3;
 112
 113	for (y = 0; y < GB_VIDEO_VERTICAL_PIXELS / 8; ++y) {
 114		for (x = 0; x < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++x) {
 115			if (y > y0 && y < y1 && x > x0 && x < x1) {
 116				if (block[0] & 1) {
 117					_setAttribute(renderer->d.sgbAttributes, x, y, pIn);
 118				}
 119			} else if (y < y0 || y > y1 || x < x0 || x > x1) {
 120				if (block[0] & 4) {
 121					_setAttribute(renderer->d.sgbAttributes, x, y, pOut);
 122				}
 123			} else {
 124				if (block[0] & 2) {
 125					_setAttribute(renderer->d.sgbAttributes, x, y, pPerim);
 126				} else if (block[0] & 1) {
 127					_setAttribute(renderer->d.sgbAttributes, x, y, pIn);
 128				} else if (block[0] & 4) {
 129					_setAttribute(renderer->d.sgbAttributes, x, y, pOut);
 130				}
 131			}
 132		}
 133	}
 134}
 135
 136static void _parseAttrLine(struct GBVideoSoftwareRenderer* renderer, int start) {
 137	uint8_t byte = renderer->sgbPacket[start];
 138	unsigned line = byte & 0x1F;
 139	int pal = (byte >> 5) & 3;
 140
 141	if (byte & 0x80) {
 142		if (line > GB_VIDEO_VERTICAL_PIXELS / 8) {
 143			return;
 144		}
 145		int x;
 146		for (x = 0; x < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++x) {
 147			_setAttribute(renderer->d.sgbAttributes, x, line, pal);
 148		}
 149	} else {
 150		if (line > GB_VIDEO_HORIZONTAL_PIXELS / 8) {
 151			return;
 152		}
 153		int y;
 154		for (y = 0; y < GB_VIDEO_VERTICAL_PIXELS / 8; ++y) {
 155			_setAttribute(renderer->d.sgbAttributes, line, y, pal);
 156		}
 157	}
 158}
 159
 160static bool _inWindow(struct GBVideoSoftwareRenderer* renderer) {
 161	return GBRegisterLCDCIsWindow(renderer->lcdc) && GB_VIDEO_HORIZONTAL_PIXELS + 7 > renderer->wx;
 162}
 163
 164void GBVideoSoftwareRendererCreate(struct GBVideoSoftwareRenderer* renderer) {
 165	renderer->d.init = GBVideoSoftwareRendererInit;
 166	renderer->d.deinit = GBVideoSoftwareRendererDeinit;
 167	renderer->d.writeVideoRegister = GBVideoSoftwareRendererWriteVideoRegister;
 168	renderer->d.writeSGBPacket = GBVideoSoftwareRendererWriteSGBPacket;
 169	renderer->d.writePalette = GBVideoSoftwareRendererWritePalette;
 170	renderer->d.writeVRAM = GBVideoSoftwareRendererWriteVRAM;
 171	renderer->d.writeOAM = GBVideoSoftwareRendererWriteOAM;
 172	renderer->d.drawRange = GBVideoSoftwareRendererDrawRange;
 173	renderer->d.finishScanline = GBVideoSoftwareRendererFinishScanline;
 174	renderer->d.finishFrame = GBVideoSoftwareRendererFinishFrame;
 175	renderer->d.enableSGBBorder = GBVideoSoftwareRendererEnableSGBBorder;
 176	renderer->d.getPixels = GBVideoSoftwareRendererGetPixels;
 177	renderer->d.putPixels = GBVideoSoftwareRendererPutPixels;
 178
 179	renderer->d.disableBG = false;
 180	renderer->d.disableOBJ = false;
 181	renderer->d.disableWIN = false;
 182
 183	renderer->temporaryBuffer = 0;
 184}
 185
 186static void GBVideoSoftwareRendererInit(struct GBVideoRenderer* renderer, enum GBModel model, bool sgbBorders) {
 187	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 188	softwareRenderer->lcdc = 0;
 189	softwareRenderer->scy = 0;
 190	softwareRenderer->scx = 0;
 191	softwareRenderer->wy = 0;
 192	softwareRenderer->currentWy = 0;
 193	softwareRenderer->currentWx = 0;
 194	softwareRenderer->lastY = GB_VIDEO_VERTICAL_PIXELS;
 195	softwareRenderer->lastX = 0;
 196	softwareRenderer->hasWindow = false;
 197	softwareRenderer->wx = 0;
 198	softwareRenderer->model = model;
 199	softwareRenderer->sgbTransfer = 0;
 200	softwareRenderer->sgbCommandHeader = 0;
 201	softwareRenderer->sgbBorders = sgbBorders;
 202	softwareRenderer->objOffsetX = 0;
 203	softwareRenderer->objOffsetY = 0;
 204	softwareRenderer->offsetScx = 0;
 205	softwareRenderer->offsetScy = 0;
 206	softwareRenderer->offsetWx = 0;
 207	softwareRenderer->offsetWy = 0;
 208
 209	int i;
 210	for (i = 0; i < 64; ++i) {
 211		softwareRenderer->lookup[i] = i;
 212		softwareRenderer->lookup[i] = i;
 213		softwareRenderer->lookup[i] = i;
 214		softwareRenderer->lookup[i] = i;
 215	}
 216
 217	memset(softwareRenderer->palette, 0, sizeof(softwareRenderer->palette));
 218}
 219
 220static void GBVideoSoftwareRendererDeinit(struct GBVideoRenderer* renderer) {
 221	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 222	UNUSED(softwareRenderer);
 223}
 224
 225static void GBVideoSoftwareRendererUpdateWindow(struct GBVideoSoftwareRenderer* renderer, bool before, bool after, uint8_t oldWy) {
 226	if (renderer->lastY >= GB_VIDEO_VERTICAL_PIXELS || !(after || before)) {
 227		return;
 228	}
 229	if (!renderer->hasWindow && renderer->lastX == GB_VIDEO_HORIZONTAL_PIXELS) {
 230		return;
 231	}
 232	if (renderer->lastY >= oldWy) {
 233		if (!after) {
 234			renderer->currentWy -= renderer->lastY;
 235			renderer->hasWindow = true;
 236		} else if (!before) {
 237			if (!renderer->hasWindow) {
 238				renderer->currentWy = renderer->lastY - renderer->wy;
 239				if (renderer->lastY >= renderer->wy && renderer->lastX > renderer->wx) {
 240					++renderer->currentWy;
 241				}
 242			} else {
 243				renderer->currentWy += renderer->lastY;
 244			}
 245		} else if (renderer->wy != oldWy) {
 246			renderer->currentWy += oldWy - renderer->wy;
 247			renderer->hasWindow = true;
 248		}
 249	}
 250}
 251
 252static uint8_t GBVideoSoftwareRendererWriteVideoRegister(struct GBVideoRenderer* renderer, uint16_t address, uint8_t value) {
 253	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 254	if (renderer->cache) {
 255		GBVideoCacheWriteVideoRegister(renderer->cache, address, value);
 256	}
 257	bool wasWindow = _inWindow(softwareRenderer);
 258	uint8_t wy = softwareRenderer->wy;
 259	switch (address) {
 260	case GB_REG_LCDC:
 261		softwareRenderer->lcdc = value;
 262		GBVideoSoftwareRendererUpdateWindow(softwareRenderer, wasWindow, _inWindow(softwareRenderer), wy);
 263		break;
 264	case GB_REG_SCY:
 265		softwareRenderer->scy = value;
 266		break;
 267	case GB_REG_SCX:
 268		softwareRenderer->scx = value;
 269		break;
 270	case GB_REG_WY:
 271		softwareRenderer->wy = value;
 272		GBVideoSoftwareRendererUpdateWindow(softwareRenderer, wasWindow, _inWindow(softwareRenderer), wy);
 273		break;
 274	case GB_REG_WX:
 275		softwareRenderer->wx = value;
 276		GBVideoSoftwareRendererUpdateWindow(softwareRenderer, wasWindow, _inWindow(softwareRenderer), wy);
 277		break;
 278	case GB_REG_BGP:
 279		softwareRenderer->lookup[0] = value & 3;
 280		softwareRenderer->lookup[1] = (value >> 2) & 3;
 281		softwareRenderer->lookup[2] = (value >> 4) & 3;
 282		softwareRenderer->lookup[3] = (value >> 6) & 3;
 283		break;
 284	case GB_REG_OBP0:
 285		softwareRenderer->lookup[0x20 + 0] = value & 3;
 286		softwareRenderer->lookup[0x20 + 1] = (value >> 2) & 3;
 287		softwareRenderer->lookup[0x20 + 2] = (value >> 4) & 3;
 288		softwareRenderer->lookup[0x20 + 3] = (value >> 6) & 3;
 289		break;
 290	case GB_REG_OBP1:
 291		softwareRenderer->lookup[0x24 + 0] = value & 3;
 292		softwareRenderer->lookup[0x24 + 1] = (value >> 2) & 3;
 293		softwareRenderer->lookup[0x24 + 2] = (value >> 4) & 3;
 294		softwareRenderer->lookup[0x24 + 3] = (value >> 6) & 3;
 295		break;
 296	}
 297	return value;
 298}
 299
 300static void GBVideoSoftwareRendererWriteSGBPacket(struct GBVideoRenderer* renderer, uint8_t* data) {
 301	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 302	memcpy(softwareRenderer->sgbPacket, data, sizeof(softwareRenderer->sgbPacket));
 303	int i;
 304	softwareRenderer->sgbCommandHeader = data[0];
 305	softwareRenderer->sgbTransfer = 0;
 306	int set;
 307	int sets;
 308	int attrX;
 309	int attrY;
 310	int attrDirection;
 311	int pBefore;
 312	int pAfter;
 313	int pDiv;
 314	switch (softwareRenderer->sgbCommandHeader >> 3) {
 315	case SGB_PAL_SET:
 316		softwareRenderer->sgbPacket[1] = data[9];
 317		if (!(data[9] & 0x80)) {
 318			break;
 319		}
 320		// Fall through
 321	case SGB_ATTR_SET:
 322		set = softwareRenderer->sgbPacket[1] & 0x3F;
 323		if (set <= 0x2C) {
 324			memcpy(renderer->sgbAttributes, &renderer->sgbAttributeFiles[set * 90], 90);
 325		}
 326		break;
 327	case SGB_ATTR_BLK:
 328		sets = softwareRenderer->sgbPacket[1];
 329		i = 2;
 330		for (; i < (softwareRenderer->sgbCommandHeader & 7) << 4 && sets; i += 6, --sets) {
 331			_parseAttrBlock(softwareRenderer, i);
 332		}
 333		break;
 334	case SGB_ATTR_LIN:
 335		sets = softwareRenderer->sgbPacket[1];
 336		i = 2;
 337		for (; i < (softwareRenderer->sgbCommandHeader & 7) << 4 && sets; ++i, --sets) {
 338			_parseAttrLine(softwareRenderer, i);
 339		}
 340		break;
 341	case SGB_ATTR_DIV:
 342		pAfter = softwareRenderer->sgbPacket[1] & 3;
 343		pBefore = (softwareRenderer->sgbPacket[1] >> 2) & 3;
 344		pDiv = (softwareRenderer->sgbPacket[1] >> 4) & 3;
 345		attrX = softwareRenderer->sgbPacket[2];
 346		if (softwareRenderer->sgbPacket[1] & 0x40) {
 347			if (attrX > GB_VIDEO_VERTICAL_PIXELS / 8) {
 348				attrX = GB_VIDEO_VERTICAL_PIXELS / 8;
 349			}
 350			int j;
 351			for (j = 0; j < attrX; ++j) {
 352				for (i = 0; i < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++i) {
 353					_setAttribute(renderer->sgbAttributes, i, j, pBefore);
 354				}
 355			}
 356			if (attrX < GB_VIDEO_VERTICAL_PIXELS / 8) {
 357				for (i = 0; i < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++i) {
 358					_setAttribute(renderer->sgbAttributes, i, attrX, pDiv);
 359				}
 360
 361			}
 362			for (; j < GB_VIDEO_VERTICAL_PIXELS / 8; ++j) {
 363				for (i = 0; i < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++i) {
 364					_setAttribute(renderer->sgbAttributes, i, j, pAfter);
 365				}
 366			}
 367		} else {
 368			if (attrX > GB_VIDEO_HORIZONTAL_PIXELS / 8) {
 369				attrX = GB_VIDEO_HORIZONTAL_PIXELS / 8;
 370			}
 371			int j;
 372			for (j = 0; j < attrX; ++j) {
 373				for (i = 0; i < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++i) {
 374					_setAttribute(renderer->sgbAttributes, j, i, pBefore);
 375				}
 376			}
 377			if (attrX < GB_VIDEO_HORIZONTAL_PIXELS / 8) {
 378				for (i = 0; i < GB_VIDEO_VERTICAL_PIXELS / 8; ++i) {
 379					_setAttribute(renderer->sgbAttributes, attrX, i, pDiv);
 380				}
 381
 382			}
 383			for (; j < GB_VIDEO_HORIZONTAL_PIXELS / 8; ++j) {
 384				for (i = 0; i < GB_VIDEO_VERTICAL_PIXELS / 8; ++i) {
 385					_setAttribute(renderer->sgbAttributes, j, i, pAfter);
 386				}
 387			}
 388		}
 389		break;
 390	case SGB_ATTR_CHR:
 391		attrX = softwareRenderer->sgbPacket[1];
 392		attrY = softwareRenderer->sgbPacket[2];
 393		if (attrX >= GB_VIDEO_HORIZONTAL_PIXELS / 8) {
 394			attrX = 0;
 395		}
 396		if (attrY >= GB_VIDEO_VERTICAL_PIXELS / 8) {
 397			attrY = 0;
 398		}
 399		sets = softwareRenderer->sgbPacket[3];
 400		sets |= softwareRenderer->sgbPacket[4] << 8;
 401		attrDirection = softwareRenderer->sgbPacket[5];
 402		i = 6;
 403		for (; i < (softwareRenderer->sgbCommandHeader & 7) << 4 && sets; ++i) {
 404			int j;
 405			for (j = 0; j < 4 && sets; ++j, --sets) {
 406				uint8_t p = softwareRenderer->sgbPacket[i] >> (6 - j * 2);
 407				_setAttribute(renderer->sgbAttributes, attrX, attrY, p & 3);
 408				if (attrDirection) {
 409					++attrY;
 410					if (attrY >= GB_VIDEO_VERTICAL_PIXELS / 8) {
 411						attrY = 0;
 412						++attrX;
 413					}
 414					if (attrX >= GB_VIDEO_HORIZONTAL_PIXELS / 8) {
 415						attrX = 0;
 416					}
 417				} else {
 418					++attrX;
 419					if (attrX >= GB_VIDEO_HORIZONTAL_PIXELS / 8) {
 420						attrX = 0;
 421						++attrY;
 422					}
 423					if (attrY >= GB_VIDEO_VERTICAL_PIXELS / 8) {
 424						attrY = 0;
 425					}
 426				}
 427			}
 428		}
 429
 430		break;
 431	case SGB_ATRC_EN:
 432	case SGB_MASK_EN:
 433		if (softwareRenderer->sgbBorders && !renderer->sgbRenderMode) {
 434			_regenerateSGBBorder(softwareRenderer);
 435		}
 436	}
 437}
 438
 439static void GBVideoSoftwareRendererWritePalette(struct GBVideoRenderer* renderer, int index, uint16_t value) {
 440	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 441	color_t color = mColorFrom555(value);
 442	if (softwareRenderer->model & GB_MODEL_SGB) {
 443		if (index < 0x10 && index && !(index & 3)) {
 444			color = softwareRenderer->palette[0];
 445		} else if (index >= 0x40 && !(index & 0xF)) {
 446			color = softwareRenderer->palette[0];
 447		}
 448	}
 449	if (renderer->cache) {
 450		mCacheSetWritePalette(renderer->cache, index, color);
 451	}
 452	if (softwareRenderer->model == GB_MODEL_AGB) {
 453		unsigned r = M_R5(value);
 454		unsigned g = M_G5(value);
 455		unsigned b = M_B5(value);
 456		r = r * r;
 457		g = g * g;
 458		b = b * b;
 459#ifdef COLOR_16_BIT
 460		r /= 31;
 461		g /= 31;
 462		b /= 31;
 463		color = mColorFrom555(r | (g << 5) | (b << 10));
 464#else
 465		r >>= 2;
 466		r += r >> 4;
 467		g >>= 2;
 468		g += g >> 4;
 469		b >>= 2;
 470		b += b >> 4;
 471		color = r | (g << 8) | (b << 16);
 472#endif
 473	}
 474	softwareRenderer->palette[index] = color;
 475
 476	if (softwareRenderer->model & GB_MODEL_SGB && !index && GBRegisterLCDCIsEnable(softwareRenderer->lcdc)) {
 477		renderer->writePalette(renderer, 0x04, value);
 478		renderer->writePalette(renderer, 0x08, value);
 479		renderer->writePalette(renderer, 0x0C, value);
 480		renderer->writePalette(renderer, 0x40, value);
 481		renderer->writePalette(renderer, 0x50, value);
 482		renderer->writePalette(renderer, 0x60, value);
 483		renderer->writePalette(renderer, 0x70, value);
 484		if (softwareRenderer->sgbBorders && !renderer->sgbRenderMode) {
 485			_regenerateSGBBorder(softwareRenderer);
 486		}
 487	}
 488}
 489
 490static void GBVideoSoftwareRendererWriteVRAM(struct GBVideoRenderer* renderer, uint16_t address) {
 491	if (renderer->cache) {
 492		mCacheSetWriteVRAM(renderer->cache, address);
 493	}
 494}
 495
 496static void GBVideoSoftwareRendererWriteOAM(struct GBVideoRenderer* renderer, uint16_t oam) {
 497	UNUSED(renderer);
 498	UNUSED(oam);
 499	// Nothing to do
 500}
 501
 502static void _cleanOAM(struct GBVideoSoftwareRenderer* renderer, int y) {
 503	// TODO: GBC differences
 504	// TODO: Optimize
 505	int spriteHeight = 8;
 506	if (GBRegisterLCDCIsObjSize(renderer->lcdc)) {
 507		spriteHeight = 16;
 508	}
 509	int o = 0;
 510	int i;
 511	for (i = 0; i < 40 && o < 10; ++i) {
 512		uint8_t oy = renderer->d.oam->obj[i].y;
 513		if (y < oy - 16 || y >= oy - 16 + spriteHeight) {
 514			continue;
 515		}
 516		// TODO: Sort
 517		renderer->obj[o] = renderer->d.oam->obj[i];
 518		++o;
 519		if (o == 10) {
 520			break;
 521		}
 522	}
 523	renderer->objMax = o;
 524}
 525
 526static void GBVideoSoftwareRendererDrawRange(struct GBVideoRenderer* renderer, int startX, int endX, int y) {
 527	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 528	softwareRenderer->lastY = y;
 529	softwareRenderer->lastX = endX;
 530	uint8_t* maps = &softwareRenderer->d.vram[GB_BASE_MAP];
 531	if (GBRegisterLCDCIsTileMap(softwareRenderer->lcdc)) {
 532		maps += GB_SIZE_MAP;
 533	}
 534	if (softwareRenderer->d.disableBG) {
 535		memset(&softwareRenderer->row[startX], 0, endX - startX);
 536	}
 537	if (GBRegisterLCDCIsBgEnable(softwareRenderer->lcdc) || softwareRenderer->model >= GB_MODEL_CGB) {
 538		int wy = softwareRenderer->wy + softwareRenderer->currentWy;
 539		int wx = softwareRenderer->wx + softwareRenderer->currentWx - 7;
 540		if (GBRegisterLCDCIsWindow(softwareRenderer->lcdc) && wy == y && wx <= endX) {
 541			softwareRenderer->hasWindow = true;
 542		}
 543		if (GBRegisterLCDCIsWindow(softwareRenderer->lcdc) && softwareRenderer->hasWindow && wx <= endX && !softwareRenderer->d.disableWIN) {
 544			if (wx > 0 && !softwareRenderer->d.disableBG) {
 545				GBVideoSoftwareRendererDrawBackground(softwareRenderer, maps, startX, wx, softwareRenderer->scx - softwareRenderer->offsetScx, softwareRenderer->scy + y - softwareRenderer->offsetScy);
 546			}
 547
 548			maps = &softwareRenderer->d.vram[GB_BASE_MAP];
 549			if (GBRegisterLCDCIsWindowTileMap(softwareRenderer->lcdc)) {
 550				maps += GB_SIZE_MAP;
 551			}
 552			GBVideoSoftwareRendererDrawBackground(softwareRenderer, maps, wx, endX, -wx - softwareRenderer->offsetWx, y - wy - softwareRenderer->offsetWy);
 553		} else if (!softwareRenderer->d.disableBG) {
 554			GBVideoSoftwareRendererDrawBackground(softwareRenderer, maps, startX, endX, softwareRenderer->scx - softwareRenderer->offsetScx, softwareRenderer->scy + y - softwareRenderer->offsetScy);
 555		}
 556	} else if (!softwareRenderer->d.disableBG) {
 557		memset(&softwareRenderer->row[startX], 0, endX - startX);
 558	}
 559
 560	if (GBRegisterLCDCIsObjEnable(softwareRenderer->lcdc) && !softwareRenderer->d.disableOBJ) {
 561		if (startX == 0) {
 562			_cleanOAM(softwareRenderer, y);
 563		}
 564		int i;
 565		for (i = 0; i < softwareRenderer->objMax; ++i) {
 566			GBVideoSoftwareRendererDrawObj(softwareRenderer, &softwareRenderer->obj[i], startX, endX, y);
 567		}
 568	}
 569
 570	size_t sgbOffset = 0;
 571	if (softwareRenderer->model & GB_MODEL_SGB && softwareRenderer->sgbBorders) {
 572		sgbOffset = softwareRenderer->outputBufferStride * 40 + 48;
 573	}
 574	color_t* row = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * y + sgbOffset];
 575	int x = startX;
 576	int p = 0;
 577	switch (softwareRenderer->d.sgbRenderMode) {
 578	case 0:
 579		if (softwareRenderer->model & GB_MODEL_SGB) {
 580			p = softwareRenderer->d.sgbAttributes[(startX >> 5) + 5 * (y >> 3)];
 581			p >>= 6 - ((x / 4) & 0x6);
 582			p &= 3;
 583			p <<= 2;
 584		}
 585		for (; x < ((startX + 7) & ~7) && x < endX; ++x) {
 586			row[x] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x] & 0x7F]];
 587		}
 588		for (; x + 7 < (endX & ~7); x += 8) {
 589			if (softwareRenderer->model & GB_MODEL_SGB) {
 590				p = softwareRenderer->d.sgbAttributes[(x >> 5) + 5 * (y >> 3)];
 591				p >>= 6 - ((x / 4) & 0x6);
 592				p &= 3;
 593				p <<= 2;
 594			}
 595			row[x + 0] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x] & 0x7F]];
 596			row[x + 1] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 1] & 0x7F]];
 597			row[x + 2] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 2] & 0x7F]];
 598			row[x + 3] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 3] & 0x7F]];
 599			row[x + 4] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 4] & 0x7F]];
 600			row[x + 5] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 5] & 0x7F]];
 601			row[x + 6] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 6] & 0x7F]];
 602			row[x + 7] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x + 7] & 0x7F]];
 603		}
 604		if (softwareRenderer->model & GB_MODEL_SGB) {
 605			p = softwareRenderer->d.sgbAttributes[(x >> 5) + 5 * (y >> 3)];
 606			p >>= 6 - ((x / 4) & 0x6);
 607			p &= 3;
 608			p <<= 2;
 609		}
 610		for (; x < endX; ++x) {
 611			row[x] = softwareRenderer->palette[p | softwareRenderer->lookup[softwareRenderer->row[x] & 0x7F]];
 612		}
 613		break;
 614	case 1:
 615		break;
 616	case 2:
 617		for (; x < ((startX + 7) & ~7) && x < endX; ++x) {
 618			row[x] = 0;
 619		}
 620		for (; x + 7 < (endX & ~7); x += 8) {
 621			row[x] = 0;
 622			row[x + 1] = 0;
 623			row[x + 2] = 0;
 624			row[x + 3] = 0;
 625			row[x + 4] = 0;
 626			row[x + 5] = 0;
 627			row[x + 6] = 0;
 628			row[x + 7] = 0;
 629		}
 630		for (; x < endX; ++x) {
 631			row[x] = 0;
 632		}
 633		break;
 634	case 3:
 635		for (; x < ((startX + 7) & ~7) && x < endX; ++x) {
 636			row[x] = softwareRenderer->palette[0];
 637		}
 638		for (; x + 7 < (endX & ~7); x += 8) {
 639			row[x] = softwareRenderer->palette[0];
 640			row[x + 1] = softwareRenderer->palette[0];
 641			row[x + 2] = softwareRenderer->palette[0];
 642			row[x + 3] = softwareRenderer->palette[0];
 643			row[x + 4] = softwareRenderer->palette[0];
 644			row[x + 5] = softwareRenderer->palette[0];
 645			row[x + 6] = softwareRenderer->palette[0];
 646			row[x + 7] = softwareRenderer->palette[0];
 647		}
 648		for (; x < endX; ++x) {
 649			row[x] = softwareRenderer->palette[0];
 650		}
 651		break;
 652	}
 653}
 654
 655static void GBVideoSoftwareRendererFinishScanline(struct GBVideoRenderer* renderer, int y) {
 656	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 657
 658	softwareRenderer->lastX = 0;
 659	softwareRenderer->currentWx = 0;
 660
 661	if (softwareRenderer->sgbTransfer == 1) {
 662		size_t offset = 2 * ((y & 7) + (y >> 3) * GB_VIDEO_HORIZONTAL_PIXELS);
 663		if (offset >= 0x1000) {
 664			return;
 665		}
 666		uint8_t* buffer = NULL;
 667		switch (softwareRenderer->sgbCommandHeader >> 3) {
 668		case SGB_PAL_TRN:
 669			buffer = renderer->sgbPalRam;
 670			break;
 671		case SGB_CHR_TRN:
 672			buffer = &renderer->sgbCharRam[SGB_SIZE_CHAR_RAM / 2 * (softwareRenderer->sgbPacket[1] & 1)];
 673			break;
 674		case SGB_PCT_TRN:
 675			buffer = renderer->sgbMapRam;
 676			break;
 677		case SGB_ATTR_TRN:
 678			buffer = renderer->sgbAttributeFiles;
 679			break;
 680		default:
 681			break;
 682		}
 683		if (buffer) {
 684			int i;
 685			for (i = 0; i < GB_VIDEO_HORIZONTAL_PIXELS; i += 8) {
 686				if (UNLIKELY(offset + (i << 1) + 1 >= 0x1000)) {
 687					break;
 688				}
 689				uint8_t hi = 0;
 690				uint8_t lo = 0;
 691				hi |= (softwareRenderer->row[i + 0] & 0x2) << 6;
 692				lo |= (softwareRenderer->row[i + 0] & 0x1) << 7;
 693				hi |= (softwareRenderer->row[i + 1] & 0x2) << 5;
 694				lo |= (softwareRenderer->row[i + 1] & 0x1) << 6;
 695				hi |= (softwareRenderer->row[i + 2] & 0x2) << 4;
 696				lo |= (softwareRenderer->row[i + 2] & 0x1) << 5;
 697				hi |= (softwareRenderer->row[i + 3] & 0x2) << 3;
 698				lo |= (softwareRenderer->row[i + 3] & 0x1) << 4;
 699				hi |= (softwareRenderer->row[i + 4] & 0x2) << 2;
 700				lo |= (softwareRenderer->row[i + 4] & 0x1) << 3;
 701				hi |= (softwareRenderer->row[i + 5] & 0x2) << 1;
 702				lo |= (softwareRenderer->row[i + 5] & 0x1) << 2;
 703				hi |= (softwareRenderer->row[i + 6] & 0x2) << 0;
 704				lo |= (softwareRenderer->row[i + 6] & 0x1) << 1;
 705				hi |= (softwareRenderer->row[i + 7] & 0x2) >> 1;
 706				lo |= (softwareRenderer->row[i + 7] & 0x1) >> 0;
 707				buffer[offset + (i << 1) + 0] = lo;
 708				buffer[offset + (i << 1) + 1] = hi;
 709			}
 710		}
 711	}
 712}
 713
 714static void GBVideoSoftwareRendererFinishFrame(struct GBVideoRenderer* renderer) {
 715	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 716
 717	if (softwareRenderer->temporaryBuffer) {
 718		mappedMemoryFree(softwareRenderer->temporaryBuffer, GB_VIDEO_HORIZONTAL_PIXELS * GB_VIDEO_VERTICAL_PIXELS * 4);
 719		softwareRenderer->temporaryBuffer = 0;
 720	}
 721	if (!GBRegisterLCDCIsEnable(softwareRenderer->lcdc)) {
 722		_clearScreen(softwareRenderer);
 723	}
 724	if (softwareRenderer->model & GB_MODEL_SGB) {
 725		switch (softwareRenderer->sgbCommandHeader >> 3) {
 726		case SGB_PAL_SET:
 727		case SGB_ATTR_SET:
 728			if (softwareRenderer->sgbPacket[1] & 0x40) {
 729				renderer->sgbRenderMode = 0;
 730			}
 731			break;
 732		case SGB_PAL_TRN:
 733		case SGB_CHR_TRN:
 734		case SGB_PCT_TRN:
 735		case SGB_ATRC_EN:
 736		case SGB_MASK_EN:
 737			if (softwareRenderer->sgbBorders && !renderer->sgbRenderMode) {
 738				// Make sure every buffer sees this if we're multibuffering
 739				_regenerateSGBBorder(softwareRenderer);
 740			}
 741			// Fall through
 742		case SGB_ATTR_TRN:
 743			++softwareRenderer->sgbTransfer;
 744			if (softwareRenderer->sgbTransfer == 5) {
 745				softwareRenderer->sgbCommandHeader = 0;
 746			}
 747			break;
 748		default:
 749			break;
 750		}
 751	}
 752	softwareRenderer->lastY = GB_VIDEO_VERTICAL_PIXELS;
 753	softwareRenderer->lastX = 0;
 754	softwareRenderer->currentWy = 0;
 755	softwareRenderer->currentWx = 0;
 756	softwareRenderer->hasWindow = false;
 757}
 758
 759static void GBVideoSoftwareRendererEnableSGBBorder(struct GBVideoRenderer* renderer, bool enable) {
 760	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
 761	if (softwareRenderer->model & GB_MODEL_SGB) {
 762		if (enable == softwareRenderer->sgbBorders) {
 763			return;
 764		}
 765		softwareRenderer->sgbBorders = enable;
 766		if (softwareRenderer->sgbBorders && !renderer->sgbRenderMode) {
 767			_regenerateSGBBorder(softwareRenderer);
 768		}
 769	}
 770}
 771
 772static void GBVideoSoftwareRendererDrawBackground(struct GBVideoSoftwareRenderer* renderer, uint8_t* maps, int startX, int endX, int sx, int sy) {
 773	uint8_t* data = renderer->d.vram;
 774	uint8_t* attr = &maps[GB_SIZE_VRAM_BANK0];
 775	if (!GBRegisterLCDCIsTileData(renderer->lcdc)) {
 776		data += 0x1000;
 777	}
 778	int topY = ((sy >> 3) & 0x1F) * 0x20;
 779	int bottomY = sy & 7;
 780	if (startX < 0) {
 781		startX = 0;
 782	}
 783	int x;
 784	if ((startX + sx) & 7) {
 785		int startX2 = startX + 8 - ((startX + sx) & 7);
 786		for (x = startX; x < startX2; ++x) {
 787			uint8_t* localData = data;
 788			int localY = bottomY;
 789			int topX = ((x + sx) >> 3) & 0x1F;
 790			int bottomX = 7 - ((x + sx) & 7);
 791			int bgTile;
 792			if (GBRegisterLCDCIsTileData(renderer->lcdc)) {
 793				bgTile = maps[topX + topY];
 794			} else {
 795				bgTile = ((int8_t*) maps)[topX + topY];
 796			}
 797			int p = 0;
 798			if (renderer->model >= GB_MODEL_CGB) {
 799				GBObjAttributes attrs = attr[topX + topY];
 800				p = GBObjAttributesGetCGBPalette(attrs) * 4;
 801				if (GBObjAttributesIsPriority(attrs) && GBRegisterLCDCIsBgEnable(renderer->lcdc)) {
 802					p |= 0x80;
 803				}
 804				if (GBObjAttributesIsBank(attrs)) {
 805					localData += GB_SIZE_VRAM_BANK0;
 806				}
 807				if (GBObjAttributesIsYFlip(attrs)) {
 808					localY = 7 - bottomY;
 809				}
 810				if (GBObjAttributesIsXFlip(attrs)) {
 811					bottomX = 7 - bottomX;
 812				}
 813			}
 814			uint8_t tileDataLower = localData[(bgTile * 8 + localY) * 2];
 815			uint8_t tileDataUpper = localData[(bgTile * 8 + localY) * 2 + 1];
 816			tileDataUpper >>= bottomX;
 817			tileDataLower >>= bottomX;
 818			renderer->row[x] = p | ((tileDataUpper & 1) << 1) | (tileDataLower & 1);
 819		}
 820		startX = startX2;
 821	}
 822	for (x = startX; x < endX; x += 8) {
 823		uint8_t* localData = data;
 824		int localY = bottomY;
 825		int topX = ((x + sx) >> 3) & 0x1F;
 826		int bgTile;
 827		if (GBRegisterLCDCIsTileData(renderer->lcdc)) {
 828			bgTile = maps[topX + topY];
 829		} else {
 830			bgTile = ((int8_t*) maps)[topX + topY];
 831		}
 832		int p = 0;
 833		if (renderer->model >= GB_MODEL_CGB) {
 834			GBObjAttributes attrs = attr[topX + topY];
 835			p = GBObjAttributesGetCGBPalette(attrs) * 4;
 836			if (GBObjAttributesIsPriority(attrs) && GBRegisterLCDCIsBgEnable(renderer->lcdc)) {
 837				p |= 0x80;
 838			}
 839			if (GBObjAttributesIsBank(attrs)) {
 840				localData += GB_SIZE_VRAM_BANK0;
 841			}
 842			if (GBObjAttributesIsYFlip(attrs)) {
 843				localY = 7 - bottomY;
 844			}
 845			if (GBObjAttributesIsXFlip(attrs)) {
 846				uint8_t tileDataLower = localData[(bgTile * 8 + localY) * 2];
 847				uint8_t tileDataUpper = localData[(bgTile * 8 + localY) * 2 + 1];
 848				renderer->row[x + 0] = p | ((tileDataUpper & 1) << 1) | (tileDataLower & 1);
 849				renderer->row[x + 1] = p | (tileDataUpper & 2) | ((tileDataLower & 2) >> 1);
 850				renderer->row[x + 2] = p | ((tileDataUpper & 4) >> 1) | ((tileDataLower & 4) >> 2);
 851				renderer->row[x + 3] = p | ((tileDataUpper & 8) >> 2) | ((tileDataLower & 8) >> 3);
 852				renderer->row[x + 4] = p | ((tileDataUpper & 16) >> 3) | ((tileDataLower & 16) >> 4);
 853				renderer->row[x + 5] = p | ((tileDataUpper & 32) >> 4) | ((tileDataLower & 32) >> 5);
 854				renderer->row[x + 6] = p | ((tileDataUpper & 64) >> 5) | ((tileDataLower & 64) >> 6);
 855				renderer->row[x + 7] = p | ((tileDataUpper & 128) >> 6) | ((tileDataLower & 128) >> 7);
 856				continue;
 857			}
 858		}
 859		uint8_t tileDataLower = localData[(bgTile * 8 + localY) * 2];
 860		uint8_t tileDataUpper = localData[(bgTile * 8 + localY) * 2 + 1];
 861		renderer->row[x + 7] = p | ((tileDataUpper & 1) << 1) | (tileDataLower & 1);
 862		renderer->row[x + 6] = p | (tileDataUpper & 2) | ((tileDataLower & 2) >> 1);
 863		renderer->row[x + 5] = p | ((tileDataUpper & 4) >> 1) | ((tileDataLower & 4) >> 2);
 864		renderer->row[x + 4] = p | ((tileDataUpper & 8) >> 2) | ((tileDataLower & 8) >> 3);
 865		renderer->row[x + 3] = p | ((tileDataUpper & 16) >> 3) | ((tileDataLower & 16) >> 4);
 866		renderer->row[x + 2] = p | ((tileDataUpper & 32) >> 4) | ((tileDataLower & 32) >> 5);
 867		renderer->row[x + 1] = p | ((tileDataUpper & 64) >> 5) | ((tileDataLower & 64) >> 6);
 868		renderer->row[x + 0] = p | ((tileDataUpper & 128) >> 6) | ((tileDataLower & 128) >> 7);
 869	}
 870}
 871
 872static void GBVideoSoftwareRendererDrawObj(struct GBVideoSoftwareRenderer* renderer, struct GBObj* obj, int startX, int endX, int y) {
 873	int objX = obj->x + renderer->objOffsetX;
 874	int ix = objX - 8;
 875	if (endX < ix || startX >= ix + 8) {
 876		return;
 877	}
 878	if (objX < endX) {
 879		endX = objX;
 880	}
 881	if (objX - 8 > startX) {
 882		startX = objX - 8;
 883	}
 884	if (startX < 0) {
 885		startX = 0;
 886	}
 887	uint8_t* data = renderer->d.vram;
 888	int tileOffset = 0;
 889	int bottomY;
 890	int objY = obj->y + renderer->objOffsetY;
 891	if (GBObjAttributesIsYFlip(obj->attr)) {
 892		bottomY = 7 - ((y - objY - 16) & 7);
 893		if (GBRegisterLCDCIsObjSize(renderer->lcdc) && y - objY < -8) {
 894			++tileOffset;
 895		}
 896	} else {
 897		bottomY = (y - objY - 16) & 7;
 898		if (GBRegisterLCDCIsObjSize(renderer->lcdc) && y - objY >= -8) {
 899			++tileOffset;
 900		}
 901	}
 902	if (GBRegisterLCDCIsObjSize(renderer->lcdc) && obj->tile & 1) {
 903		--tileOffset;
 904	}
 905	uint8_t mask = GBObjAttributesIsPriority(obj->attr) ? 0x63 : 0x60;
 906	uint8_t mask2 = GBObjAttributesIsPriority(obj->attr) ? 0 : 0x83;
 907	int p;
 908	if (renderer->model >= GB_MODEL_CGB) {
 909		p = (GBObjAttributesGetCGBPalette(obj->attr) + 8) * 4;
 910		if (GBObjAttributesIsBank(obj->attr)) {
 911			data += GB_SIZE_VRAM_BANK0;
 912		}
 913		if (!GBRegisterLCDCIsBgEnable(renderer->lcdc)) {
 914			mask = 0x60;
 915			mask2 = 0x83;
 916		}
 917	} else {
 918		p = (GBObjAttributesGetPalette(obj->attr) + 8) * 4;
 919	}
 920	int bottomX;
 921	int x = startX;
 922	if ((x - objX) & 7) {
 923		for (; x < endX; ++x) {
 924			if (GBObjAttributesIsXFlip(obj->attr)) {
 925				bottomX = (x - objX) & 7;
 926			} else {
 927				bottomX = 7 - ((x - objX) & 7);
 928			}
 929			int objTile = obj->tile + tileOffset;
 930			uint8_t tileDataLower = data[(objTile * 8 + bottomY) * 2];
 931			uint8_t tileDataUpper = data[(objTile * 8 + bottomY) * 2 + 1];
 932			tileDataUpper >>= bottomX;
 933			tileDataLower >>= bottomX;
 934			color_t current = renderer->row[x];
 935			if (((tileDataUpper | tileDataLower) & 1) && !(current & mask) && (current & mask2) <= 0x80) {
 936				renderer->row[x] = p | ((tileDataUpper & 1) << 1) | (tileDataLower & 1);
 937			}
 938		}
 939	} else if (GBObjAttributesIsXFlip(obj->attr)) {
 940		int objTile = obj->tile + tileOffset;
 941		uint8_t tileDataLower = data[(objTile * 8 + bottomY) * 2];
 942		uint8_t tileDataUpper = data[(objTile * 8 + bottomY) * 2 + 1];
 943		color_t current;
 944		current = renderer->row[x];
 945		if (((tileDataUpper | tileDataLower) & 1) && !(current & mask) && (current & mask2) <= 0x80) {
 946			renderer->row[x] = p | ((tileDataUpper & 1) << 1) | (tileDataLower & 1);
 947		}
 948		current = renderer->row[x + 1];
 949		if (((tileDataUpper | tileDataLower) & 2) && !(current & mask) && (current & mask2) <= 0x80) {
 950			renderer->row[x + 1] = p | (tileDataUpper & 2) | ((tileDataLower & 2) >> 1);
 951		}
 952		current = renderer->row[x + 2];
 953		if (((tileDataUpper | tileDataLower) & 4) && !(current & mask) && (current & mask2) <= 0x80) {
 954			renderer->row[x + 2] = p | ((tileDataUpper & 4) >> 1) | ((tileDataLower & 4) >> 2);
 955		}
 956		current = renderer->row[x + 3];
 957		if (((tileDataUpper | tileDataLower) & 8) && !(current & mask) && (current & mask2) <= 0x80) {
 958			renderer->row[x + 3] = p | ((tileDataUpper & 8) >> 2) | ((tileDataLower & 8) >> 3);
 959		}
 960		current = renderer->row[x + 4];
 961		if (((tileDataUpper | tileDataLower) & 16) && !(current & mask) && (current & mask2) <= 0x80) {
 962			renderer->row[x + 4] = p | ((tileDataUpper & 16) >> 3) | ((tileDataLower & 16) >> 4);
 963		}
 964		current = renderer->row[x + 5];
 965		if (((tileDataUpper | tileDataLower) & 32) && !(current & mask) && (current & mask2) <= 0x80) {
 966			renderer->row[x + 5] = p | ((tileDataUpper & 32) >> 4) | ((tileDataLower & 32) >> 5);
 967		}
 968		current = renderer->row[x + 6];
 969		if (((tileDataUpper | tileDataLower) & 64) && !(current & mask) && (current & mask2) <= 0x80) {
 970			renderer->row[x + 6] = p | ((tileDataUpper & 64) >> 5) | ((tileDataLower & 64) >> 6);
 971		}
 972		current = renderer->row[x + 7];
 973		if (((tileDataUpper | tileDataLower) & 128) && !(current & mask) && (current & mask2) <= 0x80) {
 974			renderer->row[x + 7] = p | ((tileDataUpper & 128) >> 6) | ((tileDataLower & 128) >> 7);
 975		}
 976	} else {
 977		int objTile = obj->tile + tileOffset;
 978		uint8_t tileDataLower = data[(objTile * 8 + bottomY) * 2];
 979		uint8_t tileDataUpper = data[(objTile * 8 + bottomY) * 2 + 1];
 980		color_t current;
 981		current = renderer->row[x + 7];
 982		if (((tileDataUpper | tileDataLower) & 1) && !(current & mask) && (current & mask2) <= 0x80) {
 983			renderer->row[x + 7] = p | ((tileDataUpper & 1) << 1) | (tileDataLower & 1);
 984		}
 985		current = renderer->row[x + 6];
 986		if (((tileDataUpper | tileDataLower) & 2) && !(current & mask) && (current & mask2) <= 0x80) {
 987			renderer->row[x + 6] = p | (tileDataUpper & 2) | ((tileDataLower & 2) >> 1);
 988		}
 989		current = renderer->row[x + 5];
 990		if (((tileDataUpper | tileDataLower) & 4) && !(current & mask) && (current & mask2) <= 0x80) {
 991			renderer->row[x + 5] = p | ((tileDataUpper & 4) >> 1) | ((tileDataLower & 4) >> 2);
 992		}
 993		current = renderer->row[x + 4];
 994		if (((tileDataUpper | tileDataLower) & 8) && !(current & mask) && (current & mask2) <= 0x80) {
 995			renderer->row[x + 4] = p | ((tileDataUpper & 8) >> 2) | ((tileDataLower & 8) >> 3);
 996		}
 997		current = renderer->row[x + 3];
 998		if (((tileDataUpper | tileDataLower) & 16) && !(current & mask) && (current & mask2) <= 0x80) {
 999			renderer->row[x + 3] = p | ((tileDataUpper & 16) >> 3) | ((tileDataLower & 16) >> 4);
1000		}
1001		current = renderer->row[x + 2];
1002		if (((tileDataUpper | tileDataLower) & 32) && !(current & mask) && (current & mask2) <= 0x80) {
1003			renderer->row[x + 2] = p | ((tileDataUpper & 32) >> 4) | ((tileDataLower & 32) >> 5);
1004		}
1005		current = renderer->row[x + 1];
1006		if (((tileDataUpper | tileDataLower) & 64) && !(current & mask) && (current & mask2) <= 0x80) {
1007			renderer->row[x + 1] = p | ((tileDataUpper & 64) >> 5) | ((tileDataLower & 64) >> 6);
1008		}
1009		current = renderer->row[x];
1010		if (((tileDataUpper | tileDataLower) & 128) && !(current & mask) && (current & mask2) <= 0x80) {
1011			renderer->row[x] = p | ((tileDataUpper & 128) >> 6) | ((tileDataLower & 128) >> 7);
1012		}
1013	}
1014}
1015
1016static void GBVideoSoftwareRendererGetPixels(struct GBVideoRenderer* renderer, size_t* stride, const void** pixels) {
1017	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
1018	*stride = softwareRenderer->outputBufferStride;
1019	*pixels = softwareRenderer->outputBuffer;
1020}
1021
1022static void GBVideoSoftwareRendererPutPixels(struct GBVideoRenderer* renderer, size_t stride, const void* pixels) {
1023	struct GBVideoSoftwareRenderer* softwareRenderer = (struct GBVideoSoftwareRenderer*) renderer;
1024	// TODO: Share with GBAVideoSoftwareRendererGetPixels
1025
1026	const color_t* colorPixels = pixels;
1027	unsigned i;
1028	for (i = 0; i < GB_VIDEO_VERTICAL_PIXELS; ++i) {
1029		memmove(&softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * i], &colorPixels[stride * i], GB_VIDEO_HORIZONTAL_PIXELS * BYTES_PER_PIXEL);
1030	}
1031}