Mercurial > sdl-ios-xcode

comparison src/video/ps3/SDL_ps3render.c @ 3146:9e902f423497 gsoc2009_ps3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
YUV-Textures with SPU-support working.
author Martin Lowinski <martin@goldtopf.org>
date Mon, 15 Jun 2009 16:33:03 +0000
parents 0d8d1f870964
children a80760096937
comparison
equal deleted inserted replaced
3145:7828eed2f31a 3146:9e902f423497
59 static void SDL_PS3_DestroyRenderer(SDL_Renderer * renderer); 59 static void SDL_PS3_DestroyRenderer(SDL_Renderer * renderer);
60 60
61 /* Texture */ 61 /* Texture */
62 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); 63 static int PS3_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, void **pixels, int *pitch);
64 static int PS3_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * rect, const void *pixels, int pitch);
65 static int PS3_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture, const SDL_Rect * rect, int markDirty, void **pixels, int *pitch);
66 static void PS3_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
64 static void PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture); 67 static void PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture);
65 68
66 69
67 SDL_RenderDriver SDL_PS3_RenderDriver = { 70 SDL_RenderDriver SDL_PS3_RenderDriver = {
68 SDL_PS3_CreateRenderer, 71 SDL_PS3_CreateRenderer,
69 { 72 {
70 "ps3", 73 "ps3",
71 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTVSYNC | 74 (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTVSYNC |
72 SDL_RENDERER_PRESENTFLIP2) 75 SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTDISCARD |
73 /* (SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTCOPY | 76 SDL_RENDERER_ACCELERATED)
74 SDL_RENDERER_PRESENTFLIP2 | SDL_RENDERER_PRESENTFLIP3 |
75 SDL_RENDERER_PRESENTDISCARD) */,
76 } 77 }
77 }; 78 };
78 79
79 typedef struct 80 typedef struct
80 { 81 {
81 int current_screen; 82 int current_screen;
82 SDL_Surface *screens[3]; 83 //SDL_Surface *screens[2];
84 SDL_Surface *screen[1];
83 SDL_VideoDisplay *display; 85 SDL_VideoDisplay *display;
84 uint8_t *center[2]; 86 uint8_t *center[2];
85 87
86 /* width of input (bounded by writeable width) */ 88 /* width of input (bounded by writeable width) */
87 unsigned int bounded_width; 89 unsigned int bounded_width;
107 volatile struct yuv2rgb_parms_t * converter_parms __attribute__((aligned(128))); 109 volatile struct yuv2rgb_parms_t * converter_parms __attribute__((aligned(128)));
108 } SDL_PS3_RenderData; 110 } SDL_PS3_RenderData;
109 111
110 typedef struct 112 typedef struct
111 { 113 {
114 //SDL_PixelFormat * format;
112 int pitch; 115 int pitch;
113 int bpp; 116 volatile void *pixels;// __attribute__((aligned(128))); we don't need alignment here
114 volatile void *pixels __attribute__((aligned(128))); 117 SDL_SW_YUVTexture *yuv;
115 } PS3_TextureData; 118 } PS3_TextureData;
116 119
117 SDL_Renderer * 120 SDL_Renderer *
118 SDL_PS3_CreateRenderer(SDL_Window * window, Uint32 flags) 121 SDL_PS3_CreateRenderer(SDL_Window * window, Uint32 flags)
119 { 122 {
120 deprintf(1, "SDL_PS3_CreateRenderer()\n"); 123 deprintf(1, "+SDL_PS3_CreateRenderer()\n");
121 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 124 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
122 SDL_DisplayMode *displayMode = &display->current_mode; 125 SDL_DisplayMode *displayMode = &display->current_mode;
123 SDL_Renderer *renderer; 126 SDL_Renderer *renderer;
124 SDL_PS3_RenderData *data; 127 SDL_PS3_RenderData *data;
125 int i, n; 128 int i, n;
144 SDL_OutOfMemory(); 147 SDL_OutOfMemory();
145 return NULL; 148 return NULL;
146 } 149 }
147 SDL_zerop(data); 150 SDL_zerop(data);
148 151
149 //renderer->CreateTexture = PS3_CreateTexture; 152 #if 1
150 //renderer->DestroyTexture = PS3_DestroyTexture; 153 renderer->CreateTexture = PS3_CreateTexture;
151 //renderer->QueryTexturePixels = PS3_QueryTexturePixels; 154 renderer->DestroyTexture = PS3_DestroyTexture;
155 renderer->QueryTexturePixels = PS3_QueryTexturePixels;
156 renderer->UpdateTexture = PS3_UpdateTexture;
157 renderer->LockTexture = PS3_LockTexture;
158 renderer->UnlockTexture = PS3_UnlockTexture;
159 #endif
152 renderer->ActivateRenderer = SDL_PS3_ActivateRenderer; 160 renderer->ActivateRenderer = SDL_PS3_ActivateRenderer;
153 renderer->RenderPoint = SDL_PS3_RenderPoint; 161 renderer->RenderPoint = SDL_PS3_RenderPoint;
154 renderer->RenderLine = SDL_PS3_RenderLine; 162 renderer->RenderLine = SDL_PS3_RenderLine;
155 renderer->RenderFill = SDL_PS3_RenderFill; 163 renderer->RenderFill = SDL_PS3_RenderFill;
156 renderer->RenderCopy = SDL_PS3_RenderCopy; 164 renderer->RenderCopy = SDL_PS3_RenderCopy;
158 renderer->DestroyRenderer = SDL_PS3_DestroyRenderer; 166 renderer->DestroyRenderer = SDL_PS3_DestroyRenderer;
159 renderer->info.name = SDL_PS3_RenderDriver.info.name; 167 renderer->info.name = SDL_PS3_RenderDriver.info.name;
160 renderer->info.flags = 0; 168 renderer->info.flags = 0;
161 renderer->window = window->id; 169 renderer->window = window->id;
162 renderer->driverdata = data; 170 renderer->driverdata = data;
163 Setup_SoftwareRenderer(renderer); 171 //Setup_SoftwareRenderer(renderer);
164 172
165 deprintf(1, "window->w = %u\n", window->w); 173 deprintf(1, "window->w = %u\n", window->w);
166 deprintf(1, "window->h = %u\n", window->h); 174 deprintf(1, "window->h = %u\n", window->h);
167 175
168 data->double_buffering = 0; 176 data->double_buffering = 0;
174 } else { 182 } else {
175 renderer->info.flags |= SDL_RENDERER_PRESENTCOPY; 183 renderer->info.flags |= SDL_RENDERER_PRESENTCOPY;
176 n = 1; 184 n = 1;
177 } 185 }
178 for (i = 0; i < n; ++i) { 186 for (i = 0; i < n; ++i) {
179 data->screens[i] = 187 data->screen[i] =
180 SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask, 188 SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask,
181 Bmask, Amask); 189 Bmask, Amask);
182 if (!data->screens[i]) { 190 if (!data->screen[i]) {
183 SDL_PS3_DestroyRenderer(renderer); 191 SDL_PS3_DestroyRenderer(renderer);
184 return NULL; 192 return NULL;
185 } 193 }
186 /* Allocate aligned memory for pixels */ 194 /* Allocate aligned memory for pixels */
187 SDL_free(data->screens[i]->pixels); 195 SDL_free(data->screen[i]->pixels);
188 data->screens[i]->pixels = (void *)memalign(16, data->screens[i]->h * data->screens[i]->pitch); 196 data->screen[i]->pixels = (void *)memalign(16, data->screen[i]->h * data->screen[i]->pitch);
189 if (!data->screens[i]->pixels) { 197 if (!data->screen[i]->pixels) {
190 SDL_FreeSurface(data->screens[i]); 198 SDL_FreeSurface(data->screen[i]);
191 SDL_OutOfMemory(); 199 SDL_OutOfMemory();
192 return NULL; 200 return NULL;
193 } 201 }
194 SDL_memset(data->screens[i]->pixels, 0, data->screens[i]->h * data->screens[i]->pitch); 202 SDL_memset(data->screen[i]->pixels, 0, data->screen[i]->h * data->screen[i]->pitch);
195 SDL_SetSurfacePalette(data->screens[i], display->palette); 203 SDL_SetSurfacePalette(data->screen[i], display->palette);
196 } 204 }
197 data->current_screen = 0; 205 data->current_screen = 0;
198 206
199 /* Create SPU parms structure */ 207 /* Create SPU parms structure */
200 data->converter_parms = (struct yuv2rgb_parms_t *) memalign(16, sizeof(struct yuv2rgb_parms_t)); 208 data->converter_parms = (struct yuv2rgb_parms_t *) memalign(16, sizeof(struct yuv2rgb_parms_t));
217 data->converter_thread_data->keepalive = 1; 225 data->converter_thread_data->keepalive = 1;
218 data->converter_thread_data->booted = 0; 226 data->converter_thread_data->booted = 0;
219 227
220 SPE_Start(data->converter_thread_data); 228 SPE_Start(data->converter_thread_data);
221 229
230 deprintf(1, "-SDL_PS3_CreateRenderer()\n");
222 return renderer; 231 return renderer;
223 } 232 }
224 233
225 static int 234 static int
226 SDL_PS3_ActivateRenderer(SDL_Renderer * renderer) 235 SDL_PS3_ActivateRenderer(SDL_Renderer * renderer)
227 { 236 {
228 deprintf(1, "PS3_ActivateRenderer()\n"); 237 deprintf(1, "+PS3_ActivateRenderer()\n");
229 SDL_PS3_RenderData *data = (SDL_PS3_RenderData *) renderer->driverdata; 238 SDL_PS3_RenderData *data = (SDL_PS3_RenderData *) renderer->driverdata;
230 239
240 deprintf(1, "-PS3_ActivateRenderer()\n");
231 return 0; 241 return 0;
232 } 242 }
233 243
234 static int 244 static int
235 PS3_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) { 245 PS3_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture) {
236 deprintf(1, "PS3_CreateTexture()\n"); 246 deprintf(1, "+PS3_CreateTexture()\n");
237 PS3_TextureData *data; 247 PS3_TextureData *data;
238 data = (PS3_TextureData *) SDL_calloc(1, sizeof(*data)); 248 data = (PS3_TextureData *) SDL_calloc(1, sizeof(*data));
239 if (!data) { 249 if (!data) {
240 SDL_OutOfMemory(); 250 SDL_OutOfMemory();
241 return -1; 251 return -1;
242 } 252 }
243
244 data->bpp = SDL_BYTESPERPIXEL(texture->format);
245 data->pitch = (texture->w * SDL_BYTESPERPIXEL(texture->format)); 253 data->pitch = (texture->w * SDL_BYTESPERPIXEL(texture->format));
246 254
247 data->pixels = NULL; 255 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
248 data->pixels = (void *)memalign(16, texture->h * data->pitch); 256 /* Use SDLs SW_YUVTexture */
249 if (!data->pixels) { 257 data->yuv =
250 PS3_DestroyTexture(renderer, texture); 258 SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);
251 SDL_OutOfMemory(); 259 if (!data->yuv) {
252 return -1; 260 SDL_OutOfMemory();
253 } 261 return -1;
254 262 }
263 /* but align pixels */
264 SDL_free(data->yuv->pixels);
265 data->yuv->pixels = (Uint8 *)memalign(16, texture->w * texture->h * 2);
266
267 /* Redo: Find the pitch and offset values for the overlay */
268 SDL_SW_YUVTexture *swdata = (SDL_SW_YUVTexture *) data->yuv;
269 switch (texture->format) {
270 case SDL_PIXELFORMAT_YV12:
271 case SDL_PIXELFORMAT_IYUV:
272 swdata->pitches[0] = texture->w;
273 swdata->pitches[1] = swdata->pitches[0] / 2;
274 swdata->pitches[2] = swdata->pitches[0] / 2;
275 swdata->planes[0] = swdata->pixels;
276 swdata->planes[1] = swdata->planes[0] + swdata->pitches[0] * texture->h;
277 swdata->planes[2] = swdata->planes[1] + swdata->pitches[1] * texture->h / 2;
278 break;
279 case SDL_PIXELFORMAT_YUY2:
280 case SDL_PIXELFORMAT_UYVY:
281 case SDL_PIXELFORMAT_YVYU:
282 swdata->pitches[0] = texture->w * 2;
283 swdata->planes[0] = swdata->pixels;
284 break;
285 default:
286 /* We should never get here (caught above) */
287 break;
288 }
289 } else {
290 data->pixels = NULL;
291 data->pixels = SDL_malloc(texture->h * data->pitch);
292 if (!data->pixels) {
293 PS3_DestroyTexture(renderer, texture);
294 SDL_OutOfMemory();
295 return -1;
296 }
297 }
255 texture->driverdata = data; 298 texture->driverdata = data;
299 deprintf(1, "-PS3_CreateTexture()\n");
256 return 0; 300 return 0;
257 } 301 }
258 302
259 static int 303 static int
260 PS3_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture, 304 PS3_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
261 void **pixels, int *pitch) 305 void **pixels, int *pitch)
262 { 306 {
307 deprintf(1, "+PS3_QueryTexturePixels()\n");
263 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata; 308 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
264 309
265 *pixels = (void *)data->pixels; 310 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
266 *pitch = data->pitch; 311 return SDL_SW_QueryYUVTexturePixels(data->yuv, pixels, pitch);
267 312 } else {
313 *pixels = (void *)data->pixels;
314 *pitch = data->pitch;
315 }
316
317 deprintf(1, "-PS3_QueryTexturePixels()\n");
268 return 0; 318 return 0;
319 }
320
321 static int
322 PS3_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
323 const SDL_Rect * rect, const void *pixels, int pitch)
324 {
325 deprintf(1, "+PS3_UpdateTexture()\n");
326 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
327
328 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
329 return SDL_SW_UpdateYUVTexture(data->yuv, rect, pixels, pitch);
330 } else {
331 Uint8 *src, *dst;
332 int row;
333 size_t length;
334 int dstpitch;
335 Uint8 *dstpixels;
336
337 src = (Uint8 *) pixels;
338 dst = (Uint8 *) dstpixels + rect->y * dstpitch + rect->x
339 * SDL_BYTESPERPIXEL(texture->format);
340 length = rect->w * SDL_BYTESPERPIXEL(texture->format);
341 for (row = 0; row < rect->h; ++row) {
342 SDL_memcpy(dst, src, length);
343 src += pitch;
344 dst += dstpitch;
345 }
346 }
347 deprintf(1, "-PS3_UpdateTexture()\n");
348 return 0;
349 }
350
351 static int
352 PS3_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
353 const SDL_Rect * rect, int markDirty, void **pixels,
354 int *pitch)
355 {
356 deprintf(1, "+PS3_LockTexture()\n");
357 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
358
359 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
360 return SDL_SW_LockYUVTexture(data->yuv, rect, markDirty, pixels, pitch);
361 } else {
362 *pixels =
363 (void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
364 rect->x * SDL_BYTESPERPIXEL(texture->format));
365 *pitch = data->pitch;
366 return 0;
367 }
368 deprintf(1, "-PS3_LockTexture()\n");
369 }
370
371 static void
372 PS3_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
373 {
374 deprintf(1, "+PS3_UnlockTexture()\n");
375 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
376
377 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
378 SDL_SW_UnlockYUVTexture(data->yuv);
379 }
380 deprintf(1, "-PS3_UnlockTexture()\n");
269 } 381 }
270 382
271 static void 383 static void
272 PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture) 384 PS3_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
273 { 385 {
274 deprintf(1, "PS3_DestroyTexture()\n"); 386 deprintf(1, "+PS3_DestroyTexture()\n");
275 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata; 387 PS3_TextureData *data = (PS3_TextureData *) texture->driverdata;
276 388
277 if (!data) { 389 if (!data) {
278 return; 390 return;
279 } 391 }
280 392 if (data->yuv) {
281 free((void *)data->pixels); 393 SDL_SW_DestroyYUVTexture(data->yuv);
394 }
395 if (data->pixels) {
396 SDL_free((void *)data->pixels);
397 }
398 deprintf(1, "-PS3_DestroyTexture()\n");
282 } 399 }
283 400
284 static int 401 static int
285 SDL_PS3_RenderPoint(SDL_Renderer * renderer, int x, int y) 402 SDL_PS3_RenderPoint(SDL_Renderer * renderer, int x, int y)
286 { 403 {
287 SDL_PS3_RenderData *data = 404 SDL_PS3_RenderData *data =
288 (SDL_PS3_RenderData *) renderer->driverdata; 405 (SDL_PS3_RenderData *) renderer->driverdata;
289 SDL_Surface *target = data->screens[data->current_screen]; 406 SDL_Surface *target = data->screen[data->current_screen];
290 int status; 407 int status;
291 408
292 if (renderer->blendMode == SDL_BLENDMODE_NONE || 409 if (renderer->blendMode == SDL_BLENDMODE_NONE ||
293 renderer->blendMode == SDL_BLENDMODE_MASK) { 410 renderer->blendMode == SDL_BLENDMODE_MASK) {
294 Uint32 color = 411 Uint32 color =
307 static int 424 static int
308 SDL_PS3_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2) 425 SDL_PS3_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
309 { 426 {
310 SDL_PS3_RenderData *data = 427 SDL_PS3_RenderData *data =
311 (SDL_PS3_RenderData *) renderer->driverdata; 428 (SDL_PS3_RenderData *) renderer->driverdata;
312 SDL_Surface *target = data->screens[data->current_screen]; 429 SDL_Surface *target = data->screen[data->current_screen];
313 int status; 430 int status;
314 431
315 if (renderer->blendMode == SDL_BLENDMODE_NONE || 432 if (renderer->blendMode == SDL_BLENDMODE_NONE ||
316 renderer->blendMode == SDL_BLENDMODE_MASK) { 433 renderer->blendMode == SDL_BLENDMODE_MASK) {
317 Uint32 color = 434 Uint32 color =
331 SDL_PS3_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect) 448 SDL_PS3_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect)
332 { 449 {
333 deprintf(1, "SDL_PS3_RenderFill()\n"); 450 deprintf(1, "SDL_PS3_RenderFill()\n");
334 SDL_PS3_RenderData *data = 451 SDL_PS3_RenderData *data =
335 (SDL_PS3_RenderData *) renderer->driverdata; 452 (SDL_PS3_RenderData *) renderer->driverdata;
336 SDL_Surface *target = data->screens[data->current_screen]; 453 SDL_Surface *target = data->screen[data->current_screen];
337 SDL_Rect real_rect = *rect; 454 SDL_Rect real_rect = *rect;
338 int status; 455 int status;
339 456
340 if (renderer->blendMode == SDL_BLENDMODE_NONE) { 457 if (renderer->blendMode == SDL_BLENDMODE_NONE) {
341 Uint32 color = 458 Uint32 color =
353 470
354 static int 471 static int
355 SDL_PS3_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture, 472 SDL_PS3_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
356 const SDL_Rect * srcrect, const SDL_Rect * dstrect) 473 const SDL_Rect * srcrect, const SDL_Rect * dstrect)
357 { 474 {
358 deprintf(1, "SDL_PS3_RenderCopy()\n"); 475 deprintf(1, "+SDL_PS3_RenderCopy()\n");
359 SDL_PS3_RenderData *data = 476 SDL_PS3_RenderData *data =
360 (SDL_PS3_RenderData *) renderer->driverdata; 477 (SDL_PS3_RenderData *) renderer->driverdata;
361 SDL_Window *window = SDL_GetWindowFromID(renderer->window); 478 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
362 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 479 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
363 //PS3_TextureData *txdata = (PS3_TextureData *) texture->driverdata; 480 PS3_TextureData *txdata = (PS3_TextureData *) texture->driverdata;
364 SDL_SW_YUVTexture *txdata = (SDL_SW_YUVTexture *) texture->driverdata;
365 SDL_VideoData *devdata = display->device->driverdata; 481 SDL_VideoData *devdata = display->device->driverdata;
482
483 deprintf(1, "srcrect->w = %u\n", srcrect->w);
484 deprintf(1, "srcrect->h = %u\n", srcrect->h);
485 deprintf(1, "srcrect->x = %u\n", srcrect->x);
486 deprintf(1, "srcrect->y = %u\n", srcrect->y);
487 deprintf(1, "dstrect->w = %u\n", dstrect->w);
488 deprintf(1, "dstrect->h = %u\n", dstrect->h);
489 deprintf(1, "dstrect->x = %u\n", dstrect->x);
490 deprintf(1, "dstrect->y = %u\n", dstrect->y);
366 491
367 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) { 492 if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
368 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = true\n"); 493 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = true\n");
369 SDL_Surface *target = data->screens[data->current_screen]; 494 #if 1
370 void *pixels =
371 (Uint8 *) target->pixels + dstrect->y * target->pitch +
372 dstrect->x * target->format->BytesPerPixel;
373 #if 0
374 /* Not yet tested */ 495 /* Not yet tested */
375 Uint8 *lum, *Cr, *Cb; 496 Uint8 *lum, *Cr, *Cb;
376 SDL_SW_YUVTexture *swdata = (SDL_SW_YUVTexture *) texture->driverdata; 497 SDL_SW_YUVTexture *swdata = (SDL_SW_YUVTexture *) txdata->yuv;
377 switch (swdata->format) { 498 switch (swdata->format) {
378 case SDL_PIXELFORMAT_YV12: 499 case SDL_PIXELFORMAT_YV12:
379 lum = swdata->planes[0]; 500 lum = swdata->planes[0];
380 Cr = swdata->planes[1]; 501 Cr = swdata->planes[1];
381 Cb = swdata->planes[2]; 502 Cb = swdata->planes[2];
387 break; 508 break;
388 default: 509 default:
389 return -1; 510 return -1;
390 } 511 }
391 512
392 data->converter_parms->src_pixel_width = dstrect->w; 513 data->converter_parms->y_plane = lum;
393 data->converter_parms->src_pixel_height = dstrect->h; 514 data->converter_parms->v_plane = Cr;
394 data->converter_parms->dstBuffer = (Uint8 *)pixels; 515 data->converter_parms->u_plane = Cb;
516 data->converter_parms->src_pixel_width = swdata->w;//dstrect->w;
517 data->converter_parms->src_pixel_height = swdata->h;//dstrect->h;
518 data->converter_parms->dstBuffer = (Uint8 *)data->screen[0]->pixels;
395 data->converter_thread_data->argp = (void *)data->converter_parms; 519 data->converter_thread_data->argp = (void *)data->converter_parms;
396 520
397 /* Convert YUV overlay to RGB */ 521 /* Convert YUV overlay to RGB */
398 SPE_SendMsg(data->converter_thread_data, SPU_START); 522 SPE_SendMsg(data->converter_thread_data, SPU_START);
399 SPE_SendMsg(data->converter_thread_data, (unsigned int)data->converter_thread_data->argp); 523 SPE_SendMsg(data->converter_thread_data, (unsigned int)data->converter_thread_data->argp);
400 524
525 SPE_WaitForMsg(data->converter_thread_data, SPU_FIN);
526
401 return 0; 527 return 0;
402 #else 528 #else
403 return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata, 529 return SDL_SW_CopyYUVToRGB(txdata->yuv, srcrect, display->current_mode.format,
404 srcrect, display->current_mode.format, 530 dstrect->w, dstrect->h, data->screen[0]->pixels,
405 dstrect->w, dstrect->h, pixels, 531 data->screen[0]->pitch);
406 target->pitch);
407 #endif 532 #endif
408 } else { 533 } else {
409 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = false\n"); 534 deprintf(1, "SDL_ISPIXELFORMAT_FOURCC = false\n");
410 SDL_Surface *surface = (SDL_Surface *) texture->driverdata; 535
411 SDL_Surface *target = data->screens[data->current_screen]; 536 Uint8 *src, *dst;
412 SDL_Rect real_srcrect = *srcrect; 537 int row;
413 SDL_Rect real_dstrect = *dstrect; 538 size_t length;
414 539 int dstpitch;
415 deprintf(1, "surface->w = %u\n", surface->w); // FIXME: surface->w changes to 32 540 Uint8 *dstpixels;
416 deprintf(1, "surface->h = %u\n", surface->h); 541
417 542 src = (Uint8 *) txdata->pixels;
418 deprintf(1, "srcrect->w = %u\n", srcrect->w); 543 dst = (Uint8 *) data->screen[0]->pixels + dstrect->y * dstpitch + dstrect->x
419 deprintf(1, "srcrect->h = %u\n", srcrect->h); 544 * SDL_BYTESPERPIXEL(texture->format);
420 deprintf(1, "dstrect->w = %u\n", dstrect->w); 545 length = dstrect->w * SDL_BYTESPERPIXEL(texture->format);
421 deprintf(1, "dstrect->h = %u\n", dstrect->h); 546 for (row = 0; row < dstrect->h; ++row) {
422 547 SDL_memcpy(dst, src, length);
423 //deprintf(1, "txdata->bpp = %u\n", txdata->bpp); 548 src += dstpitch;
424 deprintf(1, "texture->format (bpp) = %u\n", SDL_BYTESPERPIXEL(texture->format)); 549 dst += dstpitch;
425 550 }
426 /* For testing, align pixels */ 551 //SDL_memcpy(data->screen[0]->pixels, (void *)txdata->pixels, texture->h * texture->w * 4);
427 void *pixels = (void *)memalign(16, window->h * window->w * 4); 552 }
428 SDL_memcpy(pixels, surface->pixels, window->h * window->w * 4); 553
429 554 deprintf(1, "-SDL_PS3_RenderCopy()\n");
430 /* Get screeninfo */ 555 return 0;
431 struct fb_fix_screeninfo fb_finfo;
432 if (ioctl(devdata->fbdev, FBIOGET_FSCREENINFO, &fb_finfo)) {
433 SDL_SetError("[PS3] Can't get fixed screeninfo");
434 return -1;
435 }
436 struct fb_var_screeninfo fb_vinfo;
437 if (ioctl(devdata->fbdev, FBIOGET_VSCREENINFO, &fb_vinfo)) {
438 SDL_SetError("[PS3] Can't get VSCREENINFO");
439 return -1;
440 }
441 /* 16 and 15 bpp is reported as 16 bpp */
442 //txdata->bpp = fb_vinfo.bits_per_pixel;
443 //if (txdata->bpp == 16)
444 // txdata->bpp = fb_vinfo.red.length + fb_vinfo.green.length + fb_vinfo.blue.length;
445
446 /* Adjust centering */
447 data->bounded_width = window->w < fb_vinfo.xres ? window->w : fb_vinfo.xres;
448 data->bounded_height = window->h < fb_vinfo.yres ? window->h : fb_vinfo.yres;
449 data->offset_left = (fb_vinfo.xres - data->bounded_width) >> 1;
450 data->offset_top = (fb_vinfo.yres - data->bounded_height) >> 1;
451 data->center[0] = devdata->frame_buffer + data->offset_left * /*txdata->bpp/8*/ 4 +
452 data->offset_top * fb_finfo.line_length;
453 data->center[1] = data->center[0] + fb_vinfo.yres * fb_finfo.line_length;
454
455 deprintf(1, "offset_left = %u\n", data->offset_left);
456 deprintf(1, "offset_top = %u\n", data->offset_top);
457
458 /* Set SPU parms for copying the surface to framebuffer */
459 devdata->fb_parms->data = (unsigned char *)pixels;
460 devdata->fb_parms->center = data->center[data->current_screen];
461 devdata->fb_parms->out_line_stride = fb_finfo.line_length;
462 devdata->fb_parms->in_line_stride = dstrect->w * /*txdata->bpp / 8*/4;
463 devdata->fb_parms->bounded_input_height = data->bounded_height;
464 devdata->fb_parms->bounded_input_width = data->bounded_width;
465 //devdata->fb_parms->fb_pixel_size = txdata->bpp / 8;
466 devdata->fb_parms->fb_pixel_size = SDL_BYTESPERPIXEL(texture->format);
467
468 deprintf(3, "[PS3->SPU] fb_thread_data->argp = 0x%x\n", devdata->fb_thread_data->argp);
469
470 /* Copying.. */
471 SPE_SendMsg(devdata->fb_thread_data, SPU_START);
472 SPE_SendMsg(devdata->fb_thread_data, (unsigned int)devdata->fb_thread_data->argp);
473
474 SPE_WaitForMsg(devdata->fb_thread_data, SPU_FIN);
475 free(pixels);
476
477 return 0;
478 //return SDL_LowerBlit(surface, &real_srcrect, target, &real_dstrect);
479 }
480 } 556 }
481 557
482 static void 558 static void
483 SDL_PS3_RenderPresent(SDL_Renderer * renderer) 559 SDL_PS3_RenderPresent(SDL_Renderer * renderer)
484 { 560 {
485 deprintf(1, "SDL_PS3_RenderPresent()\n"); 561 deprintf(1, "+SDL_PS3_RenderPresent()\n");
486 static int frame_number; 562 static int frame_number;
487 SDL_PS3_RenderData *data = 563 SDL_PS3_RenderData *data =
488 (SDL_PS3_RenderData *) renderer->driverdata; 564 (SDL_PS3_RenderData *) renderer->driverdata;
489 SDL_Window *window = SDL_GetWindowFromID(renderer->window); 565 SDL_Window *window = SDL_GetWindowFromID(renderer->window);
490 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window); 566 SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
491 SDL_VideoData *devdata = display->device->driverdata; 567 SDL_VideoData *devdata = display->device->driverdata;
492 568
569 #if 0
493 /* Send the data to the display */ 570 /* Send the data to the display */
494 if (SDL_getenv("SDL_VIDEO_PS3_SAVE_FRAMES")) { 571 if (SDL_getenv("SDL_VIDEO_PS3_SAVE_FRAMES")) {
495 char file[128]; 572 char file[128];
496 SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp", 573 SDL_snprintf(file, sizeof(file), "SDL_window%d-%8.8d.bmp",
497 renderer->window, ++frame_number); 574 renderer->window, ++frame_number);
498 SDL_SaveBMP(data->screens[data->current_screen], file); 575 SDL_SaveBMP(data->screen[data->current_screen], file);
499 } 576 }
577 #endif
578
579 /* Send the data to the screen */
580 /* Get screeninfo */
581 struct fb_fix_screeninfo fb_finfo;
582 if (ioctl(devdata->fbdev, FBIOGET_FSCREENINFO, &fb_finfo)) {
583 SDL_SetError("[PS3] Can't get fixed screeninfo");
584 }
585 struct fb_var_screeninfo fb_vinfo;
586 if (ioctl(devdata->fbdev, FBIOGET_VSCREENINFO, &fb_vinfo)) {
587 SDL_SetError("[PS3] Can't get VSCREENINFO");
588 }
589 /* 16 and 15 bpp is reported as 16 bpp */
590 //txdata->bpp = fb_vinfo.bits_per_pixel;
591 //if (txdata->bpp == 16)
592 // txdata->bpp = fb_vinfo.red.length + fb_vinfo.green.length + fb_vinfo.blue.length;
593
594 /* Adjust centering */
595 data->bounded_width = window->w < fb_vinfo.xres ? window->w : fb_vinfo.xres;
596 data->bounded_height = window->h < fb_vinfo.yres ? window->h : fb_vinfo.yres;
597 data->offset_left = (fb_vinfo.xres - data->bounded_width) >> 1;
598 data->offset_top = (fb_vinfo.yres - data->bounded_height) >> 1;
599 data->center[0] = devdata->frame_buffer + data->offset_left * /*txdata->bpp/8*/ 4 +
600 data->offset_top * fb_finfo.line_length;
601 data->center[1] = data->center[0] + fb_vinfo.yres * fb_finfo.line_length;
602
603 deprintf(1, "offset_left = %u\n", data->offset_left);
604 deprintf(1, "offset_top = %u\n", data->offset_top);
605
606 /* Set SPU parms for copying the surface to framebuffer */
607 devdata->fb_parms->data = (unsigned char *)data->screen[0]->pixels;
608 devdata->fb_parms->center = data->center[data->current_screen];
609 devdata->fb_parms->out_line_stride = fb_finfo.line_length;
610 devdata->fb_parms->in_line_stride = window->w * /*txdata->bpp / 8*/4;
611 devdata->fb_parms->bounded_input_height = data->bounded_height;
612 devdata->fb_parms->bounded_input_width = data->bounded_width;
613 //devdata->fb_parms->fb_pixel_size = txdata->bpp / 8;
614 devdata->fb_parms->fb_pixel_size = 4;//SDL_BYTESPERPIXEL(window->format);
615
616 deprintf(3, "[PS3->SPU] fb_thread_data->argp = 0x%x\n", devdata->fb_thread_data->argp);
617
618 /* Copying.. */
619 SPE_SendMsg(devdata->fb_thread_data, SPU_START);
620 SPE_SendMsg(devdata->fb_thread_data, (unsigned int)devdata->fb_thread_data->argp);
621
622 SPE_WaitForMsg(devdata->fb_thread_data, SPU_FIN);
500 623
501 /* Wait for vsync */ 624 /* Wait for vsync */
502 if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) { 625 if (renderer->info.flags & SDL_RENDERER_PRESENTVSYNC) {
503 unsigned long crt = 0; 626 unsigned long crt = 0;
504 deprintf(1, "[PS3] Wait for vsync\n"); 627 deprintf(1, "[PS3] Wait for vsync\n");
511 634
512 /* Update the flipping chain, if any */ 635 /* Update the flipping chain, if any */
513 if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2 && data->double_buffering) { 636 if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2 && data->double_buffering) {
514 data->current_screen = (data->current_screen + 1) % 2; 637 data->current_screen = (data->current_screen + 1) % 2;
515 } 638 }
639 deprintf(1, "-SDL_PS3_RenderPresent()\n");
516 } 640 }
517 641
518 static void 642 static void
519 SDL_PS3_DestroyRenderer(SDL_Renderer * renderer) 643 SDL_PS3_DestroyRenderer(SDL_Renderer * renderer)
520 { 644 {
521 deprintf(1, "SDL_PS3_DestroyRenderer()\n"); 645 deprintf(1, "+SDL_PS3_DestroyRenderer()\n");
522 SDL_PS3_RenderData *data = 646 SDL_PS3_RenderData *data =
523 (SDL_PS3_RenderData *) renderer->driverdata; 647 (SDL_PS3_RenderData *) renderer->driverdata;
524 int i; 648 int i;
525 649
526 if (data) { 650 if (data) {
527 for (i = 0; i < SDL_arraysize(data->screens); ++i) { 651 for (i = 0; i < SDL_arraysize(data->screen); ++i) {
528 if (data->screens[i]) { 652 if (data->screen[i]) {
529 SDL_FreeSurface(data->screens[i]); 653 SDL_FreeSurface(data->screen[i]);
530 } 654 }
531 } 655 }
532 656
533 /* Shutdown SPE and related resources */ 657 /* Shutdown SPE and related resources */
534 if (data->converter_parms) {
535 free((void *)data->converter_parms);
536 }
537 if (data->converter_thread_data) { 658 if (data->converter_thread_data) {
538 SPE_Shutdown(data->converter_thread_data); 659 SPE_Shutdown(data->converter_thread_data);
539 free((void *)data->converter_thread_data); 660 free((void *)data->converter_thread_data);
540 } 661 }
662 if (data->converter_parms) {
663 free((void *)data->converter_parms);
664 }
541 665
542 SDL_free(data); 666 SDL_free(data);
543 } 667 }
544 SDL_free(renderer); 668 SDL_free(renderer);
669 deprintf(1, "-SDL_PS3_DestroyRenderer()\n");
545 } 670 }
546 671
547 /* vi: set ts=4 sw=4 expandtab: */ 672 /* vi: set ts=4 sw=4 expandtab: */