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