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().