Mercurial > sdl-ios-xcode
comparison src/video/SDL_blit_N.c @ 1162:2651158f59b8
Enable altivec blitters on PowerPC Linux, and some fixes for recent
GCCs versions.
author | Ryan C. Gordon <icculus@icculus.org> |
---|---|
date | Thu, 20 Oct 2005 06:55:26 +0000 |
parents | d0ae4dff7208 |
children | 867f521591e5 |
comparison
equal
deleted
inserted
replaced
1161:05d4b93b911e | 1162:2651158f59b8 |
---|---|
34 #include "SDL_cpuinfo.h" | 34 #include "SDL_cpuinfo.h" |
35 | 35 |
36 /* Functions to blit from N-bit surfaces to other surfaces */ | 36 /* Functions to blit from N-bit surfaces to other surfaces */ |
37 | 37 |
38 #ifdef USE_ALTIVEC_BLITTERS | 38 #ifdef USE_ALTIVEC_BLITTERS |
39 #include <altivec.h> | |
39 #include <assert.h> | 40 #include <assert.h> |
41 #include <stdlib.h> | |
40 #ifdef MACOSX | 42 #ifdef MACOSX |
41 #include <sys/sysctl.h> | 43 #include <sys/sysctl.h> |
42 #include <stdlib.h> | |
43 static size_t GetL3CacheSize( void ) | 44 static size_t GetL3CacheSize( void ) |
44 { | 45 { |
45 const char key[] = "hw.l3cachesize"; | 46 const char key[] = "hw.l3cachesize"; |
46 u_int64_t result = 0; | 47 u_int64_t result = 0; |
47 size_t typeSize = sizeof( result ); | 48 size_t typeSize = sizeof( result ); |
57 { | 58 { |
58 /* XXX: Just guess G4 */ | 59 /* XXX: Just guess G4 */ |
59 return 2097152; | 60 return 2097152; |
60 } | 61 } |
61 #endif /* MACOSX */ | 62 #endif /* MACOSX */ |
63 | |
64 #if ((defined MACOSX) && (__GNUC__ < 4)) | |
65 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \ | |
66 (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p ) | |
67 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \ | |
68 (vector unsigned short) ( a,b,c,d,e,f,g,h ) | |
69 #else | |
70 #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \ | |
71 (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p } | |
72 #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \ | |
73 (vector unsigned short) { a,b,c,d,e,f,g,h } | |
74 #endif | |
62 | 75 |
63 #define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F) | 76 #define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F) |
64 #define VSWIZZLE32(a,b,c,d) (vector unsigned char) \ | 77 #define VSWIZZLE32(a,b,c,d) (vector unsigned char) \ |
65 ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \ | 78 ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \ |
66 0x04+a, 0x04+b, 0x04+c, 0x04+d, \ | 79 0x04+a, 0x04+b, 0x04+c, 0x04+d, \ |
110 srcfmt = &default_pixel_format; | 123 srcfmt = &default_pixel_format; |
111 } | 124 } |
112 if (!dstfmt) { | 125 if (!dstfmt) { |
113 dstfmt = &default_pixel_format; | 126 dstfmt = &default_pixel_format; |
114 } | 127 } |
115 vector unsigned char plus = (vector unsigned char)( 0x00, 0x00, 0x00, 0x00, | 128 vector unsigned char plus = VECUINT8_LITERAL( |
129 0x00, 0x00, 0x00, 0x00, | |
116 0x04, 0x04, 0x04, 0x04, | 130 0x04, 0x04, 0x04, 0x04, |
117 0x08, 0x08, 0x08, 0x08, | 131 0x08, 0x08, 0x08, 0x08, |
118 0x0C, 0x0C, 0x0C, 0x0C ); | 132 0x0C, 0x0C, 0x0C, 0x0C ); |
119 vector unsigned char vswiz; | 133 vector unsigned char vswiz; |
120 vector unsigned int srcvec; | 134 vector unsigned int srcvec; |
128 amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift); | 142 amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift); |
129 } else { | 143 } else { |
130 amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF); | 144 amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF); |
131 } | 145 } |
132 #undef RESHIFT | 146 #undef RESHIFT |
133 ((unsigned int *)&srcvec)[0] = (rmask | gmask | bmask | amask); | 147 ((unsigned int *)(char*)&srcvec)[0] = (rmask | gmask | bmask | amask); |
134 vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0)); | 148 vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0)); |
135 return(vswiz); | 149 return(vswiz); |
136 } | 150 } |
137 | 151 |
138 static void Blit_RGB888_RGB565(SDL_BlitInfo *info); | 152 static void Blit_RGB888_RGB565(SDL_BlitInfo *info); |
143 Uint8 *dst = (Uint8 *) info->d_pixels; | 157 Uint8 *dst = (Uint8 *) info->d_pixels; |
144 int dstskip = info->d_skip; | 158 int dstskip = info->d_skip; |
145 SDL_PixelFormat *srcfmt = info->src; | 159 SDL_PixelFormat *srcfmt = info->src; |
146 vector unsigned char valpha = vec_splat_u8(0); | 160 vector unsigned char valpha = vec_splat_u8(0); |
147 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL); | 161 vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL); |
148 vector unsigned char vgmerge = (vector unsigned char)( | 162 vector unsigned char vgmerge = VECUINT8_LITERAL( |
149 0x00, 0x02, 0x00, 0x06, | 163 0x00, 0x02, 0x00, 0x06, |
150 0x00, 0x0a, 0x00, 0x0e, | 164 0x00, 0x0a, 0x00, 0x0e, |
151 0x00, 0x12, 0x00, 0x16, | 165 0x00, 0x12, 0x00, 0x16, |
152 0x00, 0x1a, 0x00, 0x1e); | 166 0x00, 0x1a, 0x00, 0x1e); |
153 vector unsigned short v1 = vec_splat_u16(1); | 167 vector unsigned short v1 = vec_splat_u16(1); |
154 vector unsigned short v3 = vec_splat_u16(3); | 168 vector unsigned short v3 = vec_splat_u16(3); |
155 vector unsigned short v3f = (vector unsigned short)( | 169 vector unsigned short v3f = VECUINT16_LITERAL( |
156 0x003f, 0x003f, 0x003f, 0x003f, | 170 0x003f, 0x003f, 0x003f, 0x003f, |
157 0x003f, 0x003f, 0x003f, 0x003f); | 171 0x003f, 0x003f, 0x003f, 0x003f); |
158 vector unsigned short vfc = (vector unsigned short)( | 172 vector unsigned short vfc = VECUINT16_LITERAL( |
159 0x00fc, 0x00fc, 0x00fc, 0x00fc, | 173 0x00fc, 0x00fc, 0x00fc, 0x00fc, |
160 0x00fc, 0x00fc, 0x00fc, 0x00fc); | 174 0x00fc, 0x00fc, 0x00fc, 0x00fc); |
161 vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7); | 175 vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7); |
162 vf800 = vec_sl(vf800, vec_splat_u16(8)); | 176 vf800 = vec_sl(vf800, vec_splat_u16(8)); |
163 | 177 |
170 int extrawidth; | 184 int extrawidth; |
171 | 185 |
172 /* do scalar until we can align... */ | 186 /* do scalar until we can align... */ |
173 #define ONE_PIXEL_BLEND(condition, widthvar) \ | 187 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
174 while (condition) { \ | 188 while (condition) { \ |
175 Uint32 pixel; \ | 189 Uint32 Pixel; \ |
176 unsigned sR, sG, sB, sA; \ | 190 unsigned sR, sG, sB, sA; \ |
177 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, pixel, \ | 191 DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \ |
178 sR, sG, sB, sA); \ | 192 sR, sG, sB, sA); \ |
179 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \ | 193 *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \ |
180 ((sG << 3) & 0x000007E0) | \ | 194 ((sG << 3) & 0x000007E0) | \ |
181 ((sB >> 3) & 0x0000001F)); \ | 195 ((sB >> 3) & 0x0000001F)); \ |
182 dst += 2; \ | 196 dst += 2; \ |
257 /* | 271 /* |
258 0x10 - 0x1f is the alpha | 272 0x10 - 0x1f is the alpha |
259 0x00 - 0x0e evens are the red | 273 0x00 - 0x0e evens are the red |
260 0x01 - 0x0f odds are zero | 274 0x01 - 0x0f odds are zero |
261 */ | 275 */ |
262 vector unsigned char vredalpha1 = (vector unsigned char)( | 276 vector unsigned char vredalpha1 = VECUINT8_LITERAL( |
263 0x10, 0x00, 0x01, 0x01, | 277 0x10, 0x00, 0x01, 0x01, |
264 0x10, 0x02, 0x01, 0x01, | 278 0x10, 0x02, 0x01, 0x01, |
265 0x10, 0x04, 0x01, 0x01, | 279 0x10, 0x04, 0x01, 0x01, |
266 0x10, 0x06, 0x01, 0x01 | 280 0x10, 0x06, 0x01, 0x01 |
267 ); | 281 ); |
268 vector unsigned char vredalpha2 = (vector unsigned char)( | 282 vector unsigned char vredalpha2 = (vector unsigned char) ( |
269 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16)) | 283 vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16)) |
270 ); | 284 ); |
271 /* | 285 /* |
272 0x00 - 0x0f is ARxx ARxx ARxx ARxx | 286 0x00 - 0x0f is ARxx ARxx ARxx ARxx |
273 0x11 - 0x0f odds are blue | 287 0x11 - 0x0f odds are blue |
274 */ | 288 */ |
275 vector unsigned char vblue1 = (vector unsigned char)( | 289 vector unsigned char vblue1 = VECUINT8_LITERAL( |
276 0x00, 0x01, 0x02, 0x11, | 290 0x00, 0x01, 0x02, 0x11, |
277 0x04, 0x05, 0x06, 0x13, | 291 0x04, 0x05, 0x06, 0x13, |
278 0x08, 0x09, 0x0a, 0x15, | 292 0x08, 0x09, 0x0a, 0x15, |
279 0x0c, 0x0d, 0x0e, 0x17 | 293 0x0c, 0x0d, 0x0e, 0x17 |
280 ); | 294 ); |
283 ); | 297 ); |
284 /* | 298 /* |
285 0x00 - 0x0f is ARxB ARxB ARxB ARxB | 299 0x00 - 0x0f is ARxB ARxB ARxB ARxB |
286 0x10 - 0x0e evens are green | 300 0x10 - 0x0e evens are green |
287 */ | 301 */ |
288 vector unsigned char vgreen1 = (vector unsigned char)( | 302 vector unsigned char vgreen1 = VECUINT8_LITERAL( |
289 0x00, 0x01, 0x10, 0x03, | 303 0x00, 0x01, 0x10, 0x03, |
290 0x04, 0x05, 0x12, 0x07, | 304 0x04, 0x05, 0x12, 0x07, |
291 0x08, 0x09, 0x14, 0x0b, | 305 0x08, 0x09, 0x14, 0x0b, |
292 0x0c, 0x0d, 0x16, 0x0f | 306 0x0c, 0x0d, 0x16, 0x0f |
293 ); | 307 ); |
321 | 335 |
322 /* do scalar until we can align... */ | 336 /* do scalar until we can align... */ |
323 #define ONE_PIXEL_BLEND(condition, widthvar) \ | 337 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
324 while (condition) { \ | 338 while (condition) { \ |
325 unsigned sR, sG, sB; \ | 339 unsigned sR, sG, sB; \ |
326 unsigned short pixel = *((unsigned short *)src); \ | 340 unsigned short Pixel = *((unsigned short *)src); \ |
327 sR = (pixel >> 8) & 0xf8; \ | 341 sR = (Pixel >> 8) & 0xf8; \ |
328 sG = (pixel >> 3) & 0xfc; \ | 342 sG = (Pixel >> 3) & 0xfc; \ |
329 sB = (pixel << 3) & 0xf8; \ | 343 sB = (Pixel << 3) & 0xf8; \ |
330 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ | 344 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ |
331 src += 2; \ | 345 src += 2; \ |
332 dst += 4; \ | 346 dst += 4; \ |
333 widthvar--; \ | 347 widthvar--; \ |
334 } | 348 } |
402 /* | 416 /* |
403 0x10 - 0x1f is the alpha | 417 0x10 - 0x1f is the alpha |
404 0x00 - 0x0e evens are the red | 418 0x00 - 0x0e evens are the red |
405 0x01 - 0x0f odds are zero | 419 0x01 - 0x0f odds are zero |
406 */ | 420 */ |
407 vector unsigned char vredalpha1 = (vector unsigned char)( | 421 vector unsigned char vredalpha1 = VECUINT8_LITERAL( |
408 0x10, 0x00, 0x01, 0x01, | 422 0x10, 0x00, 0x01, 0x01, |
409 0x10, 0x02, 0x01, 0x01, | 423 0x10, 0x02, 0x01, 0x01, |
410 0x10, 0x04, 0x01, 0x01, | 424 0x10, 0x04, 0x01, 0x01, |
411 0x10, 0x06, 0x01, 0x01 | 425 0x10, 0x06, 0x01, 0x01 |
412 ); | 426 ); |
415 ); | 429 ); |
416 /* | 430 /* |
417 0x00 - 0x0f is ARxx ARxx ARxx ARxx | 431 0x00 - 0x0f is ARxx ARxx ARxx ARxx |
418 0x11 - 0x0f odds are blue | 432 0x11 - 0x0f odds are blue |
419 */ | 433 */ |
420 vector unsigned char vblue1 = (vector unsigned char)( | 434 vector unsigned char vblue1 = VECUINT8_LITERAL( |
421 0x00, 0x01, 0x02, 0x11, | 435 0x00, 0x01, 0x02, 0x11, |
422 0x04, 0x05, 0x06, 0x13, | 436 0x04, 0x05, 0x06, 0x13, |
423 0x08, 0x09, 0x0a, 0x15, | 437 0x08, 0x09, 0x0a, 0x15, |
424 0x0c, 0x0d, 0x0e, 0x17 | 438 0x0c, 0x0d, 0x0e, 0x17 |
425 ); | 439 ); |
428 ); | 442 ); |
429 /* | 443 /* |
430 0x00 - 0x0f is ARxB ARxB ARxB ARxB | 444 0x00 - 0x0f is ARxB ARxB ARxB ARxB |
431 0x10 - 0x0e evens are green | 445 0x10 - 0x0e evens are green |
432 */ | 446 */ |
433 vector unsigned char vgreen1 = (vector unsigned char)( | 447 vector unsigned char vgreen1 = VECUINT8_LITERAL( |
434 0x00, 0x01, 0x10, 0x03, | 448 0x00, 0x01, 0x10, 0x03, |
435 0x04, 0x05, 0x12, 0x07, | 449 0x04, 0x05, 0x12, 0x07, |
436 0x08, 0x09, 0x14, 0x0b, | 450 0x08, 0x09, 0x14, 0x0b, |
437 0x0c, 0x0d, 0x16, 0x0f | 451 0x0c, 0x0d, 0x16, 0x0f |
438 ); | 452 ); |
466 | 480 |
467 /* do scalar until we can align... */ | 481 /* do scalar until we can align... */ |
468 #define ONE_PIXEL_BLEND(condition, widthvar) \ | 482 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
469 while (condition) { \ | 483 while (condition) { \ |
470 unsigned sR, sG, sB; \ | 484 unsigned sR, sG, sB; \ |
471 unsigned short pixel = *((unsigned short *)src); \ | 485 unsigned short Pixel = *((unsigned short *)src); \ |
472 sR = (pixel >> 7) & 0xf8; \ | 486 sR = (Pixel >> 7) & 0xf8; \ |
473 sG = (pixel >> 2) & 0xf8; \ | 487 sG = (Pixel >> 2) & 0xf8; \ |
474 sB = (pixel << 3) & 0xf8; \ | 488 sB = (Pixel << 3) & 0xf8; \ |
475 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ | 489 ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \ |
476 src += 2; \ | 490 src += 2; \ |
477 dst += 4; \ | 491 dst += 4; \ |
478 widthvar--; \ | 492 widthvar--; \ |
479 } | 493 } |
563 valpha = (vector unsigned int)vec_splat((vector unsigned char)valpha, 0); | 577 valpha = (vector unsigned int)vec_splat((vector unsigned char)valpha, 0); |
564 } else { | 578 } else { |
565 valpha = (vector unsigned int)vzero; | 579 valpha = (vector unsigned int)vzero; |
566 } | 580 } |
567 ckey &= rgbmask; | 581 ckey &= rgbmask; |
568 ((unsigned int *)&vckey)[0] = ckey; | 582 ((unsigned int *)(char*)&vckey)[0] = ckey; |
569 vckey = vec_splat(vckey, 0); | 583 vckey = vec_splat(vckey, 0); |
570 ((unsigned int *)&vrgbmask)[0] = rgbmask; | 584 ((unsigned int *)(char*)&vrgbmask)[0] = rgbmask; |
571 vrgbmask = vec_splat(vrgbmask, 0); | 585 vrgbmask = vec_splat(vrgbmask, 0); |
572 | 586 |
573 while (height--) { | 587 while (height--) { |
574 #define ONE_PIXEL_BLEND(condition, widthvar) \ | 588 #define ONE_PIXEL_BLEND(condition, widthvar) \ |
575 if (copy_alpha) { \ | 589 if (copy_alpha) { \ |
576 while (condition) { \ | 590 while (condition) { \ |
577 Uint32 pixel; \ | 591 Uint32 Pixel; \ |
578 unsigned sR, sG, sB, sA; \ | 592 unsigned sR, sG, sB, sA; \ |
579 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, pixel, \ | 593 DISEMBLE_RGBA((Uint8 *)srcp, srcbpp, srcfmt, Pixel, \ |
580 sR, sG, sB, sA); \ | 594 sR, sG, sB, sA); \ |
581 if ( (pixel & rgbmask) != ckey ) { \ | 595 if ( (Pixel & rgbmask) != ckey ) { \ |
582 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \ | 596 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \ |
583 sR, sG, sB, sA); \ | 597 sR, sG, sB, sA); \ |
584 } \ | 598 } \ |
585 ((Uint8 *)dstp) += dstbpp; \ | 599 dstp = (Uint32 *) (((Uint8 *) dstp) + dstbpp); \ |
586 ((Uint8 *)srcp) += srcbpp; \ | 600 srcp = (Uint32 *) (((Uint8 *) srcp) + srcbpp); \ |
587 widthvar--; \ | 601 widthvar--; \ |
588 } \ | 602 } \ |
589 } else { \ | 603 } else { \ |
590 while (condition) { \ | 604 while (condition) { \ |
591 Uint32 pixel; \ | 605 Uint32 Pixel; \ |
592 unsigned sR, sG, sB; \ | 606 unsigned sR, sG, sB; \ |
593 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, pixel); \ | 607 RETRIEVE_RGB_PIXEL((Uint8 *)srcp, srcbpp, Pixel); \ |
594 if ( pixel != ckey ) { \ | 608 if ( Pixel != ckey ) { \ |
595 RGB_FROM_PIXEL(pixel, srcfmt, sR, sG, sB); \ | 609 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); \ |
596 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \ | 610 ASSEMBLE_RGBA((Uint8 *)dstp, dstbpp, dstfmt, \ |
597 sR, sG, sB, alpha); \ | 611 sR, sG, sB, alpha); \ |
598 } \ | 612 } \ |
599 ((Uint8 *)dstp) += dstbpp; \ | 613 dstp = (Uint32 *) (((Uint8 *)dstp) + dstbpp); \ |
600 ((Uint8 *)srcp) += srcbpp; \ | 614 srcp = (Uint32 *) (((Uint8 *)srcp) + srcbpp); \ |
601 widthvar--; \ | 615 widthvar--; \ |
602 } \ | 616 } \ |
603 } | 617 } |
604 int width = info->d_width; | 618 int width = info->d_width; |
605 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width); | 619 ONE_PIXEL_BLEND((UNALIGNED_PTR(dstp)) && (width), width); |
817 /* Feature 1 is has-MMX */ | 831 /* Feature 1 is has-MMX */ |
818 | ((SDL_HasMMX()) ? 1 : 0) | 832 | ((SDL_HasMMX()) ? 1 : 0) |
819 /* Feature 2 is has-AltiVec */ | 833 /* Feature 2 is has-AltiVec */ |
820 | ((SDL_HasAltiVec()) ? 2 : 0) | 834 | ((SDL_HasAltiVec()) ? 2 : 0) |
821 /* Feature 4 is dont-use-prefetch */ | 835 /* Feature 4 is dont-use-prefetch */ |
836 /* !!!! FIXME: Check for G5 or later, not the cache size! Always prefetch on a G4. */ | |
822 | ((GetL3CacheSize() == 0) ? 4 : 0) | 837 | ((GetL3CacheSize() == 0) ? 4 : 0) |
823 ); | 838 ); |
824 } | 839 } |
825 } | 840 } |
826 return features; | 841 return features; |
909 #endif /* USE_DUFFS_LOOP */ | 924 #endif /* USE_DUFFS_LOOP */ |
910 src += srcskip; | 925 src += srcskip; |
911 dst += dstskip; | 926 dst += dstskip; |
912 } | 927 } |
913 } else { | 928 } else { |
914 int pixel; | 929 int Pixel; |
915 | 930 |
916 while ( height-- ) { | 931 while ( height-- ) { |
917 #ifdef USE_DUFFS_LOOP | 932 #ifdef USE_DUFFS_LOOP |
918 DUFFS_LOOP( | 933 DUFFS_LOOP( |
919 RGB888_RGB332(pixel, *src); | 934 RGB888_RGB332(Pixel, *src); |
920 *dst++ = map[pixel]; | 935 *dst++ = map[Pixel]; |
921 ++src; | 936 ++src; |
922 , width); | 937 , width); |
923 #else | 938 #else |
924 for ( c=width/4; c; --c ) { | 939 for ( c=width/4; c; --c ) { |
925 /* Pack RGB into 8bit pixel */ | 940 /* Pack RGB into 8bit pixel */ |
926 RGB888_RGB332(pixel, *src); | 941 RGB888_RGB332(Pixel, *src); |
927 *dst++ = map[pixel]; | 942 *dst++ = map[Pixel]; |
928 ++src; | 943 ++src; |
929 RGB888_RGB332(pixel, *src); | 944 RGB888_RGB332(Pixel, *src); |
930 *dst++ = map[pixel]; | 945 *dst++ = map[Pixel]; |
931 ++src; | 946 ++src; |
932 RGB888_RGB332(pixel, *src); | 947 RGB888_RGB332(Pixel, *src); |
933 *dst++ = map[pixel]; | 948 *dst++ = map[Pixel]; |
934 ++src; | 949 ++src; |
935 RGB888_RGB332(pixel, *src); | 950 RGB888_RGB332(Pixel, *src); |
936 *dst++ = map[pixel]; | 951 *dst++ = map[Pixel]; |
937 ++src; | 952 ++src; |
938 } | 953 } |
939 switch ( width & 3 ) { | 954 switch ( width & 3 ) { |
940 case 3: | 955 case 3: |
941 RGB888_RGB332(pixel, *src); | 956 RGB888_RGB332(Pixel, *src); |
942 *dst++ = map[pixel]; | 957 *dst++ = map[Pixel]; |
943 ++src; | 958 ++src; |
944 case 2: | 959 case 2: |
945 RGB888_RGB332(pixel, *src); | 960 RGB888_RGB332(Pixel, *src); |
946 *dst++ = map[pixel]; | 961 *dst++ = map[Pixel]; |
947 ++src; | 962 ++src; |
948 case 1: | 963 case 1: |
949 RGB888_RGB332(pixel, *src); | 964 RGB888_RGB332(Pixel, *src); |
950 *dst++ = map[pixel]; | 965 *dst++ = map[Pixel]; |
951 ++src; | 966 ++src; |
952 } | 967 } |
953 #endif /* USE_DUFFS_LOOP */ | 968 #endif /* USE_DUFFS_LOOP */ |
954 src += srcskip; | 969 src += srcskip; |
955 dst += dstskip; | 970 dst += dstskip; |
1818 static void Blit_RGB888_index8_map(SDL_BlitInfo *info) | 1833 static void Blit_RGB888_index8_map(SDL_BlitInfo *info) |
1819 { | 1834 { |
1820 #ifndef USE_DUFFS_LOOP | 1835 #ifndef USE_DUFFS_LOOP |
1821 int c; | 1836 int c; |
1822 #endif | 1837 #endif |
1823 int pixel; | 1838 int Pixel; |
1824 int width, height; | 1839 int width, height; |
1825 Uint32 *src; | 1840 Uint32 *src; |
1826 const Uint8 *map; | 1841 const Uint8 *map; |
1827 Uint8 *dst; | 1842 Uint8 *dst; |
1828 int srcskip, dstskip; | 1843 int srcskip, dstskip; |
1837 map = info->table; | 1852 map = info->table; |
1838 | 1853 |
1839 #ifdef USE_DUFFS_LOOP | 1854 #ifdef USE_DUFFS_LOOP |
1840 while ( height-- ) { | 1855 while ( height-- ) { |
1841 DUFFS_LOOP( | 1856 DUFFS_LOOP( |
1842 RGB888_RGB332(pixel, *src); | 1857 RGB888_RGB332(Pixel, *src); |
1843 *dst++ = map[pixel]; | 1858 *dst++ = map[Pixel]; |
1844 ++src; | 1859 ++src; |
1845 , width); | 1860 , width); |
1846 src += srcskip; | 1861 src += srcskip; |
1847 dst += dstskip; | 1862 dst += dstskip; |
1848 } | 1863 } |
1849 #else | 1864 #else |
1850 while ( height-- ) { | 1865 while ( height-- ) { |
1851 for ( c=width/4; c; --c ) { | 1866 for ( c=width/4; c; --c ) { |
1852 /* Pack RGB into 8bit pixel */ | 1867 /* Pack RGB into 8bit pixel */ |
1853 RGB888_RGB332(pixel, *src); | 1868 RGB888_RGB332(Pixel, *src); |
1854 *dst++ = map[pixel]; | 1869 *dst++ = map[Pixel]; |
1855 ++src; | 1870 ++src; |
1856 RGB888_RGB332(pixel, *src); | 1871 RGB888_RGB332(Pixel, *src); |
1857 *dst++ = map[pixel]; | 1872 *dst++ = map[Pixel]; |
1858 ++src; | 1873 ++src; |
1859 RGB888_RGB332(pixel, *src); | 1874 RGB888_RGB332(Pixel, *src); |
1860 *dst++ = map[pixel]; | 1875 *dst++ = map[Pixel]; |
1861 ++src; | 1876 ++src; |
1862 RGB888_RGB332(pixel, *src); | 1877 RGB888_RGB332(Pixel, *src); |
1863 *dst++ = map[pixel]; | 1878 *dst++ = map[Pixel]; |
1864 ++src; | 1879 ++src; |
1865 } | 1880 } |
1866 switch ( width & 3 ) { | 1881 switch ( width & 3 ) { |
1867 case 3: | 1882 case 3: |
1868 RGB888_RGB332(pixel, *src); | 1883 RGB888_RGB332(Pixel, *src); |
1869 *dst++ = map[pixel]; | 1884 *dst++ = map[Pixel]; |
1870 ++src; | 1885 ++src; |
1871 case 2: | 1886 case 2: |
1872 RGB888_RGB332(pixel, *src); | 1887 RGB888_RGB332(Pixel, *src); |
1873 *dst++ = map[pixel]; | 1888 *dst++ = map[Pixel]; |
1874 ++src; | 1889 ++src; |
1875 case 1: | 1890 case 1: |
1876 RGB888_RGB332(pixel, *src); | 1891 RGB888_RGB332(Pixel, *src); |
1877 *dst++ = map[pixel]; | 1892 *dst++ = map[Pixel]; |
1878 ++src; | 1893 ++src; |
1879 } | 1894 } |
1880 src += srcskip; | 1895 src += srcskip; |
1881 dst += dstskip; | 1896 dst += dstskip; |
1882 } | 1897 } |
1891 Uint8 *src; | 1906 Uint8 *src; |
1892 const Uint8 *map; | 1907 const Uint8 *map; |
1893 Uint8 *dst; | 1908 Uint8 *dst; |
1894 int srcskip, dstskip; | 1909 int srcskip, dstskip; |
1895 int srcbpp; | 1910 int srcbpp; |
1896 Uint32 pixel; | 1911 Uint32 Pixel; |
1897 int sR, sG, sB; | 1912 int sR, sG, sB; |
1898 SDL_PixelFormat *srcfmt; | 1913 SDL_PixelFormat *srcfmt; |
1899 | 1914 |
1900 /* Set up some basic variables */ | 1915 /* Set up some basic variables */ |
1901 width = info->d_width; | 1916 width = info->d_width; |
1910 | 1925 |
1911 if ( map == NULL ) { | 1926 if ( map == NULL ) { |
1912 while ( height-- ) { | 1927 while ( height-- ) { |
1913 #ifdef USE_DUFFS_LOOP | 1928 #ifdef USE_DUFFS_LOOP |
1914 DUFFS_LOOP( | 1929 DUFFS_LOOP( |
1915 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, | 1930 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
1916 sR, sG, sB); | 1931 sR, sG, sB); |
1917 if ( 1 ) { | 1932 if ( 1 ) { |
1918 /* Pack RGB into 8bit pixel */ | 1933 /* Pack RGB into 8bit pixel */ |
1919 *dst = ((sR>>5)<<(3+2))| | 1934 *dst = ((sR>>5)<<(3+2))| |
1920 ((sG>>5)<<(2)) | | 1935 ((sG>>5)<<(2)) | |
1923 dst++; | 1938 dst++; |
1924 src += srcbpp; | 1939 src += srcbpp; |
1925 , width); | 1940 , width); |
1926 #else | 1941 #else |
1927 for ( c=width; c; --c ) { | 1942 for ( c=width; c; --c ) { |
1928 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, | 1943 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
1929 sR, sG, sB); | 1944 sR, sG, sB); |
1930 if ( 1 ) { | 1945 if ( 1 ) { |
1931 /* Pack RGB into 8bit pixel */ | 1946 /* Pack RGB into 8bit pixel */ |
1932 *dst = ((sR>>5)<<(3+2))| | 1947 *dst = ((sR>>5)<<(3+2))| |
1933 ((sG>>5)<<(2)) | | 1948 ((sG>>5)<<(2)) | |
1942 } | 1957 } |
1943 } else { | 1958 } else { |
1944 while ( height-- ) { | 1959 while ( height-- ) { |
1945 #ifdef USE_DUFFS_LOOP | 1960 #ifdef USE_DUFFS_LOOP |
1946 DUFFS_LOOP( | 1961 DUFFS_LOOP( |
1947 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, | 1962 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
1948 sR, sG, sB); | 1963 sR, sG, sB); |
1949 if ( 1 ) { | 1964 if ( 1 ) { |
1950 /* Pack RGB into 8bit pixel */ | 1965 /* Pack RGB into 8bit pixel */ |
1951 *dst = map[((sR>>5)<<(3+2))| | 1966 *dst = map[((sR>>5)<<(3+2))| |
1952 ((sG>>5)<<(2)) | | 1967 ((sG>>5)<<(2)) | |
1955 dst++; | 1970 dst++; |
1956 src += srcbpp; | 1971 src += srcbpp; |
1957 , width); | 1972 , width); |
1958 #else | 1973 #else |
1959 for ( c=width; c; --c ) { | 1974 for ( c=width; c; --c ) { |
1960 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, | 1975 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
1961 sR, sG, sB); | 1976 sR, sG, sB); |
1962 if ( 1 ) { | 1977 if ( 1 ) { |
1963 /* Pack RGB into 8bit pixel */ | 1978 /* Pack RGB into 8bit pixel */ |
1964 *dst = map[((sR>>5)<<(3+2))| | 1979 *dst = map[((sR>>5)<<(3+2))| |
1965 ((sG>>5)<<(2)) | | 1980 ((sG>>5)<<(2)) | |
1989 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; | 2004 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; |
1990 | 2005 |
1991 while ( height-- ) { | 2006 while ( height-- ) { |
1992 DUFFS_LOOP( | 2007 DUFFS_LOOP( |
1993 { | 2008 { |
1994 Uint32 pixel; | 2009 Uint32 Pixel; |
1995 unsigned sR; | 2010 unsigned sR; |
1996 unsigned sG; | 2011 unsigned sG; |
1997 unsigned sB; | 2012 unsigned sB; |
1998 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, sR, sG, sB); | 2013 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB); |
1999 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha); | 2014 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, sR, sG, sB, alpha); |
2000 dst += dstbpp; | 2015 dst += dstbpp; |
2001 src += srcbpp; | 2016 src += srcbpp; |
2002 }, | 2017 }, |
2003 width); | 2018 width); |
2021 int c; | 2036 int c; |
2022 | 2037 |
2023 /* FIXME: should map alpha to [0..255] correctly! */ | 2038 /* FIXME: should map alpha to [0..255] correctly! */ |
2024 while ( height-- ) { | 2039 while ( height-- ) { |
2025 for ( c=width; c; --c ) { | 2040 for ( c=width; c; --c ) { |
2026 Uint32 pixel; | 2041 Uint32 Pixel; |
2027 unsigned sR, sG, sB, sA; | 2042 unsigned sR, sG, sB, sA; |
2028 DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel, | 2043 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, |
2029 sR, sG, sB, sA); | 2044 sR, sG, sB, sA); |
2030 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, | 2045 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, |
2031 sR, sG, sB, sA); | 2046 sR, sG, sB, sA); |
2032 dst += dstbpp; | 2047 dst += dstbpp; |
2033 src += srcbpp; | 2048 src += srcbpp; |
2048 SDL_PixelFormat *srcfmt = info->src; | 2063 SDL_PixelFormat *srcfmt = info->src; |
2049 const Uint8 *palmap = info->table; | 2064 const Uint8 *palmap = info->table; |
2050 Uint32 ckey = srcfmt->colorkey; | 2065 Uint32 ckey = srcfmt->colorkey; |
2051 Uint32 rgbmask = ~srcfmt->Amask; | 2066 Uint32 rgbmask = ~srcfmt->Amask; |
2052 int srcbpp; | 2067 int srcbpp; |
2053 Uint32 pixel; | 2068 Uint32 Pixel; |
2054 Uint8 sR, sG, sB; | 2069 Uint8 sR, sG, sB; |
2055 | 2070 |
2056 /* Set up some basic variables */ | 2071 /* Set up some basic variables */ |
2057 srcbpp = srcfmt->BytesPerPixel; | 2072 srcbpp = srcfmt->BytesPerPixel; |
2058 ckey &= rgbmask; | 2073 ckey &= rgbmask; |
2059 | 2074 |
2060 if ( palmap == NULL ) { | 2075 if ( palmap == NULL ) { |
2061 while ( height-- ) { | 2076 while ( height-- ) { |
2062 DUFFS_LOOP( | 2077 DUFFS_LOOP( |
2063 { | 2078 { |
2064 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, | 2079 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
2065 sR, sG, sB); | 2080 sR, sG, sB); |
2066 if ( (pixel & rgbmask) != ckey ) { | 2081 if ( (Pixel & rgbmask) != ckey ) { |
2067 /* Pack RGB into 8bit pixel */ | 2082 /* Pack RGB into 8bit pixel */ |
2068 *dst = ((sR>>5)<<(3+2))| | 2083 *dst = ((sR>>5)<<(3+2))| |
2069 ((sG>>5)<<(2)) | | 2084 ((sG>>5)<<(2)) | |
2070 ((sB>>6)<<(0)) ; | 2085 ((sB>>6)<<(0)) ; |
2071 } | 2086 } |
2078 } | 2093 } |
2079 } else { | 2094 } else { |
2080 while ( height-- ) { | 2095 while ( height-- ) { |
2081 DUFFS_LOOP( | 2096 DUFFS_LOOP( |
2082 { | 2097 { |
2083 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, | 2098 DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, |
2084 sR, sG, sB); | 2099 sR, sG, sB); |
2085 if ( (pixel & rgbmask) != ckey ) { | 2100 if ( (Pixel & rgbmask) != ckey ) { |
2086 /* Pack RGB into 8bit pixel */ | 2101 /* Pack RGB into 8bit pixel */ |
2087 *dst = palmap[((sR>>5)<<(3+2))| | 2102 *dst = palmap[((sR>>5)<<(3+2))| |
2088 ((sG>>5)<<(2)) | | 2103 ((sG>>5)<<(2)) | |
2089 ((sB>>6)<<(0)) ]; | 2104 ((sB>>6)<<(0)) ]; |
2090 } | 2105 } |
2145 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; | 2160 unsigned alpha = dstfmt->Amask ? srcfmt->alpha : 0; |
2146 | 2161 |
2147 while ( height-- ) { | 2162 while ( height-- ) { |
2148 DUFFS_LOOP( | 2163 DUFFS_LOOP( |
2149 { | 2164 { |
2150 Uint32 pixel; | 2165 Uint32 Pixel; |
2151 unsigned sR; | 2166 unsigned sR; |
2152 unsigned sG; | 2167 unsigned sG; |
2153 unsigned sB; | 2168 unsigned sB; |
2154 RETRIEVE_RGB_PIXEL(src, srcbpp, pixel); | 2169 RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel); |
2155 if ( pixel != ckey ) { | 2170 if ( Pixel != ckey ) { |
2156 RGB_FROM_PIXEL(pixel, srcfmt, sR, sG, sB); | 2171 RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB); |
2157 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, | 2172 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, |
2158 sR, sG, sB, alpha); | 2173 sR, sG, sB, alpha); |
2159 } | 2174 } |
2160 dst += dstbpp; | 2175 dst += dstbpp; |
2161 src += srcbpp; | 2176 src += srcbpp; |
2179 SDL_PixelFormat *dstfmt = info->dst; | 2194 SDL_PixelFormat *dstfmt = info->dst; |
2180 Uint32 rgbmask = ~srcfmt->Amask; | 2195 Uint32 rgbmask = ~srcfmt->Amask; |
2181 | 2196 |
2182 Uint8 srcbpp; | 2197 Uint8 srcbpp; |
2183 Uint8 dstbpp; | 2198 Uint8 dstbpp; |
2184 Uint32 pixel; | 2199 Uint32 Pixel; |
2185 Uint8 sR, sG, sB, sA; | 2200 Uint8 sR, sG, sB, sA; |
2186 | 2201 |
2187 /* Set up some basic variables */ | 2202 /* Set up some basic variables */ |
2188 srcbpp = srcfmt->BytesPerPixel; | 2203 srcbpp = srcfmt->BytesPerPixel; |
2189 dstbpp = dstfmt->BytesPerPixel; | 2204 dstbpp = dstfmt->BytesPerPixel; |
2191 | 2206 |
2192 /* FIXME: should map alpha to [0..255] correctly! */ | 2207 /* FIXME: should map alpha to [0..255] correctly! */ |
2193 while ( height-- ) { | 2208 while ( height-- ) { |
2194 DUFFS_LOOP( | 2209 DUFFS_LOOP( |
2195 { | 2210 { |
2196 DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel, | 2211 DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, |
2197 sR, sG, sB, sA); | 2212 sR, sG, sB, sA); |
2198 if ( (pixel & rgbmask) != ckey ) { | 2213 if ( (Pixel & rgbmask) != ckey ) { |
2199 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, | 2214 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, |
2200 sR, sG, sB, sA); | 2215 sR, sG, sB, sA); |
2201 } | 2216 } |
2202 dst += dstbpp; | 2217 dst += dstbpp; |
2203 src += srcbpp; | 2218 src += srcbpp; |