SDL 2.0
SDL_blit.h File Reference
#include "../SDL_internal.h"
#include "SDL_cpuinfo.h"
#include "SDL_endian.h"
#include "SDL_surface.h"
+ Include dependency graph for SDL_blit.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  SDL_BlitInfo
 
struct  SDL_BlitFuncEntry
 
struct  SDL_BlitMap
 

Macros

#define SDL_COPY_MODULATE_COLOR   0x00000001
 
#define SDL_COPY_MODULATE_ALPHA   0x00000002
 
#define SDL_COPY_BLEND   0x00000010
 
#define SDL_COPY_ADD   0x00000020
 
#define SDL_COPY_MOD   0x00000040
 
#define SDL_COPY_COLORKEY   0x00000100
 
#define SDL_COPY_NEAREST   0x00000200
 
#define SDL_COPY_RLE_DESIRED   0x00001000
 
#define SDL_COPY_RLE_COLORKEY   0x00002000
 
#define SDL_COPY_RLE_ALPHAKEY   0x00004000
 
#define SDL_COPY_RLE_MASK   (SDL_COPY_RLE_DESIRED|SDL_COPY_RLE_COLORKEY|SDL_COPY_RLE_ALPHAKEY)
 
#define SDL_CPU_ANY   0x00000000
 
#define SDL_CPU_MMX   0x00000001
 
#define SDL_CPU_3DNOW   0x00000002
 
#define SDL_CPU_SSE   0x00000004
 
#define SDL_CPU_SSE2   0x00000008
 
#define SDL_CPU_ALTIVEC_PREFETCH   0x00000010
 
#define SDL_CPU_ALTIVEC_NOPREFETCH   0x00000020
 
#define DECLARE_ALIGNED(t, v, a)   t v
 
#define RGB_FROM_PIXEL(Pixel, fmt, r, g, b)
 
#define RGB_FROM_RGB565(Pixel, r, g, b)
 
#define RGB_FROM_RGB555(Pixel, r, g, b)
 
#define RGB_FROM_RGB888(Pixel, r, g, b)
 
#define RETRIEVE_RGB_PIXEL(buf, bpp, Pixel)
 
#define DISEMBLE_RGB(buf, bpp, fmt, Pixel, r, g, b)
 
#define PIXEL_FROM_RGB(Pixel, fmt, r, g, b)
 
#define RGB565_FROM_RGB(Pixel, r, g, b)
 
#define RGB555_FROM_RGB(Pixel, r, g, b)
 
#define RGB888_FROM_RGB(Pixel, r, g, b)
 
#define ARGB8888_FROM_RGBA(Pixel, r, g, b, a)
 
#define RGBA8888_FROM_RGBA(Pixel, r, g, b, a)
 
#define ABGR8888_FROM_RGBA(Pixel, r, g, b, a)
 
#define BGRA8888_FROM_RGBA(Pixel, r, g, b, a)
 
#define ARGB2101010_FROM_RGBA(Pixel, r, g, b, a)
 
#define ASSEMBLE_RGB(buf, bpp, fmt, r, g, b)
 
#define RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a)
 
#define RGBA_FROM_8888(Pixel, fmt, r, g, b, a)
 
#define RGBA_FROM_RGBA8888(Pixel, r, g, b, a)
 
#define RGBA_FROM_ARGB8888(Pixel, r, g, b, a)
 
#define RGBA_FROM_ABGR8888(Pixel, r, g, b, a)
 
#define RGBA_FROM_BGRA8888(Pixel, r, g, b, a)
 
#define RGBA_FROM_ARGB2101010(Pixel, r, g, b, a)
 
#define DISEMBLE_RGBA(buf, bpp, fmt, Pixel, r, g, b, a)
 
#define PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a)
 
#define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a)
 
#define ALPHA_BLEND_RGB(sR, sG, sB, A, dR, dG, dB)
 
#define ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA)
 
#define USE_DUFFS_LOOP
 
#define DUFFS_LOOP8(pixel_copy_increment, width)
 
#define DUFFS_LOOP4(pixel_copy_increment, width)
 
#define DUFFS_LOOP(pixel_copy_increment, width)    DUFFS_LOOP8(pixel_copy_increment, width)
 
#define DUFFS_LOOP_124(pixel_copy_increment1, pixel_copy_increment2, pixel_copy_increment4, width)
 

Typedefs

typedef void(* SDL_BlitFunc) (SDL_BlitInfo *info)
 

Functions

int SDL_CalculateBlit (SDL_Surface *surface)
 
SDL_BlitFunc SDL_CalculateBlit0 (SDL_Surface *surface)
 
SDL_BlitFunc SDL_CalculateBlit1 (SDL_Surface *surface)
 
SDL_BlitFunc SDL_CalculateBlitN (SDL_Surface *surface)
 
SDL_BlitFunc SDL_CalculateBlitA (SDL_Surface *surface)
 

Variables

Uint8SDL_expand_byte [9]
 

Macro Definition Documentation

◆ ABGR8888_FROM_RGBA

#define ABGR8888_FROM_RGBA (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
Pixel = (a<<24)|(b<<16)|(g<<8)|r; \
}
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
GLboolean GLboolean GLboolean b
GLboolean GLboolean GLboolean GLboolean a
GLboolean GLboolean g

Definition at line 245 of file SDL_blit.h.

◆ ALPHA_BLEND_RGB

#define ALPHA_BLEND_RGB (   sR,
  sG,
  sB,
  A,
  dR,
  dG,
  dB 
)
Value:
do { \
dR = (Uint8)((((int)(sR-dR)*(int)A)/255)+dR); \
dG = (Uint8)((((int)(sG-dG)*(int)A)/255)+dG); \
dB = (Uint8)((((int)(sB-dB)*(int)A)/255)+dB); \
} while(0)
uint8_t Uint8
Definition: SDL_stdinc.h:179

Definition at line 445 of file SDL_blit.h.

◆ ALPHA_BLEND_RGBA

#define ALPHA_BLEND_RGBA (   sR,
  sG,
  sB,
  sA,
  dR,
  dG,
  dB,
  dA 
)
Value:
do { \
dR = (Uint8)((((int)(sR-dR)*(int)sA)/255)+dR); \
dG = (Uint8)((((int)(sG-dG)*(int)sA)/255)+dG); \
dB = (Uint8)((((int)(sB-dB)*(int)sA)/255)+dB); \
dA = (Uint8)((int)sA+dA-((int)sA*dA)/255); \
} while(0)

Definition at line 454 of file SDL_blit.h.

◆ ARGB2101010_FROM_RGBA

#define ARGB2101010_FROM_RGBA (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = r ? ((r << 2) | 0x3) : 0; \
g = g ? ((g << 2) | 0x3) : 0; \
b = b ? ((b << 2) | 0x3) : 0; \
a = (a * 3) / 255; \
Pixel = (a<<30)|(r<<20)|(g<<10)|b; \
}

Definition at line 253 of file SDL_blit.h.

◆ ARGB8888_FROM_RGBA

#define ARGB8888_FROM_RGBA (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
Pixel = (a<<24)|(r<<16)|(g<<8)|b; \
}

Definition at line 237 of file SDL_blit.h.

◆ ASSEMBLE_RGB

#define ASSEMBLE_RGB (   buf,
  bpp,
  fmt,
  r,
  g,
  b 
)

Definition at line 261 of file SDL_blit.h.

◆ ASSEMBLE_RGBA

#define ASSEMBLE_RGBA (   buf,
  bpp,
  fmt,
  r,
  g,
  b,
  a 
)

Definition at line 402 of file SDL_blit.h.

◆ BGRA8888_FROM_RGBA

#define BGRA8888_FROM_RGBA (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
Pixel = (b<<24)|(g<<16)|(r<<8)|a; \
}

Definition at line 249 of file SDL_blit.h.

◆ DECLARE_ALIGNED

#define DECLARE_ALIGNED (   t,
  v,
  a 
)    t v

Definition at line 118 of file SDL_blit.h.

◆ DISEMBLE_RGB

#define DISEMBLE_RGB (   buf,
  bpp,
  fmt,
  Pixel,
  r,
  g,
  b 
)

Definition at line 177 of file SDL_blit.h.

◆ DISEMBLE_RGBA

#define DISEMBLE_RGBA (   buf,
  bpp,
  fmt,
  Pixel,
  r,
  g,
  b,
  a 
)

Definition at line 353 of file SDL_blit.h.

◆ DUFFS_LOOP

#define DUFFS_LOOP (   pixel_copy_increment,
  width 
)     DUFFS_LOOP8(pixel_copy_increment, width)

Definition at line 500 of file SDL_blit.h.

◆ DUFFS_LOOP4

#define DUFFS_LOOP4 (   pixel_copy_increment,
  width 
)
Value:
{ int n = (width+3)/4; \
switch (width & 3) { \
case 0: do { pixel_copy_increment; /* fallthrough */ \
case 3: pixel_copy_increment; /* fallthrough */ \
case 2: pixel_copy_increment; /* fallthrough */ \
case 1: pixel_copy_increment; /* fallthrough */ \
} while (--n > 0); \
} \
}
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
GLdouble n

Definition at line 488 of file SDL_blit.h.

◆ DUFFS_LOOP8

#define DUFFS_LOOP8 (   pixel_copy_increment,
  width 
)
Value:
{ int n = (width+7)/8; \
switch (width & 7) { \
case 0: do { pixel_copy_increment; /* fallthrough */ \
case 7: pixel_copy_increment; /* fallthrough */ \
case 6: pixel_copy_increment; /* fallthrough */ \
case 5: pixel_copy_increment; /* fallthrough */ \
case 4: pixel_copy_increment; /* fallthrough */ \
case 3: pixel_copy_increment; /* fallthrough */ \
case 2: pixel_copy_increment; /* fallthrough */ \
case 1: pixel_copy_increment; /* fallthrough */ \
} while ( --n > 0 ); \
} \
}

Definition at line 472 of file SDL_blit.h.

◆ DUFFS_LOOP_124

#define DUFFS_LOOP_124 (   pixel_copy_increment1,
  pixel_copy_increment2,
  pixel_copy_increment4,
  width 
)
Value:
{ int n = width; \
if (n & 1) { \
pixel_copy_increment1; n -= 1; \
} \
if (n & 2) { \
pixel_copy_increment2; n -= 2; \
} \
if (n & 4) { \
pixel_copy_increment4; n -= 4; \
} \
if (n) { \
n /= 8; \
do { \
pixel_copy_increment4; \
pixel_copy_increment4; \
} while (--n > 0); \
} \
}

Definition at line 504 of file SDL_blit.h.

◆ PIXEL_FROM_RGB

#define PIXEL_FROM_RGB (   Pixel,
  fmt,
  r,
  g,
  b 
)
Value:
{ \
Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \
((g>>fmt->Gloss)<<fmt->Gshift)| \
((b>>fmt->Bloss)<<fmt->Bshift)| \
fmt->Amask; \
}

Definition at line 218 of file SDL_blit.h.

◆ PIXEL_FROM_RGBA

#define PIXEL_FROM_RGBA (   Pixel,
  fmt,
  r,
  g,
  b,
  a 
)
Value:
{ \
Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \
((g>>fmt->Gloss)<<fmt->Gshift)| \
((b>>fmt->Bloss)<<fmt->Bshift)| \
((a>>fmt->Aloss)<<fmt->Ashift); \
}

Definition at line 395 of file SDL_blit.h.

◆ RETRIEVE_RGB_PIXEL

#define RETRIEVE_RGB_PIXEL (   buf,
  bpp,
  Pixel 
)
Value:
do { \
switch (bpp) { \
case 1: \
Pixel = *((Uint8 *)(buf)); \
break; \
\
case 2: \
Pixel = *((Uint16 *)(buf)); \
break; \
\
case 3: { \
Uint8 *B = (Uint8 *)(buf); \
Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \
} else { \
Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \
} \
} \
break; \
\
case 4: \
Pixel = *((Uint32 *)(buf)); \
break; \
\
default: \
Pixel = 0; /* stop gcc complaints */ \
break; \
} \
} while (0)
#define SDL_BYTEORDER
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
GLenum GLuint GLenum GLsizei const GLchar * buf
uint32_t Uint32
Definition: SDL_stdinc.h:203
uint16_t Uint16
Definition: SDL_stdinc.h:191

Definition at line 146 of file SDL_blit.h.

◆ RGB555_FROM_RGB

#define RGB555_FROM_RGB (   Pixel,
  r,
  g,
  b 
)
Value:
{ \
Pixel = ((r>>3)<<10)|((g>>3)<<5)|(b>>3); \
}

Definition at line 229 of file SDL_blit.h.

◆ RGB565_FROM_RGB

#define RGB565_FROM_RGB (   Pixel,
  r,
  g,
  b 
)
Value:
{ \
Pixel = ((r>>3)<<11)|((g>>2)<<5)|(b>>3); \
}

Definition at line 225 of file SDL_blit.h.

◆ RGB888_FROM_RGB

#define RGB888_FROM_RGB (   Pixel,
  r,
  g,
  b 
)
Value:
{ \
Pixel = (r<<16)|(g<<8)|b; \
}

Definition at line 233 of file SDL_blit.h.

◆ RGB_FROM_PIXEL

#define RGB_FROM_PIXEL (   Pixel,
  fmt,
  r,
  g,
  b 
)
Value:
{ \
r = SDL_expand_byte[fmt->Rloss][((Pixel&fmt->Rmask)>>fmt->Rshift)]; \
g = SDL_expand_byte[fmt->Gloss][((Pixel&fmt->Gmask)>>fmt->Gshift)]; \
b = SDL_expand_byte[fmt->Bloss][((Pixel&fmt->Bmask)>>fmt->Bshift)]; \
}
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71

Definition at line 122 of file SDL_blit.h.

◆ RGB_FROM_RGB555

#define RGB_FROM_RGB555 (   Pixel,
  r,
  g,
  b 
)
Value:
{ \
r = SDL_expand_byte[3][((Pixel&0x7C00)>>10)]; \
g = SDL_expand_byte[3][((Pixel&0x03E0)>>5)]; \
b = SDL_expand_byte[3][(Pixel&0x001F)]; \
}

Definition at line 134 of file SDL_blit.h.

◆ RGB_FROM_RGB565

#define RGB_FROM_RGB565 (   Pixel,
  r,
  g,
  b 
)
Value:
{ \
r = SDL_expand_byte[3][((Pixel&0xF800)>>11)]; \
g = SDL_expand_byte[2][((Pixel&0x07E0)>>5)]; \
b = SDL_expand_byte[3][(Pixel&0x001F)]; \
}

Definition at line 128 of file SDL_blit.h.

◆ RGB_FROM_RGB888

#define RGB_FROM_RGB888 (   Pixel,
  r,
  g,
  b 
)
Value:
{ \
r = ((Pixel&0xFF0000)>>16); \
g = ((Pixel&0xFF00)>>8); \
b = (Pixel&0xFF); \
}

Definition at line 140 of file SDL_blit.h.

◆ RGBA8888_FROM_RGBA

#define RGBA8888_FROM_RGBA (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
Pixel = (r<<24)|(g<<16)|(b<<8)|a; \
}

Definition at line 241 of file SDL_blit.h.

◆ RGBA_FROM_8888

#define RGBA_FROM_8888 (   Pixel,
  fmt,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = (Pixel&fmt->Rmask)>>fmt->Rshift; \
g = (Pixel&fmt->Gmask)>>fmt->Gshift; \
b = (Pixel&fmt->Bmask)>>fmt->Bshift; \
a = (Pixel&fmt->Amask)>>fmt->Ashift; \
}

Definition at line 311 of file SDL_blit.h.

◆ RGBA_FROM_ABGR8888

#define RGBA_FROM_ABGR8888 (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = (Pixel&0xFF); \
g = ((Pixel>>8)&0xFF); \
b = ((Pixel>>16)&0xFF); \
a = (Pixel>>24); \
}

Definition at line 332 of file SDL_blit.h.

◆ RGBA_FROM_ARGB2101010

#define RGBA_FROM_ARGB2101010 (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = ((Pixel>>22)&0xFF); \
g = ((Pixel>>12)&0xFF); \
b = ((Pixel>>2)&0xFF); \
a = SDL_expand_byte[6][(Pixel>>30)]; \
}

Definition at line 346 of file SDL_blit.h.

◆ RGBA_FROM_ARGB8888

#define RGBA_FROM_ARGB8888 (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = ((Pixel>>16)&0xFF); \
g = ((Pixel>>8)&0xFF); \
b = (Pixel&0xFF); \
a = (Pixel>>24); \
}

Definition at line 325 of file SDL_blit.h.

◆ RGBA_FROM_BGRA8888

#define RGBA_FROM_BGRA8888 (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = ((Pixel>>8)&0xFF); \
g = ((Pixel>>16)&0xFF); \
b = (Pixel>>24); \
a = (Pixel&0xFF); \
}

Definition at line 339 of file SDL_blit.h.

◆ RGBA_FROM_PIXEL

#define RGBA_FROM_PIXEL (   Pixel,
  fmt,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = SDL_expand_byte[fmt->Rloss][((Pixel&fmt->Rmask)>>fmt->Rshift)]; \
g = SDL_expand_byte[fmt->Gloss][((Pixel&fmt->Gmask)>>fmt->Gshift)]; \
b = SDL_expand_byte[fmt->Bloss][((Pixel&fmt->Bmask)>>fmt->Bshift)]; \
a = SDL_expand_byte[fmt->Aloss][((Pixel&fmt->Amask)>>fmt->Ashift)]; \
}

Definition at line 304 of file SDL_blit.h.

◆ RGBA_FROM_RGBA8888

#define RGBA_FROM_RGBA8888 (   Pixel,
  r,
  g,
  b,
  a 
)
Value:
{ \
r = (Pixel>>24); \
g = ((Pixel>>16)&0xFF); \
b = ((Pixel>>8)&0xFF); \
a = (Pixel&0xFF); \
}

Definition at line 318 of file SDL_blit.h.

◆ SDL_COPY_ADD

#define SDL_COPY_ADD   0x00000020

Definition at line 37 of file SDL_blit.h.

◆ SDL_COPY_BLEND

#define SDL_COPY_BLEND   0x00000010

Definition at line 36 of file SDL_blit.h.

◆ SDL_COPY_COLORKEY

#define SDL_COPY_COLORKEY   0x00000100

Definition at line 39 of file SDL_blit.h.

◆ SDL_COPY_MOD

#define SDL_COPY_MOD   0x00000040

Definition at line 38 of file SDL_blit.h.

◆ SDL_COPY_MODULATE_ALPHA

#define SDL_COPY_MODULATE_ALPHA   0x00000002

Definition at line 35 of file SDL_blit.h.

◆ SDL_COPY_MODULATE_COLOR

#define SDL_COPY_MODULATE_COLOR   0x00000001

Definition at line 34 of file SDL_blit.h.

◆ SDL_COPY_NEAREST

#define SDL_COPY_NEAREST   0x00000200

Definition at line 40 of file SDL_blit.h.

◆ SDL_COPY_RLE_ALPHAKEY

#define SDL_COPY_RLE_ALPHAKEY   0x00004000

Definition at line 43 of file SDL_blit.h.

◆ SDL_COPY_RLE_COLORKEY

#define SDL_COPY_RLE_COLORKEY   0x00002000

Definition at line 42 of file SDL_blit.h.

◆ SDL_COPY_RLE_DESIRED

#define SDL_COPY_RLE_DESIRED   0x00001000

Definition at line 41 of file SDL_blit.h.

◆ SDL_COPY_RLE_MASK

Definition at line 44 of file SDL_blit.h.

◆ SDL_CPU_3DNOW

#define SDL_CPU_3DNOW   0x00000002

Definition at line 49 of file SDL_blit.h.

◆ SDL_CPU_ALTIVEC_NOPREFETCH

#define SDL_CPU_ALTIVEC_NOPREFETCH   0x00000020

Definition at line 53 of file SDL_blit.h.

◆ SDL_CPU_ALTIVEC_PREFETCH

#define SDL_CPU_ALTIVEC_PREFETCH   0x00000010

Definition at line 52 of file SDL_blit.h.

◆ SDL_CPU_ANY

#define SDL_CPU_ANY   0x00000000

Definition at line 47 of file SDL_blit.h.

◆ SDL_CPU_MMX

#define SDL_CPU_MMX   0x00000001

Definition at line 48 of file SDL_blit.h.

◆ SDL_CPU_SSE

#define SDL_CPU_SSE   0x00000004

Definition at line 50 of file SDL_blit.h.

◆ SDL_CPU_SSE2

#define SDL_CPU_SSE2   0x00000008

Definition at line 51 of file SDL_blit.h.

◆ USE_DUFFS_LOOP

#define USE_DUFFS_LOOP

Definition at line 467 of file SDL_blit.h.

Typedef Documentation

◆ SDL_BlitFunc

typedef void(* SDL_BlitFunc) (SDL_BlitInfo *info)

Definition at line 73 of file SDL_blit.h.

Function Documentation

◆ SDL_CalculateBlit()

int SDL_CalculateBlit ( SDL_Surface surface)

Definition at line 216 of file SDL_blit.c.

217{
218 SDL_BlitFunc blit = NULL;
219 SDL_BlitMap *map = surface->map;
220 SDL_Surface *dst = map->dst;
221
222 /* We don't currently support blitting to < 8 bpp surfaces */
223 if (dst->format->BitsPerPixel < 8) {
225 return SDL_SetError("Blit combination not supported");
226 }
227
228 /* Clean everything out to start */
229 if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
231 }
232 map->blit = SDL_SoftBlit;
233 map->info.src_fmt = surface->format;
234 map->info.src_pitch = surface->pitch;
235 map->info.dst_fmt = dst->format;
236 map->info.dst_pitch = dst->pitch;
237
238 /* See if we can do RLE acceleration */
239 if (map->info.flags & SDL_COPY_RLE_DESIRED) {
240 if (SDL_RLESurface(surface) == 0) {
241 return 0;
242 }
243 }
244
245 /* Choose a standard blit function */
246 if (map->identity && !(map->info.flags & ~SDL_COPY_RLE_DESIRED)) {
247 blit = SDL_BlitCopy;
248 } else if (surface->format->Rloss > 8 || dst->format->Rloss > 8) {
249 /* Greater than 8 bits per channel not supported yet */
251 return SDL_SetError("Blit combination not supported");
252 } else if (surface->format->BitsPerPixel < 8 &&
253 SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
255 } else if (surface->format->BytesPerPixel == 1 &&
256 SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
258 } else if (map->info.flags & SDL_COPY_BLEND) {
260 } else {
262 }
263 if (blit == NULL) {
264 Uint32 src_format = surface->format->format;
265 Uint32 dst_format = dst->format->format;
266
267 blit =
268 SDL_ChooseBlitFunc(src_format, dst_format, map->info.flags,
270 }
271#ifndef TEST_SLOW_BLIT
272 if (blit == NULL)
273#endif
274 {
275 Uint32 src_format = surface->format->format;
276 Uint32 dst_format = dst->format->format;
277
278 if (!SDL_ISPIXELFORMAT_INDEXED(src_format) &&
279 !SDL_ISPIXELFORMAT_FOURCC(src_format) &&
280 !SDL_ISPIXELFORMAT_INDEXED(dst_format) &&
281 !SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
282 blit = SDL_Blit_Slow;
283 }
284 }
285 map->data = blit;
286
287 /* Make sure we have a blit function */
288 if (blit == NULL) {
290 return SDL_SetError("Blit combination not supported");
291 }
292
293 return 0;
294}
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
int SDL_RLESurface(SDL_Surface *surface)
static SDL_BlitFunc SDL_ChooseBlitFunc(Uint32 src_format, Uint32 dst_format, int flags, SDL_BlitFuncEntry *entries)
Definition: SDL_blit.c:128
static int SDL_SoftBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_blit.c:34
SDL_BlitFunc SDL_CalculateBlitA(SDL_Surface *surface)
Definition: SDL_blit_A.c:1269
SDL_BlitFunc SDL_CalculateBlitN(SDL_Surface *surface)
Definition: SDL_blit_N.c:3266
SDL_BlitFunc SDL_CalculateBlit1(SDL_Surface *surface)
Definition: SDL_blit_1.c:522
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
void(* SDL_BlitFunc)(SDL_BlitInfo *info)
Definition: SDL_blit.h:73
SDL_BlitFunc SDL_CalculateBlit0(SDL_Surface *surface)
Definition: SDL_blit_0.c:454
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitFuncEntry SDL_GeneratedBlitFuncTable[]
void SDL_BlitCopy(SDL_BlitInfo *info)
Definition: SDL_blit_copy.c:91
void SDL_Blit_Slow(SDL_BlitInfo *info)
Definition: SDL_blit_slow.c:31
#define SDL_SetError
const GLubyte GLuint GLuint GLuint GLuint alpha GLboolean GLboolean GLboolean GLboolean alpha GLint GLint GLsizei GLsizei GLenum type GLenum GLint GLenum GLint GLint GLsizei GLsizei GLint border GLenum GLint GLint GLint GLint GLint GLsizei GLsizei height GLsizei GLsizei GLenum GLenum const GLvoid *pixels GLenum GLint GLint GLint GLint j2 GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLint *params GLenum GLenum GLfloat *params GLenum GLint GLenum GLenum GLvoid *pixels GLenum GLint GLenum GLint *params GLenum GLenum GLint *params GLenum GLsizei const GLvoid *pointer GLenum GLenum const GLint *params GLenum GLfloat GLfloat GLint GLint const GLfloat *points GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat *points GLint GLfloat GLfloat GLint GLfloat GLfloat v2 GLenum GLenum const GLint *params GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble zFar GLenum map
Definition: SDL_glfuncs.h:291
GLenum GLenum dst
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
#define NULL
Definition: begin_code.h:167
EGLSurface surface
Definition: eglext.h:248
A collection of pixels used in software blitting.
Definition: SDL_surface.h:71

References map, NULL, SDL_Blit_Slow(), SDL_BlitCopy(), SDL_CalculateBlit0(), SDL_CalculateBlit1(), SDL_CalculateBlitA(), SDL_CalculateBlitN(), SDL_ChooseBlitFunc(), SDL_COPY_BLEND, SDL_COPY_RLE_DESIRED, SDL_GeneratedBlitFuncTable, SDL_InvalidateMap(), SDL_ISPIXELFORMAT_FOURCC, SDL_ISPIXELFORMAT_INDEXED, SDL_RLEACCEL, SDL_RLESurface(), SDL_SetError, SDL_SoftBlit(), and SDL_UnRLESurface().

Referenced by SDL_MapSurface().

◆ SDL_CalculateBlit0()

SDL_BlitFunc SDL_CalculateBlit0 ( SDL_Surface surface)

Definition at line 454 of file SDL_blit_0.c.

455{
456 int which;
457
458 if (surface->format->BitsPerPixel != 1) {
459 /* We don't support sub 8-bit packed pixel modes */
460 return (SDL_BlitFunc) NULL;
461 }
462 if (surface->map->dst->format->BitsPerPixel < 8) {
463 which = 0;
464 } else {
465 which = surface->map->dst->format->BytesPerPixel;
466 }
467 switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
468 case 0:
469 return bitmap_blit[which];
470
472 return colorkey_blit[which];
473
475 return which >= 2 ? BlitBtoNAlpha : (SDL_BlitFunc) NULL;
476
478 return which >= 2 ? BlitBtoNAlphaKey : (SDL_BlitFunc) NULL;
479 }
480 return (SDL_BlitFunc) NULL;
481}
#define SDL_COPY_RLE_MASK
Definition: SDL_blit.h:44
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
static void BlitBtoNAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_0.c:354
static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_0.c:399
static const SDL_BlitFunc bitmap_blit[]
Definition: SDL_blit_0.c:445
static const SDL_BlitFunc colorkey_blit[]
Definition: SDL_blit_0.c:449

References bitmap_blit, BlitBtoNAlpha(), BlitBtoNAlphaKey(), colorkey_blit, NULL, SDL_COPY_BLEND, SDL_COPY_COLORKEY, SDL_COPY_MODULATE_ALPHA, and SDL_COPY_RLE_MASK.

Referenced by SDL_CalculateBlit().

◆ SDL_CalculateBlit1()

SDL_BlitFunc SDL_CalculateBlit1 ( SDL_Surface surface)

Definition at line 522 of file SDL_blit_1.c.

523{
524 int which;
525 SDL_PixelFormat *dstfmt;
526
527 dstfmt = surface->map->dst->format;
528 if (dstfmt->BitsPerPixel < 8) {
529 which = 0;
530 } else {
531 which = dstfmt->BytesPerPixel;
532 }
533 switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
534 case 0:
535 return one_blit[which];
536
538 return one_blitkey[which];
539
541 /* Supporting 8bpp->8bpp alpha is doable but requires lots of
542 tables which consume space and takes time to precompute,
543 so is better left to the user */
544 return which >= 2 ? Blit1toNAlpha : (SDL_BlitFunc) NULL;
545
547 return which >= 2 ? Blit1toNAlphaKey : (SDL_BlitFunc) NULL;
548 }
549 return (SDL_BlitFunc) NULL;
550}
static const SDL_BlitFunc one_blitkey[]
Definition: SDL_blit_1.c:517
static const SDL_BlitFunc one_blit[]
Definition: SDL_blit_1.c:513
static void Blit1toNAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:471
static void Blit1toNAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:431
Uint8 BytesPerPixel
Definition: SDL_pixels.h:320
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319

References SDL_PixelFormat::BitsPerPixel, Blit1toNAlpha(), Blit1toNAlphaKey(), SDL_PixelFormat::BytesPerPixel, SDL_PixelFormat::format, NULL, one_blit, one_blitkey, SDL_COPY_BLEND, SDL_COPY_COLORKEY, SDL_COPY_MODULATE_ALPHA, and SDL_COPY_RLE_MASK.

Referenced by SDL_CalculateBlit().

◆ SDL_CalculateBlitA()

SDL_BlitFunc SDL_CalculateBlitA ( SDL_Surface surface)

Definition at line 1269 of file SDL_blit_A.c.

1270{
1272 SDL_PixelFormat *df = surface->map->dst->format;
1273
1274 switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
1275 case SDL_COPY_BLEND:
1276 /* Per-pixel alpha blits */
1277 switch (df->BytesPerPixel) {
1278 case 1:
1279 if (df->palette != NULL) {
1280 return BlitNto1PixelAlpha;
1281 } else {
1282 /* RGB332 has no palette ! */
1283 return BlitNtoNPixelAlpha;
1284 }
1285
1286 case 2:
1287 if (sf->BytesPerPixel == 4 && sf->Amask == 0xff000000
1288 && sf->Gmask == 0xff00
1289 && ((sf->Rmask == 0xff && df->Rmask == 0x1f)
1290 || (sf->Bmask == 0xff && df->Bmask == 0x1f))) {
1291 if (df->Gmask == 0x7e0)
1293 else if (df->Gmask == 0x3e0)
1295 }
1296 return BlitNtoNPixelAlpha;
1297
1298 case 4:
1299 if (sf->Rmask == df->Rmask
1300 && sf->Gmask == df->Gmask
1301 && sf->Bmask == df->Bmask && sf->BytesPerPixel == 4) {
1302#if defined(__MMX__) || defined(__3dNOW__)
1303 if (sf->Rshift % 8 == 0
1304 && sf->Gshift % 8 == 0
1305 && sf->Bshift % 8 == 0
1306 && sf->Ashift % 8 == 0 && sf->Aloss == 0) {
1307#ifdef __3dNOW__
1308 if (SDL_Has3DNow())
1309 return BlitRGBtoRGBPixelAlphaMMX3DNOW;
1310#endif
1311#ifdef __MMX__
1312 if (SDL_HasMMX())
1313 return BlitRGBtoRGBPixelAlphaMMX;
1314#endif
1315 }
1316#endif /* __MMX__ || __3dNOW__ */
1317 if (sf->Amask == 0xff000000) {
1319 }
1320 }
1321 return BlitNtoNPixelAlpha;
1322
1323 case 3:
1324 default:
1325 break;
1326 }
1327 return BlitNtoNPixelAlpha;
1328
1330 if (sf->Amask == 0) {
1331 /* Per-surface alpha blits */
1332 switch (df->BytesPerPixel) {
1333 case 1:
1334 if (df->palette != NULL) {
1335 return BlitNto1SurfaceAlpha;
1336 } else {
1337 /* RGB332 has no palette ! */
1338 return BlitNtoNSurfaceAlpha;
1339 }
1340
1341 case 2:
1342 if (surface->map->identity) {
1343 if (df->Gmask == 0x7e0) {
1344#ifdef __MMX__
1345 if (SDL_HasMMX())
1346 return Blit565to565SurfaceAlphaMMX;
1347 else
1348#endif
1350 } else if (df->Gmask == 0x3e0) {
1351#ifdef __MMX__
1352 if (SDL_HasMMX())
1353 return Blit555to555SurfaceAlphaMMX;
1354 else
1355#endif
1357 }
1358 }
1359 return BlitNtoNSurfaceAlpha;
1360
1361 case 4:
1362 if (sf->Rmask == df->Rmask
1363 && sf->Gmask == df->Gmask
1364 && sf->Bmask == df->Bmask && sf->BytesPerPixel == 4) {
1365#ifdef __MMX__
1366 if (sf->Rshift % 8 == 0
1367 && sf->Gshift % 8 == 0
1368 && sf->Bshift % 8 == 0 && SDL_HasMMX())
1369 return BlitRGBtoRGBSurfaceAlphaMMX;
1370#endif
1371 if ((sf->Rmask | sf->Gmask | sf->Bmask) == 0xffffff) {
1373 }
1374 }
1375 return BlitNtoNSurfaceAlpha;
1376
1377 case 3:
1378 default:
1379 return BlitNtoNSurfaceAlpha;
1380 }
1381 }
1382 break;
1383
1385 if (sf->Amask == 0) {
1386 if (df->BytesPerPixel == 1) {
1387
1388 if (df->palette != NULL) {
1390 } else {
1391 /* RGB332 has no palette ! */
1393 }
1394 } else {
1396 }
1397 }
1398 break;
1399 }
1400
1401 return NULL;
1402}
static void BlitNto1PixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:77
static void BlitNtoNSurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1147
static void BlitNto1SurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:30
static void BlitNto1SurfaceAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:123
static void BlitARGBto555PixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1100
static void BlitNtoNSurfaceAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1186
static void Blit565to565SurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:976
static void BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:419
static void BlitARGBto565PixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1054
static void BlitNtoNPixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1227
static void BlitRGBtoRGBPixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:461
static void Blit555to555SurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1015
#define SDL_HasMMX
#define SDL_Has3DNow
SDL_Palette * palette
Definition: SDL_pixels.h:318

References SDL_PixelFormat::Aloss, SDL_PixelFormat::Amask, SDL_PixelFormat::Ashift, Blit555to555SurfaceAlpha(), Blit565to565SurfaceAlpha(), BlitARGBto555PixelAlpha(), BlitARGBto565PixelAlpha(), BlitNto1PixelAlpha(), BlitNto1SurfaceAlpha(), BlitNto1SurfaceAlphaKey(), BlitNtoNPixelAlpha(), BlitNtoNSurfaceAlpha(), BlitNtoNSurfaceAlphaKey(), BlitRGBtoRGBPixelAlpha(), BlitRGBtoRGBSurfaceAlpha(), SDL_PixelFormat::Bmask, SDL_PixelFormat::Bshift, SDL_PixelFormat::BytesPerPixel, SDL_PixelFormat::format, SDL_PixelFormat::Gmask, SDL_PixelFormat::Gshift, NULL, SDL_PixelFormat::palette, SDL_PixelFormat::Rmask, SDL_PixelFormat::Rshift, SDL_COPY_BLEND, SDL_COPY_COLORKEY, SDL_COPY_MODULATE_ALPHA, SDL_COPY_RLE_MASK, SDL_Has3DNow, and SDL_HasMMX.

Referenced by SDL_CalculateBlit().

◆ SDL_CalculateBlitN()

SDL_BlitFunc SDL_CalculateBlitN ( SDL_Surface surface)

Definition at line 3266 of file SDL_blit_N.c.

3267{
3268 SDL_PixelFormat *srcfmt;
3269 SDL_PixelFormat *dstfmt;
3270 const struct blit_table *table;
3271 int which;
3272 SDL_BlitFunc blitfun;
3273
3274 /* Set up data for choosing the blit */
3275 srcfmt = surface->format;
3276 dstfmt = surface->map->dst->format;
3277
3278 /* We don't support destinations less than 8-bits */
3279 if (dstfmt->BitsPerPixel < 8) {
3280 return (NULL);
3281 }
3282
3283 switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
3284 case 0:
3285 blitfun = NULL;
3286 if (dstfmt->BitsPerPixel == 8) {
3287 if ((srcfmt->BytesPerPixel == 4) &&
3288 (srcfmt->Rmask == 0x00FF0000) &&
3289 (srcfmt->Gmask == 0x0000FF00) &&
3290 (srcfmt->Bmask == 0x000000FF)) {
3291 blitfun = Blit_RGB888_index8;
3292 } else if ((srcfmt->BytesPerPixel == 4) &&
3293 (srcfmt->Rmask == 0x3FF00000) &&
3294 (srcfmt->Gmask == 0x000FFC00) &&
3295 (srcfmt->Bmask == 0x000003FF)) {
3296 blitfun = Blit_RGB101010_index8;
3297 } else {
3298 blitfun = BlitNto1;
3299 }
3300 } else {
3301 /* Now the meat, choose the blitter we want */
3302 Uint32 a_need = NO_ALPHA;
3303 if (dstfmt->Amask)
3304 a_need = srcfmt->Amask ? COPY_ALPHA : SET_ALPHA;
3305 table = normal_blit[srcfmt->BytesPerPixel - 1];
3306 for (which = 0; table[which].dstbpp; ++which) {
3307 if (MASKOK(srcfmt->Rmask, table[which].srcR) &&
3308 MASKOK(srcfmt->Gmask, table[which].srcG) &&
3309 MASKOK(srcfmt->Bmask, table[which].srcB) &&
3310 MASKOK(dstfmt->Rmask, table[which].dstR) &&
3311 MASKOK(dstfmt->Gmask, table[which].dstG) &&
3312 MASKOK(dstfmt->Bmask, table[which].dstB) &&
3313 dstfmt->BytesPerPixel == table[which].dstbpp &&
3314 (a_need & table[which].alpha) == a_need &&
3315 ((table[which].blit_features & GetBlitFeatures()) ==
3316 table[which].blit_features))
3317 break;
3318 }
3319 blitfun = table[which].blitfunc;
3320
3321 if (blitfun == BlitNtoN) { /* default C fallback catch-all. Slow! */
3322 if (srcfmt->format == SDL_PIXELFORMAT_ARGB2101010) {
3323 blitfun = Blit2101010toN;
3324 } else if (dstfmt->format == SDL_PIXELFORMAT_ARGB2101010) {
3325 blitfun = BlitNto2101010;
3326 } else if (srcfmt->BytesPerPixel == 4 &&
3327 dstfmt->BytesPerPixel == 4 &&
3328 srcfmt->Rmask == dstfmt->Rmask &&
3329 srcfmt->Gmask == dstfmt->Gmask &&
3330 srcfmt->Bmask == dstfmt->Bmask) {
3331 if (a_need == COPY_ALPHA) {
3332 if (srcfmt->Amask == dstfmt->Amask) {
3333 /* Fastpath C fallback: 32bit RGBA<->RGBA blit with matching RGBA */
3334 blitfun = Blit4to4CopyAlpha;
3335 } else {
3336 blitfun = BlitNtoNCopyAlpha;
3337 }
3338 } else {
3339 /* Fastpath C fallback: 32bit RGB<->RGBA blit with matching RGB */
3340 blitfun = Blit4to4MaskAlpha;
3341 }
3342 } else if (a_need == COPY_ALPHA) {
3343 blitfun = BlitNtoNCopyAlpha;
3344 }
3345 }
3346 }
3347 return (blitfun);
3348
3349 case SDL_COPY_COLORKEY:
3350 /* colorkey blit: Here we don't have too many options, mostly
3351 because RLE is the preferred fast way to deal with this.
3352 If a particular case turns out to be useful we'll add it. */
3353
3354 if (srcfmt->BytesPerPixel == 2 && surface->map->identity)
3355 return Blit2to2Key;
3356 else if (dstfmt->BytesPerPixel == 1)
3357 return BlitNto1Key;
3358 else {
3359#if SDL_ALTIVEC_BLITTERS
3360 if ((srcfmt->BytesPerPixel == 4) && (dstfmt->BytesPerPixel == 4)
3361 && SDL_HasAltiVec()) {
3362 return Blit32to32KeyAltivec;
3363 } else
3364#endif
3365 if (srcfmt->Amask && dstfmt->Amask) {
3366 return BlitNtoNKeyCopyAlpha;
3367 } else {
3368 return BlitNtoNKey;
3369 }
3370 }
3371 }
3372
3373 return NULL;
3374}
static void BlitNtoN(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2244
static void BlitNto1Key(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2421
static void Blit2to2Key(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2487
static void BlitNto1(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1991
static void Blit4to4CopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2136
#define MASKOK(x, y)
Definition: SDL_blit_N.c:3263
#define NO_ALPHA
Definition: SDL_blit_N.c:3140
#define GetBlitFeatures()
Definition: SDL_blit_N.c:887
static void Blit4to4MaskAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2086
static void Blit_RGB888_index8(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:906
static void Blit_RGB101010_index8(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1016
static const struct blit_table *const normal_blit[]
Definition: SDL_blit_N.c:3258
static void BlitNtoNKey(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2521
#define COPY_ALPHA
Definition: SDL_blit_N.c:3142
static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2363
#define SET_ALPHA
Definition: SDL_blit_N.c:3141
static void BlitNto2101010(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2929
static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2793
static void Blit2101010toN(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2897
#define SDL_HasAltiVec
GLenum GLsizei GLenum GLenum const void * table
@ SDL_PIXELFORMAT_ARGB2101010
Definition: SDL_pixels.h:260
Uint32 blit_features
Definition: SDL_blit_N.c:3148
SDL_BlitFunc blitfunc
Definition: SDL_blit_N.c:3149

References SDL_PixelFormat::Amask, SDL_PixelFormat::BitsPerPixel, Blit2101010toN(), Blit2to2Key(), Blit4to4CopyAlpha(), Blit4to4MaskAlpha(), blit_table::blit_features, Blit_RGB101010_index8(), Blit_RGB888_index8(), blit_table::blitfunc, BlitNto1(), BlitNto1Key(), BlitNto2101010(), BlitNtoN(), BlitNtoNCopyAlpha(), BlitNtoNKey(), BlitNtoNKeyCopyAlpha(), SDL_PixelFormat::Bmask, SDL_PixelFormat::BytesPerPixel, COPY_ALPHA, SDL_PixelFormat::format, GetBlitFeatures, SDL_PixelFormat::Gmask, MASKOK, NO_ALPHA, normal_blit, NULL, SDL_PixelFormat::Rmask, SDL_COPY_COLORKEY, SDL_COPY_RLE_MASK, SDL_HasAltiVec, SDL_PIXELFORMAT_ARGB2101010, and SET_ALPHA.

Referenced by SDL_CalculateBlit().

Variable Documentation

◆ SDL_expand_byte

Uint8* SDL_expand_byte[9]
extern

Definition at line 71 of file SDL_pixels.c.

Referenced by SDL_GetRGB(), and SDL_GetRGBA().