mirror of
https://github.com/Relintai/sdl2_frt.git
synced 2024-12-20 22:16:49 +01:00
1584 lines
58 KiB
C
1584 lines
58 KiB
C
/*
|
|
Simple DirectMedia Layer
|
|
Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
*/
|
|
#include "../SDL_internal.h"
|
|
|
|
/*
|
|
* RLE encoding for software colorkey and alpha-channel acceleration
|
|
*
|
|
* Original version by Sam Lantinga
|
|
*
|
|
* Mattias Engdegård (Yorick): Rewrite. New encoding format, encoder and
|
|
* decoder. Added per-surface alpha blitter. Added per-pixel alpha
|
|
* format, encoder and blitter.
|
|
*
|
|
* Many thanks to Xark and johns for hints, benchmarks and useful comments
|
|
* leading to this code.
|
|
*
|
|
* Welcome to Macro Mayhem.
|
|
*/
|
|
|
|
/*
|
|
* The encoding translates the image data to a stream of segments of the form
|
|
*
|
|
* <skip> <run> <data>
|
|
*
|
|
* where <skip> is the number of transparent pixels to skip,
|
|
* <run> is the number of opaque pixels to blit,
|
|
* and <data> are the pixels themselves.
|
|
*
|
|
* This basic structure is used both for colorkeyed surfaces, used for simple
|
|
* binary transparency and for per-surface alpha blending, and for surfaces
|
|
* with per-pixel alpha. The details differ, however:
|
|
*
|
|
* Encoding of colorkeyed surfaces:
|
|
*
|
|
* Encoded pixels always have the same format as the target surface.
|
|
* <skip> and <run> are unsigned 8 bit integers, except for 32 bit depth
|
|
* where they are 16 bit. This makes the pixel data aligned at all times.
|
|
* Segments never wrap around from one scan line to the next.
|
|
*
|
|
* The end of the sequence is marked by a zero <skip>,<run> pair at the *
|
|
* beginning of a line.
|
|
*
|
|
* Encoding of surfaces with per-pixel alpha:
|
|
*
|
|
* The sequence begins with a struct RLEDestFormat describing the target
|
|
* pixel format, to provide reliable un-encoding.
|
|
*
|
|
* Each scan line is encoded twice: First all completely opaque pixels,
|
|
* encoded in the target format as described above, and then all
|
|
* partially transparent (translucent) pixels (where 1 <= alpha <= 254),
|
|
* in the following 32-bit format:
|
|
*
|
|
* For 32-bit targets, each pixel has the target RGB format but with
|
|
* the alpha value occupying the highest 8 bits. The <skip> and <run>
|
|
* counts are 16 bit.
|
|
*
|
|
* For 16-bit targets, each pixel has the target RGB format, but with
|
|
* the middle component (usually green) shifted 16 steps to the left,
|
|
* and the hole filled with the 5 most significant bits of the alpha value.
|
|
* i.e. if the target has the format rrrrrggggggbbbbb,
|
|
* the encoded pixel will be 00000gggggg00000rrrrr0aaaaabbbbb.
|
|
* The <skip> and <run> counts are 8 bit for the opaque lines, 16 bit
|
|
* for the translucent lines. Two padding bytes may be inserted
|
|
* before each translucent line to keep them 32-bit aligned.
|
|
*
|
|
* The end of the sequence is marked by a zero <skip>,<run> pair at the
|
|
* beginning of an opaque line.
|
|
*/
|
|
|
|
#include "SDL_video.h"
|
|
#include "SDL_sysvideo.h"
|
|
#include "SDL_blit.h"
|
|
#include "SDL_RLEaccel_c.h"
|
|
|
|
#ifndef MIN
|
|
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
#endif
|
|
|
|
#define PIXEL_COPY(to, from, len, bpp) \
|
|
SDL_memcpy(to, from, (size_t)(len) * (bpp))
|
|
|
|
/*
|
|
* Various colorkey blit methods, for opaque and per-surface alpha
|
|
*/
|
|
|
|
#define OPAQUE_BLIT(to, from, length, bpp, alpha) \
|
|
PIXEL_COPY(to, from, length, bpp)
|
|
|
|
/*
|
|
* For 32bpp pixels on the form 0x00rrggbb:
|
|
* If we treat the middle component separately, we can process the two
|
|
* remaining in parallel. This is safe to do because of the gap to the left
|
|
* of each component, so the bits from the multiplication don't collide.
|
|
* This can be used for any RGB permutation of course.
|
|
*/
|
|
#define ALPHA_BLIT32_888(to, from, length, bpp, alpha) \
|
|
do { \
|
|
int i; \
|
|
Uint32 *src = (Uint32 *)(from); \
|
|
Uint32 *dst = (Uint32 *)(to); \
|
|
for (i = 0; i < (int)(length); i++) { \
|
|
Uint32 s = *src++; \
|
|
Uint32 d = *dst; \
|
|
Uint32 s1 = s & 0xff00ff; \
|
|
Uint32 d1 = d & 0xff00ff; \
|
|
d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff; \
|
|
s &= 0xff00; \
|
|
d &= 0xff00; \
|
|
d = (d + ((s - d) * alpha >> 8)) & 0xff00; \
|
|
*dst++ = d1 | d; \
|
|
} \
|
|
} while (0)
|
|
|
|
/*
|
|
* For 16bpp pixels we can go a step further: put the middle component
|
|
* in the high 16 bits of a 32 bit word, and process all three RGB
|
|
* components at the same time. Since the smallest gap is here just
|
|
* 5 bits, we have to scale alpha down to 5 bits as well.
|
|
*/
|
|
#define ALPHA_BLIT16_565(to, from, length, bpp, alpha) \
|
|
do { \
|
|
int i; \
|
|
Uint16 *src = (Uint16 *)(from); \
|
|
Uint16 *dst = (Uint16 *)(to); \
|
|
Uint32 ALPHA = alpha >> 3; \
|
|
for(i = 0; i < (int)(length); i++) { \
|
|
Uint32 s = *src++; \
|
|
Uint32 d = *dst; \
|
|
s = (s | s << 16) & 0x07e0f81f; \
|
|
d = (d | d << 16) & 0x07e0f81f; \
|
|
d += (s - d) * ALPHA >> 5; \
|
|
d &= 0x07e0f81f; \
|
|
*dst++ = (Uint16)(d | d >> 16); \
|
|
} \
|
|
} while(0)
|
|
|
|
#define ALPHA_BLIT16_555(to, from, length, bpp, alpha) \
|
|
do { \
|
|
int i; \
|
|
Uint16 *src = (Uint16 *)(from); \
|
|
Uint16 *dst = (Uint16 *)(to); \
|
|
Uint32 ALPHA = alpha >> 3; \
|
|
for(i = 0; i < (int)(length); i++) { \
|
|
Uint32 s = *src++; \
|
|
Uint32 d = *dst; \
|
|
s = (s | s << 16) & 0x03e07c1f; \
|
|
d = (d | d << 16) & 0x03e07c1f; \
|
|
d += (s - d) * ALPHA >> 5; \
|
|
d &= 0x03e07c1f; \
|
|
*dst++ = (Uint16)(d | d >> 16); \
|
|
} \
|
|
} while(0)
|
|
|
|
/*
|
|
* The general slow catch-all function, for remaining depths and formats
|
|
*/
|
|
#define ALPHA_BLIT_ANY(to, from, length, bpp, alpha) \
|
|
do { \
|
|
int i; \
|
|
Uint8 *src = from; \
|
|
Uint8 *dst = to; \
|
|
for (i = 0; i < (int)(length); i++) { \
|
|
Uint32 s, d; \
|
|
unsigned rs, gs, bs, rd, gd, bd; \
|
|
switch (bpp) { \
|
|
case 2: \
|
|
s = *(Uint16 *)src; \
|
|
d = *(Uint16 *)dst; \
|
|
break; \
|
|
case 3: \
|
|
if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { \
|
|
s = (src[0] << 16) | (src[1] << 8) | src[2]; \
|
|
d = (dst[0] << 16) | (dst[1] << 8) | dst[2]; \
|
|
} else { \
|
|
s = (src[2] << 16) | (src[1] << 8) | src[0]; \
|
|
d = (dst[2] << 16) | (dst[1] << 8) | dst[0]; \
|
|
} \
|
|
break; \
|
|
case 4: \
|
|
s = *(Uint32 *)src; \
|
|
d = *(Uint32 *)dst; \
|
|
break; \
|
|
} \
|
|
RGB_FROM_PIXEL(s, fmt, rs, gs, bs); \
|
|
RGB_FROM_PIXEL(d, fmt, rd, gd, bd); \
|
|
rd += (rs - rd) * alpha >> 8; \
|
|
gd += (gs - gd) * alpha >> 8; \
|
|
bd += (bs - bd) * alpha >> 8; \
|
|
PIXEL_FROM_RGB(d, fmt, rd, gd, bd); \
|
|
switch (bpp) { \
|
|
case 2: \
|
|
*(Uint16 *)dst = (Uint16)d; \
|
|
break; \
|
|
case 3: \
|
|
if (SDL_BYTEORDER == SDL_BIG_ENDIAN) { \
|
|
dst[0] = (Uint8)(d >> 16); \
|
|
dst[1] = (Uint8)(d >> 8); \
|
|
dst[2] = (Uint8)(d); \
|
|
} else { \
|
|
dst[0] = (Uint8)d; \
|
|
dst[1] = (Uint8)(d >> 8); \
|
|
dst[2] = (Uint8)(d >> 16); \
|
|
} \
|
|
break; \
|
|
case 4: \
|
|
*(Uint32 *)dst = d; \
|
|
break; \
|
|
} \
|
|
src += bpp; \
|
|
dst += bpp; \
|
|
} \
|
|
} while(0)
|
|
|
|
/*
|
|
* Special case: 50% alpha (alpha=128)
|
|
* This is treated specially because it can be optimized very well, and
|
|
* since it is good for many cases of semi-translucency.
|
|
* The theory is to do all three components at the same time:
|
|
* First zero the lowest bit of each component, which gives us room to
|
|
* add them. Then shift right and add the sum of the lowest bits.
|
|
*/
|
|
#define ALPHA_BLIT32_888_50(to, from, length, bpp, alpha) \
|
|
do { \
|
|
int i; \
|
|
Uint32 *src = (Uint32 *)(from); \
|
|
Uint32 *dst = (Uint32 *)(to); \
|
|
for(i = 0; i < (int)(length); i++) { \
|
|
Uint32 s = *src++; \
|
|
Uint32 d = *dst; \
|
|
*dst++ = (((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1) \
|
|
+ (s & d & 0x00010101); \
|
|
} \
|
|
} while(0)
|
|
|
|
/*
|
|
* For 16bpp, we can actually blend two pixels in parallel, if we take
|
|
* care to shift before we add, not after.
|
|
*/
|
|
|
|
/* helper: blend a single 16 bit pixel at 50% */
|
|
#define BLEND16_50(dst, src, mask) \
|
|
do { \
|
|
Uint32 s = *src++; \
|
|
Uint32 d = *dst; \
|
|
*dst++ = (Uint16)((((s & mask) + (d & mask)) >> 1) + \
|
|
(s & d & (~mask & 0xffff))); \
|
|
} while(0)
|
|
|
|
/* basic 16bpp blender. mask is the pixels to keep when adding. */
|
|
#define ALPHA_BLIT16_50(to, from, length, bpp, alpha, mask) \
|
|
do { \
|
|
unsigned n = (length); \
|
|
Uint16 *src = (Uint16 *)(from); \
|
|
Uint16 *dst = (Uint16 *)(to); \
|
|
if (((uintptr_t)src ^ (uintptr_t)dst) & 3) { \
|
|
/* source and destination not in phase, blit one by one */ \
|
|
while (n--) \
|
|
BLEND16_50(dst, src, mask); \
|
|
} else { \
|
|
if ((uintptr_t)src & 3) { \
|
|
/* first odd pixel */ \
|
|
BLEND16_50(dst, src, mask); \
|
|
n--; \
|
|
} \
|
|
for (; n > 1; n -= 2) { \
|
|
Uint32 s = *(Uint32 *)src; \
|
|
Uint32 d = *(Uint32 *)dst; \
|
|
*(Uint32 *)dst = ((s & (mask | mask << 16)) >> 1) \
|
|
+ ((d & (mask | mask << 16)) >> 1) \
|
|
+ (s & d & (~(mask | mask << 16))); \
|
|
src += 2; \
|
|
dst += 2; \
|
|
} \
|
|
if (n) \
|
|
BLEND16_50(dst, src, mask); /* last odd pixel */ \
|
|
} \
|
|
} while(0)
|
|
|
|
#define ALPHA_BLIT16_565_50(to, from, length, bpp, alpha) \
|
|
ALPHA_BLIT16_50(to, from, length, bpp, alpha, 0xf7de)
|
|
|
|
#define ALPHA_BLIT16_555_50(to, from, length, bpp, alpha) \
|
|
ALPHA_BLIT16_50(to, from, length, bpp, alpha, 0xfbde)
|
|
|
|
#define CHOOSE_BLIT(blitter, alpha, fmt) \
|
|
do { \
|
|
if (alpha == 255) { \
|
|
switch (fmt->BytesPerPixel) { \
|
|
case 1: blitter(1, Uint8, OPAQUE_BLIT); break; \
|
|
case 2: blitter(2, Uint8, OPAQUE_BLIT); break; \
|
|
case 3: blitter(3, Uint8, OPAQUE_BLIT); break; \
|
|
case 4: blitter(4, Uint16, OPAQUE_BLIT); break; \
|
|
} \
|
|
} else { \
|
|
switch (fmt->BytesPerPixel) { \
|
|
case 1: \
|
|
/* No 8bpp alpha blitting */ \
|
|
break; \
|
|
\
|
|
case 2: \
|
|
switch (fmt->Rmask | fmt->Gmask | fmt->Bmask) { \
|
|
case 0xffff: \
|
|
if (fmt->Gmask == 0x07e0 \
|
|
|| fmt->Rmask == 0x07e0 \
|
|
|| fmt->Bmask == 0x07e0) { \
|
|
if (alpha == 128) { \
|
|
blitter(2, Uint8, ALPHA_BLIT16_565_50); \
|
|
} else { \
|
|
blitter(2, Uint8, ALPHA_BLIT16_565); \
|
|
} \
|
|
} else \
|
|
goto general16; \
|
|
break; \
|
|
\
|
|
case 0x7fff: \
|
|
if (fmt->Gmask == 0x03e0 \
|
|
|| fmt->Rmask == 0x03e0 \
|
|
|| fmt->Bmask == 0x03e0) { \
|
|
if (alpha == 128) { \
|
|
blitter(2, Uint8, ALPHA_BLIT16_555_50); \
|
|
} else { \
|
|
blitter(2, Uint8, ALPHA_BLIT16_555); \
|
|
} \
|
|
break; \
|
|
} else \
|
|
goto general16; \
|
|
break; \
|
|
\
|
|
default: \
|
|
general16: \
|
|
blitter(2, Uint8, ALPHA_BLIT_ANY); \
|
|
} \
|
|
break; \
|
|
\
|
|
case 3: \
|
|
blitter(3, Uint8, ALPHA_BLIT_ANY); \
|
|
break; \
|
|
\
|
|
case 4: \
|
|
if ((fmt->Rmask | fmt->Gmask | fmt->Bmask) == 0x00ffffff \
|
|
&& (fmt->Gmask == 0xff00 || fmt->Rmask == 0xff00 \
|
|
|| fmt->Bmask == 0xff00)) { \
|
|
if (alpha == 128) { \
|
|
blitter(4, Uint16, ALPHA_BLIT32_888_50); \
|
|
} else { \
|
|
blitter(4, Uint16, ALPHA_BLIT32_888); \
|
|
} \
|
|
} else \
|
|
blitter(4, Uint16, ALPHA_BLIT_ANY); \
|
|
break; \
|
|
} \
|
|
} \
|
|
} while(0)
|
|
|
|
/*
|
|
* Set a pixel value using the given format, except that the alpha value is
|
|
* placed in the top byte. This is the format used for RLE with alpha.
|
|
*/
|
|
#define RLEPIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a) \
|
|
{ \
|
|
Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \
|
|
((g>>fmt->Gloss)<<fmt->Gshift)| \
|
|
((b>>fmt->Bloss)<<fmt->Bshift)| \
|
|
(a<<24); \
|
|
}
|
|
|
|
/*
|
|
* This takes care of the case when the surface is clipped on the left and/or
|
|
* right. Top clipping has already been taken care of.
|
|
*/
|
|
static void
|
|
RLEClipBlit(int w, Uint8 * srcbuf, SDL_Surface * surf_dst,
|
|
Uint8 * dstbuf, SDL_Rect * srcrect, unsigned alpha)
|
|
{
|
|
SDL_PixelFormat *fmt = surf_dst->format;
|
|
|
|
#define RLECLIPBLIT(bpp, Type, do_blit) \
|
|
do { \
|
|
int linecount = srcrect->h; \
|
|
int ofs = 0; \
|
|
int left = srcrect->x; \
|
|
int right = left + srcrect->w; \
|
|
dstbuf -= left * bpp; \
|
|
for (;;) { \
|
|
int run; \
|
|
ofs += *(Type *)srcbuf; \
|
|
run = ((Type *)srcbuf)[1]; \
|
|
srcbuf += 2 * sizeof(Type); \
|
|
if (run) { \
|
|
/* clip to left and right borders */ \
|
|
if (ofs < right) { \
|
|
int start = 0; \
|
|
int len = run; \
|
|
int startcol; \
|
|
if (left - ofs > 0) { \
|
|
start = left - ofs; \
|
|
len -= start; \
|
|
if (len <= 0) \
|
|
goto nocopy ## bpp ## do_blit; \
|
|
} \
|
|
startcol = ofs + start; \
|
|
if (len > right - startcol) \
|
|
len = right - startcol; \
|
|
do_blit(dstbuf + startcol * bpp, srcbuf + start * bpp, \
|
|
len, bpp, alpha); \
|
|
} \
|
|
nocopy ## bpp ## do_blit: \
|
|
srcbuf += run * bpp; \
|
|
ofs += run; \
|
|
} else if (!ofs) \
|
|
break; \
|
|
\
|
|
if (ofs == w) { \
|
|
ofs = 0; \
|
|
dstbuf += surf_dst->pitch; \
|
|
if (!--linecount) \
|
|
break; \
|
|
} \
|
|
} \
|
|
} while(0)
|
|
|
|
CHOOSE_BLIT(RLECLIPBLIT, alpha, fmt);
|
|
|
|
#undef RLECLIPBLIT
|
|
|
|
}
|
|
|
|
|
|
/* blit a colorkeyed RLE surface */
|
|
int SDLCALL
|
|
SDL_RLEBlit(SDL_Surface * surf_src, SDL_Rect * srcrect,
|
|
SDL_Surface * surf_dst, SDL_Rect * dstrect)
|
|
{
|
|
Uint8 *dstbuf;
|
|
Uint8 *srcbuf;
|
|
int x, y;
|
|
int w = surf_src->w;
|
|
unsigned alpha;
|
|
|
|
/* Lock the destination if necessary */
|
|
if (SDL_MUSTLOCK(surf_dst)) {
|
|
if (SDL_LockSurface(surf_dst) < 0) {
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
/* Set up the source and destination pointers */
|
|
x = dstrect->x;
|
|
y = dstrect->y;
|
|
dstbuf = (Uint8 *) surf_dst->pixels
|
|
+ y * surf_dst->pitch + x * surf_src->format->BytesPerPixel;
|
|
srcbuf = (Uint8 *) surf_src->map->data;
|
|
|
|
{
|
|
/* skip lines at the top if necessary */
|
|
int vskip = srcrect->y;
|
|
int ofs = 0;
|
|
if (vskip) {
|
|
|
|
#define RLESKIP(bpp, Type) \
|
|
for(;;) { \
|
|
int run; \
|
|
ofs += *(Type *)srcbuf; \
|
|
run = ((Type *)srcbuf)[1]; \
|
|
srcbuf += sizeof(Type) * 2; \
|
|
if(run) { \
|
|
srcbuf += run * bpp; \
|
|
ofs += run; \
|
|
} else if(!ofs) \
|
|
goto done; \
|
|
if(ofs == w) { \
|
|
ofs = 0; \
|
|
if(!--vskip) \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
switch (surf_src->format->BytesPerPixel) {
|
|
case 1:
|
|
RLESKIP(1, Uint8);
|
|
break;
|
|
case 2:
|
|
RLESKIP(2, Uint8);
|
|
break;
|
|
case 3:
|
|
RLESKIP(3, Uint8);
|
|
break;
|
|
case 4:
|
|
RLESKIP(4, Uint16);
|
|
break;
|
|
}
|
|
|
|
#undef RLESKIP
|
|
|
|
}
|
|
}
|
|
|
|
alpha = surf_src->map->info.a;
|
|
/* if left or right edge clipping needed, call clip blit */
|
|
if (srcrect->x || srcrect->w != surf_src->w) {
|
|
RLEClipBlit(w, srcbuf, surf_dst, dstbuf, srcrect, alpha);
|
|
} else {
|
|
SDL_PixelFormat *fmt = surf_src->format;
|
|
|
|
#define RLEBLIT(bpp, Type, do_blit) \
|
|
do { \
|
|
int linecount = srcrect->h; \
|
|
int ofs = 0; \
|
|
for(;;) { \
|
|
unsigned run; \
|
|
ofs += *(Type *)srcbuf; \
|
|
run = ((Type *)srcbuf)[1]; \
|
|
srcbuf += 2 * sizeof(Type); \
|
|
if(run) { \
|
|
do_blit(dstbuf + ofs * bpp, srcbuf, run, bpp, alpha); \
|
|
srcbuf += run * bpp; \
|
|
ofs += run; \
|
|
} else if(!ofs) \
|
|
break; \
|
|
if(ofs == w) { \
|
|
ofs = 0; \
|
|
dstbuf += surf_dst->pitch; \
|
|
if(!--linecount) \
|
|
break; \
|
|
} \
|
|
} \
|
|
} while(0)
|
|
|
|
CHOOSE_BLIT(RLEBLIT, alpha, fmt);
|
|
|
|
#undef RLEBLIT
|
|
}
|
|
|
|
done:
|
|
/* Unlock the destination if necessary */
|
|
if (SDL_MUSTLOCK(surf_dst)) {
|
|
SDL_UnlockSurface(surf_dst);
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
#undef OPAQUE_BLIT
|
|
|
|
/*
|
|
* Per-pixel blitting macros for translucent pixels:
|
|
* These use the same techniques as the per-surface blitting macros
|
|
*/
|
|
|
|
/*
|
|
* For 32bpp pixels, we have made sure the alpha is stored in the top
|
|
* 8 bits, so proceed as usual
|
|
*/
|
|
#define BLIT_TRANSL_888(src, dst) \
|
|
do { \
|
|
Uint32 s = src; \
|
|
Uint32 d = dst; \
|
|
unsigned alpha = s >> 24; \
|
|
Uint32 s1 = s & 0xff00ff; \
|
|
Uint32 d1 = d & 0xff00ff; \
|
|
d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff; \
|
|
s &= 0xff00; \
|
|
d &= 0xff00; \
|
|
d = (d + ((s - d) * alpha >> 8)) & 0xff00; \
|
|
dst = d1 | d | 0xff000000; \
|
|
} while(0)
|
|
|
|
/*
|
|
* For 16bpp pixels, we have stored the 5 most significant alpha bits in
|
|
* bits 5-10. As before, we can process all 3 RGB components at the same time.
|
|
*/
|
|
#define BLIT_TRANSL_565(src, dst) \
|
|
do { \
|
|
Uint32 s = src; \
|
|
Uint32 d = dst; \
|
|
unsigned alpha = (s & 0x3e0) >> 5; \
|
|
s &= 0x07e0f81f; \
|
|
d = (d | d << 16) & 0x07e0f81f; \
|
|
d += (s - d) * alpha >> 5; \
|
|
d &= 0x07e0f81f; \
|
|
dst = (Uint16)(d | d >> 16); \
|
|
} while(0)
|
|
|
|
#define BLIT_TRANSL_555(src, dst) \
|
|
do { \
|
|
Uint32 s = src; \
|
|
Uint32 d = dst; \
|
|
unsigned alpha = (s & 0x3e0) >> 5; \
|
|
s &= 0x03e07c1f; \
|
|
d = (d | d << 16) & 0x03e07c1f; \
|
|
d += (s - d) * alpha >> 5; \
|
|
d &= 0x03e07c1f; \
|
|
dst = (Uint16)(d | d >> 16); \
|
|
} while(0)
|
|
|
|
/* used to save the destination format in the encoding. Designed to be
|
|
macro-compatible with SDL_PixelFormat but without the unneeded fields */
|
|
typedef struct
|
|
{
|
|
Uint8 BytesPerPixel;
|
|
Uint8 padding[3];
|
|
Uint32 Rmask;
|
|
Uint32 Gmask;
|
|
Uint32 Bmask;
|
|
Uint32 Amask;
|
|
Uint8 Rloss;
|
|
Uint8 Gloss;
|
|
Uint8 Bloss;
|
|
Uint8 Aloss;
|
|
Uint8 Rshift;
|
|
Uint8 Gshift;
|
|
Uint8 Bshift;
|
|
Uint8 Ashift;
|
|
} RLEDestFormat;
|
|
|
|
/* blit a pixel-alpha RLE surface clipped at the right and/or left edges */
|
|
static void
|
|
RLEAlphaClipBlit(int w, Uint8 * srcbuf, SDL_Surface * surf_dst,
|
|
Uint8 * dstbuf, SDL_Rect * srcrect)
|
|
{
|
|
SDL_PixelFormat *df = surf_dst->format;
|
|
/*
|
|
* clipped blitter: Ptype is the destination pixel type,
|
|
* Ctype the translucent count type, and do_blend the macro
|
|
* to blend one pixel.
|
|
*/
|
|
#define RLEALPHACLIPBLIT(Ptype, Ctype, do_blend) \
|
|
do { \
|
|
int linecount = srcrect->h; \
|
|
int left = srcrect->x; \
|
|
int right = left + srcrect->w; \
|
|
dstbuf -= left * sizeof(Ptype); \
|
|
do { \
|
|
int ofs = 0; \
|
|
/* blit opaque pixels on one line */ \
|
|
do { \
|
|
unsigned run; \
|
|
ofs += ((Ctype *)srcbuf)[0]; \
|
|
run = ((Ctype *)srcbuf)[1]; \
|
|
srcbuf += 2 * sizeof(Ctype); \
|
|
if(run) { \
|
|
/* clip to left and right borders */ \
|
|
int cofs = ofs; \
|
|
int crun = run; \
|
|
if(left - cofs > 0) { \
|
|
crun -= left - cofs; \
|
|
cofs = left; \
|
|
} \
|
|
if(crun > right - cofs) \
|
|
crun = right - cofs; \
|
|
if(crun > 0) \
|
|
PIXEL_COPY(dstbuf + cofs * sizeof(Ptype), \
|
|
srcbuf + (cofs - ofs) * sizeof(Ptype), \
|
|
(unsigned)crun, sizeof(Ptype)); \
|
|
srcbuf += run * sizeof(Ptype); \
|
|
ofs += run; \
|
|
} else if(!ofs) \
|
|
return; \
|
|
} while(ofs < w); \
|
|
/* skip padding if necessary */ \
|
|
if(sizeof(Ptype) == 2) \
|
|
srcbuf += (uintptr_t)srcbuf & 2; \
|
|
/* blit translucent pixels on the same line */ \
|
|
ofs = 0; \
|
|
do { \
|
|
unsigned run; \
|
|
ofs += ((Uint16 *)srcbuf)[0]; \
|
|
run = ((Uint16 *)srcbuf)[1]; \
|
|
srcbuf += 4; \
|
|
if(run) { \
|
|
/* clip to left and right borders */ \
|
|
int cofs = ofs; \
|
|
int crun = run; \
|
|
if(left - cofs > 0) { \
|
|
crun -= left - cofs; \
|
|
cofs = left; \
|
|
} \
|
|
if(crun > right - cofs) \
|
|
crun = right - cofs; \
|
|
if(crun > 0) { \
|
|
Ptype *dst = (Ptype *)dstbuf + cofs; \
|
|
Uint32 *src = (Uint32 *)srcbuf + (cofs - ofs); \
|
|
int i; \
|
|
for(i = 0; i < crun; i++) \
|
|
do_blend(src[i], dst[i]); \
|
|
} \
|
|
srcbuf += run * 4; \
|
|
ofs += run; \
|
|
} \
|
|
} while(ofs < w); \
|
|
dstbuf += surf_dst->pitch; \
|
|
} while(--linecount); \
|
|
} while(0)
|
|
|
|
switch (df->BytesPerPixel) {
|
|
case 2:
|
|
if (df->Gmask == 0x07e0 || df->Rmask == 0x07e0 || df->Bmask == 0x07e0)
|
|
RLEALPHACLIPBLIT(Uint16, Uint8, BLIT_TRANSL_565);
|
|
else
|
|
RLEALPHACLIPBLIT(Uint16, Uint8, BLIT_TRANSL_555);
|
|
break;
|
|
case 4:
|
|
RLEALPHACLIPBLIT(Uint32, Uint16, BLIT_TRANSL_888);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* blit a pixel-alpha RLE surface */
|
|
int SDLCALL
|
|
SDL_RLEAlphaBlit(SDL_Surface * surf_src, SDL_Rect * srcrect,
|
|
SDL_Surface * surf_dst, SDL_Rect * dstrect)
|
|
{
|
|
int x, y;
|
|
int w = surf_src->w;
|
|
Uint8 *srcbuf, *dstbuf;
|
|
SDL_PixelFormat *df = surf_dst->format;
|
|
|
|
/* Lock the destination if necessary */
|
|
if (SDL_MUSTLOCK(surf_dst)) {
|
|
if (SDL_LockSurface(surf_dst) < 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
x = dstrect->x;
|
|
y = dstrect->y;
|
|
dstbuf = (Uint8 *) surf_dst->pixels + y * surf_dst->pitch + x * df->BytesPerPixel;
|
|
srcbuf = (Uint8 *) surf_src->map->data + sizeof(RLEDestFormat);
|
|
|
|
{
|
|
/* skip lines at the top if necessary */
|
|
int vskip = srcrect->y;
|
|
if (vskip) {
|
|
int ofs;
|
|
if (df->BytesPerPixel == 2) {
|
|
/* the 16/32 interleaved format */
|
|
do {
|
|
/* skip opaque line */
|
|
ofs = 0;
|
|
do {
|
|
int run;
|
|
ofs += srcbuf[0];
|
|
run = srcbuf[1];
|
|
srcbuf += 2;
|
|
if (run) {
|
|
srcbuf += 2 * run;
|
|
ofs += run;
|
|
} else if (!ofs)
|
|
goto done;
|
|
} while (ofs < w);
|
|
|
|
/* skip padding */
|
|
srcbuf += (uintptr_t) srcbuf & 2;
|
|
|
|
/* skip translucent line */
|
|
ofs = 0;
|
|
do {
|
|
int run;
|
|
ofs += ((Uint16 *) srcbuf)[0];
|
|
run = ((Uint16 *) srcbuf)[1];
|
|
srcbuf += 4 * (run + 1);
|
|
ofs += run;
|
|
} while (ofs < w);
|
|
} while (--vskip);
|
|
} else {
|
|
/* the 32/32 interleaved format */
|
|
vskip <<= 1; /* opaque and translucent have same format */
|
|
do {
|
|
ofs = 0;
|
|
do {
|
|
int run;
|
|
ofs += ((Uint16 *) srcbuf)[0];
|
|
run = ((Uint16 *) srcbuf)[1];
|
|
srcbuf += 4;
|
|
if (run) {
|
|
srcbuf += 4 * run;
|
|
ofs += run;
|
|
} else if (!ofs)
|
|
goto done;
|
|
} while (ofs < w);
|
|
} while (--vskip);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* if left or right edge clipping needed, call clip blit */
|
|
if (srcrect->x || srcrect->w != surf_src->w) {
|
|
RLEAlphaClipBlit(w, srcbuf, surf_dst, dstbuf, srcrect);
|
|
} else {
|
|
|
|
/*
|
|
* non-clipped blitter. Ptype is the destination pixel type,
|
|
* Ctype the translucent count type, and do_blend the
|
|
* macro to blend one pixel.
|
|
*/
|
|
#define RLEALPHABLIT(Ptype, Ctype, do_blend) \
|
|
do { \
|
|
int linecount = srcrect->h; \
|
|
do { \
|
|
int ofs = 0; \
|
|
/* blit opaque pixels on one line */ \
|
|
do { \
|
|
unsigned run; \
|
|
ofs += ((Ctype *)srcbuf)[0]; \
|
|
run = ((Ctype *)srcbuf)[1]; \
|
|
srcbuf += 2 * sizeof(Ctype); \
|
|
if(run) { \
|
|
PIXEL_COPY(dstbuf + ofs * sizeof(Ptype), srcbuf, \
|
|
run, sizeof(Ptype)); \
|
|
srcbuf += run * sizeof(Ptype); \
|
|
ofs += run; \
|
|
} else if(!ofs) \
|
|
goto done; \
|
|
} while(ofs < w); \
|
|
/* skip padding if necessary */ \
|
|
if(sizeof(Ptype) == 2) \
|
|
srcbuf += (uintptr_t)srcbuf & 2; \
|
|
/* blit translucent pixels on the same line */ \
|
|
ofs = 0; \
|
|
do { \
|
|
unsigned run; \
|
|
ofs += ((Uint16 *)srcbuf)[0]; \
|
|
run = ((Uint16 *)srcbuf)[1]; \
|
|
srcbuf += 4; \
|
|
if(run) { \
|
|
Ptype *dst = (Ptype *)dstbuf + ofs; \
|
|
unsigned i; \
|
|
for(i = 0; i < run; i++) { \
|
|
Uint32 src = *(Uint32 *)srcbuf; \
|
|
do_blend(src, *dst); \
|
|
srcbuf += 4; \
|
|
dst++; \
|
|
} \
|
|
ofs += run; \
|
|
} \
|
|
} while(ofs < w); \
|
|
dstbuf += surf_dst->pitch; \
|
|
} while(--linecount); \
|
|
} while(0)
|
|
|
|
switch (df->BytesPerPixel) {
|
|
case 2:
|
|
if (df->Gmask == 0x07e0 || df->Rmask == 0x07e0
|
|
|| df->Bmask == 0x07e0)
|
|
RLEALPHABLIT(Uint16, Uint8, BLIT_TRANSL_565);
|
|
else
|
|
RLEALPHABLIT(Uint16, Uint8, BLIT_TRANSL_555);
|
|
break;
|
|
case 4:
|
|
RLEALPHABLIT(Uint32, Uint16, BLIT_TRANSL_888);
|
|
break;
|
|
}
|
|
}
|
|
|
|
done:
|
|
/* Unlock the destination if necessary */
|
|
if (SDL_MUSTLOCK(surf_dst)) {
|
|
SDL_UnlockSurface(surf_dst);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Auxiliary functions:
|
|
* The encoding functions take 32bpp rgb + a, and
|
|
* return the number of bytes copied to the destination.
|
|
* The decoding functions copy to 32bpp rgb + a, and
|
|
* return the number of bytes copied from the source.
|
|
* These are only used in the encoder and un-RLE code and are therefore not
|
|
* highly optimised.
|
|
*/
|
|
|
|
/* encode 32bpp rgb + a into 16bpp rgb, losing alpha */
|
|
static int
|
|
copy_opaque_16(void *dst, Uint32 * src, int n,
|
|
SDL_PixelFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint16 *d = dst;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b;
|
|
RGB_FROM_PIXEL(*src, sfmt, r, g, b);
|
|
PIXEL_FROM_RGB(*d, dfmt, r, g, b);
|
|
src++;
|
|
d++;
|
|
}
|
|
return n * 2;
|
|
}
|
|
|
|
/* decode opaque pixels from 16bpp to 32bpp rgb + a */
|
|
static int
|
|
uncopy_opaque_16(Uint32 * dst, void *src, int n,
|
|
RLEDestFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint16 *s = src;
|
|
unsigned alpha = dfmt->Amask ? 255 : 0;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b;
|
|
RGB_FROM_PIXEL(*s, sfmt, r, g, b);
|
|
PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, alpha);
|
|
s++;
|
|
dst++;
|
|
}
|
|
return n * 2;
|
|
}
|
|
|
|
|
|
|
|
/* encode 32bpp rgb + a into 32bpp G0RAB format for blitting into 565 */
|
|
static int
|
|
copy_transl_565(void *dst, Uint32 * src, int n,
|
|
SDL_PixelFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint32 *d = dst;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b, a;
|
|
Uint16 pix;
|
|
RGBA_FROM_8888(*src, sfmt, r, g, b, a);
|
|
PIXEL_FROM_RGB(pix, dfmt, r, g, b);
|
|
*d = ((pix & 0x7e0) << 16) | (pix & 0xf81f) | ((a << 2) & 0x7e0);
|
|
src++;
|
|
d++;
|
|
}
|
|
return n * 4;
|
|
}
|
|
|
|
/* encode 32bpp rgb + a into 32bpp G0RAB format for blitting into 555 */
|
|
static int
|
|
copy_transl_555(void *dst, Uint32 * src, int n,
|
|
SDL_PixelFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint32 *d = dst;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b, a;
|
|
Uint16 pix;
|
|
RGBA_FROM_8888(*src, sfmt, r, g, b, a);
|
|
PIXEL_FROM_RGB(pix, dfmt, r, g, b);
|
|
*d = ((pix & 0x3e0) << 16) | (pix & 0xfc1f) | ((a << 2) & 0x3e0);
|
|
src++;
|
|
d++;
|
|
}
|
|
return n * 4;
|
|
}
|
|
|
|
/* decode translucent pixels from 32bpp GORAB to 32bpp rgb + a */
|
|
static int
|
|
uncopy_transl_16(Uint32 * dst, void *src, int n,
|
|
RLEDestFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint32 *s = src;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b, a;
|
|
Uint32 pix = *s++;
|
|
a = (pix & 0x3e0) >> 2;
|
|
pix = (pix & ~0x3e0) | pix >> 16;
|
|
RGB_FROM_PIXEL(pix, sfmt, r, g, b);
|
|
PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, a);
|
|
dst++;
|
|
}
|
|
return n * 4;
|
|
}
|
|
|
|
/* encode 32bpp rgba into 32bpp rgba, keeping alpha (dual purpose) */
|
|
static int
|
|
copy_32(void *dst, Uint32 * src, int n,
|
|
SDL_PixelFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint32 *d = dst;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b, a;
|
|
RGBA_FROM_8888(*src, sfmt, r, g, b, a);
|
|
RLEPIXEL_FROM_RGBA(*d, dfmt, r, g, b, a);
|
|
d++;
|
|
src++;
|
|
}
|
|
return n * 4;
|
|
}
|
|
|
|
/* decode 32bpp rgba into 32bpp rgba, keeping alpha (dual purpose) */
|
|
static int
|
|
uncopy_32(Uint32 * dst, void *src, int n,
|
|
RLEDestFormat * sfmt, SDL_PixelFormat * dfmt)
|
|
{
|
|
int i;
|
|
Uint32 *s = src;
|
|
for (i = 0; i < n; i++) {
|
|
unsigned r, g, b, a;
|
|
Uint32 pixel = *s++;
|
|
RGB_FROM_PIXEL(pixel, sfmt, r, g, b);
|
|
a = pixel >> 24;
|
|
PIXEL_FROM_RGBA(*dst, dfmt, r, g, b, a);
|
|
dst++;
|
|
}
|
|
return n * 4;
|
|
}
|
|
|
|
#define ISOPAQUE(pixel, fmt) ((((pixel) & fmt->Amask) >> fmt->Ashift) == 255)
|
|
|
|
#define ISTRANSL(pixel, fmt) \
|
|
((unsigned)((((pixel) & fmt->Amask) >> fmt->Ashift) - 1U) < 254U)
|
|
|
|
/* convert surface to be quickly alpha-blittable onto dest, if possible */
|
|
static int
|
|
RLEAlphaSurface(SDL_Surface * surface)
|
|
{
|
|
SDL_Surface *dest;
|
|
SDL_PixelFormat *df;
|
|
int maxsize = 0;
|
|
int max_opaque_run;
|
|
int max_transl_run = 65535;
|
|
unsigned masksum;
|
|
Uint8 *rlebuf, *dst;
|
|
int (*copy_opaque) (void *, Uint32 *, int,
|
|
SDL_PixelFormat *, SDL_PixelFormat *);
|
|
int (*copy_transl) (void *, Uint32 *, int,
|
|
SDL_PixelFormat *, SDL_PixelFormat *);
|
|
|
|
dest = surface->map->dst;
|
|
if (!dest)
|
|
return -1;
|
|
df = dest->format;
|
|
if (surface->format->BitsPerPixel != 32)
|
|
return -1; /* only 32bpp source supported */
|
|
|
|
/* find out whether the destination is one we support,
|
|
and determine the max size of the encoded result */
|
|
masksum = df->Rmask | df->Gmask | df->Bmask;
|
|
switch (df->BytesPerPixel) {
|
|
case 2:
|
|
/* 16bpp: only support 565 and 555 formats */
|
|
switch (masksum) {
|
|
case 0xffff:
|
|
if (df->Gmask == 0x07e0
|
|
|| df->Rmask == 0x07e0 || df->Bmask == 0x07e0) {
|
|
copy_opaque = copy_opaque_16;
|
|
copy_transl = copy_transl_565;
|
|
} else
|
|
return -1;
|
|
break;
|
|
case 0x7fff:
|
|
if (df->Gmask == 0x03e0
|
|
|| df->Rmask == 0x03e0 || df->Bmask == 0x03e0) {
|
|
copy_opaque = copy_opaque_16;
|
|
copy_transl = copy_transl_555;
|
|
} else
|
|
return -1;
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
max_opaque_run = 255; /* runs stored as bytes */
|
|
|
|
/* worst case is alternating opaque and translucent pixels,
|
|
with room for alignment padding between lines */
|
|
maxsize = surface->h * (2 + (4 + 2) * (surface->w + 1)) + 2;
|
|
break;
|
|
case 4:
|
|
if (masksum != 0x00ffffff)
|
|
return -1; /* requires unused high byte */
|
|
copy_opaque = copy_32;
|
|
copy_transl = copy_32;
|
|
max_opaque_run = 255; /* runs stored as short ints */
|
|
|
|
/* worst case is alternating opaque and translucent pixels */
|
|
maxsize = surface->h * 2 * 4 * (surface->w + 1) + 4;
|
|
break;
|
|
default:
|
|
return -1; /* anything else unsupported right now */
|
|
}
|
|
|
|
maxsize += sizeof(RLEDestFormat);
|
|
rlebuf = (Uint8 *) SDL_malloc(maxsize);
|
|
if (!rlebuf) {
|
|
return SDL_OutOfMemory();
|
|
}
|
|
{
|
|
/* save the destination format so we can undo the encoding later */
|
|
RLEDestFormat *r = (RLEDestFormat *) rlebuf;
|
|
r->BytesPerPixel = df->BytesPerPixel;
|
|
r->Rmask = df->Rmask;
|
|
r->Gmask = df->Gmask;
|
|
r->Bmask = df->Bmask;
|
|
r->Amask = df->Amask;
|
|
r->Rloss = df->Rloss;
|
|
r->Gloss = df->Gloss;
|
|
r->Bloss = df->Bloss;
|
|
r->Aloss = df->Aloss;
|
|
r->Rshift = df->Rshift;
|
|
r->Gshift = df->Gshift;
|
|
r->Bshift = df->Bshift;
|
|
r->Ashift = df->Ashift;
|
|
}
|
|
dst = rlebuf + sizeof(RLEDestFormat);
|
|
|
|
/* Do the actual encoding */
|
|
{
|
|
int x, y;
|
|
int h = surface->h, w = surface->w;
|
|
SDL_PixelFormat *sf = surface->format;
|
|
Uint32 *src = (Uint32 *) surface->pixels;
|
|
Uint8 *lastline = dst; /* end of last non-blank line */
|
|
|
|
/* opaque counts are 8 or 16 bits, depending on target depth */
|
|
#define ADD_OPAQUE_COUNTS(n, m) \
|
|
if(df->BytesPerPixel == 4) { \
|
|
((Uint16 *)dst)[0] = n; \
|
|
((Uint16 *)dst)[1] = m; \
|
|
dst += 4; \
|
|
} else { \
|
|
dst[0] = n; \
|
|
dst[1] = m; \
|
|
dst += 2; \
|
|
}
|
|
|
|
/* translucent counts are always 16 bit */
|
|
#define ADD_TRANSL_COUNTS(n, m) \
|
|
(((Uint16 *)dst)[0] = n, ((Uint16 *)dst)[1] = m, dst += 4)
|
|
|
|
for (y = 0; y < h; y++) {
|
|
int runstart, skipstart;
|
|
int blankline = 0;
|
|
/* First encode all opaque pixels of a scan line */
|
|
x = 0;
|
|
do {
|
|
int run, skip, len;
|
|
skipstart = x;
|
|
while (x < w && !ISOPAQUE(src[x], sf))
|
|
x++;
|
|
runstart = x;
|
|
while (x < w && ISOPAQUE(src[x], sf))
|
|
x++;
|
|
skip = runstart - skipstart;
|
|
if (skip == w)
|
|
blankline = 1;
|
|
run = x - runstart;
|
|
while (skip > max_opaque_run) {
|
|
ADD_OPAQUE_COUNTS(max_opaque_run, 0);
|
|
skip -= max_opaque_run;
|
|
}
|
|
len = MIN(run, max_opaque_run);
|
|
ADD_OPAQUE_COUNTS(skip, len);
|
|
dst += copy_opaque(dst, src + runstart, len, sf, df);
|
|
runstart += len;
|
|
run -= len;
|
|
while (run) {
|
|
len = MIN(run, max_opaque_run);
|
|
ADD_OPAQUE_COUNTS(0, len);
|
|
dst += copy_opaque(dst, src + runstart, len, sf, df);
|
|
runstart += len;
|
|
run -= len;
|
|
}
|
|
} while (x < w);
|
|
|
|
/* Make sure the next output address is 32-bit aligned */
|
|
dst += (uintptr_t) dst & 2;
|
|
|
|
/* Next, encode all translucent pixels of the same scan line */
|
|
x = 0;
|
|
do {
|
|
int run, skip, len;
|
|
skipstart = x;
|
|
while (x < w && !ISTRANSL(src[x], sf))
|
|
x++;
|
|
runstart = x;
|
|
while (x < w && ISTRANSL(src[x], sf))
|
|
x++;
|
|
skip = runstart - skipstart;
|
|
blankline &= (skip == w);
|
|
run = x - runstart;
|
|
while (skip > max_transl_run) {
|
|
ADD_TRANSL_COUNTS(max_transl_run, 0);
|
|
skip -= max_transl_run;
|
|
}
|
|
len = MIN(run, max_transl_run);
|
|
ADD_TRANSL_COUNTS(skip, len);
|
|
dst += copy_transl(dst, src + runstart, len, sf, df);
|
|
runstart += len;
|
|
run -= len;
|
|
while (run) {
|
|
len = MIN(run, max_transl_run);
|
|
ADD_TRANSL_COUNTS(0, len);
|
|
dst += copy_transl(dst, src + runstart, len, sf, df);
|
|
runstart += len;
|
|
run -= len;
|
|
}
|
|
if (!blankline)
|
|
lastline = dst;
|
|
} while (x < w);
|
|
|
|
src += surface->pitch >> 2;
|
|
}
|
|
dst = lastline; /* back up past trailing blank lines */
|
|
ADD_OPAQUE_COUNTS(0, 0);
|
|
}
|
|
|
|
#undef ADD_OPAQUE_COUNTS
|
|
#undef ADD_TRANSL_COUNTS
|
|
|
|
/* Now that we have it encoded, release the original pixels */
|
|
if (!(surface->flags & SDL_PREALLOC)) {
|
|
SDL_free(surface->pixels);
|
|
surface->pixels = NULL;
|
|
}
|
|
|
|
/* realloc the buffer to release unused memory */
|
|
{
|
|
Uint8 *p = SDL_realloc(rlebuf, dst - rlebuf);
|
|
if (!p)
|
|
p = rlebuf;
|
|
surface->map->data = p;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static Uint32
|
|
getpix_8(Uint8 * srcbuf)
|
|
{
|
|
return *srcbuf;
|
|
}
|
|
|
|
static Uint32
|
|
getpix_16(Uint8 * srcbuf)
|
|
{
|
|
return *(Uint16 *) srcbuf;
|
|
}
|
|
|
|
static Uint32
|
|
getpix_24(Uint8 * srcbuf)
|
|
{
|
|
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
|
|
return srcbuf[0] + (srcbuf[1] << 8) + (srcbuf[2] << 16);
|
|
#else
|
|
return (srcbuf[0] << 16) + (srcbuf[1] << 8) + srcbuf[2];
|
|
#endif
|
|
}
|
|
|
|
static Uint32
|
|
getpix_32(Uint8 * srcbuf)
|
|
{
|
|
return *(Uint32 *) srcbuf;
|
|
}
|
|
|
|
typedef Uint32(*getpix_func) (Uint8 *);
|
|
|
|
static const getpix_func getpixes[4] = {
|
|
getpix_8, getpix_16, getpix_24, getpix_32
|
|
};
|
|
|
|
static int
|
|
RLEColorkeySurface(SDL_Surface * surface)
|
|
{
|
|
Uint8 *rlebuf, *dst;
|
|
int maxn;
|
|
int y;
|
|
Uint8 *srcbuf, *lastline;
|
|
int maxsize = 0;
|
|
const int bpp = surface->format->BytesPerPixel;
|
|
getpix_func getpix;
|
|
Uint32 ckey, rgbmask;
|
|
int w, h;
|
|
|
|
/* calculate the worst case size for the compressed surface */
|
|
switch (bpp) {
|
|
case 1:
|
|
/* worst case is alternating opaque and transparent pixels,
|
|
starting with an opaque pixel */
|
|
maxsize = surface->h * 3 * (surface->w / 2 + 1) + 2;
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
/* worst case is solid runs, at most 255 pixels wide */
|
|
maxsize = surface->h * (2 * (surface->w / 255 + 1)
|
|
+ surface->w * bpp) + 2;
|
|
break;
|
|
case 4:
|
|
/* worst case is solid runs, at most 65535 pixels wide */
|
|
maxsize = surface->h * (4 * (surface->w / 65535 + 1)
|
|
+ surface->w * 4) + 4;
|
|
break;
|
|
|
|
default:
|
|
return -1;
|
|
}
|
|
|
|
rlebuf = (Uint8 *) SDL_malloc(maxsize);
|
|
if (rlebuf == NULL) {
|
|
return SDL_OutOfMemory();
|
|
}
|
|
|
|
/* Set up the conversion */
|
|
srcbuf = (Uint8 *) surface->pixels;
|
|
maxn = bpp == 4 ? 65535 : 255;
|
|
dst = rlebuf;
|
|
rgbmask = ~surface->format->Amask;
|
|
ckey = surface->map->info.colorkey & rgbmask;
|
|
lastline = dst;
|
|
getpix = getpixes[bpp - 1];
|
|
w = surface->w;
|
|
h = surface->h;
|
|
|
|
#define ADD_COUNTS(n, m) \
|
|
if(bpp == 4) { \
|
|
((Uint16 *)dst)[0] = n; \
|
|
((Uint16 *)dst)[1] = m; \
|
|
dst += 4; \
|
|
} else { \
|
|
dst[0] = n; \
|
|
dst[1] = m; \
|
|
dst += 2; \
|
|
}
|
|
|
|
for (y = 0; y < h; y++) {
|
|
int x = 0;
|
|
int blankline = 0;
|
|
do {
|
|
int run, skip, len;
|
|
int runstart;
|
|
int skipstart = x;
|
|
|
|
/* find run of transparent, then opaque pixels */
|
|
while (x < w && (getpix(srcbuf + x * bpp) & rgbmask) == ckey)
|
|
x++;
|
|
runstart = x;
|
|
while (x < w && (getpix(srcbuf + x * bpp) & rgbmask) != ckey)
|
|
x++;
|
|
skip = runstart - skipstart;
|
|
if (skip == w)
|
|
blankline = 1;
|
|
run = x - runstart;
|
|
|
|
/* encode segment */
|
|
while (skip > maxn) {
|
|
ADD_COUNTS(maxn, 0);
|
|
skip -= maxn;
|
|
}
|
|
len = MIN(run, maxn);
|
|
ADD_COUNTS(skip, len);
|
|
SDL_memcpy(dst, srcbuf + runstart * bpp, len * bpp);
|
|
dst += len * bpp;
|
|
run -= len;
|
|
runstart += len;
|
|
while (run) {
|
|
len = MIN(run, maxn);
|
|
ADD_COUNTS(0, len);
|
|
SDL_memcpy(dst, srcbuf + runstart * bpp, len * bpp);
|
|
dst += len * bpp;
|
|
runstart += len;
|
|
run -= len;
|
|
}
|
|
if (!blankline)
|
|
lastline = dst;
|
|
} while (x < w);
|
|
|
|
srcbuf += surface->pitch;
|
|
}
|
|
dst = lastline; /* back up bast trailing blank lines */
|
|
ADD_COUNTS(0, 0);
|
|
|
|
#undef ADD_COUNTS
|
|
|
|
/* Now that we have it encoded, release the original pixels */
|
|
if (!(surface->flags & SDL_PREALLOC)) {
|
|
SDL_free(surface->pixels);
|
|
surface->pixels = NULL;
|
|
}
|
|
|
|
/* realloc the buffer to release unused memory */
|
|
{
|
|
/* If realloc returns NULL, the original block is left intact */
|
|
Uint8 *p = SDL_realloc(rlebuf, dst - rlebuf);
|
|
if (!p)
|
|
p = rlebuf;
|
|
surface->map->data = p;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
SDL_RLESurface(SDL_Surface * surface)
|
|
{
|
|
int flags;
|
|
|
|
/* Clear any previous RLE conversion */
|
|
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
|
|
SDL_UnRLESurface(surface, 1);
|
|
}
|
|
|
|
/* We don't support RLE encoding of bitmaps */
|
|
if (surface->format->BitsPerPixel < 8) {
|
|
return -1;
|
|
}
|
|
|
|
/* Make sure the pixels are available */
|
|
if (!surface->pixels) {
|
|
return -1;
|
|
}
|
|
|
|
/* If we don't have colorkey or blending, nothing to do... */
|
|
flags = surface->map->info.flags;
|
|
if (!(flags & (SDL_COPY_COLORKEY | SDL_COPY_BLEND))) {
|
|
return -1;
|
|
}
|
|
|
|
/* Pass on combinations not supported */
|
|
if ((flags & SDL_COPY_MODULATE_COLOR) ||
|
|
((flags & SDL_COPY_MODULATE_ALPHA) && surface->format->Amask) ||
|
|
(flags & (SDL_COPY_ADD | SDL_COPY_MOD)) ||
|
|
(flags & SDL_COPY_NEAREST)) {
|
|
return -1;
|
|
}
|
|
|
|
/* Encode and set up the blit */
|
|
if (!surface->format->Amask || !(flags & SDL_COPY_BLEND)) {
|
|
if (!surface->map->identity) {
|
|
return -1;
|
|
}
|
|
if (RLEColorkeySurface(surface) < 0) {
|
|
return -1;
|
|
}
|
|
surface->map->blit = SDL_RLEBlit;
|
|
surface->map->info.flags |= SDL_COPY_RLE_COLORKEY;
|
|
} else {
|
|
if (RLEAlphaSurface(surface) < 0) {
|
|
return -1;
|
|
}
|
|
surface->map->blit = SDL_RLEAlphaBlit;
|
|
surface->map->info.flags |= SDL_COPY_RLE_ALPHAKEY;
|
|
}
|
|
|
|
/* The surface is now accelerated */
|
|
surface->flags |= SDL_RLEACCEL;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* Un-RLE a surface with pixel alpha
|
|
* This may not give back exactly the image before RLE-encoding; all
|
|
* completely transparent pixels will be lost, and color and alpha depth
|
|
* may have been reduced (when encoding for 16bpp targets).
|
|
*/
|
|
static SDL_bool
|
|
UnRLEAlpha(SDL_Surface * surface)
|
|
{
|
|
Uint8 *srcbuf;
|
|
Uint32 *dst;
|
|
SDL_PixelFormat *sf = surface->format;
|
|
RLEDestFormat *df = surface->map->data;
|
|
int (*uncopy_opaque) (Uint32 *, void *, int,
|
|
RLEDestFormat *, SDL_PixelFormat *);
|
|
int (*uncopy_transl) (Uint32 *, void *, int,
|
|
RLEDestFormat *, SDL_PixelFormat *);
|
|
int w = surface->w;
|
|
int bpp = df->BytesPerPixel;
|
|
|
|
if (bpp == 2) {
|
|
uncopy_opaque = uncopy_opaque_16;
|
|
uncopy_transl = uncopy_transl_16;
|
|
} else {
|
|
uncopy_opaque = uncopy_transl = uncopy_32;
|
|
}
|
|
|
|
surface->pixels = SDL_malloc(surface->h * surface->pitch);
|
|
if (!surface->pixels) {
|
|
return (SDL_FALSE);
|
|
}
|
|
/* fill background with transparent pixels */
|
|
SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
|
|
|
|
dst = surface->pixels;
|
|
srcbuf = (Uint8 *) (df + 1);
|
|
for (;;) {
|
|
/* copy opaque pixels */
|
|
int ofs = 0;
|
|
do {
|
|
unsigned run;
|
|
if (bpp == 2) {
|
|
ofs += srcbuf[0];
|
|
run = srcbuf[1];
|
|
srcbuf += 2;
|
|
} else {
|
|
ofs += ((Uint16 *) srcbuf)[0];
|
|
run = ((Uint16 *) srcbuf)[1];
|
|
srcbuf += 4;
|
|
}
|
|
if (run) {
|
|
srcbuf += uncopy_opaque(dst + ofs, srcbuf, run, df, sf);
|
|
ofs += run;
|
|
} else if (!ofs) {
|
|
goto end_function;
|
|
}
|
|
} while (ofs < w);
|
|
|
|
/* skip padding if needed */
|
|
if (bpp == 2)
|
|
srcbuf += (uintptr_t) srcbuf & 2;
|
|
|
|
/* copy translucent pixels */
|
|
ofs = 0;
|
|
do {
|
|
unsigned run;
|
|
ofs += ((Uint16 *) srcbuf)[0];
|
|
run = ((Uint16 *) srcbuf)[1];
|
|
srcbuf += 4;
|
|
if (run) {
|
|
srcbuf += uncopy_transl(dst + ofs, srcbuf, run, df, sf);
|
|
ofs += run;
|
|
}
|
|
} while (ofs < w);
|
|
dst += surface->pitch >> 2;
|
|
}
|
|
|
|
end_function:
|
|
return (SDL_TRUE);
|
|
}
|
|
|
|
void
|
|
SDL_UnRLESurface(SDL_Surface * surface, int recode)
|
|
{
|
|
if (surface->flags & SDL_RLEACCEL) {
|
|
surface->flags &= ~SDL_RLEACCEL;
|
|
|
|
if (recode && !(surface->flags & SDL_PREALLOC)) {
|
|
if (surface->map->info.flags & SDL_COPY_RLE_COLORKEY) {
|
|
SDL_Rect full;
|
|
|
|
/* re-create the original surface */
|
|
surface->pixels = SDL_malloc(surface->h * surface->pitch);
|
|
if (!surface->pixels) {
|
|
/* Oh crap... */
|
|
surface->flags |= SDL_RLEACCEL;
|
|
return;
|
|
}
|
|
|
|
/* fill it with the background color */
|
|
SDL_FillRect(surface, NULL, surface->map->info.colorkey);
|
|
|
|
/* now render the encoded surface */
|
|
full.x = full.y = 0;
|
|
full.w = surface->w;
|
|
full.h = surface->h;
|
|
SDL_RLEBlit(surface, &full, surface, &full);
|
|
} else {
|
|
if (!UnRLEAlpha(surface)) {
|
|
/* Oh crap... */
|
|
surface->flags |= SDL_RLEACCEL;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
surface->map->info.flags &=
|
|
~(SDL_COPY_RLE_COLORKEY | SDL_COPY_RLE_ALPHAKEY);
|
|
|
|
SDL_free(surface->map->data);
|
|
surface->map->data = NULL;
|
|
}
|
|
}
|
|
|
|
/* vi: set ts=4 sw=4 expandtab: */
|