1 /* 2 SDL - Simple DirectMedia Layer 3 Copyright (C) 1997-2012 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)+255)>>8)+dR; \ 388 dG = (((sG-dG)*(A)+255)>>8)+dG; \ 389 dB = (((sB-dB)*(A)+255)>>8)+dB; \ 390 } while(0) 391 392 393 /* This is a very useful loop for optimizing blitters */ 394 #if defined(_MSC_VER) && (_MSC_VER == 1300) 395 /* There's a bug in the Visual C++ 7 optimizer when compiling this code */ 396 #else 397 #define USE_DUFFS_LOOP 398 #endif 399 #ifdef USE_DUFFS_LOOP 400 401 /* 8-times unrolled loop */ 402 #define DUFFS_LOOP8(pixel_copy_increment, width) \ 403 { int n = (width+7)/8; \ 404 switch (width & 7) { \ 405 case 0: do { pixel_copy_increment; \ 406 case 7: pixel_copy_increment; \ 407 case 6: pixel_copy_increment; \ 408 case 5: pixel_copy_increment; \ 409 case 4: pixel_copy_increment; \ 410 case 3: pixel_copy_increment; \ 411 case 2: pixel_copy_increment; \ 412 case 1: pixel_copy_increment; \ 413 } while ( --n > 0 ); \ 414 } \ 415 } 416 417 /* 4-times unrolled loop */ 418 #define DUFFS_LOOP4(pixel_copy_increment, width) \ 419 { int n = (width+3)/4; \ 420 switch (width & 3) { \ 421 case 0: do { pixel_copy_increment; \ 422 case 3: pixel_copy_increment; \ 423 case 2: pixel_copy_increment; \ 424 case 1: pixel_copy_increment; \ 425 } while ( --n > 0 ); \ 426 } \ 427 } 428 429 /* 2 - times unrolled loop */ 430 #define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \ 431 double_pixel_copy_increment, width) \ 432 { int n, w = width; \ 433 if( w & 1 ) { \ 434 pixel_copy_increment; \ 435 w--; \ 436 } \ 437 if ( w > 0 ) { \ 438 n = ( w + 2) / 4; \ 439 switch( w & 2 ) { \ 440 case 0: do { double_pixel_copy_increment; \ 441 case 2: double_pixel_copy_increment; \ 442 } while ( --n > 0 ); \ 443 } \ 444 } \ 445 } 446 447 /* 2 - times unrolled loop 4 pixels */ 448 #define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \ 449 double_pixel_copy_increment, \ 450 quatro_pixel_copy_increment, width) \ 451 { int n, w = width; \ 452 if(w & 1) { \ 453 pixel_copy_increment; \ 454 w--; \ 455 } \ 456 if(w & 2) { \ 457 double_pixel_copy_increment; \ 458 w -= 2; \ 459 } \ 460 if ( w > 0 ) { \ 461 n = ( w + 7 ) / 8; \ 462 switch( w & 4 ) { \ 463 case 0: do { quatro_pixel_copy_increment; \ 464 case 4: quatro_pixel_copy_increment; \ 465 } while ( --n > 0 ); \ 466 } \ 467 } \ 468 } 469 470 /* Use the 8-times version of the loop by default */ 471 #define DUFFS_LOOP(pixel_copy_increment, width) \ 472 DUFFS_LOOP8(pixel_copy_increment, width) 473 474 #else 475 476 /* Don't use Duff's device to unroll loops */ 477 #define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \ 478 double_pixel_copy_increment, width) \ 479 { int n = width; \ 480 if( n & 1 ) { \ 481 pixel_copy_increment; \ 482 n--; \ 483 } \ 484 n=n>>1; \ 485 for(; n > 0; --n) { \ 486 double_pixel_copy_increment; \ 487 } \ 488 } 489 490 /* Don't use Duff's device to unroll loops */ 491 #define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \ 492 double_pixel_copy_increment, \ 493 quatro_pixel_copy_increment, width) \ 494 { int n = width; \ 495 if(n & 1) { \ 496 pixel_copy_increment; \ 497 n--; \ 498 } \ 499 if(n & 2) { \ 500 double_pixel_copy_increment; \ 501 n -= 2; \ 502 } \ 503 n=n>>2; \ 504 for(; n > 0; --n) { \ 505 quatro_pixel_copy_increment; \ 506 } \ 507 } 508 509 /* Don't use Duff's device to unroll loops */ 510 #define DUFFS_LOOP(pixel_copy_increment, width) \ 511 { int n; \ 512 for ( n=width; n > 0; --n ) { \ 513 pixel_copy_increment; \ 514 } \ 515 } 516 #define DUFFS_LOOP8(pixel_copy_increment, width) \ 517 DUFFS_LOOP(pixel_copy_increment, width) 518 #define DUFFS_LOOP4(pixel_copy_increment, width) \ 519 DUFFS_LOOP(pixel_copy_increment, width) 520 521 #endif /* USE_DUFFS_LOOP */ 522 523 /* Prevent Visual C++ 6.0 from printing out stupid warnings */ 524 #if defined(_MSC_VER) && (_MSC_VER >= 600) 525 #pragma warning(disable: 4550) 526 #endif 527 528 #endif /* _SDL_blit_h */ 529
