src/gba/video.c (view raw)
1/* Copyright (c) 2013-2015 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/gba/video.h>
7
8#include <mgba/core/sync.h>
9#include <mgba/core/cache-set.h>
10#include <mgba/internal/arm/macros.h>
11#include <mgba/internal/gba/dma.h>
12#include <mgba/internal/gba/gba.h>
13#include <mgba/internal/gba/io.h>
14#include <mgba/internal/gba/renderers/cache-set.h>
15#include <mgba/internal/gba/serialize.h>
16
17#include <mgba-util/memory.h>
18
19mLOG_DEFINE_CATEGORY(GBA_VIDEO, "GBA Video", "gba.video");
20
21static void GBAVideoDummyRendererInit(struct GBAVideoRenderer* renderer);
22static void GBAVideoDummyRendererReset(struct GBAVideoRenderer* renderer);
23static void GBAVideoDummyRendererDeinit(struct GBAVideoRenderer* renderer);
24static uint16_t GBAVideoDummyRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value);
25static void GBAVideoDummyRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address);
26static void GBAVideoDummyRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value);
27static void GBAVideoDummyRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam);
28static void GBAVideoDummyRendererDrawScanline(struct GBAVideoRenderer* renderer, int y);
29static void GBAVideoDummyRendererFinishFrame(struct GBAVideoRenderer* renderer);
30static void GBAVideoDummyRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels);
31static void GBAVideoDummyRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels);
32
33static void _startHblank(struct mTiming*, void* context, uint32_t cyclesLate);
34static void _startHdraw(struct mTiming*, void* context, uint32_t cyclesLate);
35
36static uint16_t _zeroes[0x2000] = {};
37
38MGBA_EXPORT const int GBAVideoObjSizes[16][2] = {
39 { 8, 8 },
40 { 16, 16 },
41 { 32, 32 },
42 { 64, 64 },
43 { 16, 8 },
44 { 32, 8 },
45 { 32, 16 },
46 { 64, 32 },
47 { 8, 16 },
48 { 8, 32 },
49 { 16, 32 },
50 { 32, 64 },
51 { 0, 0 },
52 { 0, 0 },
53 { 0, 0 },
54 { 0, 0 },
55};
56
57static struct GBAVideoRenderer dummyRenderer = {
58 .init = GBAVideoDummyRendererInit,
59 .reset = GBAVideoDummyRendererReset,
60 .deinit = GBAVideoDummyRendererDeinit,
61 .writeVideoRegister = GBAVideoDummyRendererWriteVideoRegister,
62 .writeVRAM = GBAVideoDummyRendererWriteVRAM,
63 .writePalette = GBAVideoDummyRendererWritePalette,
64 .writeOAM = GBAVideoDummyRendererWriteOAM,
65 .drawScanline = GBAVideoDummyRendererDrawScanline,
66 .finishFrame = GBAVideoDummyRendererFinishFrame,
67 .getPixels = GBAVideoDummyRendererGetPixels,
68 .putPixels = GBAVideoDummyRendererPutPixels,
69};
70
71void GBAVideoInit(struct GBAVideo* video) {
72 video->renderer = &dummyRenderer;
73 video->renderer->cache = NULL;
74 video->vram = anonymousMemoryMap(SIZE_VRAM);
75 video->frameskip = 0;
76 video->event.name = "GBA Video";
77 video->event.callback = NULL;
78 video->event.context = video;
79 video->event.priority = 8;
80}
81
82void GBAVideoReset(struct GBAVideo* video) {
83 int32_t nextEvent = VIDEO_HDRAW_LENGTH;
84 if (video->p->memory.fullBios) {
85 video->vcount = 0;
86 } else {
87 // TODO: Verify exact scanline on hardware
88 video->vcount = 0x7E;
89 nextEvent = 170;
90 }
91 video->p->memory.io[REG_VCOUNT >> 1] = video->vcount;
92
93 video->event.callback = _startHblank;
94 mTimingSchedule(&video->p->timing, &video->event, nextEvent);
95
96 video->frameCounter = 0;
97 video->frameskipCounter = 0;
98
99 memset(video->renderer->vramBG, 0, sizeof(video->renderer->vramBG));
100 video->renderer->vramBG[0] = &video->vram[0x0000];
101 video->renderer->vramBG[1] = &video->vram[0x2000];
102 video->renderer->vramBG[2] = &video->vram[0x4000];
103 video->renderer->vramBG[3] = &video->vram[0x6000];
104 memset(video->renderer->vramOBJ, 0, sizeof(video->renderer->vramOBJ));
105 video->renderer->vramOBJ[0] = &video->vram[0x8000];
106 video->renderer->vramOBJ[1] = &video->vram[0xA000];
107 video->renderer->vramOBJ[2] = _zeroes;
108 video->renderer->vramOBJ[3] = _zeroes;
109
110 memset(video->palette, 0, sizeof(video->palette));
111 memset(video->oam.raw, 0, sizeof(video->oam.raw));
112
113 video->renderer->reset(video->renderer);
114}
115
116void GBAVideoDeinit(struct GBAVideo* video) {
117 video->renderer->deinit(video->renderer);
118 mappedMemoryFree(video->vram, SIZE_VRAM);
119}
120
121void GBAVideoAssociateRenderer(struct GBAVideo* video, struct GBAVideoRenderer* renderer) {
122 video->renderer->deinit(video->renderer);
123 renderer->cache = video->renderer->cache;
124 video->renderer = renderer;
125 renderer->palette = video->palette;
126 memset(renderer->vramBG, 0, sizeof(renderer->vramBG));
127 renderer->vramBG[0] = &video->vram[0x0000];
128 renderer->vramBG[1] = &video->vram[0x2000];
129 renderer->vramBG[2] = &video->vram[0x4000];
130 renderer->vramBG[3] = &video->vram[0x6000];
131 memset(renderer->vramOBJ, 0, sizeof(renderer->vramOBJ));
132 renderer->vramOBJ[0] = &video->vram[0x8000];
133 renderer->vramOBJ[1] = &video->vram[0xA000];
134 renderer->vramOBJ[2] = _zeroes;
135 renderer->vramOBJ[3] = _zeroes;
136 renderer->oam = &video->oam;
137 video->renderer->init(video->renderer);
138}
139
140void _startHdraw(struct mTiming* timing, void* context, uint32_t cyclesLate) {
141 struct GBAVideo* video = context;
142 GBARegisterDISPSTAT dispstat = video->p->memory.io[REG_DISPSTAT >> 1];
143 dispstat = GBARegisterDISPSTATClearInHblank(dispstat);
144 video->event.callback = _startHblank;
145 mTimingSchedule(timing, &video->event, VIDEO_HDRAW_LENGTH - cyclesLate);
146
147 ++video->vcount;
148 if (video->vcount == VIDEO_VERTICAL_TOTAL_PIXELS) {
149 video->vcount = 0;
150 }
151 video->p->memory.io[REG_VCOUNT >> 1] = video->vcount;
152
153 if (video->vcount == GBARegisterDISPSTATGetVcountSetting(dispstat)) {
154 dispstat = GBARegisterDISPSTATFillVcounter(dispstat);
155 if (GBARegisterDISPSTATIsVcounterIRQ(dispstat)) {
156 GBARaiseIRQ(video->p, IRQ_VCOUNTER, cyclesLate);
157 }
158 } else {
159 dispstat = GBARegisterDISPSTATClearVcounter(dispstat);
160 }
161 video->p->memory.io[REG_DISPSTAT >> 1] = dispstat;
162
163 // Note: state may be recorded during callbacks, so ensure it is consistent!
164 switch (video->vcount) {
165 case 0:
166 GBAFrameStarted(video->p);
167 break;
168 case GBA_VIDEO_VERTICAL_PIXELS:
169 video->p->memory.io[REG_DISPSTAT >> 1] = GBARegisterDISPSTATFillInVblank(dispstat);
170 if (video->frameskipCounter <= 0) {
171 video->renderer->finishFrame(video->renderer);
172 }
173 GBADMARunVblank(video->p, -cyclesLate);
174 if (GBARegisterDISPSTATIsVblankIRQ(dispstat)) {
175 GBARaiseIRQ(video->p, IRQ_VBLANK, cyclesLate);
176 }
177 GBAFrameEnded(video->p);
178 mCoreSyncPostFrame(video->p->sync);
179 --video->frameskipCounter;
180 if (video->frameskipCounter < 0) {
181 video->frameskipCounter = video->frameskip;
182 }
183 ++video->frameCounter;
184 break;
185 case VIDEO_VERTICAL_TOTAL_PIXELS - 1:
186 video->p->memory.io[REG_DISPSTAT >> 1] = GBARegisterDISPSTATClearInVblank(dispstat);
187 break;
188 }
189}
190
191void _startHblank(struct mTiming* timing, void* context, uint32_t cyclesLate) {
192 struct GBAVideo* video = context;
193 GBARegisterDISPSTAT dispstat = video->p->memory.io[REG_DISPSTAT >> 1];
194 dispstat = GBARegisterDISPSTATFillInHblank(dispstat);
195 video->event.callback = _startHdraw;
196 mTimingSchedule(timing, &video->event, VIDEO_HBLANK_LENGTH - cyclesLate);
197
198 // Begin Hblank
199 dispstat = GBARegisterDISPSTATFillInHblank(dispstat);
200 if (video->vcount < GBA_VIDEO_VERTICAL_PIXELS && video->frameskipCounter <= 0) {
201 video->renderer->drawScanline(video->renderer, video->vcount);
202 }
203
204 if (video->vcount < GBA_VIDEO_VERTICAL_PIXELS) {
205 GBADMARunHblank(video->p, -cyclesLate);
206 }
207 if (video->vcount >= 2 && video->vcount < GBA_VIDEO_VERTICAL_PIXELS + 2) {
208 GBADMARunDisplayStart(video->p, -cyclesLate);
209 }
210 if (GBARegisterDISPSTATIsHblankIRQ(dispstat)) {
211 GBARaiseIRQ(video->p, IRQ_HBLANK, cyclesLate);
212 }
213 video->p->memory.io[REG_DISPSTAT >> 1] = dispstat;
214}
215
216void GBAVideoWriteDISPSTAT(struct GBAVideo* video, uint16_t value) {
217 video->p->memory.io[REG_DISPSTAT >> 1] &= 0x7;
218 video->p->memory.io[REG_DISPSTAT >> 1] |= value;
219 // TODO: Does a VCounter IRQ trigger on write?
220}
221
222static void GBAVideoDummyRendererInit(struct GBAVideoRenderer* renderer) {
223 UNUSED(renderer);
224 // Nothing to do
225}
226
227static void GBAVideoDummyRendererReset(struct GBAVideoRenderer* renderer) {
228 UNUSED(renderer);
229 // Nothing to do
230}
231
232static void GBAVideoDummyRendererDeinit(struct GBAVideoRenderer* renderer) {
233 UNUSED(renderer);
234 // Nothing to do
235}
236
237static uint16_t GBAVideoDummyRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
238 if (renderer->cache) {
239 GBAVideoCacheWriteVideoRegister(renderer->cache, address, value);
240 }
241 switch (address) {
242 case REG_DISPCNT:
243 value &= 0xFFF7;
244 break;
245 case REG_BG0CNT:
246 case REG_BG1CNT:
247 value &= 0xDFFF;
248 break;
249 case REG_BG2CNT:
250 case REG_BG3CNT:
251 value &= 0xFFFF;
252 break;
253 case REG_BG0HOFS:
254 case REG_BG0VOFS:
255 case REG_BG1HOFS:
256 case REG_BG1VOFS:
257 case REG_BG2HOFS:
258 case REG_BG2VOFS:
259 case REG_BG3HOFS:
260 case REG_BG3VOFS:
261 value &= 0x01FF;
262 break;
263 case REG_BLDCNT:
264 value &= 0x3FFF;
265 break;
266 case REG_BLDALPHA:
267 value &= 0x1F1F;
268 break;
269 case REG_WININ:
270 case REG_WINOUT:
271 value &= 0x3F3F;
272 break;
273 default:
274 break;
275 }
276 return value;
277}
278
279static void GBAVideoDummyRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address) {
280 if (renderer->cache) {
281 mCacheSetWriteVRAM(renderer->cache, address);
282 }
283}
284
285static void GBAVideoDummyRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
286 if (renderer->cache) {
287 mCacheSetWritePalette(renderer->cache, address >> 1, mColorFrom555(value));
288 }
289}
290
291static void GBAVideoDummyRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam) {
292 UNUSED(renderer);
293 UNUSED(oam);
294 // Nothing to do
295}
296
297static void GBAVideoDummyRendererDrawScanline(struct GBAVideoRenderer* renderer, int y) {
298 UNUSED(renderer);
299 UNUSED(y);
300 // Nothing to do
301}
302
303static void GBAVideoDummyRendererFinishFrame(struct GBAVideoRenderer* renderer) {
304 UNUSED(renderer);
305 // Nothing to do
306}
307
308static void GBAVideoDummyRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels) {
309 UNUSED(renderer);
310 UNUSED(stride);
311 UNUSED(pixels);
312 // Nothing to do
313}
314
315static void GBAVideoDummyRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels) {
316 UNUSED(renderer);
317 UNUSED(stride);
318 UNUSED(pixels);
319 // Nothing to do
320}
321
322void GBAVideoSerialize(const struct GBAVideo* video, struct GBASerializedState* state) {
323 memcpy(state->vram, video->vram, SIZE_VRAM);
324 memcpy(state->oam, video->oam.raw, SIZE_OAM);
325 memcpy(state->pram, video->palette, SIZE_PALETTE_RAM);
326 STORE_32(video->event.when - mTimingCurrentTime(&video->p->timing), 0, &state->video.nextEvent);
327 STORE_32(video->frameCounter, 0, &state->video.frameCounter);
328}
329
330void GBAVideoDeserialize(struct GBAVideo* video, const struct GBASerializedState* state) {
331 memcpy(video->vram, state->vram, SIZE_VRAM);
332 uint16_t value;
333 int i;
334 for (i = 0; i < SIZE_OAM; i += 2) {
335 LOAD_16(value, i, state->oam);
336 GBAStore16(video->p->cpu, BASE_OAM | i, value, 0);
337 }
338 for (i = 0; i < SIZE_PALETTE_RAM; i += 2) {
339 LOAD_16(value, i, state->pram);
340 GBAStore16(video->p->cpu, BASE_PALETTE_RAM | i, value, 0);
341 }
342 LOAD_32(video->frameCounter, 0, &state->video.frameCounter);
343
344 uint32_t when;
345 LOAD_32(when, 0, &state->video.nextEvent);
346 GBARegisterDISPSTAT dispstat = state->io[REG_DISPSTAT >> 1];
347 if (GBARegisterDISPSTATIsInHblank(dispstat)) {
348 video->event.callback = _startHdraw;
349 } else {
350 video->event.callback = _startHblank;
351 }
352 mTimingSchedule(&video->p->timing, &video->event, when);
353
354 LOAD_16(video->vcount, REG_VCOUNT, state->io);
355 video->renderer->reset(video->renderer);
356}