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 /* 25 * RLE encoding for software colorkey and alpha-channel acceleration 26 * 27 * Original version by Sam Lantinga 28 * 29 * Mattias Engdegrd (Yorick): Rewrite. New encoding format, encoder and 30 * decoder. Added per-surface alpha blitter. Added per-pixel alpha 31 * format, encoder and blitter. 32 * 33 * Many thanks to Xark and johns for hints, benchmarks and useful comments 34 * leading to this code. 35 * 36 * Welcome to Macro Mayhem. 37 */ 38 39 /* 40 * The encoding translates the image data to a stream of segments of the form 41 * 42 * <skip> <run> <data> 43 * 44 * where <skip> is the number of transparent pixels to skip, 45 * <run> is the number of opaque pixels to blit, 46 * and <data> are the pixels themselves. 47 * 48 * This basic structure is used both for colorkeyed surfaces, used for simple 49 * binary transparency and for per-surface alpha blending, and for surfaces 50 * with per-pixel alpha. The details differ, however: 51 * 52 * Encoding of colorkeyed surfaces: 53 * 54 * Encoded pixels always have the same format as the target surface. 55 * <skip> and <run> are unsigned 8 bit integers, except for 32 bit depth 56 * where they are 16 bit. This makes the pixel data aligned at all times. 57 * Segments never wrap around from one scan line to the next. 58 * 59 * The end of the sequence is marked by a zero <skip>,<run> pair at the * 60 * beginning of a line. 61 * 62 * Encoding of surfaces with per-pixel alpha: 63 * 64 * The sequence begins with a struct RLEDestFormat describing the target 65 * pixel format, to provide reliable un-encoding. 66 * 67 * Each scan line is encoded twice: First all completely opaque pixels, 68 * encoded in the target format as described above, and then all 69 * partially transparent (translucent) pixels (where 1 <= alpha <= 254), 70 * in the following 32-bit format: 71 * 72 * For 32-bit targets, each pixel has the target RGB format but with 73 * the alpha value occupying the highest 8 bits. The <skip> and <run> 74 * counts are 16 bit. 75 * 76 * For 16-bit targets, each pixel has the target RGB format, but with 77 * the middle component (usually green) shifted 16 steps to the left, 78 * and the hole filled with the 5 most significant bits of the alpha value. 79 * i.e. if the target has the format rrrrrggggggbbbbb, 80 * the encoded pixel will be 00000gggggg00000rrrrr0aaaaabbbbb. 81 * The <skip> and <run> counts are 8 bit for the opaque lines, 16 bit 82 * for the translucent lines. Two padding bytes may be inserted 83 * before each translucent line to keep them 32-bit aligned. 84 * 85 * The end of the sequence is marked by a zero <skip>,<run> pair at the 86 * beginning of an opaque line. 87 */ 88 89 #include "SDL_video.h" 90 #include "SDL_sysvideo.h" 91 #include "SDL_blit.h" 92 #include "SDL_RLEaccel_c.h" 93 94 #if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && SDL_ASSEMBLY_ROUTINES 95 #define MMX_ASMBLIT 96 #endif 97 98 #ifdef MMX_ASMBLIT 99 #include "mmx.h" 100 #include "SDL_cpuinfo.h" 101 #endif 102 103 #ifndef MAX 104 #define MAX(a, b) ((a) > (b) ? (a) : (b)) 105 #endif 106 #ifndef MIN 107 #define MIN(a, b) ((a) < (b) ? (a) : (b)) 108 #endif 109 110 #define PIXEL_COPY(to, from, len, bpp) \ 111 do { \ 112 if(bpp == 4) { \ 113 SDL_memcpy4(to, from, (size_t)(len)); \ 114 } else { \ 115 SDL_memcpy(to, from, (size_t)(len) * (bpp)); \ 116 } \ 117 } while(0) 118 119 /* 120 * Various colorkey blit methods, for opaque and per-surface alpha 121 */ 122 123 #define OPAQUE_BLIT(to, from, length, bpp, alpha) \ 124 PIXEL_COPY(to, from, length, bpp) 125 126 #ifdef MMX_ASMBLIT 127 128 #define ALPHA_BLIT32_888MMX(to, from, length, bpp, alpha) \ 129 do { \ 130 Uint32 *srcp = (Uint32 *)(from); \ 131 Uint32 *dstp = (Uint32 *)(to); \ 132 int i = 0x00FF00FF; \ 133 movd_m2r(*(&i), mm3); \ 134 punpckldq_r2r(mm3, mm3); \ 135 i = 0xFF000000; \ 136 movd_m2r(*(&i), mm7); \ 137 punpckldq_r2r(mm7, mm7); \ 138 i = alpha | alpha << 16; \ 139 movd_m2r(*(&i), mm4); \ 140 punpckldq_r2r(mm4, mm4); \ 141 pcmpeqd_r2r(mm5,mm5); /* set mm5 to "1" */ \ 142 pxor_r2r(mm7, mm5); /* make clear alpha mask */ \ 143 i = length; \ 144 if(i & 1) { \ 145 movd_m2r((*srcp), mm1); /* src -> mm1 */ \ 146 punpcklbw_r2r(mm1, mm1); \ 147 pand_r2r(mm3, mm1); \ 148 movd_m2r((*dstp), mm2); /* dst -> mm2 */ \ 149 punpcklbw_r2r(mm2, mm2); \ 150 pand_r2r(mm3, mm2); \ 151 psubw_r2r(mm2, mm1); \ 152 pmullw_r2r(mm4, mm1); \ 153 psrlw_i2r(8, mm1); \ 154 paddw_r2r(mm1, mm2); \ 155 pand_r2r(mm3, mm2); \ 156 packuswb_r2r(mm2, mm2); \ 157 pand_r2r(mm5, mm2); /* 00000RGB -> mm2 */ \ 158 movd_r2m(mm2, *dstp); \ 159 ++srcp; \ 160 ++dstp; \ 161 i--; \ 162 } \ 163 for(; i > 0; --i) { \ 164 movq_m2r((*srcp), mm0); \ 165 movq_r2r(mm0, mm1); \ 166 punpcklbw_r2r(mm0, mm0); \ 167 movq_m2r((*dstp), mm2); \ 168 punpckhbw_r2r(mm1, mm1); \ 169 movq_r2r(mm2, mm6); \ 170 pand_r2r(mm3, mm0); \ 171 punpcklbw_r2r(mm2, mm2); \ 172 pand_r2r(mm3, mm1); \ 173 punpckhbw_r2r(mm6, mm6); \ 174 pand_r2r(mm3, mm2); \ 175 psubw_r2r(mm2, mm0); \ 176 pmullw_r2r(mm4, mm0); \ 177 pand_r2r(mm3, mm6); \ 178 psubw_r2r(mm6, mm1); \ 179 pmullw_r2r(mm4, mm1); \ 180 psrlw_i2r(8, mm0); \ 181 paddw_r2r(mm0, mm2); \ 182 psrlw_i2r(8, mm1); \ 183 paddw_r2r(mm1, mm6); \ 184 pand_r2r(mm3, mm2); \ 185 pand_r2r(mm3, mm6); \ 186 packuswb_r2r(mm2, mm2); \ 187 packuswb_r2r(mm6, mm6); \ 188 psrlq_i2r(32, mm2); \ 189 psllq_i2r(32, mm6); \ 190 por_r2r(mm6, mm2); \ 191 pand_r2r(mm5, mm2); /* 00000RGB -> mm2 */ \ 192 movq_r2m(mm2, *dstp); \ 193 srcp += 2; \ 194 dstp += 2; \ 195 i--; \ 196 } \ 197 emms(); \ 198 } while(0) 199 200 #define ALPHA_BLIT16_565MMX(to, from, length, bpp, alpha) \ 201 do { \ 202 int i, n = 0; \ 203 Uint16 *srcp = (Uint16 *)(from); \ 204 Uint16 *dstp = (Uint16 *)(to); \ 205 Uint32 ALPHA = 0xF800; \ 206 movd_m2r(*(&ALPHA), mm1); \ 207 punpcklwd_r2r(mm1, mm1); \ 208 punpcklwd_r2r(mm1, mm1); \ 209 ALPHA = 0x07E0; \ 210 movd_m2r(*(&ALPHA), mm4); \ 211 punpcklwd_r2r(mm4, mm4); \ 212 punpcklwd_r2r(mm4, mm4); \ 213 ALPHA = 0x001F; \ 214 movd_m2r(*(&ALPHA), mm7); \ 215 punpcklwd_r2r(mm7, mm7); \ 216 punpcklwd_r2r(mm7, mm7); \ 217 alpha &= ~(1+2+4); \ 218 i = (Uint32)alpha | (Uint32)alpha << 16; \ 219 movd_m2r(*(&i), mm0); \ 220 punpckldq_r2r(mm0, mm0); \ 221 ALPHA = alpha >> 3; \ 222 i = ((int)(length) & 3); \ 223 for(; i > 0; --i) { \ 224 Uint32 s = *srcp++; \ 225 Uint32 d = *dstp; \ 226 s = (s | s << 16) & 0x07e0f81f; \ 227 d = (d | d << 16) & 0x07e0f81f; \ 228 d += (s - d) * ALPHA >> 5; \ 229 d &= 0x07e0f81f; \ 230 *dstp++ = d | d >> 16; \ 231 n++; \ 232 } \ 233 i = (int)(length) - n; \ 234 for(; i > 0; --i) { \ 235 movq_m2r((*dstp), mm3); \ 236 movq_m2r((*srcp), mm2); \ 237 movq_r2r(mm2, mm5); \ 238 pand_r2r(mm1 , mm5); \ 239 psrlq_i2r(11, mm5); \ 240 movq_r2r(mm3, mm6); \ 241 pand_r2r(mm1 , mm6); \ 242 psrlq_i2r(11, mm6); \ 243 psubw_r2r(mm6, mm5); \ 244 pmullw_r2r(mm0, mm5); \ 245 psrlw_i2r(8, mm5); \ 246 paddw_r2r(mm5, mm6); \ 247 psllq_i2r(11, mm6); \ 248 pand_r2r(mm1, mm6); \ 249 movq_r2r(mm4, mm5); \ 250 por_r2r(mm7, mm5); \ 251 pand_r2r(mm5, mm3); \ 252 por_r2r(mm6, mm3); \ 253 movq_r2r(mm2, mm5); \ 254 pand_r2r(mm4 , mm5); \ 255 psrlq_i2r(5, mm5); \ 256 movq_r2r(mm3, mm6); \ 257 pand_r2r(mm4 , mm6); \ 258 psrlq_i2r(5, mm6); \ 259 psubw_r2r(mm6, mm5); \ 260 pmullw_r2r(mm0, mm5); \ 261 psrlw_i2r(8, mm5); \ 262 paddw_r2r(mm5, mm6); \ 263 psllq_i2r(5, mm6); \ 264 pand_r2r(mm4, mm6); \ 265 movq_r2r(mm1, mm5); \ 266 por_r2r(mm7, mm5); \ 267 pand_r2r(mm5, mm3); \ 268 por_r2r(mm6, mm3); \ 269 movq_r2r(mm2, mm5); \ 270 pand_r2r(mm7 , mm5); \ 271 movq_r2r(mm3, mm6); \ 272 pand_r2r(mm7 , mm6); \ 273 psubw_r2r(mm6, mm5); \ 274 pmullw_r2r(mm0, mm5); \ 275 psrlw_i2r(8, mm5); \ 276 paddw_r2r(mm5, mm6); \ 277 pand_r2r(mm7, mm6); \ 278 movq_r2r(mm1, mm5); \ 279 por_r2r(mm4, mm5); \ 280 pand_r2r(mm5, mm3); \ 281 por_r2r(mm6, mm3); \ 282 movq_r2m(mm3, *dstp); \ 283 srcp += 4; \ 284 dstp += 4; \ 285 i -= 3; \ 286 } \ 287 emms(); \ 288 } while(0) 289 290 #define ALPHA_BLIT16_555MMX(to, from, length, bpp, alpha) \ 291 do { \ 292 int i, n = 0; \ 293 Uint16 *srcp = (Uint16 *)(from); \ 294 Uint16 *dstp = (Uint16 *)(to); \ 295 Uint32 ALPHA = 0x7C00; \ 296 movd_m2r(*(&ALPHA), mm1); \ 297 punpcklwd_r2r(mm1, mm1); \ 298 punpcklwd_r2r(mm1, mm1); \ 299 ALPHA = 0x03E0; \ 300 movd_m2r(*(&ALPHA), mm4); \ 301 punpcklwd_r2r(mm4, mm4); \ 302 punpcklwd_r2r(mm4, mm4); \ 303 ALPHA = 0x001F; \ 304 movd_m2r(*(&ALPHA), mm7); \ 305 punpcklwd_r2r(mm7, mm7); \ 306 punpcklwd_r2r(mm7, mm7); \ 307 alpha &= ~(1+2+4); \ 308 i = (Uint32)alpha | (Uint32)alpha << 16; \ 309 movd_m2r(*(&i), mm0); \ 310 punpckldq_r2r(mm0, mm0); \ 311 i = ((int)(length) & 3); \ 312 ALPHA = alpha >> 3; \ 313 for(; i > 0; --i) { \ 314 Uint32 s = *srcp++; \ 315 Uint32 d = *dstp; \ 316 s = (s | s << 16) & 0x03e07c1f; \ 317 d = (d | d << 16) & 0x03e07c1f; \ 318 d += (s - d) * ALPHA >> 5; \ 319 d &= 0x03e07c1f; \ 320 *dstp++ = d | d >> 16; \ 321 n++; \ 322 } \ 323 i = (int)(length) - n; \ 324 for(; i > 0; --i) { \ 325 movq_m2r((*dstp), mm3); \ 326 movq_m2r((*srcp), mm2); \ 327 movq_r2r(mm2, mm5); \ 328 pand_r2r(mm1 , mm5); \ 329 psrlq_i2r(10, mm5); \ 330 movq_r2r(mm3, mm6); \ 331 pand_r2r(mm1 , mm6); \ 332 psrlq_i2r(10, mm6); \ 333 psubw_r2r(mm6, mm5); \ 334 pmullw_r2r(mm0, mm5); \ 335 psrlw_i2r(8, mm5); \ 336 paddw_r2r(mm5, mm6); \ 337 psllq_i2r(10, mm6); \ 338 pand_r2r(mm1, mm6); \ 339 movq_r2r(mm4, mm5); \ 340 por_r2r(mm7, mm5); \ 341 pand_r2r(mm5, mm3); \ 342 por_r2r(mm6, mm3); \ 343 movq_r2r(mm2, mm5); \ 344 pand_r2r(mm4 , mm5); \ 345 psrlq_i2r(5, mm5); \ 346 movq_r2r(mm3, mm6); \ 347 pand_r2r(mm4 , mm6); \ 348 psrlq_i2r(5, mm6); \ 349 psubw_r2r(mm6, mm5); \ 350 pmullw_r2r(mm0, mm5); \ 351 psrlw_i2r(8, mm5); \ 352 paddw_r2r(mm5, mm6); \ 353 psllq_i2r(5, mm6); \ 354 pand_r2r(mm4, mm6); \ 355 movq_r2r(mm1, mm5); \ 356 por_r2r(mm7, mm5); \ 357 pand_r2r(mm5, mm3); \ 358 por_r2r(mm6, mm3); \ 359 movq_r2r(mm2, mm5); \ 360 pand_r2r(mm7 , mm5); \ 361 movq_r2r(mm3, mm6); \ 362 pand_r2r(mm7 , mm6); \ 363 psubw_r2r(mm6, mm5); \ 364 pmullw_r2r(mm0, mm5); \ 365 psrlw_i2r(8, mm5); \ 366 paddw_r2r(mm5, mm6); \ 367 pand_r2r(mm7, mm6); \ 368 movq_r2r(mm1, mm5); \ 369 por_r2r(mm4, mm5); \ 370 pand_r2r(mm5, mm3); \ 371 por_r2r(mm6, mm3); \ 372 movq_r2m(mm3, *dstp); \ 373 srcp += 4; \ 374 dstp += 4; \ 375 i -= 3; \ 376 } \ 377 emms(); \ 378 } while(0) 379 380 #endif 381 382 /* 383 * For 32bpp pixels on the form 0x00rrggbb: 384 * If we treat the middle component separately, we can process the two 385 * remaining in parallel. This is safe to do because of the gap to the left 386 * of each component, so the bits from the multiplication don't collide. 387 * This can be used for any RGB permutation of course. 388 */ 389 #define ALPHA_BLIT32_888(to, from, length, bpp, alpha) \ 390 do { \ 391 int i; \ 392 Uint32 *src = (Uint32 *)(from); \ 393 Uint32 *dst = (Uint32 *)(to); \ 394 for(i = 0; i < (int)(length); i++) { \ 395 Uint32 s = *src++; \ 396 Uint32 d = *dst; \ 397 Uint32 s1 = s & 0xff00ff; \ 398 Uint32 d1 = d & 0xff00ff; \ 399 d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff; \ 400 s &= 0xff00; \ 401 d &= 0xff00; \ 402 d = (d + ((s - d) * alpha >> 8)) & 0xff00; \ 403 *dst++ = d1 | d; \ 404 } \ 405 } while(0) 406 407 /* 408 * For 16bpp pixels we can go a step further: put the middle component 409 * in the high 16 bits of a 32 bit word, and process all three RGB 410 * components at the same time. Since the smallest gap is here just 411 * 5 bits, we have to scale alpha down to 5 bits as well. 412 */ 413 #define ALPHA_BLIT16_565(to, from, length, bpp, alpha) \ 414 do { \ 415 int i; \ 416 Uint16 *src = (Uint16 *)(from); \ 417 Uint16 *dst = (Uint16 *)(to); \ 418 Uint32 ALPHA = alpha >> 3; \ 419 for(i = 0; i < (int)(length); i++) { \ 420 Uint32 s = *src++; \ 421 Uint32 d = *dst; \ 422 s = (s | s << 16) & 0x07e0f81f; \ 423 d = (d | d << 16) & 0x07e0f81f; \ 424 d += (s - d) * ALPHA >> 5; \ 425 d &= 0x07e0f81f; \ 426 *dst++ = (Uint16)(d | d >> 16); \ 427 } \ 428 } while(0) 429 430 #define ALPHA_BLIT16_555(to, from, length, bpp, alpha) \ 431 do { \ 432 int i; \ 433 Uint16 *src = (Uint16 *)(from); \ 434 Uint16 *dst = (Uint16 *)(to); \ 435 Uint32 ALPHA = alpha >> 3; \ 436 for(i = 0; i < (int)(length); i++) { \ 437 Uint32 s = *src++; \ 438 Uint32 d = *dst; \ 439 s = (s | s << 16) & 0x03e07c1f; \ 440 d = (d | d << 16) & 0x03e07c1f; \ 441 d += (s - d) * ALPHA >> 5; \ 442 d &= 0x03e07c1f; \ 443 *dst++ = (Uint16)(d | d >> 16); \ 444 } \ 445 } while(0) 446 447 /* 448 * The general slow catch-all function, for remaining depths and formats 449 */ 450 #define ALPHA_BLIT_ANY(to, from, length, bpp, alpha) \ 451 do { \ 452 int i; \ 453 Uint8 *src = from; \ 454 Uint8 *dst = to; \ 455 for(i = 0; i < (int)(length); i++) { \ 456 Uint32 s, d; \ 457 unsigned rs, gs, bs, rd, gd, bd; \ 458 switch(bpp) { \ 459 case 2: \ 460 s = *(Uint16 *)src; \ 461 d = *(Uint16 *)dst; \ 462 break; \ 463 case 3: \ 464 if(SDL_BYTEORDER == SDL_BIG_ENDIAN) { \ 465 s = (src[0] << 16) | (src[1] << 8) | src[2]; \ 466 d = (dst[0] << 16) | (dst[1] << 8) | dst[2]; \ 467 } else { \ 468 s = (src[2] << 16) | (src[1] << 8) | src[0]; \ 469 d = (dst[2] << 16) | (dst[1] << 8) | dst[0]; \ 470 } \ 471 break; \ 472 case 4: \ 473 s = *(Uint32 *)src; \ 474 d = *(Uint32 *)dst; \ 475 break; \ 476 } \ 477 RGB_FROM_PIXEL(s, fmt, rs, gs, bs); \ 478 RGB_FROM_PIXEL(d, fmt, rd, gd, bd); \ 479 rd += (rs - rd) * alpha >> 8; \ 480 gd += (gs - gd) * alpha >> 8; \ 481 bd += (bs - bd) * alpha >> 8; \ 482 PIXEL_FROM_RGB(d, fmt, rd, gd, bd); \ 483 switch(bpp) { \ 484 case 2: \ 485 *(Uint16 *)dst = (Uint16)d; \ 486 break; \ 487 case 3: \ 488 if(SDL_BYTEORDER == SDL_BIG_ENDIAN) { \ 489 dst[0] = (Uint8)(d >> 16); \ 490 dst[1] = (Uint8)(d >> 8); \ 491 dst[2] = (Uint8)(d); \ 492 } else { \ 493 dst[0] = (Uint8)d; \ 494 dst[1] = (Uint8)(d >> 8); \ 495 dst[2] = (Uint8)(d >> 16); \ 496 } \ 497 break; \ 498 case 4: \ 499 *(Uint32 *)dst = d; \ 500 break; \ 501 } \ 502 src += bpp; \ 503 dst += bpp; \ 504 } \ 505 } while(0) 506 507 #ifdef MMX_ASMBLIT 508 509 #define ALPHA_BLIT32_888_50MMX(to, from, length, bpp, alpha) \ 510 do { \ 511 Uint32 *srcp = (Uint32 *)(from); \ 512 Uint32 *dstp = (Uint32 *)(to); \ 513 int i = 0x00fefefe; \ 514 movd_m2r(*(&i), mm4); \ 515 punpckldq_r2r(mm4, mm4); \ 516 i = 0x00010101; \ 517 movd_m2r(*(&i), mm3); \ 518 punpckldq_r2r(mm3, mm3); \ 519 i = (int)(length); \ 520 if( i & 1 ) { \ 521 Uint32 s = *srcp++; \ 522 Uint32 d = *dstp; \ 523 *dstp++ = (((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1) \ 524 + (s & d & 0x00010101); \ 525 i--; \ 526 } \ 527 for(; i > 0; --i) { \ 528 movq_m2r((*dstp), mm2); /* dst -> mm2 */ \ 529 movq_r2r(mm2, mm6); /* dst -> mm6 */ \ 530 movq_m2r((*srcp), mm1); /* src -> mm1 */ \ 531 movq_r2r(mm1, mm5); /* src -> mm5 */ \ 532 pand_r2r(mm4, mm6); /* dst & 0x00fefefe -> mm6 */ \ 533 pand_r2r(mm4, mm5); /* src & 0x00fefefe -> mm5 */ \ 534 paddd_r2r(mm6, mm5); /* (dst & 0x00fefefe) + (dst & 0x00fefefe) -> mm5 */ \ 535 psrld_i2r(1, mm5); \ 536 pand_r2r(mm1, mm2); /* s & d -> mm2 */ \ 537 pand_r2r(mm3, mm2); /* s & d & 0x00010101 -> mm2 */ \ 538 paddd_r2r(mm5, mm2); \ 539 movq_r2m(mm2, (*dstp)); \ 540 dstp += 2; \ 541 srcp += 2; \ 542 i--; \ 543 } \ 544 emms(); \ 545 } while(0) 546 547 #endif 548 549 /* 550 * Special case: 50% alpha (alpha=128) 551 * This is treated specially because it can be optimized very well, and 552 * since it is good for many cases of semi-translucency. 553 * The theory is to do all three components at the same time: 554 * First zero the lowest bit of each component, which gives us room to 555 * add them. Then shift right and add the sum of the lowest bits. 556 */ 557 #define ALPHA_BLIT32_888_50(to, from, length, bpp, alpha) \ 558 do { \ 559 int i; \ 560 Uint32 *src = (Uint32 *)(from); \ 561 Uint32 *dst = (Uint32 *)(to); \ 562 for(i = 0; i < (int)(length); i++) { \ 563 Uint32 s = *src++; \ 564 Uint32 d = *dst; \ 565 *dst++ = (((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1) \ 566 + (s & d & 0x00010101); \ 567 } \ 568 } while(0) 569 570 /* 571 * For 16bpp, we can actually blend two pixels in parallel, if we take 572 * care to shift before we add, not after. 573 */ 574 575 /* helper: blend a single 16 bit pixel at 50% */ 576 #define BLEND16_50(dst, src, mask) \ 577 do { \ 578 Uint32 s = *src++; \ 579 Uint32 d = *dst; \ 580 *dst++ = (Uint16)((((s & mask) + (d & mask)) >> 1) + \ 581 (s & d & (~mask & 0xffff))); \ 582 } while(0) 583 584 /* basic 16bpp blender. mask is the pixels to keep when adding. */ 585 #define ALPHA_BLIT16_50(to, from, length, bpp, alpha, mask) \ 586 do { \ 587 unsigned n = (length); \ 588 Uint16 *src = (Uint16 *)(from); \ 589 Uint16 *dst = (Uint16 *)(to); \ 590 if(((uintptr_t)src ^ (uintptr_t)dst) & 3) { \ 591 /* source and destination not in phase, blit one by one */ \ 592 while(n--) \ 593 BLEND16_50(dst, src, mask); \ 594 } else { \ 595 if((uintptr_t)src & 3) { \ 596 /* first odd pixel */ \ 597 BLEND16_50(dst, src, mask); \ 598 n--; \ 599 } \ 600 for(; n > 1; n -= 2) { \ 601 Uint32 s = *(Uint32 *)src; \ 602 Uint32 d = *(Uint32 *)dst; \ 603 *(Uint32 *)dst = ((s & (mask | mask << 16)) >> 1) \ 604 + ((d & (mask | mask << 16)) >> 1) \ 605 + (s & d & (~(mask | mask << 16))); \ 606 src += 2; \ 607 dst += 2; \ 608 } \ 609 if(n) \ 610 BLEND16_50(dst, src, mask); /* last odd pixel */ \ 611 } \ 612 } while(0) 613 614 #define ALPHA_BLIT16_565_50(to, from, length, bpp, alpha) \ 615 ALPHA_BLIT16_50(to, from, length, bpp, alpha, 0xf7de) 616 617 #define ALPHA_BLIT16_555_50(to, from, length, bpp, alpha) \ 618 ALPHA_BLIT16_50(to, from, length, bpp, alpha, 0xfbde) 619 620 #ifdef MMX_ASMBLIT 621 622 #define CHOOSE_BLIT(blitter, alpha, fmt) \ 623 do { \ 624 if(alpha == 255) { \ 625 switch(fmt->BytesPerPixel) { \ 626 case 1: blitter(1, Uint8, OPAQUE_BLIT); break; \ 627 case 2: blitter(2, Uint8, OPAQUE_BLIT); break; \ 628 case 3: blitter(3, Uint8, OPAQUE_BLIT); break; \ 629 case 4: blitter(4, Uint16, OPAQUE_BLIT); break; \ 630 } \ 631 } else { \ 632 switch(fmt->BytesPerPixel) { \ 633 case 1: \ 634 /* No 8bpp alpha blitting */ \ 635 break; \ 636 \ 637 case 2: \ 638 switch(fmt->Rmask | fmt->Gmask | fmt->Bmask) { \ 639 case 0xffff: \ 640 if(fmt->Gmask == 0x07e0 \ 641 || fmt->Rmask == 0x07e0 \ 642 || fmt->Bmask == 0x07e0) { \ 643 if(alpha == 128) \ 644 blitter(2, Uint8, ALPHA_BLIT16_565_50); \ 645 else { \ 646 if(SDL_HasMMX()) \ 647 blitter(2, Uint8, ALPHA_BLIT16_565MMX); \ 648 else \ 649 blitter(2, Uint8, ALPHA_BLIT16_565); \ 650 } \ 651 } else \ 652 goto general16; \ 653 break; \ 654 \ 655 case 0x7fff: \ 656 if(fmt->Gmask == 0x03e0 \ 657 || fmt->Rmask == 0x03e0 \ 658 || fmt->Bmask == 0x03e0) { \ 659 if(alpha == 128) \ 660 blitter(2, Uint8, ALPHA_BLIT16_555_50); \ 661 else { \ 662 if(SDL_HasMMX()) \ 663 blitter(2, Uint8, ALPHA_BLIT16_555MMX); \ 664 else \ 665 blitter(2, Uint8, ALPHA_BLIT16_555); \ 666 } \ 667 break; \ 668 } \ 669 /* fallthrough */ \ 670 \ 671 default: \ 672 general16: \ 673 blitter(2, Uint8, ALPHA_BLIT_ANY); \ 674 } \ 675 break; \ 676 \ 677 case 3: \ 678 blitter(3, Uint8, ALPHA_BLIT_ANY); \ 679 break; \ 680 \ 681 case 4: \ 682 if((fmt->Rmask | fmt->Gmask | fmt->Bmask) == 0x00ffffff \ 683 && (fmt->Gmask == 0xff00 || fmt->Rmask == 0xff00 \ 684 || fmt->Bmask == 0xff00)) { \ 685 if(alpha == 128) \ 686 { \ 687 if(SDL_HasMMX()) \ 688 blitter(4, Uint16, ALPHA_BLIT32_888_50MMX);\ 689 else \ 690 blitter(4, Uint16, ALPHA_BLIT32_888_50);\ 691 } \ 692 else \ 693 { \ 694 if(SDL_HasMMX()) \ 695 blitter(4, Uint16, ALPHA_BLIT32_888MMX);\ 696 else \ 697 blitter(4, Uint16, ALPHA_BLIT32_888); \ 698 } \ 699 } else \ 700 blitter(4, Uint16, ALPHA_BLIT_ANY); \ 701 break; \ 702 } \ 703 } \ 704 } while(0) 705 706 #else 707 708 #define CHOOSE_BLIT(blitter, alpha, fmt) \ 709 do { \ 710 if(alpha == 255) { \ 711 switch(fmt->BytesPerPixel) { \ 712 case 1: blitter(1, Uint8, OPAQUE_BLIT); break; \ 713 case 2: blitter(2, Uint8, OPAQUE_BLIT); break; \ 714 case 3: blitter(3, Uint8, OPAQUE_BLIT); break; \ 715 case 4: blitter(4, Uint16, OPAQUE_BLIT); break; \ 716 } \ 717 } else { \ 718 switch(fmt->BytesPerPixel) { \ 719 case 1: \ 720 /* No 8bpp alpha blitting */ \ 721 break; \ 722 \ 723 case 2: \ 724 switch(fmt->Rmask | fmt->Gmask | fmt->Bmask) { \ 725 case 0xffff: \ 726 if(fmt->Gmask == 0x07e0 \ 727 || fmt->Rmask == 0x07e0 \ 728 || fmt->Bmask == 0x07e0) { \ 729 if(alpha == 128) \ 730 blitter(2, Uint8, ALPHA_BLIT16_565_50); \ 731 else { \ 732 blitter(2, Uint8, ALPHA_BLIT16_565); \ 733 } \ 734 } else \ 735 goto general16; \ 736 break; \ 737 \ 738 case 0x7fff: \ 739 if(fmt->Gmask == 0x03e0 \ 740 || fmt->Rmask == 0x03e0 \ 741 || fmt->Bmask == 0x03e0) { \ 742 if(alpha == 128) \ 743 blitter(2, Uint8, ALPHA_BLIT16_555_50); \ 744 else { \ 745 blitter(2, Uint8, ALPHA_BLIT16_555); \ 746 } \ 747 break; \ 748 } \ 749 /* fallthrough */ \ 750 \ 751 default: \ 752 general16: \ 753 blitter(2, Uint8, ALPHA_BLIT_ANY); \ 754 } \ 755 break; \ 756 \ 757 case 3: \ 758 blitter(3, Uint8, ALPHA_BLIT_ANY); \ 759 break; \ 760 \ 761 case 4: \ 762 if((fmt->Rmask | fmt->Gmask | fmt->Bmask) == 0x00ffffff \ 763 && (fmt->Gmask == 0xff00 || fmt->Rmask == 0xff00 \ 764 || fmt->Bmask == 0xff00)) { \ 765 if(alpha == 128) \ 766 blitter(4, Uint16, ALPHA_BLIT32_888_50); \ 767 else \ 768 blitter(4, Uint16, ALPHA_BLIT32_888); \ 769 } else \ 770 blitter(4, Uint16, ALPHA_BLIT_ANY); \ 771 break; \ 772 } \ 773 } \ 774 } while(0) 775 776 #endif 777 778 /* 779 * This takes care of the case when the surface is clipped on the left and/or 780 * right. Top clipping has already been taken care of. 781 */ 782 static void RLEClipBlit(int w, Uint8 *srcbuf, SDL_Surface *dst, 783 Uint8 *dstbuf, SDL_Rect *srcrect, unsigned alpha) 784 { 785 SDL_PixelFormat *fmt = dst->format; 786 787 #define RLECLIPBLIT(bpp, Type, do_blit) \ 788 do { \ 789 int linecount = srcrect->h; \ 790 int ofs = 0; \ 791 int left = srcrect->x; \ 792 int right = left + srcrect->w; \ 793 dstbuf -= left * bpp; \ 794 for(;;) { \ 795 int run; \ 796 ofs += *(Type *)srcbuf; \ 797 run = ((Type *)srcbuf)[1]; \ 798 srcbuf += 2 * sizeof(Type); \ 799 if(run) { \ 800 /* clip to left and right borders */ \ 801 if(ofs < right) { \ 802 int start = 0; \ 803 int len = run; \ 804 int startcol; \ 805 if(left - ofs > 0) { \ 806 start = left - ofs; \ 807 len -= start; \ 808 if(len <= 0) \ 809 goto nocopy ## bpp ## do_blit; \ 810 } \ 811 startcol = ofs + start; \ 812 if(len > right - startcol) \ 813 len = right - startcol; \ 814 do_blit(dstbuf + startcol * bpp, srcbuf + start * bpp, \ 815 len, bpp, alpha); \ 816 } \ 817 nocopy ## bpp ## do_blit: \ 818 srcbuf += run * bpp; \ 819 ofs += run; \ 820 } else if(!ofs) \ 821 break; \ 822 if(ofs == w) { \ 823 ofs = 0; \ 824 dstbuf += dst->pitch; \ 825 if(!--linecount) \ 826 break; \ 827 } \ 828 } \ 829 } while(0) 830 831 CHOOSE_BLIT(RLECLIPBLIT, alpha, fmt); 832 833 #undef RLECLIPBLIT 834 835 } 836 837 838 /* blit a colorkeyed RLE surface */ 839 int SDL_RLEBlit(SDL_Surface *src, SDL_Rect *srcrect, 840 SDL_Surface *dst, SDL_Rect *dstrect) 841 { 842 Uint8 *dstbuf; 843 Uint8 *srcbuf; 844 int x, y; 845 int w = src->w; 846 unsigned alpha; 847 848 /* Lock the destination if necessary */ 849 if ( SDL_MUSTLOCK(dst) ) { 850 if ( SDL_LockSurface(dst) < 0 ) { 851 return(-1); 852 } 853 } 854 855 /* Set up the source and destination pointers */ 856 x = dstrect->x; 857 y = dstrect->y; 858 dstbuf = (Uint8 *)dst->pixels 859 + y * dst->pitch + x * src->format->BytesPerPixel; 860 srcbuf = (Uint8 *)src->map->sw_data->aux_data; 861 862 { 863 /* skip lines at the top if neccessary */ 864 int vskip = srcrect->y; 865 int ofs = 0; 866 if(vskip) { 867 868 #define RLESKIP(bpp, Type) \ 869 for(;;) { \ 870 int run; \ 871 ofs += *(Type *)srcbuf; \ 872 run = ((Type *)srcbuf)[1]; \ 873 srcbuf += sizeof(Type) * 2; \ 874 if(run) { \ 875 srcbuf += run * bpp; \ 876 ofs += run; \ 877 } else if(!ofs) \ 878 goto done; \ 879 if(ofs == w) { \ 880 ofs = 0; \ 881 if(!--vskip) \ 882 break; \ 883 } \ 884 } 885 886 switch(src->format->BytesPerPixel) { 887 case 1: RLESKIP(1, Uint8); break; 888 case 2: RLESKIP(2, Uint8); break; 889 case 3: RLESKIP(3, Uint8); break; 890 case 4: RLESKIP(4, Uint16); break; 891 } 892 893 #undef RLESKIP 894 895 } 896 } 897 898 alpha = (src->flags & SDL_SRCALPHA) == SDL_SRCALPHA 899 ? src->format->alpha : 255; 900 /* if left or right edge clipping needed, call clip blit */ 901 if ( srcrect->x || srcrect->w != src->w ) { 902 RLEClipBlit(w, srcbuf, dst, dstbuf, srcrect, alpha); 903 } else { 904 SDL_PixelFormat *fmt = src->format; 905 906 #define RLEBLIT(bpp, Type, do_blit) \ 907 do { \ 908 int linecount = srcrect->h; \ 909 int ofs = 0; \ 910 for(;;) { \ 911 unsigned run; \ 912 ofs += *(Type *)srcbuf; \ 913 run = ((Type *)srcbuf)[1]; \ 914 srcbuf += 2 * sizeof(Type); \ 915 if(run) { \ 916 do_blit(dstbuf + ofs * bpp, srcbuf, run, bpp, alpha); \ 917 srcbuf += run * bpp; \ 918 ofs += run; \ 919 } else if(!ofs) \ 920 break; \ 921 if(ofs == w) { \ 922 ofs = 0; \ 923 dstbuf += dst->pitch; \ 924 if(!--linecount) \ 925 break; \ 926 } \ 927 } \ 928 } while(0) 929 930 CHOOSE_BLIT(RLEBLIT, alpha, fmt); 931 932 #undef RLEBLIT 933 } 934 935 done: 936 /* Unlock the destination if necessary */ 937 if ( SDL_MUSTLOCK(dst) ) { 938 SDL_UnlockSurface(dst); 939 } 940 return(0); 941 } 942 943 #undef OPAQUE_BLIT 944 945 /* 946 * Per-pixel blitting macros for translucent pixels: 947 * These use the same techniques as the per-surface blitting macros 948 */ 949 950 /* 951 * For 32bpp pixels, we have made sure the alpha is stored in the top 952 * 8 bits, so proceed as usual 953 */ 954 #define BLIT_TRANSL_888(src, dst) \ 955 do { \ 956 Uint32 s = src; \ 957 Uint32 d = dst; \ 958 unsigned alpha = s >> 24; \ 959 Uint32 s1 = s & 0xff00ff; \ 960 Uint32 d1 = d & 0xff00ff; \ 961 d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff; \ 962 s &= 0xff00; \ 963 d &= 0xff00; \ 964 d = (d + ((s - d) * alpha >> 8)) & 0xff00; \ 965 dst = d1 | d; \ 966 } while(0) 967 968 /* 969 * For 16bpp pixels, we have stored the 5 most significant alpha bits in 970 * bits 5-10. As before, we can process all 3 RGB components at the same time. 971 */ 972 #define BLIT_TRANSL_565(src, dst) \ 973 do { \ 974 Uint32 s = src; \ 975 Uint32 d = dst; \ 976 unsigned alpha = (s & 0x3e0) >> 5; \ 977 s &= 0x07e0f81f; \ 978 d = (d | d << 16) & 0x07e0f81f; \ 979 d += (s - d) * alpha >> 5; \ 980 d &= 0x07e0f81f; \ 981 dst = (Uint16)(d | d >> 16); \ 982 } while(0) 983 984 #define BLIT_TRANSL_555(src, dst) \ 985 do { \ 986 Uint32 s = src; \ 987 Uint32 d = dst; \ 988 unsigned alpha = (s & 0x3e0) >> 5; \ 989 s &= 0x03e07c1f; \ 990 d = (d | d << 16) & 0x03e07c1f; \ 991 d += (s - d) * alpha >> 5; \ 992 d &= 0x03e07c1f; \ 993 dst = (Uint16)(d | d >> 16); \ 994 } while(0) 995 996 /* used to save the destination format in the encoding. Designed to be 997 macro-compatible with SDL_PixelFormat but without the unneeded fields */ 998 typedef struct { 999 Uint8 BytesPerPixel; 1000 Uint8 Rloss; 1001 Uint8 Gloss; 1002 Uint8 Bloss; 1003 Uint8 Rshift; 1004 Uint8 Gshift; 1005 Uint8 Bshift; 1006 Uint8 Ashift; 1007 Uint32 Rmask; 1008 Uint32 Gmask; 1009 Uint32 Bmask; 1010 Uint32 Amask; 1011 } RLEDestFormat; 1012 1013 /* blit a pixel-alpha RLE surface clipped at the right and/or left edges */ 1014 static void RLEAlphaClipBlit(int w, Uint8 *srcbuf, SDL_Surface *dst, 1015 Uint8 *dstbuf, SDL_Rect *srcrect) 1016 { 1017 SDL_PixelFormat *df = dst->format; 1018 /* 1019 * clipped blitter: Ptype is the destination pixel type, 1020 * Ctype the translucent count type, and do_blend the macro 1021 * to blend one pixel. 1022 */ 1023 #define RLEALPHACLIPBLIT(Ptype, Ctype, do_blend) \ 1024 do { \ 1025 int linecount = srcrect->h; \ 1026 int left = srcrect->x; \ 1027 int right = left + srcrect->w; \ 1028 dstbuf -= left * sizeof(Ptype); \ 1029 do { \ 1030 int ofs = 0; \ 1031 /* blit opaque pixels on one line */ \ 1032 do { \ 1033 unsigned run; \ 1034 ofs += ((Ctype *)srcbuf)[0]; \ 1035 run = ((Ctype *)srcbuf)[1]; \ 1036 srcbuf += 2 * sizeof(Ctype); \ 1037 if(run) { \ 1038 /* clip to left and right borders */ \ 1039 int cofs = ofs; \ 1040 int crun = run; \ 1041 if(left - cofs > 0) { \ 1042 crun -= left - cofs; \ 1043 cofs = left; \ 1044 } \ 1045 if(crun > right - cofs) \ 1046 crun = right - cofs; \ 1047 if(crun > 0) \ 1048 PIXEL_COPY(dstbuf + cofs * sizeof(Ptype), \ 1049 srcbuf + (cofs - ofs) * sizeof(Ptype), \ 1050 (unsigned)crun, sizeof(Ptype)); \ 1051 srcbuf += run * sizeof(Ptype); \ 1052 ofs += run; \ 1053 } else if(!ofs) \ 1054 return; \ 1055 } while(ofs < w); \ 1056 /* skip padding if necessary */ \ 1057 if(sizeof(Ptype) == 2) \ 1058 srcbuf += (uintptr_t)srcbuf & 2; \ 1059 /* blit translucent pixels on the same line */ \ 1060 ofs = 0; \ 1061 do { \ 1062 unsigned run; \ 1063 ofs += ((Uint16 *)srcbuf)[0]; \ 1064 run = ((Uint16 *)srcbuf)[1]; \ 1065 srcbuf += 4; \ 1066 if(run) { \ 1067 /* clip to left and right borders */ \ 1068 int cofs = ofs; \ 1069 int crun = run; \ 1070 if(left - cofs > 0) { \ 1071 crun -= left - cofs; \ 1072 cofs = left; \ 1073 } \ 1074 if(crun > right - cofs) \ 1075 crun = right - cofs; \ 1076 if(crun > 0) { \ 1077 Ptype *dst = (Ptype *)dstbuf + cofs; \ 1078 Uint32 *src = (Uint32 *)srcbuf + (cofs - ofs); \ 1079 int i; \ 1080 for(i = 0; i < crun; i++) \ 1081 do_blend(src[i], dst[i]); \ 1082 } \ 1083 srcbuf += run * 4; \ 1084 ofs += run; \ 1085 } \ 1086 } while(ofs < w); \ 1087 dstbuf += dst->pitch; \ 1088 } while(--linecount); \ 1089 } while(0) 1090 1091 switch(df->BytesPerPixel) { 1092 case 2: 1093 if(df->Gmask == 0x07e0 || df->Rmask == 0x07e0 1094 || df->Bmask == 0x07e0) 1095 RLEALPHACLIPBLIT(Uint16, Uint8, BLIT_TRANSL_565); 1096 else 1097 RLEALPHACLIPBLIT(Uint16, Uint8, BLIT_TRANSL_555); 1098 break; 1099 case 4: 1100 RLEALPHACLIPBLIT(Uint32, Uint16, BLIT_TRANSL_888); 1101 break; 1102 } 1103 } 1104 1105 /* blit a pixel-alpha RLE surface */ 1106 int SDL_RLEAlphaBlit(SDL_Surface *src, SDL_Rect *srcrect, 1107 SDL_Surface *dst, SDL_Rect *dstrect) 1108 { 1109 int x, y; 1110 int w = src->w; 1111 Uint8 *srcbuf, *dstbuf; 1112 SDL_PixelFormat *df = dst->format; 1113 1114 /* Lock the destination if necessary */ 1115 if ( SDL_MUSTLOCK(dst) ) { 1116 if ( SDL_LockSurface(dst) < 0 ) { 1117 return -1; 1118 } 1119 } 1120 1121 x = dstrect->x; 1122 y = dstrect->y; 1123 dstbuf = (Uint8 *)dst->pixels 1124 + y * dst->pitch + x * df->BytesPerPixel; 1125 srcbuf = (Uint8 *)src->map->sw_data->aux_data + sizeof(RLEDestFormat); 1126 1127 { 1128 /* skip lines at the top if necessary */ 1129 int vskip = srcrect->y; 1130 if(vskip) { 1131 int ofs; 1132 if(df->BytesPerPixel == 2) { 1133 /* the 16/32 interleaved format */ 1134 do { 1135 /* skip opaque line */ 1136 ofs = 0; 1137 do { 1138 int run; 1139 ofs += srcbuf[0]; 1140 run = srcbuf[1]; 1141 srcbuf += 2; 1142 if(run) { 1143 srcbuf += 2 * run; 1144 ofs += run; 1145 } else if(!ofs) 1146 goto done; 1147 } while(ofs < w); 1148 1149 /* skip padding */ 1150 srcbuf += (uintptr_t)srcbuf & 2; 1151 1152 /* skip translucent line */ 1153 ofs = 0; 1154 do { 1155 int run; 1156 ofs += ((Uint16 *)srcbuf)[0]; 1157 run = ((Uint16 *)srcbuf)[1]; 1158 srcbuf += 4 * (run + 1); 1159 ofs += run; 1160 } while(ofs < w); 1161 } while(--vskip); 1162 } else { 1163 /* the 32/32 interleaved format */ 1164 vskip <<= 1; /* opaque and translucent have same format */ 1165 do { 1166 ofs = 0; 1167 do { 1168 int run; 1169 ofs += ((Uint16 *)srcbuf)[0]; 1170 run = ((Uint16 *)srcbuf)[1]; 1171 srcbuf += 4; 1172 if(run) { 1173 srcbuf += 4 * run; 1174 ofs += run; 1175 } else if(!ofs) 1176 goto done; 1177 } while(ofs < w); 1178 } while(--vskip); 1179 } 1180 } 1181 } 1182 1183 /* if left or right edge clipping needed, call clip blit */ 1184 if(srcrect->x || srcrect->w != src->w) { 1185 RLEAlphaClipBlit(w, srcbuf, dst, dstbuf, srcrect); 1186 } else { 1187 1188 /* 1189 * non-clipped blitter. Ptype is the destination pixel type, 1190 * Ctype the translucent count type, and do_blend the 1191 * macro to blend one pixel. 1192 */ 1193 #define RLEALPHABLIT(Ptype, Ctype, do_blend) \ 1194 do { \ 1195 int linecount = srcrect->h; \ 1196 do { \ 1197 int ofs = 0; \ 1198 /* blit opaque pixels on one line */ \ 1199 do { \ 1200 unsigned run; \ 1201 ofs += ((Ctype *)srcbuf)[0]; \ 1202 run = ((Ctype *)srcbuf)[1]; \ 1203 srcbuf += 2 * sizeof(Ctype); \ 1204 if(run) { \ 1205 PIXEL_COPY(dstbuf + ofs * sizeof(Ptype), srcbuf, \ 1206 run, sizeof(Ptype)); \ 1207 srcbuf += run * sizeof(Ptype); \ 1208 ofs += run; \ 1209 } else if(!ofs) \ 1210 goto done; \ 1211 } while(ofs < w); \ 1212 /* skip padding if necessary */ \ 1213 if(sizeof(Ptype) == 2) \ 1214 srcbuf += (uintptr_t)srcbuf & 2; \ 1215 /* blit translucent pixels on the same line */ \ 1216 ofs = 0; \ 1217 do { \ 1218 unsigned run; \ 1219 ofs += ((Uint16 *)srcbuf)[0]; \ 1220 run = ((Uint16 *)srcbuf)[1]; \ 1221 srcbuf += 4; \ 1222 if(run) { \ 1223 Ptype *dst = (Ptype *)dstbuf + ofs; \ 1224 unsigned i; \ 1225 for(i = 0; i < run; i++) { \ 1226 Uint32 src = *(Uint32 *)srcbuf; \ 1227 do_blend(src, *dst); \ 1228 srcbuf += 4; \ 1229 dst++; \ 1230 } \ 1231 ofs += run; \ 1232 } \ 1233 } while(ofs < w); \ 1234 dstbuf += dst->pitch; \ 1235 } while(--linecount); \ 1236 } while(0) 1237 1238 switch(df->BytesPerPixel) { 1239 case 2: 1240 if(df->Gmask == 0x07e0 || df->Rmask == 0x07e0 1241 || df->Bmask == 0x07e0) 1242 RLEALPHABLIT(Uint16, Uint8, BLIT_TRANSL_565); 1243 else 1244 RLEALPHABLIT(Uint16, Uint8, BLIT_TRANSL_555); 1245 break; 1246 case 4: 1247 RLEALPHABLIT(Uint32, Uint16, BLIT_TRANSL_888); 1248 break; 1249 } 1250 } 1251 1252 done: 1253 /* Unlock the destination if necessary */ 1254 if ( SDL_MUSTLOCK(dst) ) { 1255 SDL_UnlockSurface(dst); 1256 } 1257 return 0; 1258 } 1259 1260 /* 1261 * Auxiliary functions: 1262 * The encoding functions take 32bpp rgb + a, and 1263 * return the number of bytes copied to the destination. 1264 * The decoding functions copy to 32bpp rgb + a, and 1265 * return the number of bytes copied from the source. 1266 * These are only used in the encoder and un-RLE code and are therefore not 1267 * highly optimised. 1268 */ 1269 1270 /* encode 32bpp rgb + a into 16bpp rgb, losing alpha */ 1271 static int copy_opaque_16(void *dst, Uint32 *src, int n, 1272 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt) 1273 { 1274 int i; 1275 Uint16 *d = dst; 1276 for(i = 0; i < n; i++) { 1277 unsigned r, g, b; 1278 RGB_FROM_PIXEL(*src, sfmt, r, g, b); 1279 PIXEL_FROM_RGB(*d, dfmt, r, g, b); 1280 src++; 1281 d++; 1282 } 1283 return n * 2; 1284 } 1285 1286 /* decode opaque pixels from 16bpp to 32bpp rgb + a */ 1287 static int uncopy_opaque_16(Uint32 *dst, void *src, int n, 1288 RLEDestFormat *sfmt, SDL_PixelFormat *dfmt) 1289 { 1290 int i; 1291 Uint16 *s = src; 1292 unsigned alpha = dfmt->Amask ? 255 : 0; 1293 for(i = 0; i < n; i++) { 1294 unsigned r, g, b; 1295 RGB_FROM_PIXEL(*s, sfmt, r, g, b); 1296 PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, alpha); 1297 s++; 1298 dst++; 1299 } 1300 return n * 2; 1301 } 1302 1303 1304 1305 /* encode 32bpp rgb + a into 32bpp G0RAB format for blitting into 565 */ 1306 static int copy_transl_565(void *dst, Uint32 *src, int n, 1307 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt) 1308 { 1309 int i; 1310 Uint32 *d = dst; 1311 for(i = 0; i < n; i++) { 1312 unsigned r, g, b, a; 1313 Uint16 pix; 1314 RGBA_FROM_8888(*src, sfmt, r, g, b, a); 1315 PIXEL_FROM_RGB(pix, dfmt, r, g, b); 1316 *d = ((pix & 0x7e0) << 16) | (pix & 0xf81f) | ((a << 2) & 0x7e0); 1317 src++; 1318 d++; 1319 } 1320 return n * 4; 1321 } 1322 1323 /* encode 32bpp rgb + a into 32bpp G0RAB format for blitting into 555 */ 1324 static int copy_transl_555(void *dst, Uint32 *src, int n, 1325 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt) 1326 { 1327 int i; 1328 Uint32 *d = dst; 1329 for(i = 0; i < n; i++) { 1330 unsigned r, g, b, a; 1331 Uint16 pix; 1332 RGBA_FROM_8888(*src, sfmt, r, g, b, a); 1333 PIXEL_FROM_RGB(pix, dfmt, r, g, b); 1334 *d = ((pix & 0x3e0) << 16) | (pix & 0xfc1f) | ((a << 2) & 0x3e0); 1335 src++; 1336 d++; 1337 } 1338 return n * 4; 1339 } 1340 1341 /* decode translucent pixels from 32bpp GORAB to 32bpp rgb + a */ 1342 static int uncopy_transl_16(Uint32 *dst, void *src, int n, 1343 RLEDestFormat *sfmt, SDL_PixelFormat *dfmt) 1344 { 1345 int i; 1346 Uint32 *s = src; 1347 for(i = 0; i < n; i++) { 1348 unsigned r, g, b, a; 1349 Uint32 pix = *s++; 1350 a = (pix & 0x3e0) >> 2; 1351 pix = (pix & ~0x3e0) | pix >> 16; 1352 RGB_FROM_PIXEL(pix, sfmt, r, g, b); 1353 PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, a); 1354 dst++; 1355 } 1356 return n * 4; 1357 } 1358 1359 /* encode 32bpp rgba into 32bpp rgba, keeping alpha (dual purpose) */ 1360 static int copy_32(void *dst, Uint32 *src, int n, 1361 SDL_PixelFormat *sfmt, SDL_PixelFormat *dfmt) 1362 { 1363 int i; 1364 Uint32 *d = dst; 1365 for(i = 0; i < n; i++) { 1366 unsigned r, g, b, a; 1367 Uint32 pixel; 1368 RGBA_FROM_8888(*src, sfmt, r, g, b, a); 1369 PIXEL_FROM_RGB(pixel, dfmt, r, g, b); 1370 *d++ = pixel | a << 24; 1371 src++; 1372 } 1373 return n * 4; 1374 } 1375 1376 /* decode 32bpp rgba into 32bpp rgba, keeping alpha (dual purpose) */ 1377 static int uncopy_32(Uint32 *dst, void *src, int n, 1378 RLEDestFormat *sfmt, SDL_PixelFormat *dfmt) 1379 { 1380 int i; 1381 Uint32 *s = src; 1382 for(i = 0; i < n; i++) { 1383 unsigned r, g, b, a; 1384 Uint32 pixel = *s++; 1385 RGB_FROM_PIXEL(pixel, sfmt, r, g, b); 1386 a = pixel >> 24; 1387 PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, a); 1388 dst++; 1389 } 1390 return n * 4; 1391 } 1392 1393 #define ISOPAQUE(pixel, fmt) ((((pixel) & fmt->Amask) >> fmt->Ashift) == 255) 1394 1395 #define ISTRANSL(pixel, fmt) \ 1396 ((unsigned)((((pixel) & fmt->Amask) >> fmt->Ashift) - 1U) < 254U) 1397 1398 /* convert surface to be quickly alpha-blittable onto dest, if possible */ 1399 static int RLEAlphaSurface(SDL_Surface *surface) 1400 { 1401 SDL_Surface *dest; 1402 SDL_PixelFormat *df; 1403 int maxsize = 0; 1404 int max_opaque_run; 1405 int max_transl_run = 65535; 1406 unsigned masksum; 1407 Uint8 *rlebuf, *dst; 1408 int (*copy_opaque)(void *, Uint32 *, int, 1409 SDL_PixelFormat *, SDL_PixelFormat *); 1410 int (*copy_transl)(void *, Uint32 *, int, 1411 SDL_PixelFormat *, SDL_PixelFormat *); 1412 1413 dest = surface->map->dst; 1414 if(!dest) 1415 return -1; 1416 df = dest->format; 1417 if(surface->format->BitsPerPixel != 32) 1418 return -1; /* only 32bpp source supported */ 1419 1420 /* find out whether the destination is one we support, 1421 and determine the max size of the encoded result */ 1422 masksum = df->Rmask | df->Gmask | df->Bmask; 1423 switch(df->BytesPerPixel) { 1424 case 2: 1425 /* 16bpp: only support 565 and 555 formats */ 1426 switch(masksum) { 1427 case 0xffff: 1428 if(df->Gmask == 0x07e0 1429 || df->Rmask == 0x07e0 || df->Bmask == 0x07e0) { 1430 copy_opaque = copy_opaque_16; 1431 copy_transl = copy_transl_565; 1432 } else 1433 return -1; 1434 break; 1435 case 0x7fff: 1436 if(df->Gmask == 0x03e0 1437 || df->Rmask == 0x03e0 || df->Bmask == 0x03e0) { 1438 copy_opaque = copy_opaque_16; 1439 copy_transl = copy_transl_555; 1440 } else 1441 return -1; 1442 break; 1443 default: 1444 return -1; 1445 } 1446 max_opaque_run = 255; /* runs stored as bytes */ 1447 1448 /* worst case is alternating opaque and translucent pixels, 1449 with room for alignment padding between lines */ 1450 maxsize = surface->h * (2 + (4 + 2) * (surface->w + 1)) + 2; 1451 break; 1452 case 4: 1453 if(masksum != 0x00ffffff) 1454 return -1; /* requires unused high byte */ 1455 copy_opaque = copy_32; 1456 copy_transl = copy_32; 1457 max_opaque_run = 255; /* runs stored as short ints */ 1458 1459 /* worst case is alternating opaque and translucent pixels */ 1460 maxsize = surface->h * 2 * 4 * (surface->w + 1) + 4; 1461 break; 1462 default: 1463 return -1; /* anything else unsupported right now */ 1464 } 1465 1466 maxsize += sizeof(RLEDestFormat); 1467 rlebuf = (Uint8 *)SDL_malloc(maxsize); 1468 if(!rlebuf) { 1469 SDL_OutOfMemory(); 1470 return -1; 1471 } 1472 { 1473 /* save the destination format so we can undo the encoding later */ 1474 RLEDestFormat *r = (RLEDestFormat *)rlebuf; 1475 r->BytesPerPixel = df->BytesPerPixel; 1476 r->Rloss = df->Rloss; 1477 r->Gloss = df->Gloss; 1478 r->Bloss = df->Bloss; 1479 r->Rshift = df->Rshift; 1480 r->Gshift = df->Gshift; 1481 r->Bshift = df->Bshift; 1482 r->Ashift = df->Ashift; 1483 r->Rmask = df->Rmask; 1484 r->Gmask = df->Gmask; 1485 r->Bmask = df->Bmask; 1486 r->Amask = df->Amask; 1487 } 1488 dst = rlebuf + sizeof(RLEDestFormat); 1489 1490 /* Do the actual encoding */ 1491 { 1492 int x, y; 1493 int h = surface->h, w = surface->w; 1494 SDL_PixelFormat *sf = surface->format; 1495 Uint32 *src = (Uint32 *)surface->pixels; 1496 Uint8 *lastline = dst; /* end of last non-blank line */ 1497 1498 /* opaque counts are 8 or 16 bits, depending on target depth */ 1499 #define ADD_OPAQUE_COUNTS(n, m) \ 1500 if(df->BytesPerPixel == 4) { \ 1501 ((Uint16 *)dst)[0] = n; \ 1502 ((Uint16 *)dst)[1] = m; \ 1503 dst += 4; \ 1504 } else { \ 1505 dst[0] = n; \ 1506 dst[1] = m; \ 1507 dst += 2; \ 1508 } 1509 1510 /* translucent counts are always 16 bit */ 1511 #define ADD_TRANSL_COUNTS(n, m) \ 1512 (((Uint16 *)dst)[0] = n, ((Uint16 *)dst)[1] = m, dst += 4) 1513 1514 for(y = 0; y < h; y++) { 1515 int runstart, skipstart; 1516 int blankline = 0; 1517 /* First encode all opaque pixels of a scan line */ 1518 x = 0; 1519 do { 1520 int run, skip, len; 1521 skipstart = x; 1522 while(x < w && !ISOPAQUE(src[x], sf)) 1523 x++; 1524 runstart = x; 1525 while(x < w && ISOPAQUE(src[x], sf)) 1526 x++; 1527 skip = runstart - skipstart; 1528 if(skip == w) 1529 blankline = 1; 1530 run = x - runstart; 1531 while(skip > max_opaque_run) { 1532 ADD_OPAQUE_COUNTS(max_opaque_run, 0); 1533 skip -= max_opaque_run; 1534 } 1535 len = MIN(run, max_opaque_run); 1536 ADD_OPAQUE_COUNTS(skip, len); 1537 dst += copy_opaque(dst, src + runstart, len, sf, df); 1538 runstart += len; 1539 run -= len; 1540 while(run) { 1541 len = MIN(run, max_opaque_run); 1542 ADD_OPAQUE_COUNTS(0, len); 1543 dst += copy_opaque(dst, src + runstart, len, sf, df); 1544 runstart += len; 1545 run -= len; 1546 } 1547 } while(x < w); 1548 1549 /* Make sure the next output address is 32-bit aligned */ 1550 dst += (uintptr_t)dst & 2; 1551 1552 /* Next, encode all translucent pixels of the same scan line */ 1553 x = 0; 1554 do { 1555 int run, skip, len; 1556 skipstart = x; 1557 while(x < w && !ISTRANSL(src[x], sf)) 1558 x++; 1559 runstart = x; 1560 while(x < w && ISTRANSL(src[x], sf)) 1561 x++; 1562 skip = runstart - skipstart; 1563 blankline &= (skip == w); 1564 run = x - runstart; 1565 while(skip > max_transl_run) { 1566 ADD_TRANSL_COUNTS(max_transl_run, 0); 1567 skip -= max_transl_run; 1568 } 1569 len = MIN(run, max_transl_run); 1570 ADD_TRANSL_COUNTS(skip, len); 1571 dst += copy_transl(dst, src + runstart, len, sf, df); 1572 runstart += len; 1573 run -= len; 1574 while(run) { 1575 len = MIN(run, max_transl_run); 1576 ADD_TRANSL_COUNTS(0, len); 1577 dst += copy_transl(dst, src + runstart, len, sf, df); 1578 runstart += len; 1579 run -= len; 1580 } 1581 if(!blankline) 1582 lastline = dst; 1583 } while(x < w); 1584 1585 src += surface->pitch >> 2; 1586 } 1587 dst = lastline; /* back up past trailing blank lines */ 1588 ADD_OPAQUE_COUNTS(0, 0); 1589 } 1590 1591 #undef ADD_OPAQUE_COUNTS 1592 #undef ADD_TRANSL_COUNTS 1593 1594 /* Now that we have it encoded, release the original pixels */ 1595 if((surface->flags & SDL_PREALLOC) != SDL_PREALLOC 1596 && (surface->flags & SDL_HWSURFACE) != SDL_HWSURFACE) { 1597 SDL_free( surface->pixels ); 1598 surface->pixels = NULL; 1599 } 1600 1601 /* realloc the buffer to release unused memory */ 1602 { 1603 Uint8 *p = SDL_realloc(rlebuf, dst - rlebuf); 1604 if(!p) 1605 p = rlebuf; 1606 surface->map->sw_data->aux_data = p; 1607 } 1608 1609 return 0; 1610 } 1611 1612 static Uint32 getpix_8(Uint8 *srcbuf) 1613 { 1614 return *srcbuf; 1615 } 1616 1617 static Uint32 getpix_16(Uint8 *srcbuf) 1618 { 1619 return *(Uint16 *)srcbuf; 1620 } 1621 1622 static Uint32 getpix_24(Uint8 *srcbuf) 1623 { 1624 #if SDL_BYTEORDER == SDL_LIL_ENDIAN 1625 return srcbuf[0] + (srcbuf[1] << 8) + (srcbuf[2] << 16); 1626 #else 1627 return (srcbuf[0] << 16) + (srcbuf[1] << 8) + srcbuf[2]; 1628 #endif 1629 } 1630 1631 static Uint32 getpix_32(Uint8 *srcbuf) 1632 { 1633 return *(Uint32 *)srcbuf; 1634 } 1635 1636 typedef Uint32 (*getpix_func)(Uint8 *); 1637 1638 static getpix_func getpixes[4] = { 1639 getpix_8, getpix_16, getpix_24, getpix_32 1640 }; 1641 1642 static int RLEColorkeySurface(SDL_Surface *surface) 1643 { 1644 Uint8 *rlebuf, *dst; 1645 int maxn; 1646 int y; 1647 Uint8 *srcbuf, *curbuf, *lastline; 1648 int maxsize = 0; 1649 int skip, run; 1650 int bpp = surface->format->BytesPerPixel; 1651 getpix_func getpix; 1652 Uint32 ckey, rgbmask; 1653 int w, h; 1654 1655 /* calculate the worst case size for the compressed surface */ 1656 switch(bpp) { 1657 case 1: 1658 /* worst case is alternating opaque and transparent pixels, 1659 starting with an opaque pixel */ 1660 maxsize = surface->h * 3 * (surface->w / 2 + 1) + 2; 1661 break; 1662 case 2: 1663 case 3: 1664 /* worst case is solid runs, at most 255 pixels wide */ 1665 maxsize = surface->h * (2 * (surface->w / 255 + 1) 1666 + surface->w * bpp) + 2; 1667 break; 1668 case 4: 1669 /* worst case is solid runs, at most 65535 pixels wide */ 1670 maxsize = surface->h * (4 * (surface->w / 65535 + 1) 1671 + surface->w * 4) + 4; 1672 break; 1673 } 1674 1675 rlebuf = (Uint8 *)SDL_malloc(maxsize); 1676 if ( rlebuf == NULL ) { 1677 SDL_OutOfMemory(); 1678 return(-1); 1679 } 1680 1681 /* Set up the conversion */ 1682 srcbuf = (Uint8 *)surface->pixels; 1683 curbuf = srcbuf; 1684 maxn = bpp == 4 ? 65535 : 255; 1685 skip = run = 0; 1686 dst = rlebuf; 1687 rgbmask = ~surface->format->Amask; 1688 ckey = surface->format->colorkey & rgbmask; 1689 lastline = dst; 1690 getpix = getpixes[bpp - 1]; 1691 w = surface->w; 1692 h = surface->h; 1693 1694 #define ADD_COUNTS(n, m) \ 1695 if(bpp == 4) { \ 1696 ((Uint16 *)dst)[0] = n; \ 1697 ((Uint16 *)dst)[1] = m; \ 1698 dst += 4; \ 1699 } else { \ 1700 dst[0] = n; \ 1701 dst[1] = m; \ 1702 dst += 2; \ 1703 } 1704 1705 for(y = 0; y < h; y++) { 1706 int x = 0; 1707 int blankline = 0; 1708 do { 1709 int run, skip, len; 1710 int runstart; 1711 int skipstart = x; 1712 1713 /* find run of transparent, then opaque pixels */ 1714 while(x < w && (getpix(srcbuf + x * bpp) & rgbmask) == ckey) 1715 x++; 1716 runstart = x; 1717 while(x < w && (getpix(srcbuf + x * bpp) & rgbmask) != ckey) 1718 x++; 1719 skip = runstart - skipstart; 1720 if(skip == w) 1721 blankline = 1; 1722 run = x - runstart; 1723 1724 /* encode segment */ 1725 while(skip > maxn) { 1726 ADD_COUNTS(maxn, 0); 1727 skip -= maxn; 1728 } 1729 len = MIN(run, maxn); 1730 ADD_COUNTS(skip, len); 1731 SDL_memcpy(dst, srcbuf + runstart * bpp, len * bpp); 1732 dst += len * bpp; 1733 run -= len; 1734 runstart += len; 1735 while(run) { 1736 len = MIN(run, maxn); 1737 ADD_COUNTS(0, len); 1738 SDL_memcpy(dst, srcbuf + runstart * bpp, len * bpp); 1739 dst += len * bpp; 1740 runstart += len; 1741 run -= len; 1742 } 1743 if(!blankline) 1744 lastline = dst; 1745 } while(x < w); 1746 1747 srcbuf += surface->pitch; 1748 } 1749 dst = lastline; /* back up bast trailing blank lines */ 1750 ADD_COUNTS(0, 0); 1751 1752 #undef ADD_COUNTS 1753 1754 /* Now that we have it encoded, release the original pixels */ 1755 if((surface->flags & SDL_PREALLOC) != SDL_PREALLOC 1756 && (surface->flags & SDL_HWSURFACE) != SDL_HWSURFACE) { 1757 SDL_free( surface->pixels ); 1758 surface->pixels = NULL; 1759 } 1760 1761 /* realloc the buffer to release unused memory */ 1762 { 1763 /* If realloc returns NULL, the original block is left intact */ 1764 Uint8 *p = SDL_realloc(rlebuf, dst - rlebuf); 1765 if(!p) 1766 p = rlebuf; 1767 surface->map->sw_data->aux_data = p; 1768 } 1769 1770 return(0); 1771 } 1772 1773 int SDL_RLESurface(SDL_Surface *surface) 1774 { 1775 int retcode; 1776 1777 /* Clear any previous RLE conversion */ 1778 if ( (surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) { 1779 SDL_UnRLESurface(surface, 1); 1780 } 1781 1782 /* We don't support RLE encoding of bitmaps */ 1783 if ( surface->format->BitsPerPixel < 8 ) { 1784 return(-1); 1785 } 1786 1787 /* Lock the surface if it's in hardware */ 1788 if ( SDL_MUSTLOCK(surface) ) { 1789 if ( SDL_LockSurface(surface) < 0 ) { 1790 return(-1); 1791 } 1792 } 1793 1794 /* Encode */ 1795 if((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) { 1796 retcode = RLEColorkeySurface(surface); 1797 } else { 1798 if((surface->flags & SDL_SRCALPHA) == SDL_SRCALPHA 1799 && surface->format->Amask != 0) 1800 retcode = RLEAlphaSurface(surface); 1801 else 1802 retcode = -1; /* no RLE for per-surface alpha sans ckey */ 1803 } 1804 1805 /* Unlock the surface if it's in hardware */ 1806 if ( SDL_MUSTLOCK(surface) ) { 1807 SDL_UnlockSurface(surface); 1808 } 1809 1810 if(retcode < 0) 1811 return -1; 1812 1813 /* The surface is now accelerated */ 1814 surface->flags |= SDL_RLEACCEL; 1815 1816 return(0); 1817 } 1818 1819 /* 1820 * Un-RLE a surface with pixel alpha 1821 * This may not give back exactly the image before RLE-encoding; all 1822 * completely transparent pixels will be lost, and colour and alpha depth 1823 * may have been reduced (when encoding for 16bpp targets). 1824 */ 1825 static SDL_bool UnRLEAlpha(SDL_Surface *surface) 1826 { 1827 Uint8 *srcbuf; 1828 Uint32 *dst; 1829 SDL_PixelFormat *sf = surface->format; 1830 RLEDestFormat *df = surface->map->sw_data->aux_data; 1831 int (*uncopy_opaque)(Uint32 *, void *, int, 1832 RLEDestFormat *, SDL_PixelFormat *); 1833 int (*uncopy_transl)(Uint32 *, void *, int, 1834 RLEDestFormat *, SDL_PixelFormat *); 1835 int w = surface->w; 1836 int bpp = df->BytesPerPixel; 1837 1838 if(bpp == 2) { 1839 uncopy_opaque = uncopy_opaque_16; 1840 uncopy_transl = uncopy_transl_16; 1841 } else { 1842 uncopy_opaque = uncopy_transl = uncopy_32; 1843 } 1844 1845 surface->pixels = SDL_malloc(surface->h * surface->pitch); 1846 if ( !surface->pixels ) { 1847 return(SDL_FALSE); 1848 } 1849 /* fill background with transparent pixels */ 1850 SDL_memset(surface->pixels, 0, surface->h * surface->pitch); 1851 1852 dst = surface->pixels; 1853 srcbuf = (Uint8 *)(df + 1); 1854 for(;;) { 1855 /* copy opaque pixels */ 1856 int ofs = 0; 1857 do { 1858 unsigned run; 1859 if(bpp == 2) { 1860 ofs += srcbuf[0]; 1861 run = srcbuf[1]; 1862 srcbuf += 2; 1863 } else { 1864 ofs += ((Uint16 *)srcbuf)[0]; 1865 run = ((Uint16 *)srcbuf)[1]; 1866 srcbuf += 4; 1867 } 1868 if(run) { 1869 srcbuf += uncopy_opaque(dst + ofs, srcbuf, run, df, sf); 1870 ofs += run; 1871 } else if(!ofs) 1872 return(SDL_TRUE); 1873 } while(ofs < w); 1874 1875 /* skip padding if needed */ 1876 if(bpp == 2) 1877 srcbuf += (uintptr_t)srcbuf & 2; 1878 1879 /* copy translucent pixels */ 1880 ofs = 0; 1881 do { 1882 unsigned run; 1883 ofs += ((Uint16 *)srcbuf)[0]; 1884 run = ((Uint16 *)srcbuf)[1]; 1885 srcbuf += 4; 1886 if(run) { 1887 srcbuf += uncopy_transl(dst + ofs, srcbuf, run, df, sf); 1888 ofs += run; 1889 } 1890 } while(ofs < w); 1891 dst += surface->pitch >> 2; 1892 } 1893 /* Make the compiler happy */ 1894 return(SDL_TRUE); 1895 } 1896 1897 void SDL_UnRLESurface(SDL_Surface *surface, int recode) 1898 { 1899 if ( (surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) { 1900 surface->flags &= ~SDL_RLEACCEL; 1901 1902 if(recode && (surface->flags & SDL_PREALLOC) != SDL_PREALLOC 1903 && (surface->flags & SDL_HWSURFACE) != SDL_HWSURFACE) { 1904 if((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) { 1905 SDL_Rect full; 1906 unsigned alpha_flag; 1907 1908 /* re-create the original surface */ 1909 surface->pixels = SDL_malloc(surface->h * surface->pitch); 1910 if ( !surface->pixels ) { 1911 /* Oh crap... */ 1912 surface->flags |= SDL_RLEACCEL; 1913 return; 1914 } 1915 1916 /* fill it with the background colour */ 1917 SDL_FillRect(surface, NULL, surface->format->colorkey); 1918 1919 /* now render the encoded surface */ 1920 full.x = full.y = 0; 1921 full.w = surface->w; 1922 full.h = surface->h; 1923 alpha_flag = surface->flags & SDL_SRCALPHA; 1924 surface->flags &= ~SDL_SRCALPHA; /* opaque blit */ 1925 SDL_RLEBlit(surface, &full, surface, &full); 1926 surface->flags |= alpha_flag; 1927 } else { 1928 if ( !UnRLEAlpha(surface) ) { 1929 /* Oh crap... */ 1930 surface->flags |= SDL_RLEACCEL; 1931 return; 1932 } 1933 } 1934 } 1935 1936 if ( surface->map && surface->map->sw_data->aux_data ) { 1937 SDL_free(surface->map->sw_data->aux_data); 1938 surface->map->sw_data->aux_data = NULL; 1939 } 1940 } 1941 } 1942 1943 1944
