Mercurial > sdl-ios-xcode

comparison src/video/ps3/SDL_ps3render.c @ 3144:0d8d1f870964 gsoc2009_ps3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Moved SPE-functions to SDL_ps3spe.c. Added ActivateRenderer() and PS3_QueryTexturePixels(). Added yuv2rgb_spu but not yet in use.
author Martin Lowinski <martin@goldtopf.org>
date Wed, 10 Jun 2009 09:15:33 +0000
parents 8fdabaa064c3
children 9e902f423497
comparison
equal deleted inserted replaced
3143:8fdabaa064c3 3144:0d8d1f870964
25 #include "../SDL_sysvideo.h" 25 #include "../SDL_sysvideo.h"
26 #include "../SDL_yuv_sw_c.h" 26 #include "../SDL_yuv_sw_c.h"
27 #include "../SDL_renderer_sw.h" 27 #include "../SDL_renderer_sw.h"
28 28
29 #include "SDL_ps3video.h" 29 #include "SDL_ps3video.h"
30 #include "spulibs/spu_common.h" 30 #include "SDL_ps3spe_c.h"
31 31
32 #include <fcntl.h> 32 #include <fcntl.h>
33 #include <stdlib.h> 33 #include <stdlib.h>
34 #include <sys/ioctl.h> 34 #include <sys/ioctl.h>
35 #include <linux/kd.h> 35 #include <linux/kd.h>
36 #include <linux/fb.h> 36 #include <linux/fb.h>
37 #include <sys/mman.h> 37 #include <sys/mman.h>
38
39 #include <asm/ps3fb.h> 38 #include <asm/ps3fb.h>
39
40
41 /* Stores the executable name */
42 extern spe_program_handle_t yuv2rgb_spu;
40 43
41 /* SDL surface based renderer implementation */ 44 /* SDL surface based renderer implementation */
42 45
43 static SDL_Renderer *SDL_PS3_CreateRenderer(SDL_Window * window, 46 static SDL_Renderer *SDL_PS3_CreateRenderer(SDL_Window * window,
44 Uint32 flags); 47 Uint32 flags);
48 static int SDL_PS3_ActivateRenderer(SDL_Renderer * renderer);
45 static int SDL_PS3_RenderPoint(SDL_Renderer * renderer, int x, int y); 49 static int SDL_PS3_RenderPoint(SDL_Renderer * renderer, int x, int y);
46 static int SDL_PS3_RenderLine(SDL_Renderer * renderer, int x1, int y1, 50 static int SDL_PS3_RenderLine(SDL_Renderer * renderer, int x1, int y1,
47 int x2, int y2); 51 int x2, int y2);
48 static int SDL_PS3_RenderFill(SDL_Renderer * renderer, 52 static int SDL_PS3_RenderFill(SDL_Renderer * renderer,
49 const SDL_Rect * rect); 53 const SDL_Rect * rect);
54 static void SDL_PS3_RenderPresent(SDL_Renderer * renderer); 58 static void SDL_PS3_RenderPresent(SDL_Renderer * renderer);
55 static void SDL_PS3_DestroyRenderer(SDL_Renderer * renderer); 59 static void SDL_PS3_DestroyRenderer(SDL_Renderer * renderer);
56 60
57 /* Texture */ 61 /* Texture */
58 static int PS3_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture); 62 static int PS3_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
63 static int PS3_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, void **pixels, int *pitch);
59 static void PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture); 64 static void PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture);
60 65
61 66
62 SDL_RenderDriver SDL_PS3_RenderDriver = { 67 SDL_RenderDriver SDL_PS3_RenderDriver = {
63 SDL_PS3_CreateRenderer, 68 SDL_PS3_CreateRenderer,
93 /* size of a screen line: width * bpp/8 */ 98 /* size of a screen line: width * bpp/8 */
94 unsigned int line_length; 99 unsigned int line_length;
95 100
96 /* Use two buffers in fb? res < 720p */ 101 /* Use two buffers in fb? res < 720p */
97 unsigned int double_buffering; 102 unsigned int double_buffering;
103
104 /* SPE threading stuff */
105 spu_data_t * converter_thread_data;
106 /* YUV converting transfer data */
107 volatile struct yuv2rgb_parms_t * converter_parms __attribute__((aligned(128)));
98 } SDL_PS3_RenderData; 108 } SDL_PS3_RenderData;
99 109
100 typedef struct 110 typedef struct
101 { 111 {
102 void *pixels;
103 int pitch; 112 int pitch;
104 int bpp; 113 int bpp;
114 volatile void *pixels __attribute__((aligned(128)));
105 } PS3_TextureData; 115 } PS3_TextureData;
106 116
107 SDL_Renderer * 117 SDL_Renderer *
108 SDL_PS3_CreateRenderer(SDL_Window * window, Uint32 flags) 118 SDL_PS3_CreateRenderer(SDL_Window * window, Uint32 flags)
109 { 119 {
136 } 146 }
137 SDL_zerop(data); 147 SDL_zerop(data);
138 148
139 //renderer->CreateTexture = PS3_CreateTexture; 149 //renderer->CreateTexture = PS3_CreateTexture;
140 //renderer->DestroyTexture = PS3_DestroyTexture; 150 //renderer->DestroyTexture = PS3_DestroyTexture;
151 //renderer->QueryTexturePixels = PS3_QueryTexturePixels;
152 renderer->ActivateRenderer = SDL_PS3_ActivateRenderer;
141 renderer->RenderPoint = SDL_PS3_RenderPoint; 153 renderer->RenderPoint = SDL_PS3_RenderPoint;
142 renderer->RenderLine = SDL_PS3_RenderLine; 154 renderer->RenderLine = SDL_PS3_RenderLine;
143 renderer->RenderFill = SDL_PS3_RenderFill; 155 renderer->RenderFill = SDL_PS3_RenderFill;
144 renderer->RenderCopy = SDL_PS3_RenderCopy; 156 renderer->RenderCopy = SDL_PS3_RenderCopy;
145 renderer->RenderPresent = SDL_PS3_RenderPresent; 157 renderer->RenderPresent = SDL_PS3_RenderPresent;
182 SDL_memset(data->screens[i]->pixels, 0, data->screens[i]->h * data->screens[i]->pitch); 194 SDL_memset(data->screens[i]->pixels, 0, data->screens[i]->h * data->screens[i]->pitch);
183 SDL_SetSurfacePalette(data->screens[i], display->palette); 195 SDL_SetSurfacePalette(data->screens[i], display->palette);
184 } 196 }
185 data->current_screen = 0; 197 data->current_screen = 0;
186 198
199 /* Create SPU parms structure */
200 data->converter_parms = (struct yuv2rgb_parms_t *) memalign(16, sizeof(struct yuv2rgb_parms_t));
201 if (data->converter_parms == NULL) {
202 SDL_PS3_DestroyRenderer(renderer);
203 SDL_OutOfMemory();
204 return NULL;
205 }
206
207 /* Set up the SPEs */
208 data->converter_thread_data = (spu_data_t *) malloc(sizeof(spu_data_t));
209 if (data->converter_thread_data == NULL) {
210 SDL_PS3_DestroyRenderer(renderer);
211 SDL_OutOfMemory();
212 return NULL;
213 }
214
215 data->converter_thread_data->program = yuv2rgb_spu;
216 data->converter_thread_data->program_name = "yuv2rgb_spu";
217 data->converter_thread_data->keepalive = 1;
218 data->converter_thread_data->booted = 0;
219
220 SPE_Start(data->converter_thread_data);
221
187 return renderer; 222 return renderer;
223 }
224
225 static int
226 SDL_PS3_ActivateRenderer(SDL_Renderer * renderer)
227 {
228 deprintf(1, "PS3_ActivateRenderer()\n");
229 SDL_PS3_RenderData *data = (SDL_PS3_RenderData *) renderer->driverdata;
230
231 return 0;
188 } 232 }
189 233
190 static int 234 static int
191 PS3_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { 235 PS3_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) {
192 deprintf(1, "PS3_CreateTexture()\n"); 236 deprintf(1, "PS3_CreateTexture()\n");
195 if (!data) { 239 if (!data) {
196 SDL_OutOfMemory(); 240 SDL_OutOfMemory();
197 return -1; 241 return -1;
198 } 242 }
199 243
244 data->bpp = SDL_BYTESPERPIXEL(texture->format);
200 data->pitch = (texture->w * SDL_BYTESPERPIXEL(texture->format)); 245 data->pitch = (texture->w * SDL_BYTESPERPIXEL(texture->format));
201 246
202 data->pixels = NULL; 247 data->pixels = NULL;
203 data->pixels = (void *)memalign(16, texture->h * data->pitch); 248 data->pixels = (void *)memalign(16, texture->h * data->pitch);
204 if (!data->pixels) { 249 if (!data->pixels) {
209 254
210 texture->driverdata = data; 255 texture->driverdata = data;
211 return 0; 256 return 0;
212 } 257 }
213 258
259 static int
260 PS3_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
261 void **pixels, int *pitch)
262 {
263 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
264
265 *pixels = (void *)data->pixels;
266 *pitch = data->pitch;
267
268 return 0;
269 }
270
214 static void 271 static void
215 PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) 272 PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
216 { 273 {
274 deprintf(1, "PS3_DestroyTexture()\n");
217 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata; 275 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
218 276
219 if (!data) { 277 if (!data) {
220 return; 278 return;
221 } 279 }
222 280
223 free(data->pixels); 281 free((void *)data->pixels);
224 } 282 }
225 283
226 static int 284 static int
227 SDL_PS3_RenderPoint(SDL_Renderer * renderer, int x, int y) 285 SDL_PS3_RenderPoint(SDL_Renderer * renderer, int x, int y)
228 { 286 {
300 deprintf(1, "SDL_PS3_RenderCopy()\n"); 358 deprintf(1, "SDL_PS3_RenderCopy()\n");
301 SDL_PS3_RenderData *data = 359 SDL_PS3_RenderData *data =
302 (SDL_PS3_RenderData *) renderer->driverdata; 360 (SDL_PS3_RenderData *) renderer->driverdata;
303 SDL_Window *window = SDL_GetWindowFromID(renderer->window); 361 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
304 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 362 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
305 PS3_TextureData *txdata = (PS3_TextureData *) texture->driverdata; 363 //PS3_TextureData *txdata = (PS3_TextureData *) texture->driverdata;
364 SDL_SW_YUVTexture *txdata = (SDL_SW_YUVTexture *) texture->driverdata;
306 SDL_VideoData *devdata = display->device->driverdata; 365 SDL_VideoData *devdata = display->device->driverdata;
307 366
308 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 367 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
309 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = true\n"); 368 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = true\n");
310 SDL_Surface *target = data->screens[data->current_screen]; 369 SDL_Surface *target = data->screens[data->current_screen];
311 void *pixels = 370 void *pixels =
312 (Uint8 *) target->pixels + dstrect->y * target->pitch + 371 (Uint8 *) target->pixels + dstrect->y * target->pitch +
313 dstrect->x * target->format->BytesPerPixel; 372 dstrect->x * target->format->BytesPerPixel;
373 #if 0
374 /* Not yet tested */
375 Uint8 *lum, *Cr, *Cb;
376 SDL_SW_YUVTexture *swdata = (SDL_SW_YUVTexture *) texture->driverdata;
377 switch (swdata->format) {
378 case SDL_PIXELFORMAT_YV12:
379 lum = swdata->planes[0];
380 Cr = swdata->planes[1];
381 Cb = swdata->planes[2];
382 break;
383 case SDL_PIXELFORMAT_IYUV:
384 lum = swdata->planes[0];
385 Cr = swdata->planes[2];
386 Cb = swdata->planes[1];
387 break;
388 default:
389 return -1;
390 }
391
392 data->converter_parms->src_pixel_width = dstrect->w;
393 data->converter_parms->src_pixel_height = dstrect->h;
394 data->converter_parms->dstBuffer = (Uint8 *)pixels;
395 data->converter_thread_data->argp = (void *)data->converter_parms;
396
397 /* Convert YUV overlay to RGB */
398 SPE_SendMsg(data->converter_thread_data, SPU_START);
399 SPE_SendMsg(data->converter_thread_data, (unsigned int)data->converter_thread_data->argp);
400
401 return 0;
402 #else
314 return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata, 403 return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata,
315 srcrect, display->current_mode.format, 404 srcrect, display->current_mode.format,
316 dstrect->w, dstrect->h, pixels, 405 dstrect->w, dstrect->h, pixels,
317 target->pitch); 406 target->pitch);
407 #endif
318 } else { 408 } else {
319 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = false\n"); 409 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = false\n");
320 SDL_Surface *surface = (SDL_Surface *) texture->driverdata; 410 SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
321 SDL_Surface *target = data->screens[data->current_screen]; 411 SDL_Surface *target = data->screens[data->current_screen];
322 SDL_Rect real_srcrect = *srcrect; 412 SDL_Rect real_srcrect = *srcrect;
328 deprintf(1, "srcrect->w = %u\n", srcrect->w); 418 deprintf(1, "srcrect->w = %u\n", srcrect->w);
329 deprintf(1, "srcrect->h = %u\n", srcrect->h); 419 deprintf(1, "srcrect->h = %u\n", srcrect->h);
330 deprintf(1, "dstrect->w = %u\n", dstrect->w); 420 deprintf(1, "dstrect->w = %u\n", dstrect->w);
331 deprintf(1, "dstrect->h = %u\n", dstrect->h); 421 deprintf(1, "dstrect->h = %u\n", dstrect->h);
332 422
333 deprintf(1, "txdata->bpp = %u\n", txdata->bpp); 423 //deprintf(1, "txdata->bpp = %u\n", txdata->bpp);
334 deprintf(1, "texture->format (bpp) = %u\n", SDL_BYTESPERPIXEL(texture->format)); 424 deprintf(1, "texture->format (bpp) = %u\n", SDL_BYTESPERPIXEL(texture->format));
335 425
336 /* For testing, align pixels */ 426 /* For testing, align pixels */
337 void *pixels = (void *)memalign(16, dstrect->h * data->screens[0]->pitch); 427 void *pixels = (void *)memalign(16, window->h * window->w * 4);
338 SDL_memcpy(pixels, surface->pixels, dstrect->h * data->screens[0]->pitch); 428 SDL_memcpy(pixels, surface->pixels, window->h * window->w * 4);
339 429
340 /* Get screeninfo */ 430 /* Get screeninfo */
341 struct fb_fix_screeninfo fb_finfo; 431 struct fb_fix_screeninfo fb_finfo;
342 if (ioctl(devdata->fbdev, FBIOGET_FSCREENINFO, &fb_finfo)) { 432 if (ioctl(devdata->fbdev, FBIOGET_FSCREENINFO, &fb_finfo)) {
343 SDL_SetError("[PS3] Can't get fixed screeninfo"); 433 SDL_SetError("[PS3] Can't get fixed screeninfo");
347 if (ioctl(devdata->fbdev, FBIOGET_VSCREENINFO, &fb_vinfo)) { 437 if (ioctl(devdata->fbdev, FBIOGET_VSCREENINFO, &fb_vinfo)) {
348 SDL_SetError("[PS3] Can't get VSCREENINFO"); 438 SDL_SetError("[PS3] Can't get VSCREENINFO");
349 return -1; 439 return -1;
350 } 440 }
351 /* 16 and 15 bpp is reported as 16 bpp */ 441 /* 16 and 15 bpp is reported as 16 bpp */
352 txdata->bpp = fb_vinfo.bits_per_pixel; 442 //txdata->bpp = fb_vinfo.bits_per_pixel;
353 if (txdata->bpp == 16) 443 //if (txdata->bpp == 16)
354 txdata->bpp = fb_vinfo.red.length + fb_vinfo.green.length + fb_vinfo.blue.length; 444 // txdata->bpp = fb_vinfo.red.length + fb_vinfo.green.length + fb_vinfo.blue.length;
355 445
356 /* Adjust centering */ 446 /* Adjust centering */
357 data->bounded_width = window->w < fb_vinfo.xres ? window->w : fb_vinfo.xres; 447 data->bounded_width = window->w < fb_vinfo.xres ? window->w : fb_vinfo.xres;
358 data->bounded_height = window->h < fb_vinfo.yres ? window->h : fb_vinfo.yres; 448 data->bounded_height = window->h < fb_vinfo.yres ? window->h : fb_vinfo.yres;
359 data->offset_left = (fb_vinfo.xres - data->bounded_width) >> 1; 449 data->offset_left = (fb_vinfo.xres - data->bounded_width) >> 1;
370 devdata->fb_parms->center = data->center[data->current_screen]; 460 devdata->fb_parms->center = data->center[data->current_screen];
371 devdata->fb_parms->out_line_stride = fb_finfo.line_length; 461 devdata->fb_parms->out_line_stride = fb_finfo.line_length;
372 devdata->fb_parms->in_line_stride = dstrect->w * /*txdata->bpp / 8*/4; 462 devdata->fb_parms->in_line_stride = dstrect->w * /*txdata->bpp / 8*/4;
373 devdata->fb_parms->bounded_input_height = data->bounded_height; 463 devdata->fb_parms->bounded_input_height = data->bounded_height;
374 devdata->fb_parms->bounded_input_width = data->bounded_width; 464 devdata->fb_parms->bounded_input_width = data->bounded_width;
375 devdata->fb_parms->fb_pixel_size = txdata->bpp / 8; 465 //devdata->fb_parms->fb_pixel_size = txdata->bpp / 8;
466 devdata->fb_parms->fb_pixel_size = SDL_BYTESPERPIXEL(texture->format);
376 467
377 deprintf(3, "[PS3->SPU] fb_thread_data->argp = 0x%x\n", devdata->fb_thread_data->argp); 468 deprintf(3, "[PS3->SPU] fb_thread_data->argp = 0x%x\n", devdata->fb_thread_data->argp);
378 469
379 /* Copying.. */ 470 /* Copying.. */
380 SPE_SendMsg(devdata->fb_thread_data, SPU_START); 471 SPE_SendMsg(devdata->fb_thread_data, SPU_START);
436 for (i = 0; i < SDL_arraysize(data->screens); ++i) { 527 for (i = 0; i < SDL_arraysize(data->screens); ++i) {
437 if (data->screens[i]) { 528 if (data->screens[i]) {
438 SDL_FreeSurface(data->screens[i]); 529 SDL_FreeSurface(data->screens[i]);
439 } 530 }
440 } 531 }
532
533 /* Shutdown SPE and related resources */
534 if (data->converter_parms) {
535 free((void *)data->converter_parms);
536 }
537 if (data->converter_thread_data) {
538 SPE_Shutdown(data->converter_thread_data);
539 free((void *)data->converter_thread_data);
540 }
541
441 SDL_free(data); 542 SDL_free(data);
442 } 543 }
443 SDL_free(renderer); 544 SDL_free(renderer);
444 } 545 }
445 546