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
38const 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->deinit(video->renderer);
114 video->renderer->init(video->renderer);
115}
116
117void GBAVideoDeinit(struct GBAVideo* video) {
118 video->renderer->deinit(video->renderer);
119 mappedMemoryFree(video->vram, SIZE_VRAM);
120}
121
122void GBAVideoAssociateRenderer(struct GBAVideo* video, struct GBAVideoRenderer* renderer) {
123 video->renderer->deinit(video->renderer);
124 renderer->cache = video->renderer->cache;
125 video->renderer = renderer;
126 renderer->palette = video->palette;
127 memset(renderer->vramBG, 0, sizeof(renderer->vramBG));
128 renderer->vramBG[0] = &video->vram[0x0000];
129 renderer->vramBG[1] = &video->vram[0x2000];
130 renderer->vramBG[2] = &video->vram[0x4000];
131 renderer->vramBG[3] = &video->vram[0x6000];
132 memset(renderer->vramOBJ, 0, sizeof(renderer->vramOBJ));
133 renderer->vramOBJ[0] = &video->vram[0x8000];
134 renderer->vramOBJ[1] = &video->vram[0xA000];
135 renderer->vramOBJ[2] = _zeroes;
136 renderer->vramOBJ[3] = _zeroes;
137 renderer->oam = &video->oam;
138 video->renderer->init(video->renderer);
139}
140
141void _startHdraw(struct mTiming* timing, void* context, uint32_t cyclesLate) {
142 struct GBAVideo* video = context;
143 GBARegisterDISPSTAT dispstat = video->p->memory.io[REG_DISPSTAT >> 1];
144 dispstat = GBARegisterDISPSTATClearInHblank(dispstat);
145 video->event.callback = _startHblank;
146 mTimingSchedule(timing, &video->event, VIDEO_HDRAW_LENGTH - cyclesLate);
147
148 ++video->vcount;
149 if (video->vcount == VIDEO_VERTICAL_TOTAL_PIXELS) {
150 video->vcount = 0;
151 }
152 video->p->memory.io[REG_VCOUNT >> 1] = video->vcount;
153
154 if (video->vcount == GBARegisterDISPSTATGetVcountSetting(dispstat)) {
155 dispstat = GBARegisterDISPSTATFillVcounter(dispstat);
156 if (GBARegisterDISPSTATIsVcounterIRQ(dispstat)) {
157 GBARaiseIRQ(video->p, IRQ_VCOUNTER);
158 }
159 } else {
160 dispstat = GBARegisterDISPSTATClearVcounter(dispstat);
161 }
162 video->p->memory.io[REG_DISPSTAT >> 1] = dispstat;
163
164 // Note: state may be recorded during callbacks, so ensure it is consistent!
165 switch (video->vcount) {
166 case 0:
167 GBAFrameStarted(video->p);
168 break;
169 case VIDEO_VERTICAL_PIXELS:
170 video->p->memory.io[REG_DISPSTAT >> 1] = GBARegisterDISPSTATFillInVblank(dispstat);
171 if (video->frameskipCounter <= 0) {
172 video->renderer->finishFrame(video->renderer);
173 }
174 GBADMARunVblank(video->p, -cyclesLate);
175 if (GBARegisterDISPSTATIsVblankIRQ(dispstat)) {
176 GBARaiseIRQ(video->p, IRQ_VBLANK);
177 }
178 GBAFrameEnded(video->p);
179 mCoreSyncPostFrame(video->p->sync);
180 --video->frameskipCounter;
181 if (video->frameskipCounter < 0) {
182 video->frameskipCounter = video->frameskip;
183 }
184 ++video->frameCounter;
185 break;
186 case VIDEO_VERTICAL_TOTAL_PIXELS - 1:
187 video->p->memory.io[REG_DISPSTAT >> 1] = GBARegisterDISPSTATClearInVblank(dispstat);
188 break;
189 }
190}
191
192void _startHblank(struct mTiming* timing, void* context, uint32_t cyclesLate) {
193 struct GBAVideo* video = context;
194 GBARegisterDISPSTAT dispstat = video->p->memory.io[REG_DISPSTAT >> 1];
195 dispstat = GBARegisterDISPSTATFillInHblank(dispstat);
196 video->event.callback = _startHdraw;
197 mTimingSchedule(timing, &video->event, VIDEO_HBLANK_LENGTH - cyclesLate);
198
199 // Begin Hblank
200 dispstat = GBARegisterDISPSTATFillInHblank(dispstat);
201 if (video->vcount < VIDEO_VERTICAL_PIXELS && video->frameskipCounter <= 0) {
202 video->renderer->drawScanline(video->renderer, video->vcount);
203 }
204
205 if (video->vcount < VIDEO_VERTICAL_PIXELS) {
206 GBADMARunHblank(video->p, -cyclesLate);
207 }
208 if (video->vcount >= 2 && video->vcount < VIDEO_VERTICAL_PIXELS + 2) {
209 GBADMARunDisplayStart(video->p, -cyclesLate);
210 }
211 if (GBARegisterDISPSTATIsHblankIRQ(dispstat)) {
212 GBARaiseIRQ(video->p, IRQ_HBLANK);
213 }
214 video->p->memory.io[REG_DISPSTAT >> 1] = dispstat;
215}
216
217void GBAVideoWriteDISPSTAT(struct GBAVideo* video, uint16_t value) {
218 video->p->memory.io[REG_DISPSTAT >> 1] &= 0x7;
219 video->p->memory.io[REG_DISPSTAT >> 1] |= value;
220 // TODO: Does a VCounter IRQ trigger on write?
221}
222
223static void GBAVideoDummyRendererInit(struct GBAVideoRenderer* renderer) {
224 UNUSED(renderer);
225 // Nothing to do
226}
227
228static void GBAVideoDummyRendererReset(struct GBAVideoRenderer* renderer) {
229 UNUSED(renderer);
230 // Nothing to do
231}
232
233static void GBAVideoDummyRendererDeinit(struct GBAVideoRenderer* renderer) {
234 UNUSED(renderer);
235 // Nothing to do
236}
237
238static uint16_t GBAVideoDummyRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
239 if (renderer->cache) {
240 GBAVideoCacheWriteVideoRegister(renderer->cache, address, value);
241 }
242 switch (address) {
243 case REG_DISPCNT:
244 value &= 0xFFF7;
245 break;
246 case REG_BG0CNT:
247 case REG_BG1CNT:
248 value &= 0xDFFF;
249 break;
250 case REG_BG2CNT:
251 case REG_BG3CNT:
252 value &= 0xFFFF;
253 break;
254 case REG_BG0HOFS:
255 case REG_BG0VOFS:
256 case REG_BG1HOFS:
257 case REG_BG1VOFS:
258 case REG_BG2HOFS:
259 case REG_BG2VOFS:
260 case REG_BG3HOFS:
261 case REG_BG3VOFS:
262 value &= 0x01FF;
263 break;
264 case REG_BLDCNT:
265 value &= 0x3FFF;
266 break;
267 case REG_BLDALPHA:
268 value &= 0x1F1F;
269 break;
270 case REG_WININ:
271 case REG_WINOUT:
272 value &= 0x3F3F;
273 break;
274 default:
275 break;
276 }
277 return value;
278}
279
280static void GBAVideoDummyRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address) {
281 if (renderer->cache) {
282 mCacheSetWriteVRAM(renderer->cache, address);
283 }
284}
285
286static void GBAVideoDummyRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
287 if (renderer->cache) {
288 mCacheSetWritePalette(renderer->cache, address >> 1, mColorFrom555(value));
289 }
290}
291
292static void GBAVideoDummyRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam) {
293 UNUSED(renderer);
294 UNUSED(oam);
295 // Nothing to do
296}
297
298static void GBAVideoDummyRendererDrawScanline(struct GBAVideoRenderer* renderer, int y) {
299 UNUSED(renderer);
300 UNUSED(y);
301 // Nothing to do
302}
303
304static void GBAVideoDummyRendererFinishFrame(struct GBAVideoRenderer* renderer) {
305 UNUSED(renderer);
306 // Nothing to do
307}
308
309static void GBAVideoDummyRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels) {
310 UNUSED(renderer);
311 UNUSED(stride);
312 UNUSED(pixels);
313 // Nothing to do
314}
315
316static void GBAVideoDummyRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels) {
317 UNUSED(renderer);
318 UNUSED(stride);
319 UNUSED(pixels);
320 // Nothing to do
321}
322
323void GBAVideoSerialize(const struct GBAVideo* video, struct GBASerializedState* state) {
324 memcpy(state->vram, video->vram, SIZE_VRAM);
325 memcpy(state->oam, video->oam.raw, SIZE_OAM);
326 memcpy(state->pram, video->palette, SIZE_PALETTE_RAM);
327 STORE_32(video->event.when - mTimingCurrentTime(&video->p->timing), 0, &state->video.nextEvent);
328 STORE_32(video->frameCounter, 0, &state->video.frameCounter);
329}
330
331void GBAVideoDeserialize(struct GBAVideo* video, const struct GBASerializedState* state) {
332 memcpy(video->vram, state->vram, SIZE_VRAM);
333 uint16_t value;
334 int i;
335 for (i = 0; i < SIZE_OAM; i += 2) {
336 LOAD_16(value, i, state->oam);
337 GBAStore16(video->p->cpu, BASE_OAM | i, value, 0);
338 }
339 for (i = 0; i < SIZE_PALETTE_RAM; i += 2) {
340 LOAD_16(value, i, state->pram);
341 GBAStore16(video->p->cpu, BASE_PALETTE_RAM | i, value, 0);
342 }
343 LOAD_32(video->frameCounter, 0, &state->video.frameCounter);
344
345 uint32_t when;
346 LOAD_32(when, 0, &state->video.nextEvent);
347 GBARegisterDISPSTAT dispstat = state->io[REG_DISPSTAT >> 1];
348 if (GBARegisterDISPSTATIsInHblank(dispstat)) {
349 video->event.callback = _startHdraw;
350 } else {
351 video->event.callback = _startHblank;
352 }
353 mTimingSchedule(&video->p->timing, &video->event, when);
354
355 LOAD_16(video->vcount, REG_VCOUNT, state->io);
356 video->renderer->reset(video->renderer);
357}