diff options
Diffstat (limited to 'source/3rd-party/SDL2/src/video/SDL_fillrect.c')
| -rw-r--r-- | source/3rd-party/SDL2/src/video/SDL_fillrect.c | 343 |
1 files changed, 343 insertions, 0 deletions
diff --git a/source/3rd-party/SDL2/src/video/SDL_fillrect.c b/source/3rd-party/SDL2/src/video/SDL_fillrect.c new file mode 100644 index 0000000..63f5fcb --- /dev/null +++ b/source/3rd-party/SDL2/src/video/SDL_fillrect.c @@ -0,0 +1,343 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2018 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" + +#include "SDL_video.h" +#include "SDL_blit.h" + + +#ifdef __SSE__ +/* *INDENT-OFF* */ + +#ifdef _MSC_VER +#define SSE_BEGIN \ + __m128 c128; \ + c128.m128_u32[0] = color; \ + c128.m128_u32[1] = color; \ + c128.m128_u32[2] = color; \ + c128.m128_u32[3] = color; +#else +#define SSE_BEGIN \ + __m128 c128; \ + DECLARE_ALIGNED(Uint32, cccc[4], 16); \ + cccc[0] = color; \ + cccc[1] = color; \ + cccc[2] = color; \ + cccc[3] = color; \ + c128 = *(__m128 *)cccc; +#endif + +#define SSE_WORK \ + for (i = n / 64; i--;) { \ + _mm_stream_ps((float *)(p+0), c128); \ + _mm_stream_ps((float *)(p+16), c128); \ + _mm_stream_ps((float *)(p+32), c128); \ + _mm_stream_ps((float *)(p+48), c128); \ + p += 64; \ + } + +#define SSE_END + +#define DEFINE_SSE_FILLRECT(bpp, type) \ +static void \ +SDL_FillRect##bpp##SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h) \ +{ \ + int i, n; \ + Uint8 *p = NULL; \ + \ + SSE_BEGIN; \ + \ + while (h--) { \ + n = w * bpp; \ + p = pixels; \ + \ + if (n > 63) { \ + int adjust = 16 - ((uintptr_t)p & 15); \ + if (adjust < 16) { \ + n -= adjust; \ + adjust /= bpp; \ + while (adjust--) { \ + *((type *)p) = (type)color; \ + p += bpp; \ + } \ + } \ + SSE_WORK; \ + } \ + if (n & 63) { \ + int remainder = (n & 63); \ + remainder /= bpp; \ + while (remainder--) { \ + *((type *)p) = (type)color; \ + p += bpp; \ + } \ + } \ + pixels += pitch; \ + } \ + \ + SSE_END; \ +} + +static void +SDL_FillRect1SSE(Uint8 *pixels, int pitch, Uint32 color, int w, int h) +{ + int i, n; + + SSE_BEGIN; + while (h--) { + Uint8 *p = pixels; + n = w; + + if (n > 63) { + int adjust = 16 - ((uintptr_t)p & 15); + if (adjust) { + n -= adjust; + SDL_memset(p, color, adjust); + p += adjust; + } + SSE_WORK; + } + if (n & 63) { + int remainder = (n & 63); + SDL_memset(p, color, remainder); + } + pixels += pitch; + } + + SSE_END; +} +/* DEFINE_SSE_FILLRECT(1, Uint8) */ +DEFINE_SSE_FILLRECT(2, Uint16) +DEFINE_SSE_FILLRECT(4, Uint32) + +/* *INDENT-ON* */ +#endif /* __SSE__ */ + +static void +SDL_FillRect1(Uint8 * pixels, int pitch, Uint32 color, int w, int h) +{ + int n; + Uint8 *p = NULL; + + while (h--) { + n = w; + p = pixels; + + if (n > 3) { + switch ((uintptr_t) p & 3) { + case 1: + *p++ = (Uint8) color; + --n; /* fallthrough */ + case 2: + *p++ = (Uint8) color; + --n; /* fallthrough */ + case 3: + *p++ = (Uint8) color; + --n; /* fallthrough */ + } + SDL_memset4(p, color, (n >> 2)); + } + if (n & 3) { + p += (n & ~3); + switch (n & 3) { + case 3: + *p++ = (Uint8) color; /* fallthrough */ + case 2: + *p++ = (Uint8) color; /* fallthrough */ + case 1: + *p++ = (Uint8) color; /* fallthrough */ + } + } + pixels += pitch; + } +} + +static void +SDL_FillRect2(Uint8 * pixels, int pitch, Uint32 color, int w, int h) +{ + int n; + Uint16 *p = NULL; + + while (h--) { + n = w; + p = (Uint16 *) pixels; + + if (n > 1) { + if ((uintptr_t) p & 2) { + *p++ = (Uint16) color; + --n; + } + SDL_memset4(p, color, (n >> 1)); + } + if (n & 1) { + p[n - 1] = (Uint16) color; + } + pixels += pitch; + } +} + +static void +SDL_FillRect3(Uint8 * pixels, int pitch, Uint32 color, int w, int h) +{ +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + Uint8 b1 = (Uint8) (color & 0xFF); + Uint8 b2 = (Uint8) ((color >> 8) & 0xFF); + Uint8 b3 = (Uint8) ((color >> 16) & 0xFF); +#elif SDL_BYTEORDER == SDL_BIG_ENDIAN + Uint8 b1 = (Uint8) ((color >> 16) & 0xFF); + Uint8 b2 = (Uint8) ((color >> 8) & 0xFF); + Uint8 b3 = (Uint8) (color & 0xFF); +#endif + int n; + Uint8 *p = NULL; + + while (h--) { + n = w; + p = pixels; + + while (n--) { + *p++ = b1; + *p++ = b2; + *p++ = b3; + } + pixels += pitch; + } +} + +static void +SDL_FillRect4(Uint8 * pixels, int pitch, Uint32 color, int w, int h) +{ + while (h--) { + SDL_memset4(pixels, color, w); + pixels += pitch; + } +} + +/* + * This function performs a fast fill of the given rectangle with 'color' + */ +int +SDL_FillRect(SDL_Surface * dst, const SDL_Rect * rect, Uint32 color) +{ + SDL_Rect clipped; + Uint8 *pixels; + + if (!dst) { + return SDL_SetError("Passed NULL destination surface"); + } + + /* This function doesn't work on surfaces < 8 bpp */ + if (dst->format->BitsPerPixel < 8) { + return SDL_SetError("SDL_FillRect(): Unsupported surface format"); + } + + /* If 'rect' == NULL, then fill the whole surface */ + if (rect) { + /* Perform clipping */ + if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) { + return 0; + } + rect = &clipped; + } else { + rect = &dst->clip_rect; + /* Don't attempt to fill if the surface's clip_rect is empty */ + if (SDL_RectEmpty(rect)) { + return 0; + } + } + + /* Perform software fill */ + if (!dst->pixels) { + return SDL_SetError("SDL_FillRect(): You must lock the surface"); + } + + pixels = (Uint8 *) dst->pixels + rect->y * dst->pitch + + rect->x * dst->format->BytesPerPixel; + + switch (dst->format->BytesPerPixel) { + case 1: + { + color |= (color << 8); + color |= (color << 16); +#ifdef __SSE__ + if (SDL_HasSSE()) { + SDL_FillRect1SSE(pixels, dst->pitch, color, rect->w, rect->h); + break; + } +#endif + SDL_FillRect1(pixels, dst->pitch, color, rect->w, rect->h); + break; + } + + case 2: + { + color |= (color << 16); +#ifdef __SSE__ + if (SDL_HasSSE()) { + SDL_FillRect2SSE(pixels, dst->pitch, color, rect->w, rect->h); + break; + } +#endif + SDL_FillRect2(pixels, dst->pitch, color, rect->w, rect->h); + break; + } + + case 3: + /* 24-bit RGB is a slow path, at least for now. */ + { + SDL_FillRect3(pixels, dst->pitch, color, rect->w, rect->h); + break; + } + + case 4: + { +#ifdef __SSE__ + if (SDL_HasSSE()) { + SDL_FillRect4SSE(pixels, dst->pitch, color, rect->w, rect->h); + break; + } +#endif + SDL_FillRect4(pixels, dst->pitch, color, rect->w, rect->h); + break; + } + } + + /* We're done! */ + return 0; +} + +int +SDL_FillRects(SDL_Surface * dst, const SDL_Rect * rects, int count, + Uint32 color) +{ + int i; + int status = 0; + + if (!rects) { + return SDL_SetError("SDL_FillRects() passed NULL rects"); + } + + for (i = 0; i < count; ++i) { + status += SDL_FillRect(dst, &rects[i], color); + } + return status; +} + +/* vi: set ts=4 sw=4 expandtab: */ |