Mercurial > sdl-ios-xcode
comparison src/video/ps3/SDL_ps3render.c @ 3146:9e902f423497 gsoc2009_ps3
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: */ |