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