1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2006 Sam Lantinga 4 5 This library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public 7 License as published by the Free Software Foundation; either 8 version 2.1 of the License, or (at your option) any later version. 9 10 This library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with this library; if not, write to the Free Software 17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 18 19 Sam Lantinga 20 slouken (at) libsdl.org 21 */ 22 #include "SDL_config.h" 23 24 #ifndef _SDL_blit_h 25 #define _SDL_blit_h 26 27 #include "SDL_endian.h" 28 29 /* The structure passed to the low level blit functions */ 30 typedef struct { 31 Uint8 *s_pixels; 32 int s_width; 33 int s_height; 34 int s_skip; 35 Uint8 *d_pixels; 36 int d_width; 37 int d_height; 38 int d_skip; 39 void *aux_data; 40 SDL_PixelFormat *src; 41 Uint8 *table; 42 SDL_PixelFormat *dst; 43 } SDL_BlitInfo; 44 45 /* The type definition for the low level blit functions */ 46 typedef void (*SDL_loblit)(SDL_BlitInfo *info); 47 48 /* This is the private info structure for software accelerated blits */ 49 struct private_swaccel { 50 SDL_loblit blit; 51 void *aux_data; 52 }; 53 54 /* Blit mapping definition */ 55 typedef struct SDL_BlitMap { 56 SDL_Surface *dst; 57 int identity; 58 Uint8 *table; 59 SDL_blit hw_blit; 60 SDL_blit sw_blit; 61 struct private_hwaccel *hw_data; 62 struct private_swaccel *sw_data; 63 64 /* the version count matches the destination; mismatch indicates 65 an invalid mapping */ 66 unsigned int format_version; 67 } SDL_BlitMap; 68 69 70 /* Functions found in SDL_blit.c */ 71 extern int SDL_CalculateBlit(SDL_Surface *surface); 72 73 /* Functions found in SDL_blit_{0,1,N,A}.c */ 74 extern SDL_loblit SDL_CalculateBlit0(SDL_Surface *surface, int complex); 75 extern SDL_loblit SDL_CalculateBlit1(SDL_Surface *surface, int complex); 76 extern SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int complex); 77 extern SDL_loblit SDL_CalculateAlphaBlit(SDL_Surface *surface, int complex); 78 79 /* 80 * Useful macros for blitting routines 81 */ 82 83 #define FORMAT_EQUAL(A, B) \ 84 ((A)->BitsPerPixel == (B)->BitsPerPixel \ 85 && ((A)->Rmask == (B)->Rmask) && ((A)->Amask == (B)->Amask)) 86 87 /* Load pixel of the specified format from a buffer and get its R-G-B values */ 88 /* FIXME: rescale values to 0..255 here? */ 89 #define RGB_FROM_PIXEL(Pixel, fmt, r, g, b) \ 90 { \ 91 r = (((Pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss); \ 92 g = (((Pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss); \ 93 b = (((Pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss); \ 94 } 95 #define RGB_FROM_RGB565(Pixel, r, g, b) \ 96 { \ 97 r = (((Pixel&0xF800)>>11)<<3); \ 98 g = (((Pixel&0x07E0)>>5)<<2); \ 99 b = ((Pixel&0x001F)<<3); \ 100 } 101 #define RGB_FROM_RGB555(Pixel, r, g, b) \ 102 { \ 103 r = (((Pixel&0x7C00)>>10)<<3); \ 104 g = (((Pixel&0x03E0)>>5)<<3); \ 105 b = ((Pixel&0x001F)<<3); \ 106 } 107 #define RGB_FROM_RGB888(Pixel, r, g, b) \ 108 { \ 109 r = ((Pixel&0xFF0000)>>16); \ 110 g = ((Pixel&0xFF00)>>8); \ 111 b = (Pixel&0xFF); \ 112 } 113 #define RETRIEVE_RGB_PIXEL(buf, bpp, Pixel) \ 114 do { \ 115 switch (bpp) { \ 116 case 2: \ 117 Pixel = *((Uint16 *)(buf)); \ 118 break; \ 119 \ 120 case 3: { \ 121 Uint8 *B = (Uint8 *)(buf); \ 122 if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ 123 Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \ 124 } else { \ 125 Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \ 126 } \ 127 } \ 128 break; \ 129 \ 130 case 4: \ 131 Pixel = *((Uint32 *)(buf)); \ 132 break; \ 133 \ 134 default: \ 135 Pixel = 0; /* appease gcc */ \ 136 break; \ 137 } \ 138 } while(0) 139 140 #define DISEMBLE_RGB(buf, bpp, fmt, Pixel, r, g, b) \ 141 do { \ 142 switch (bpp) { \ 143 case 2: \ 144 Pixel = *((Uint16 *)(buf)); \ 145 break; \ 146 \ 147 case 3: { \ 148 Uint8 *B = (Uint8 *)buf; \ 149 if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ 150 Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \ 151 } else { \ 152 Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \ 153 } \ 154 } \ 155 break; \ 156 \ 157 case 4: \ 158 Pixel = *((Uint32 *)(buf)); \ 159 break; \ 160 \ 161 default: \ 162 Pixel = 0; /* prevent gcc from complaining */ \ 163 break; \ 164 } \ 165 RGB_FROM_PIXEL(Pixel, fmt, r, g, b); \ 166 } while(0) 167 168 /* Assemble R-G-B values into a specified pixel format and store them */ 169 #ifdef __NDS__ // FIXME 170 #define PIXEL_FROM_RGB(Pixel, fmt, r, g, b) \ 171 { \ 172 Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ 173 ((g>>fmt->Gloss)<<fmt->Gshift)| \ 174 ((b>>fmt->Bloss)<<fmt->Bshift) | (1<<15); \ 175 } 176 #else 177 #define PIXEL_FROM_RGB(Pixel, fmt, r, g, b) \ 178 { \ 179 Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ 180 ((g>>fmt->Gloss)<<fmt->Gshift)| \ 181 ((b>>fmt->Bloss)<<fmt->Bshift); \ 182 } 183 #endif // __NDS__ FIXME 184 #define RGB565_FROM_RGB(Pixel, r, g, b) \ 185 { \ 186 Pixel = ((r>>3)<<11)|((g>>2)<<5)|(b>>3); \ 187 } 188 #define RGB555_FROM_RGB(Pixel, r, g, b) \ 189 { \ 190 Pixel = ((r>>3)<<10)|((g>>3)<<5)|(b>>3); \ 191 } 192 #define RGB888_FROM_RGB(Pixel, r, g, b) \ 193 { \ 194 Pixel = (r<<16)|(g<<8)|b; \ 195 } 196 #define ASSEMBLE_RGB(buf, bpp, fmt, r, g, b) \ 197 { \ 198 switch (bpp) { \ 199 case 2: { \ 200 Uint16 Pixel; \ 201 \ 202 PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ 203 *((Uint16 *)(buf)) = Pixel; \ 204 } \ 205 break; \ 206 \ 207 case 3: { \ 208 if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ 209 *((buf)+fmt->Rshift/8) = r; \ 210 *((buf)+fmt->Gshift/8) = g; \ 211 *((buf)+fmt->Bshift/8) = b; \ 212 } else { \ 213 *((buf)+2-fmt->Rshift/8) = r; \ 214 *((buf)+2-fmt->Gshift/8) = g; \ 215 *((buf)+2-fmt->Bshift/8) = b; \ 216 } \ 217 } \ 218 break; \ 219 \ 220 case 4: { \ 221 Uint32 Pixel; \ 222 \ 223 PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ 224 *((Uint32 *)(buf)) = Pixel; \ 225 } \ 226 break; \ 227 } \ 228 } 229 #define ASSEMBLE_RGB_AMASK(buf, bpp, fmt, r, g, b, Amask) \ 230 { \ 231 switch (bpp) { \ 232 case 2: { \ 233 Uint16 *bufp; \ 234 Uint16 Pixel; \ 235 \ 236 bufp = (Uint16 *)buf; \ 237 PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ 238 *bufp = Pixel | (*bufp & Amask); \ 239 } \ 240 break; \ 241 \ 242 case 3: { \ 243 if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ 244 *((buf)+fmt->Rshift/8) = r; \ 245 *((buf)+fmt->Gshift/8) = g; \ 246 *((buf)+fmt->Bshift/8) = b; \ 247 } else { \ 248 *((buf)+2-fmt->Rshift/8) = r; \ 249 *((buf)+2-fmt->Gshift/8) = g; \ 250 *((buf)+2-fmt->Bshift/8) = b; \ 251 } \ 252 } \ 253 break; \ 254 \ 255 case 4: { \ 256 Uint32 *bufp; \ 257 Uint32 Pixel; \ 258 \ 259 bufp = (Uint32 *)buf; \ 260 PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \ 261 *bufp = Pixel | (*bufp & Amask); \ 262 } \ 263 break; \ 264 } \ 265 } 266 267 /* FIXME: Should we rescale alpha into 0..255 here? */ 268 #define RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a) \ 269 { \ 270 r = ((Pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss; \ 271 g = ((Pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss; \ 272 b = ((Pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss; \ 273 a = ((Pixel&fmt->Amask)>>fmt->Ashift)<<fmt->Aloss; \ 274 } 275 #define RGBA_FROM_8888(Pixel, fmt, r, g, b, a) \ 276 { \ 277 r = (Pixel&fmt->Rmask)>>fmt->Rshift; \ 278 g = (Pixel&fmt->Gmask)>>fmt->Gshift; \ 279 b = (Pixel&fmt->Bmask)>>fmt->Bshift; \ 280 a = (Pixel&fmt->Amask)>>fmt->Ashift; \ 281 } 282 #define RGBA_FROM_RGBA8888(Pixel, r, g, b, a) \ 283 { \ 284 r = (Pixel>>24); \ 285 g = ((Pixel>>16)&0xFF); \ 286 b = ((Pixel>>8)&0xFF); \ 287 a = (Pixel&0xFF); \ 288 } 289 #define RGBA_FROM_ARGB8888(Pixel, r, g, b, a) \ 290 { \ 291 r = ((Pixel>>16)&0xFF); \ 292 g = ((Pixel>>8)&0xFF); \ 293 b = (Pixel&0xFF); \ 294 a = (Pixel>>24); \ 295 } 296 #define RGBA_FROM_ABGR8888(Pixel, r, g, b, a) \ 297 { \ 298 r = (Pixel&0xFF); \ 299 g = ((Pixel>>8)&0xFF); \ 300 b = ((Pixel>>16)&0xFF); \ 301 a = (Pixel>>24); \ 302 } 303 #define DISEMBLE_RGBA(buf, bpp, fmt, Pixel, r, g, b, a) \ 304 do { \ 305 switch (bpp) { \ 306 case 2: \ 307 Pixel = *((Uint16 *)(buf)); \ 308 break; \ 309 \ 310 case 3: {/* FIXME: broken code (no alpha) */ \ 311 Uint8 *b = (Uint8 *)buf; \ 312 if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ 313 Pixel = b[0] + (b[1] << 8) + (b[2] << 16); \ 314 } else { \ 315 Pixel = (b[0] << 16) + (b[1] << 8) + b[2]; \ 316 } \ 317 } \ 318 break; \ 319 \ 320 case 4: \ 321 Pixel = *((Uint32 *)(buf)); \ 322 break; \ 323 \ 324 default: \ 325 Pixel = 0; /* stop gcc complaints */ \ 326 break; \ 327 } \ 328 RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a); \ 329 Pixel &= ~fmt->Amask; \ 330 } while(0) 331 332 /* FIXME: this isn't correct, especially for Alpha (maximum != 255) */ 333 #ifdef __NDS__ // FIXME 334 #define PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a) \ 335 { \ 336 Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ 337 ((g>>fmt->Gloss)<<fmt->Gshift)| \ 338 ((b>>fmt->Bloss)<<fmt->Bshift)| \ 339 ((a>>fmt->Aloss)<<fmt->Ashift) | (1<<15); \ 340 } 341 #else 342 #define PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a) \ 343 { \ 344 Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \ 345 ((g>>fmt->Gloss)<<fmt->Gshift)| \ 346 ((b>>fmt->Bloss)<<fmt->Bshift)| \ 347 ((a>>fmt->Aloss)<<fmt->Ashift); \ 348 } 349 #endif // __NDS__ FIXME 350 #define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a) \ 351 { \ 352 switch (bpp) { \ 353 case 2: { \ 354 Uint16 Pixel; \ 355 \ 356 PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a); \ 357 *((Uint16 *)(buf)) = Pixel; \ 358 } \ 359 break; \ 360 \ 361 case 3: { /* FIXME: broken code (no alpha) */ \ 362 if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \ 363 *((buf)+fmt->Rshift/8) = r; \ 364 *((buf)+fmt->Gshift/8) = g; \ 365 *((buf)+fmt->Bshift/8) = b; \ 366 } else { \ 367 *((buf)+2-fmt->Rshift/8) = r; \ 368 *((buf)+2-fmt->Gshift/8) = g; \ 369 *((buf)+2-fmt->Bshift/8) = b; \ 370 } \ 371 } \ 372 break; \ 373 \ 374 case 4: { \ 375 Uint32 Pixel; \ 376 \ 377 PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a); \ 378 *((Uint32 *)(buf)) = Pixel; \ 379 } \ 380 break; \ 381 } \ 382 } 383 384 /* Blend the RGB values of two Pixels based on a source alpha value */ 385 #define ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB) \ 386 do { \ 387 dR = (((sR-dR)*(A))>>8)+dR; \ 388 dG = (((sG-dG)*(A))>>8)+dG; \ 389 dB = (((sB-dB)*(A))>>8)+dB; \ 390 } while(0) 391 392 /* Blend the RGB values of two Pixels based on a source alpha value */ 393 #define ACCURATE_ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB) \ 394 do { \ 395 unsigned tR, tG, tB, tA; \ 396 tA = 255 - sA; \ 397 tR = 1 + (sR * sA) + (dR * tA); \ 398 dR = (tR + (tR >> 8)) >> 8; \ 399 tG = 1 + (sG * sA) + (dG * tA); \ 400 dG = (tG + (tG >> 8)) >> 8; \ 401 tB = 1 + (sB * sA) + (dB * tA); \ 402 dB = (tB + (tB >> 8)) >> 8; \ 403 } while(0) 404 405 406 /* This is a very useful loop for optimizing blitters */ 407 #if defined(_MSC_VER) && (_MSC_VER == 1300) 408 /* There's a bug in the Visual C++ 7 optimizer when compiling this code */ 409 #else 410 #define USE_DUFFS_LOOP 411 #endif 412 #ifdef USE_DUFFS_LOOP 413 414 /* 8-times unrolled loop */ 415 #define DUFFS_LOOP8(pixel_copy_increment, width) \ 416 { int n = (width+7)/8; \ 417 switch (width & 7) { \ 418 case 0: do { pixel_copy_increment; \ 419 case 7: pixel_copy_increment; \ 420 case 6: pixel_copy_increment; \ 421 case 5: pixel_copy_increment; \ 422 case 4: pixel_copy_increment; \ 423 case 3: pixel_copy_increment; \ 424 case 2: pixel_copy_increment; \ 425 case 1: pixel_copy_increment; \ 426 } while ( --n > 0 ); \ 427 } \ 428 } 429 430 /* 4-times unrolled loop */ 431 #define DUFFS_LOOP4(pixel_copy_increment, width) \ 432 { int n = (width+3)/4; \ 433 switch (width & 3) { \ 434 case 0: do { pixel_copy_increment; \ 435 case 3: pixel_copy_increment; \ 436 case 2: pixel_copy_increment; \ 437 case 1: pixel_copy_increment; \ 438 } while ( --n > 0 ); \ 439 } \ 440 } 441 442 /* 2 - times unrolled loop */ 443 #define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \ 444 double_pixel_copy_increment, width) \ 445 { int n, w = width; \ 446 if( w & 1 ) { \ 447 pixel_copy_increment; \ 448 w--; \ 449 } \ 450 if ( w > 0 ) { \ 451 n = ( w + 2) / 4; \ 452 switch( w & 2 ) { \ 453 case 0: do { double_pixel_copy_increment; \ 454 case 2: double_pixel_copy_increment; \ 455 } while ( --n > 0 ); \ 456 } \ 457 } \ 458 } 459 460 /* 2 - times unrolled loop 4 pixels */ 461 #define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \ 462 double_pixel_copy_increment, \ 463 quatro_pixel_copy_increment, width) \ 464 { int n, w = width; \ 465 if(w & 1) { \ 466 pixel_copy_increment; \ 467 w--; \ 468 } \ 469 if(w & 2) { \ 470 double_pixel_copy_increment; \ 471 w -= 2; \ 472 } \ 473 if ( w > 0 ) { \ 474 n = ( w + 7 ) / 8; \ 475 switch( w & 4 ) { \ 476 case 0: do { quatro_pixel_copy_increment; \ 477 case 4: quatro_pixel_copy_increment; \ 478 } while ( --n > 0 ); \ 479 } \ 480 } \ 481 } 482 483 /* Use the 8-times version of the loop by default */ 484 #define DUFFS_LOOP(pixel_copy_increment, width) \ 485 DUFFS_LOOP8(pixel_copy_increment, width) 486 487 #else 488 489 /* Don't use Duff's device to unroll loops */ 490 #define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \ 491 double_pixel_copy_increment, width) \ 492 { int n = width; \ 493 if( n & 1 ) { \ 494 pixel_copy_increment; \ 495 n--; \ 496 } \ 497 n=n>>1; \ 498 for(; n > 0; --n) { \ 499 double_pixel_copy_increment; \ 500 } \ 501 } 502 503 /* Don't use Duff's device to unroll loops */ 504 #define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \ 505 double_pixel_copy_increment, \ 506 quatro_pixel_copy_increment, width) \ 507 { int n = width; \ 508 if(n & 1) { \ 509 pixel_copy_increment; \ 510 n--; \ 511 } \ 512 if(n & 2) { \ 513 double_pixel_copy_increment; \ 514 n -= 2; \ 515 } \ 516 n=n>>2; \ 517 for(; n > 0; --n) { \ 518 quatro_pixel_copy_increment; \ 519 } \ 520 } 521 522 /* Don't use Duff's device to unroll loops */ 523 #define DUFFS_LOOP(pixel_copy_increment, width) \ 524 { int n; \ 525 for ( n=width; n > 0; --n ) { \ 526 pixel_copy_increment; \ 527 } \ 528 } 529 #define DUFFS_LOOP8(pixel_copy_increment, width) \ 530 DUFFS_LOOP(pixel_copy_increment, width) 531 #define DUFFS_LOOP4(pixel_copy_increment, width) \ 532 DUFFS_LOOP(pixel_copy_increment, width) 533 534 #endif /* USE_DUFFS_LOOP */ 535 536 /* Prevent Visual C++ 6.0 from printing out stupid warnings */ 537 #if defined(_MSC_VER) && (_MSC_VER >= 600) 538 #pragma warning(disable: 4550) 539 #endif 540 541 #endif /* _SDL_blit_h */ 542
