src/video/SDL_blit.h

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 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@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 */