src/gb/extra/proxy.c (view raw)
1/* Copyright (c) 2013-2017 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/proxy.h>
7
8#include <mgba/core/cache-set.h>
9#include <mgba/internal/gb/gb.h>
10#include <mgba/internal/gb/io.h>
11
12#define BUFFER_OAM 1
13#define BUFFER_SGB 2
14
15static void GBVideoProxyRendererInit(struct GBVideoRenderer* renderer, enum GBModel model, bool borders);
16static void GBVideoProxyRendererDeinit(struct GBVideoRenderer* renderer);
17static uint8_t GBVideoProxyRendererWriteVideoRegister(struct GBVideoRenderer* renderer, uint16_t address, uint8_t value);
18static void GBVideoProxyRendererWriteSGBPacket(struct GBVideoRenderer* renderer, uint8_t* data);
19static void GBVideoProxyRendererWriteVRAM(struct GBVideoRenderer* renderer, uint16_t address);
20static void GBVideoProxyRendererWriteOAM(struct GBVideoRenderer* renderer, uint16_t oam);
21static void GBVideoProxyRendererWritePalette(struct GBVideoRenderer* renderer, int address, uint16_t value);
22static void GBVideoProxyRendererDrawRange(struct GBVideoRenderer* renderer, int startX, int endX, int y, struct GBObj* obj, size_t oamMax);
23static void GBVideoProxyRendererFinishScanline(struct GBVideoRenderer* renderer, int y);
24static void GBVideoProxyRendererFinishFrame(struct GBVideoRenderer* renderer);
25static void GBVideoProxyRendererEnableSGBBorder(struct GBVideoRenderer* renderer, bool enable);
26static void GBVideoProxyRendererGetPixels(struct GBVideoRenderer* renderer, size_t* stride, const void** pixels);
27static void GBVideoProxyRendererPutPixels(struct GBVideoRenderer* renderer, size_t stride, const void* pixels);
28
29static bool _parsePacket(struct mVideoLogger* logger, const struct mVideoLoggerDirtyInfo* packet);
30static uint16_t* _vramBlock(struct mVideoLogger* logger, uint32_t address);
31
32void GBVideoProxyRendererCreate(struct GBVideoProxyRenderer* renderer, struct GBVideoRenderer* backend) {
33 renderer->d.init = GBVideoProxyRendererInit;
34 renderer->d.deinit = GBVideoProxyRendererDeinit;
35 renderer->d.writeVideoRegister = GBVideoProxyRendererWriteVideoRegister;
36 renderer->d.writeSGBPacket = GBVideoProxyRendererWriteSGBPacket;
37 renderer->d.writeVRAM = GBVideoProxyRendererWriteVRAM;
38 renderer->d.writeOAM = GBVideoProxyRendererWriteOAM;
39 renderer->d.writePalette = GBVideoProxyRendererWritePalette;
40 renderer->d.drawRange = GBVideoProxyRendererDrawRange;
41 renderer->d.finishScanline = GBVideoProxyRendererFinishScanline;
42 renderer->d.finishFrame = GBVideoProxyRendererFinishFrame;
43 renderer->d.enableSGBBorder = GBVideoProxyRendererEnableSGBBorder;
44 renderer->d.getPixels = GBVideoProxyRendererGetPixels;
45 renderer->d.putPixels = GBVideoProxyRendererPutPixels;
46
47 renderer->logger->context = renderer;
48 renderer->logger->parsePacket = _parsePacket;
49 renderer->logger->vramBlock = _vramBlock;
50 renderer->logger->paletteSize = 0;
51 renderer->logger->vramSize = GB_SIZE_VRAM;
52 renderer->logger->oamSize = GB_SIZE_OAM;
53
54 renderer->backend = backend;
55}
56
57static void _init(struct GBVideoProxyRenderer* proxyRenderer) {
58 mVideoLoggerRendererInit(proxyRenderer->logger);
59
60 if (proxyRenderer->logger->block) {
61 proxyRenderer->backend->vram = (uint8_t*) proxyRenderer->logger->vram;
62 proxyRenderer->backend->oam = (union GBOAM*) proxyRenderer->logger->oam;
63 proxyRenderer->backend->cache = NULL;
64 }
65}
66
67static void _reset(struct GBVideoProxyRenderer* proxyRenderer) {
68 memcpy(proxyRenderer->logger->oam, &proxyRenderer->d.oam->raw, GB_SIZE_OAM);
69 memcpy(proxyRenderer->logger->vram, proxyRenderer->d.vram, GB_SIZE_VRAM);
70
71 proxyRenderer->oamMax = 0;
72
73 mVideoLoggerRendererReset(proxyRenderer->logger);
74}
75
76void GBVideoProxyRendererShim(struct GBVideo* video, struct GBVideoProxyRenderer* renderer) {
77 if ((renderer->backend && video->renderer != renderer->backend) || video->renderer == &renderer->d) {
78 return;
79 }
80 renderer->backend = video->renderer;
81 video->renderer = &renderer->d;
82 renderer->d.cache = renderer->backend->cache;
83 renderer->d.vram = video->vram;
84 renderer->d.oam = &video->oam;
85 _init(renderer);
86 _reset(renderer);
87}
88
89void GBVideoProxyRendererUnshim(struct GBVideo* video, struct GBVideoProxyRenderer* renderer) {
90 if (video->renderer != &renderer->d) {
91 return;
92 }
93 renderer->backend->cache = video->renderer->cache;
94 video->renderer = renderer->backend;
95 renderer->backend->vram = video->vram;
96 renderer->backend->oam = &video->oam;
97
98 mVideoLoggerRendererDeinit(renderer->logger);
99}
100
101void GBVideoProxyRendererInit(struct GBVideoRenderer* renderer, enum GBModel model, bool borders) {
102 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
103
104 _init(proxyRenderer);
105
106 proxyRenderer->backend->init(proxyRenderer->backend, model, borders);
107}
108
109void GBVideoProxyRendererDeinit(struct GBVideoRenderer* renderer) {
110 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
111
112 proxyRenderer->backend->deinit(proxyRenderer->backend);
113
114 mVideoLoggerRendererDeinit(proxyRenderer->logger);
115}
116
117static bool _parsePacket(struct mVideoLogger* logger, const struct mVideoLoggerDirtyInfo* item) {
118 struct GBVideoProxyRenderer* proxyRenderer = logger->context;
119 uint8_t sgbPacket[16];
120 switch (item->type) {
121 case DIRTY_REGISTER:
122 proxyRenderer->backend->writeVideoRegister(proxyRenderer->backend, item->address, item->value);
123 break;
124 case DIRTY_PALETTE:
125 if (item->address < 64) {
126 proxyRenderer->backend->writePalette(proxyRenderer->backend, item->address, item->value);
127 }
128 break;
129 case DIRTY_OAM:
130 if (item->address < GB_SIZE_OAM) {
131 ((uint8_t*) logger->oam)[item->address] = item->value;
132 proxyRenderer->backend->writeOAM(proxyRenderer->backend, item->address);
133 }
134 break;
135 case DIRTY_VRAM:
136 proxyRenderer->backend->disableBG = proxyRenderer->d.disableBG;
137 proxyRenderer->backend->disableWIN = proxyRenderer->d.disableWIN;
138 proxyRenderer->backend->disableOBJ = proxyRenderer->d.disableOBJ;
139 if (item->address <= GB_SIZE_VRAM - 0x1000) {
140 logger->readData(logger, &logger->vram[item->address >> 1], 0x1000, true);
141 proxyRenderer->backend->writeVRAM(proxyRenderer->backend, item->address);
142 }
143 break;
144 case DIRTY_SCANLINE:
145 if (item->address < GB_VIDEO_VERTICAL_PIXELS) {
146 proxyRenderer->backend->finishScanline(proxyRenderer->backend, item->address);
147 }
148 break;
149 case DIRTY_RANGE:
150 if (item->value < item->value2 && item->value2 <= GB_VIDEO_HORIZONTAL_PIXELS && item->address < GB_VIDEO_VERTICAL_PIXELS) {
151 proxyRenderer->backend->drawRange(proxyRenderer->backend, item->value, item->value2, item->address, proxyRenderer->objThisLine, proxyRenderer->oamMax);
152 }
153 break;
154 case DIRTY_FRAME:
155 proxyRenderer->backend->finishFrame(proxyRenderer->backend);
156 break;
157 case DIRTY_BUFFER:
158 switch (item->address) {
159 case BUFFER_OAM:
160 proxyRenderer->oamMax = item->value2 / sizeof(struct GBObj);
161 if (proxyRenderer->oamMax > 40) {
162 proxyRenderer->oamMax = 0;
163 return false;
164 }
165 logger->readData(logger, &proxyRenderer->objThisLine, item->value2, true);
166 break;
167 case BUFFER_SGB:
168 logger->readData(logger, sgbPacket, 16, true);
169 proxyRenderer->backend->writeSGBPacket(proxyRenderer->backend, sgbPacket);
170 break;
171 }
172 break;
173 case DIRTY_FLUSH:
174 return false;
175 default:
176 return false;
177 }
178 return true;
179}
180
181static uint16_t* _vramBlock(struct mVideoLogger* logger, uint32_t address) {
182 struct GBVideoProxyRenderer* proxyRenderer = logger->context;
183 return (uint16_t*) &proxyRenderer->d.vram[address];
184}
185
186uint8_t GBVideoProxyRendererWriteVideoRegister(struct GBVideoRenderer* renderer, uint16_t address, uint8_t value) {
187 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
188
189 mVideoLoggerRendererWriteVideoRegister(proxyRenderer->logger, address, value);
190 if (!proxyRenderer->logger->block) {
191 proxyRenderer->backend->writeVideoRegister(proxyRenderer->backend, address, value);
192 }
193 return value;
194}
195
196void GBVideoProxyRendererWriteSGBPacket(struct GBVideoRenderer* renderer, uint8_t* data) {
197 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
198 if (!proxyRenderer->logger->block) {
199 proxyRenderer->backend->writeSGBPacket(proxyRenderer->backend, data);
200 }
201 mVideoLoggerWriteBuffer(proxyRenderer->logger, BUFFER_SGB, 0, 16, data);
202}
203
204void GBVideoProxyRendererWriteVRAM(struct GBVideoRenderer* renderer, uint16_t address) {
205 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
206 mVideoLoggerRendererWriteVRAM(proxyRenderer->logger, address);
207 if (!proxyRenderer->logger->block) {
208 proxyRenderer->backend->writeVRAM(proxyRenderer->backend, address);
209 }
210 if (renderer->cache) {
211 mCacheSetWriteVRAM(renderer->cache, address);
212 }
213}
214
215void GBVideoProxyRendererWritePalette(struct GBVideoRenderer* renderer, int address, uint16_t value) {
216 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
217 mVideoLoggerRendererWritePalette(proxyRenderer->logger, address, value);
218 if (!proxyRenderer->logger->block) {
219 proxyRenderer->backend->writePalette(proxyRenderer->backend, address, value);
220 }
221 if (renderer->cache) {
222 mCacheSetWritePalette(renderer->cache, address, mColorFrom555(value));
223 }
224}
225
226void GBVideoProxyRendererWriteOAM(struct GBVideoRenderer* renderer, uint16_t oam) {
227 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
228 if (!proxyRenderer->logger->block) {
229 proxyRenderer->backend->writeOAM(proxyRenderer->backend, oam);
230 }
231 mVideoLoggerRendererWriteOAM(proxyRenderer->logger, oam, ((uint8_t*) proxyRenderer->d.oam->raw)[oam]);
232}
233
234void GBVideoProxyRendererDrawRange(struct GBVideoRenderer* renderer, int startX, int endX, int y, struct GBObj* obj, size_t oamMax) {
235 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
236 if (!proxyRenderer->logger->block) {
237 proxyRenderer->backend->drawRange(proxyRenderer->backend, startX, endX, y, obj, oamMax);
238 }
239 mVideoLoggerWriteBuffer(proxyRenderer->logger, BUFFER_OAM, 0, oamMax * sizeof(*obj), obj);
240 mVideoLoggerRendererDrawRange(proxyRenderer->logger, startX, endX, y);
241}
242
243void GBVideoProxyRendererFinishScanline(struct GBVideoRenderer* renderer, int y) {
244 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
245 if (!proxyRenderer->logger->block) {
246 proxyRenderer->backend->finishScanline(proxyRenderer->backend, y);
247 }
248 mVideoLoggerRendererDrawScanline(proxyRenderer->logger, y);
249 if (proxyRenderer->logger->block && proxyRenderer->logger->wake) {
250 proxyRenderer->logger->wake(proxyRenderer->logger, y);
251 }
252}
253
254void GBVideoProxyRendererFinishFrame(struct GBVideoRenderer* renderer) {
255 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
256 if (!proxyRenderer->logger->block) {
257 proxyRenderer->backend->finishFrame(proxyRenderer->backend);
258 }
259 mVideoLoggerRendererFinishFrame(proxyRenderer->logger);
260 mVideoLoggerRendererFlush(proxyRenderer->logger);
261}
262
263static void GBVideoProxyRendererEnableSGBBorder(struct GBVideoRenderer* renderer, bool enable) {
264 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
265 if (proxyRenderer->logger->block && proxyRenderer->logger->wait) {
266 // Insert an extra item into the queue to make sure it gets flushed
267 mVideoLoggerRendererFlush(proxyRenderer->logger);
268 proxyRenderer->logger->wait(proxyRenderer->logger);
269 }
270 proxyRenderer->backend->enableSGBBorder(proxyRenderer->backend, enable);
271}
272
273static void GBVideoProxyRendererGetPixels(struct GBVideoRenderer* renderer, size_t* stride, const void** pixels) {
274 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
275 if (proxyRenderer->logger->block && proxyRenderer->logger->wait) {
276 proxyRenderer->logger->lock(proxyRenderer->logger);
277 // Insert an extra item into the queue to make sure it gets flushed
278 mVideoLoggerRendererFlush(proxyRenderer->logger);
279 proxyRenderer->logger->postEvent(proxyRenderer->logger, LOGGER_EVENT_GET_PIXELS);
280 mVideoLoggerRendererFlush(proxyRenderer->logger);
281 proxyRenderer->logger->unlock(proxyRenderer->logger);
282 *pixels = proxyRenderer->logger->pixelBuffer;
283 *stride = proxyRenderer->logger->pixelStride;
284 } else {
285 proxyRenderer->backend->getPixels(proxyRenderer->backend, stride, pixels);
286 }
287}
288
289static void GBVideoProxyRendererPutPixels(struct GBVideoRenderer* renderer, size_t stride, const void* pixels) {
290 struct GBVideoProxyRenderer* proxyRenderer = (struct GBVideoProxyRenderer*) renderer;
291 if (proxyRenderer->logger->block && proxyRenderer->logger->wait) {
292 proxyRenderer->logger->lock(proxyRenderer->logger);
293 }
294 proxyRenderer->backend->putPixels(proxyRenderer->backend, stride, pixels);
295 if (proxyRenderer->logger->block && proxyRenderer->logger->wait) {
296 proxyRenderer->logger->unlock(proxyRenderer->logger);
297 }
298}