This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_gsyuv.c
471 lines (428 loc) · 14.4 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
26
27
28
29
/* This is the Playstation 2 implementation of YUV video overlays */
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
30
#include <asm/page.h> /* For definition of PAGE_SIZE */
31
32
33
#include "SDL_video.h"
#include "SDL_gsyuv_c.h"
34
#include "../SDL_yuvfuncs.h"
35
36
/* The maximum number of 16x16 pixel block converted at once */
37
#define MAX_MACROBLOCKS 1024 /* 2^10 macroblocks at once */
38
39
40
/* The functions used to manipulate video overlays */
static struct private_yuvhwfuncs gs_yuvfuncs = {
41
42
43
44
GS_LockYUVOverlay,
GS_UnlockYUVOverlay,
GS_DisplayYUVOverlay,
GS_FreeYUVOverlay
45
46
};
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
struct private_yuvhwdata
{
int ipu_fd;
Uint8 *pixels;
int macroblocks;
int dma_len;
caddr_t dma_mem;
caddr_t ipu_imem;
caddr_t ipu_omem;
caddr_t dma_tags;
unsigned long long *stretch_x1y1;
unsigned long long *stretch_x2y2;
struct ps2_plist plist;
/* These are just so we don't have to allocate them separately */
Uint16 pitches[3];
Uint8 *planes[3];
64
65
};
66
static int
67
power_of_2(int value)
68
{
69
int shift;
70
71
72
73
74
for (shift = 0; (1 << shift) < value; ++shift) {
/* Keep looking */ ;
}
return (shift);
75
76
}
77
SDL_Overlay *
78
79
GS_CreateYUVOverlay(_THIS, int width, int height, Uint32 format,
SDL_Surface * display)
80
{
81
82
83
84
85
86
87
88
89
90
91
92
93
94
SDL_Overlay *overlay;
struct private_yuvhwdata *hwdata;
int map_offset;
unsigned long long *tags;
caddr_t base;
int bpp;
int fbp, fbw, psm;
int x, y, w, h;
int pnum;
struct ps2_packet *packet;
struct ps2_packet tex_packet;
/* We can only decode blocks of 16x16 pixels */
if ((width & 15) || (height & 15)) {
95
SDL_SetError("Overlay width/height must be multiples of 16");
96
97
98
99
return (NULL);
}
/* Make sure the image isn't too large for a single DMA transfer */
if (((width / 16) * (height / 16)) > MAX_MACROBLOCKS) {
100
101
SDL_SetError("Overlay too large (maximum size: %d pixels)",
MAX_MACROBLOCKS * 16 * 16);
102
103
104
105
106
107
108
109
110
111
112
113
return (NULL);
}
/* Double-check the requested format. For simplicity, we'll only
support planar YUV formats.
*/
switch (format) {
case SDL_YV12_OVERLAY:
case SDL_IYUV_OVERLAY:
/* Supported planar YUV format */
break;
default:
114
SDL_SetError("Unsupported YUV format");
115
116
117
118
return (NULL);
}
/* Create the overlay structure */
119
overlay = (SDL_Overlay *) SDL_malloc(sizeof *overlay);
120
if (overlay == NULL) {
121
SDL_OutOfMemory();
122
123
return (NULL);
}
124
SDL_memset(overlay, 0, (sizeof *overlay));
125
126
127
128
129
130
131
132
133
134
135
/* Fill in the basic members */
overlay->format = format;
overlay->w = width;
overlay->h = height;
/* Set up the YUV surface function structure */
overlay->hwfuncs = &gs_yuvfuncs;
overlay->hw_overlay = 1;
/* Create the pixel data */
136
hwdata = (struct private_yuvhwdata *) SDL_malloc(sizeof *hwdata);
137
138
overlay->hwdata = hwdata;
if (hwdata == NULL) {
139
140
SDL_FreeYUVOverlay(overlay);
SDL_OutOfMemory();
141
142
143
return (NULL);
}
hwdata->ipu_fd = -1;
144
hwdata->pixels = (Uint8 *) SDL_malloc(width * height * 2);
145
if (hwdata->pixels == NULL) {
146
147
SDL_FreeYUVOverlay(overlay);
SDL_OutOfMemory();
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
return (NULL);
}
hwdata->macroblocks = (width / 16) * (height / 16);
/* Find the pitch and offset values for the overlay */
overlay->pitches = hwdata->pitches;
overlay->pixels = hwdata->planes;
switch (format) {
case SDL_YV12_OVERLAY:
case SDL_IYUV_OVERLAY:
overlay->pitches[0] = overlay->w;
overlay->pitches[1] = overlay->pitches[0] / 2;
overlay->pitches[2] = overlay->pitches[0] / 2;
overlay->pixels[0] = hwdata->pixels;
overlay->pixels[1] = overlay->pixels[0] +
overlay->pitches[0] * overlay->h;
overlay->pixels[2] = overlay->pixels[1] +
overlay->pitches[1] * overlay->h / 2;
overlay->planes = 3;
break;
default:
/* We should never get here (caught above) */
break;
}
/* Theoretically we could support several concurrent decode
streams queueing up on the same file descriptor, but for
simplicity we'll support only one. Opening the IPU more
than once will fail with EBUSY.
*/
178
hwdata->ipu_fd = open("/dev/ps2ipu", O_RDWR);
179
if (hwdata->ipu_fd < 0) {
180
181
SDL_FreeYUVOverlay(overlay);
SDL_SetError("Playstation 2 IPU busy");
182
183
184
185
186
187
188
189
return (NULL);
}
/* Allocate a DMA area for pixel conversion */
bpp = this->screen->format->BytesPerPixel;
map_offset = (mapped_len + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
hwdata->dma_len = hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8) +
width * height * bpp +
190
191
192
193
hwdata->macroblocks * (16 * sizeof(long long)) +
12 * sizeof(long long);
hwdata->dma_mem = mmap(0, hwdata->dma_len, PROT_READ | PROT_WRITE,
MAP_SHARED, memory_fd, map_offset);
194
195
if (hwdata->dma_mem == MAP_FAILED) {
hwdata->ipu_imem = (caddr_t) 0;
196
197
SDL_FreeYUVOverlay(overlay);
SDL_SetError("Unable to map %d bytes for DMA", hwdata->dma_len);
198
199
200
201
202
203
204
205
206
207
return (NULL);
}
hwdata->ipu_imem = hwdata->dma_mem;
hwdata->ipu_omem = hwdata->ipu_imem +
hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8);
hwdata->dma_tags = hwdata->ipu_omem + width * height * bpp;
/* Allocate memory for the DMA packets */
hwdata->plist.num = hwdata->macroblocks * 4 + 1;
hwdata->plist.packet =
208
209
(struct ps2_packet *) SDL_malloc(hwdata->plist.num *
sizeof(struct ps2_packet));
210
if (!hwdata->plist.packet) {
211
212
SDL_FreeYUVOverlay(overlay);
SDL_OutOfMemory();
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
return (NULL);
}
pnum = 0;
packet = hwdata->plist.packet;
/* Set up the tags to send the image to the screen */
tags = (unsigned long long *) hwdata->dma_tags;
base = hwdata->ipu_omem;
fbp = screen_image.fbp;
fbw = screen_image.fbw;
psm = screen_image.psm;
y = screen_image.y + screen_image.h; /* Offscreen video memory */
for (h = height / 16; h; --h) {
x = 0; /* Visible video memory */
for (w = width / 16; w; --w) {
/* The head tag */
packet[pnum].ptr = &tags[0];
230
packet[pnum].len = 10 * sizeof(*tags);
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
++pnum;
tags[0] = 4 | (1LL << 60); /* GIFtag */
tags[1] = 0x0e; /* A+D */
tags[2] = ((unsigned long long) fbp << 32) |
((unsigned long long) fbw << 48) |
((unsigned long long) psm << 56);
tags[3] = PS2_GS_BITBLTBUF;
tags[4] = ((unsigned long long) x << 32) |
((unsigned long long) y << 48);
tags[5] = PS2_GS_TRXPOS;
tags[6] = (unsigned long long) 16 |
((unsigned long long) 16 << 32);
tags[7] = PS2_GS_TRXREG;
tags[8] = 0;
tags[9] = PS2_GS_TRXDIR;
/* Now the actual image data */
packet[pnum].ptr = &tags[10];
248
packet[pnum].len = 2 * sizeof(*tags);
249
250
251
252
253
254
255
++pnum;
tags[10] = ((16 * 16 * bpp) >> 4) | (2LL << 58);
tags[11] = 0;
packet[pnum].ptr = (void *) base;
packet[pnum].len = 16 * 16 * bpp;
++pnum;
packet[pnum].ptr = &tags[12];
256
packet[pnum].len = 2 * sizeof(*tags);
257
258
259
260
261
262
263
264
265
266
267
268
269
270
++pnum;
tags[12] = (0 >> 4) | (1 << 15) | (2LL << 58);
tags[13] = 0;
tags += 16;
base += 16 * 16 * bpp;
x += 16;
}
y += 16;
}
/* Set up the texture memory area for the video */
tex_packet.ptr = tags;
271
tex_packet.len = 8 * sizeof(*tags);
272
273
274
275
276
tags[0] = 3 | (1LL << 60); /* GIFtag */
tags[1] = 0x0e; /* A+D */
tags[2] = ((screen_image.y + screen_image.h) * screen_image.w) / 64 +
((unsigned long long) fbw << 14) +
((unsigned long long) psm << 20) +
277
278
((unsigned long long) power_of_2(width) << 26) +
((unsigned long long) power_of_2(height) << 30) +
279
280
281
282
283
284
((unsigned long long) 1 << 34) + ((unsigned long long) 1 << 35);
tags[3] = PS2_GS_TEX0_1;
tags[4] = (1 << 5) + (1 << 6);
tags[5] = PS2_GS_TEX1_1;
tags[6] = 0;
tags[7] = PS2_GS_TEXFLUSH;
285
ioctl(console_fd, PS2IOC_SEND, &tex_packet);
286
287
288
/* Set up the tags for scaling the image */
packet[pnum].ptr = tags;
289
packet[pnum].len = 12 * sizeof(*tags);
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
++pnum;
tags[0] = 5 | (1LL << 60); /* GIFtag */
tags[1] = 0x0e; /* A+D */
tags[2] = 6 + (1 << 4) + (1 << 8);
tags[3] = PS2_GS_PRIM;
tags[4] = ((unsigned long long) 0 * 16) +
(((unsigned long long) 0 * 16) << 16);
tags[5] = PS2_GS_UV;
tags[6] = 0; /* X1, Y1 */
tags[7] = PS2_GS_XYZ2;
hwdata->stretch_x1y1 = &tags[6];
tags[8] = ((unsigned long long) overlay->w * 16) +
(((unsigned long long) overlay->h * 16) << 16);
tags[9] = PS2_GS_UV;
tags[10] = 0; /* X2, Y2 */
tags[11] = PS2_GS_XYZ2;
hwdata->stretch_x2y2 = &tags[10];
/* We're all done.. */
return (overlay);
310
311
}
312
int
313
GS_LockYUVOverlay(_THIS, SDL_Overlay * overlay)
314
{
315
return (0);
316
317
}
318
void
319
GS_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay)
320
{
321
return;
322
323
}
324
int
325
326
GS_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay, SDL_Rect * src,
SDL_Rect * dst)
327
{
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
struct private_yuvhwdata *hwdata;
__u32 cmd;
struct ps2_packet packet;
int h, w, i;
Uint32 *lum, *Cr, *Cb;
int lum_pitch;
int crb_pitch;
Uint32 *lum_src, *Cr_src, *Cb_src;
Uint32 *srcp, *dstp;
unsigned int x, y;
SDL_Surface *screen;
/* Find out where the various portions of the image are */
hwdata = overlay->hwdata;
switch (overlay->format) {
case SDL_YV12_OVERLAY:
lum = (Uint32 *) overlay->pixels[0];
Cr = (Uint32 *) overlay->pixels[1];
Cb = (Uint32 *) overlay->pixels[2];
break;
case SDL_IYUV_OVERLAY:
lum = (Uint32 *) overlay->pixels[0];
Cr = (Uint32 *) overlay->pixels[2];
Cb = (Uint32 *) overlay->pixels[1];
default:
353
SDL_SetError("Unsupported YUV format in blit (?)");
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
return (-1);
}
dstp = (Uint32 *) hwdata->ipu_imem;
lum_pitch = overlay->w / 4;
crb_pitch = (overlay->w / 2) / 4;
/* Copy blocks of 16x16 pixels to the DMA area */
for (h = overlay->h / 16; h; --h) {
lum_src = lum;
Cr_src = Cr;
Cb_src = Cb;
for (w = overlay->w / 16; w; --w) {
srcp = lum_src;
for (i = 0; i < 16; ++i) {
dstp[0] = srcp[0];
dstp[1] = srcp[1];
dstp[2] = srcp[2];
dstp[3] = srcp[3];
srcp += lum_pitch;
dstp += 4;
}
srcp = Cb_src;
for (i = 0; i < 8; ++i) {
dstp[0] = srcp[0];
dstp[1] = srcp[1];
srcp += crb_pitch;
dstp += 2;
}
srcp = Cr_src;
for (i = 0; i < 8; ++i) {
dstp[0] = srcp[0];
dstp[1] = srcp[1];
srcp += crb_pitch;
dstp += 2;
}
lum_src += 16 / 4;
Cb_src += 8 / 4;
Cr_src += 8 / 4;
}
lum += lum_pitch * 16;
Cr += crb_pitch * 8;
Cb += crb_pitch * 8;
}
/* Send the macroblock data to the IPU */
399
#ifdef DEBUG_YUV
400
fprintf(stderr, "Sending data to IPU..\n");
401
#endif
402
403
packet.ptr = hwdata->ipu_imem;
packet.len = hwdata->macroblocks * (16 * 16 + 8 * 8 + 8 * 8);
404
ioctl(hwdata->ipu_fd, PS2IOC_SENDA, &packet);
405
406
/* Trigger the DMA to the IPU for conversion */
407
#ifdef DEBUG_YUV
408
fprintf(stderr, "Trigging conversion command\n");
409
#endif
410
411
412
413
414
cmd = (7 << 28) + hwdata->macroblocks;
if (screen_image.psm == PS2_GS_PSMCT16) {
cmd += (1 << 27) + /* Output RGB 555 */
(1 << 26); /* Dither output */
}
415
ioctl(hwdata->ipu_fd, PS2IOC_SIPUCMD, &cmd);
416
417
/* Retrieve the converted image from the IPU */
418
#ifdef DEBUG_YUV
419
fprintf(stderr, "Retrieving data from IPU..\n");
420
#endif
421
422
423
packet.ptr = hwdata->ipu_omem;
packet.len = overlay->w * overlay->h *
this->screen->format->BytesPerPixel;
424
ioctl(hwdata->ipu_fd, PS2IOC_RECV, &packet);
425
426
#ifdef DEBUG_YUV
427
fprintf(stderr, "Copying image to screen..\n");
428
#endif
429
/* Wait for previous DMA to complete */
430
ioctl(console_fd, PS2IOC_SENDQCT, 1);
431
432
433
434
435
436
437
438
439
440
441
442
443
444
/* Send the current image to the screen and scale it */
screen = this->screen;
x = (unsigned int) dst->x;
y = (unsigned int) dst->y;
if (screen->offset) {
x += (screen->offset % screen->pitch) / screen->format->BytesPerPixel;
y += (screen->offset / screen->pitch);
}
y += screen_image.y;
*hwdata->stretch_x1y1 = (x * 16) + ((y * 16) << 16);
x += (unsigned int) dst->w;
y += (unsigned int) dst->h;
*hwdata->stretch_x2y2 = (x * 16) + ((y * 16) << 16);
445
return ioctl(console_fd, PS2IOC_SENDL, &hwdata->plist);
446
447
}
448
void
449
GS_FreeYUVOverlay(_THIS, SDL_Overlay * overlay)
450
{
451
452
453
454
455
struct private_yuvhwdata *hwdata;
hwdata = overlay->hwdata;
if (hwdata) {
if (hwdata->ipu_fd >= 0) {
456
close(hwdata->ipu_fd);
457
458
}
if (hwdata->dma_mem) {
459
munmap(hwdata->dma_mem, hwdata->dma_len);
460
461
}
if (hwdata->plist.packet) {
462
SDL_free(hwdata->plist.packet);
463
464
}
if (hwdata->pixels) {
465
SDL_free(hwdata->pixels);
466
}
467
SDL_free(hwdata);
468
}
469
}
470
471
/* vi: set ts=4 sw=4 expandtab: */