sdlgfxblitfunc.cpp File Reference

(986a3bf)

#include "resources/sdlgfxblitfunc.h"
#include "utils/cast.h"
#include "utils/checkutils.h"
#include <SDL_video.h>
#include "debug.h"

Go to the source code of this file.

Data Structures
struct	anonymous_namespace{sdlgfxblitfunc.cpp}::SDL_gfxBlitInfo

Namespaces
	anonymous_namespace{sdlgfxblitfunc.cpp}

Macros
#define	GFX_DUFFS_LOOP4(pixel_copy_increment, width)

Functions
static void	_SDL_gfxBlitBlitterRGBA (const SDL_gfxBlitInfo *const info)
static int	_SDL_gfxBlitRGBACall (const SDL_Surface *const src, const SDL_Rect *const srcrect, const SDL_Surface *const dst, const SDL_Rect *const dstrect)
int	SDLgfxBlitRGBA (const SDL_Surface *const src, const SDL_Rect *const srcrect, SDL_Surface *const dst, const SDL_Rect *const dstrect)

Variables
unsigned int	anonymous_namespace{sdlgfxblitfunc.cpp}::GFX_ALPHA_ADJUST_ARRAY [256]

Macro Definition Documentation

GFX_DUFFS_LOOP4

#define GFX_DUFFS_LOOP4	(		pixel_copy_increment,
			width
	)

Value:

    int n = ((width) + 3) / 4; \
    switch ((width) & 3) \
    { \
        case 0: do { \
            pixel_copy_increment; \
        case 3: pixel_copy_increment; \
        case 2: pixel_copy_increment; \
        case 1: pixel_copy_increment; \
        default: ; \
            } while (--n > 0 ); \
    }

Definition at line 43 of file sdlgfxblitfunc.cpp.

Function Documentation

_SDL_gfxBlitBlitterRGBA()

static void _SDL_gfxBlitBlitterRGBA ( const SDL_gfxBlitInfo *const  info )

static

Definition at line 337 of file sdlgfxblitfunc.cpp.

{
    const int width = info->d_width;
    int height = info->d_height;
    Uint8 *src = info->s_pixels;
    const int srcskip = info->s_skip;
    Uint8 *dst = info->d_pixels;
    const int dstskip = info->d_skip;
    const SDL_PixelFormat *const srcfmt = info->src;
 
    while ((height--) != 0)
    {
        GFX_DUFFS_LOOP4(
        {
            Uint32 pixel;
            uint32_t sR;
            uint32_t sG;
            uint32_t sB;
            uint32_t sA;
            uint32_t dR;
            uint32_t dG;
            uint32_t dB;
            uint32_t dA;
            uint32_t sAA;
 
            pixel = *(reinterpret_cast<uint32_t *>(src));
            sR = ((pixel & srcfmt->Rmask) >> srcfmt->Rshift);
            sG = ((pixel & srcfmt->Gmask) >> srcfmt->Gshift);
            sB = ((pixel & srcfmt->Bmask) >> srcfmt->Bshift);
            sA = ((pixel & srcfmt->Amask) >> srcfmt->Ashift);
 
            pixel = *(reinterpret_cast<uint32_t *>(dst));
            dR = pixel & 0xffU;
            dG = ((pixel & 0xff00U) >> 8);
            dB = ((pixel & 0xff0000U) >> 16);
            dA = ((pixel & 0xff000000U) >> 24);
 
            sAA = GFX_ALPHA_ADJUST_ARRAY[sA & 255];
            dR = (((sR - dR) * (sAA)) / 255) + dR;
            dG = (((sG - dG) * (sAA)) / 255) + dG;
            dB = (((sB - dB) * (sAA)) / 255) + dB;
            dA |= sAA;
 
            *(reinterpret_cast<uint32_t *>(dst)) = dR |
                (dG << 8) |
                (dB << 16) |
                (dA << 24);
 
            src += 4;
            dst += 4;
        }, width)
        src += srcskip;
        dst += dstskip;
    }
}

References anonymous_namespace{sdlgfxblitfunc.cpp}::GFX_ALPHA_ADJUST_ARRAY, GFX_DUFFS_LOOP4, and Actions::info().

Referenced by _SDL_gfxBlitRGBACall().

_SDL_gfxBlitRGBACall()

static int _SDL_gfxBlitRGBACall ( const SDL_Surface *const  src, const SDL_Rect *const  srcrect, const SDL_Surface *const  dst, const SDL_Rect *const  dstrect  )

static

Definition at line 393 of file sdlgfxblitfunc.cpp.

{
    /*
    * Set up source and destination buffer pointers, then blit
    */
    if ((srcrect->w != 0U) && (srcrect->h != 0U))
    {
        SDL_gfxBlitInfo info;
 
        /*
        * Set up the blit information
        */
        info.s_pixels = static_cast<Uint8 *>(src->pixels) + src->offset +
            static_cast<Uint16>(srcrect->y) * src->pitch +
            static_cast<Uint16>(srcrect->x) * src->format->BytesPerPixel;
        info.s_width = srcrect->w;
        info.s_height = srcrect->h;
        info.s_skip = CAST_S32(src->pitch - info.s_width *
            src->format->BytesPerPixel);
        info.d_pixels = static_cast<Uint8 *>(dst->pixels) + dst->offset +
            static_cast<Uint16>(dstrect->y) * dst->pitch +
            static_cast<Uint16>(dstrect->x) * dst->format->BytesPerPixel;
        info.d_width = dstrect->w;
        info.d_height = dstrect->h;
        info.d_skip = CAST_S32(dst->pitch - info.d_width *
            dst->format->BytesPerPixel);
        info.aux_data = nullptr;
        info.src = src->format;
        info.table = nullptr;
        info.dst = dst->format;
 
        /*
        * Run the actual software blitter
        */
        _SDL_gfxBlitBlitterRGBA(&info);
        return 1;
    }
 
    return 0;
}

References _SDL_gfxBlitBlitterRGBA(), CAST_S32, and Actions::info().

Referenced by SDLgfxBlitRGBA().

SDLgfxBlitRGBA()

int SDLgfxBlitRGBA	(	const SDL_Surface *const	src,
		const SDL_Rect *const	srcrect,
		SDL_Surface *const	dst,
		const SDL_Rect *const	dstrect
	)

Definition at line 437 of file sdlgfxblitfunc.cpp.

{
    SDL_Rect sr;
    SDL_Rect dr;
    int srcx;
    int srcy;
    int w;
    int h;
 
    /*
    * Make sure the surfaces aren't locked
    */
    if (src == nullptr ||
        dst == nullptr)
    {
        reportAlways("SDLgfxBlitRGBA: passed a NULL surface")
        return -1;
    }
 
    /*
    * If the destination rectangle is NULL, use the entire dest surface
    */
    if (dstrect == nullptr)
    {
        dr.x = 0;
        dr.y = 0;
        dr.w = CAST_U16(dst->w);
        dr.h = CAST_U16(dst->h);
    }
    else
    {
        dr = *dstrect;
    }
 
    /*
    * Clip the source rectangle to the source surface
    */
    if (srcrect != nullptr)
    {
        int maxw;
        int maxh;
 
        srcx = srcrect->x;
        w = srcrect->w;
        maxw = src->w - srcx;
        if (maxw < w)
            w = maxw;
 
        srcy = srcrect->y;
        h = srcrect->h;
        maxh = src->h - srcy;
        if (maxh < h)
            h = maxh;
    }
    else
    {
        srcx = 0;
        srcy = 0;
        w = src->w;
        h = src->h;
    }
 
    /*
    * Clip the destination rectangle against the clip rectangle
    */
    const SDL_Rect *const clip = &dst->clip_rect;
    int dx;
    int dy;
 
    dx = clip->x - dr.x;
    if (dx > 0)
    {
        w -= dx;
        dr.x += dx;
        srcx += CAST_S16(dx);
    }
    dx = dr.x + w - clip->x - clip->w;
    if (dx > 0)
        w -= dx;
 
    dy = clip->y - dr.y;
    if (dy > 0)
    {
        h -= dy;
        dr.y += dy;
        srcy += CAST_S16(dy);
    }
    dy = dr.y + h - clip->y - clip->h;
    if (dy > 0)
        h -= dy;
 
    if (w > 0 && h > 0)
    {
        sr.x = CAST_S16(srcx);
        sr.y = CAST_S16(srcy);
        sr.w = dr.w = CAST_U16(w);
        sr.h = dr.h = CAST_U16(h);
        return _SDL_gfxBlitRGBACall(src, &sr, dst, &dr);
    }
 
    return 0;
}

References _SDL_gfxBlitRGBACall(), CAST_S16, CAST_U16, and reportAlways.

Referenced by SDLImageHelper::combineSurface(), and TestLauncher::testBlitSpeed().