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; \
}

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)

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); \
} \
}

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)

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)]; \
}

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)) {
254  blit = SDL_CalculateBlit0(surface);
255  } else if (surface->format->BytesPerPixel == 1 &&
256  SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
257  blit = SDL_CalculateBlit1(surface);
258  } else if (map->info.flags & SDL_COPY_BLEND) {
259  blit = SDL_CalculateBlitA(surface);
260  } else {
261  blit = SDL_CalculateBlitN(surface);
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 }

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 
471  case SDL_COPY_COLORKEY:
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 }

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 
537  case SDL_COPY_COLORKEY:
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 }

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)
1292  return BlitARGBto565PixelAlpha;
1293  else if (df->Gmask == 0x3e0)
1294  return BlitARGBto555PixelAlpha;
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) {
1318  return BlitRGBtoRGBPixelAlpha;
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
1349  return Blit565to565SurfaceAlpha;
1350  } else if (df->Gmask == 0x3e0) {
1351 #ifdef __MMX__
1352  if (SDL_HasMMX())
1353  return Blit555to555SurfaceAlphaMMX;
1354  else
1355 #endif
1356  return Blit555to555SurfaceAlpha;
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) {
1372  return BlitRGBtoRGBSurfaceAlpha;
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) {
1389  return BlitNto1SurfaceAlphaKey;
1390  } else {
1391  /* RGB332 has no palette ! */
1392  return BlitNtoNSurfaceAlphaKey;
1393  }
1394  } else {
1395  return BlitNtoNSurfaceAlphaKey;
1396  }
1397  }
1398  break;
1399  }
1400 
1401  return NULL;
1402 }

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 }

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]

Definition at line 71 of file SDL_pixels.c.

Referenced by SDL_GetRGB(), and SDL_GetRGBA().

Blit_RGB101010_index8
static void Blit_RGB101010_index8(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1016
SDL_PixelFormat::Rshift
Uint8 Rshift
Definition: SDL_pixels.h:330
SDL_PixelFormat::Ashift
Uint8 Ashift
Definition: SDL_pixels.h:333
BlitNto1SurfaceAlphaKey
static void BlitNto1SurfaceAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:123
SDL_ChooseBlitFunc
static SDL_BlitFunc SDL_ChooseBlitFunc(Uint32 src_format, Uint32 dst_format, int flags, SDL_BlitFuncEntry *entries)
Definition: SDL_blit.c:128
COPY_ALPHA
#define COPY_ALPHA
Definition: SDL_blit_N.c:3142
SDL_PixelFormat::BitsPerPixel
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:320
SDL_HasAltiVec
#define SDL_HasAltiVec
Definition: SDL_dynapi_overrides.h:104
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:70
SDL_BlitMap
Definition: SDL_blit.h:86
SDL_Has3DNow
#define SDL_Has3DNow
Definition: SDL_dynapi_overrides.h:106
BlitARGBto555PixelAlpha
static void BlitARGBto555PixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1100
SDL_RLEACCEL
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
NULL
#define NULL
Definition: begin_code.h:167
surface
EGLSurface surface
Definition: eglext.h:248
SDL_PixelFormat::format
Uint32 format
Definition: SDL_pixels.h:317
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1109
width
GLint GLint GLsizei width
Definition: SDL_opengl.h:1571
normal_blit
static const struct blit_table *const normal_blit[]
Definition: SDL_blit_N.c:3258
BlitNto1SurfaceAlpha
static void BlitNto1SurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:30
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1109
SDL_UnRLESurface
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
Definition: SDL_RLEaccel.c:1545
MASKOK
#define MASKOK(x, y)
Definition: SDL_blit_N.c:3263
Blit_RGB888_index8
static void Blit_RGB888_index8(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:906
BlitNtoNKey
static void BlitNtoNKey(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2521
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2078
BlitBtoNAlpha
static void BlitBtoNAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_0.c:354
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_Blit_Slow
void SDL_Blit_Slow(SDL_BlitInfo *info)
Definition: SDL_blit_slow.c:31
SDL_ISPIXELFORMAT_INDEXED
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
SDL_PixelFormat::Rmask
Uint32 Rmask
Definition: SDL_pixels.h:322
a
GLboolean GLboolean GLboolean GLboolean a
Definition: SDL_opengl_glext.h:1109
map
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:290
Blit2101010toN
static void Blit2101010toN(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2897
Blit4to4CopyAlpha
static void Blit4to4CopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2136
SDL_COPY_RLE_MASK
#define SDL_COPY_RLE_MASK
Definition: SDL_blit.h:44
n
GLdouble n
Definition: SDL_opengl_glext.h:1952
one_blitkey
static const SDL_BlitFunc one_blitkey[]
Definition: SDL_blit_1.c:517
SDL_COPY_RLE_DESIRED
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
dst
GLenum GLenum dst
Definition: SDL_opengl_glext.h:1737
SDL_LIL_ENDIAN
#define SDL_LIL_ENDIAN
Definition: SDL_endian.h:37
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: SDL_opengl_glext.h:2480
Uint8
uint8_t Uint8
Definition: SDL_stdinc.h:179
BlitARGBto565PixelAlpha
static void BlitARGBto565PixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1054
BlitNtoN
static void BlitNtoN(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2244
NO_ALPHA
#define NO_ALPHA
Definition: SDL_blit_N.c:3140
Blit555to555SurfaceAlpha
static void Blit555to555SurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1015
Blit1toNAlphaKey
static void Blit1toNAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:471
bitmap_blit
static const SDL_BlitFunc bitmap_blit[]
Definition: SDL_blit_0.c:445
BlitNtoNPixelAlpha
static void BlitNtoNPixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1227
BlitNtoNSurfaceAlphaKey
static void BlitNtoNSurfaceAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1186
BlitBtoNAlphaKey
static void BlitBtoNAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_0.c:399
Blit1toNAlpha
static void Blit1toNAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:431
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_RLESurface
int SDL_RLESurface(SDL_Surface *surface)
Definition: SDL_RLEaccel.c:1405
SDL_PIXELFORMAT_ARGB2101010
Definition: SDL_pixels.h:260
Blit4to4MaskAlpha
static void Blit4to4MaskAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2086
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:318
SDL_CalculateBlitA
SDL_BlitFunc SDL_CalculateBlitA(SDL_Surface *surface)
Definition: SDL_blit_A.c:1269
SET_ALPHA
#define SET_ALPHA
Definition: SDL_blit_N.c:3141
colorkey_blit
static const SDL_BlitFunc colorkey_blit[]
Definition: SDL_blit_0.c:449
blit_table::blitfunc
SDL_BlitFunc blitfunc
Definition: SDL_blit_N.c:3149
BlitNto1PixelAlpha
static void BlitNto1PixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:77
SDL_PixelFormat::Amask
Uint32 Amask
Definition: SDL_pixels.h:325
SDL_GeneratedBlitFuncTable
SDL_BlitFuncEntry SDL_GeneratedBlitFuncTable[]
Definition: SDL_blit_auto.c:7287
SDL_PixelFormat
Definition: SDL_pixels.h:315
SDL_PixelFormat::Gmask
Uint32 Gmask
Definition: SDL_pixels.h:323
Blit565to565SurfaceAlpha
static void Blit565to565SurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:976
BlitNtoNSurfaceAlpha
static void BlitNtoNSurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:1147
one_blit
static const SDL_BlitFunc one_blit[]
Definition: SDL_blit_1.c:513
BlitNto1Key
static void BlitNto1Key(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2421
SDL_COPY_MODULATE_ALPHA
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
GetBlitFeatures
#define GetBlitFeatures()
Definition: SDL_blit_N.c:887
SDL_HasMMX
#define SDL_HasMMX
Definition: SDL_dynapi_overrides.h:105
SDL_PixelFormat::Bmask
Uint32 Bmask
Definition: SDL_pixels.h:324
BlitNtoNCopyAlpha
static void BlitNtoNCopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2363
SDL_expand_byte
Uint8 * SDL_expand_byte[9]
Definition: SDL_pixels.c:71
SDL_ISPIXELFORMAT_FOURCC
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
SDL_CalculateBlitN
SDL_BlitFunc SDL_CalculateBlitN(SDL_Surface *surface)
Definition: SDL_blit_N.c:3266
BlitNto2101010
static void BlitNto2101010(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2929
BlitNtoNKeyCopyAlpha
static void BlitNtoNKeyCopyAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2793
SDL_SetError
#define SDL_SetError
Definition: SDL_dynapi_overrides.h:30
SDL_InvalidateMap
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
SDL_PixelFormat::Bshift
Uint8 Bshift
Definition: SDL_pixels.h:332
SDL_PixelFormat::Aloss
Uint8 Aloss
Definition: SDL_pixels.h:329
SDL_CalculateBlit0
SDL_BlitFunc SDL_CalculateBlit0(SDL_Surface *surface)
Definition: SDL_blit_0.c:454
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_CalculateBlit1
SDL_BlitFunc SDL_CalculateBlit1(SDL_Surface *surface)
Definition: SDL_blit_1.c:522
SDL_PixelFormat::Gshift
Uint8 Gshift
Definition: SDL_pixels.h:331
BlitRGBtoRGBPixelAlpha
static void BlitRGBtoRGBPixelAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:461
SDL_SoftBlit
static int SDL_SoftBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_blit.c:34
SDL_BYTEORDER
#define SDL_BYTEORDER
Definition: SDL_config_pandora.h:37
blit_table
Definition: SDL_blit_N.c:3143
Blit2to2Key
static void Blit2to2Key(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:2487
blit_table::blit_features
Uint32 blit_features
Definition: SDL_blit_N.c:3148
table
GLenum GLsizei GLenum GLenum const void * table
Definition: SDL_opengl_glext.h:3118
BlitRGBtoRGBSurfaceAlpha
static void BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_A.c:419
BlitNto1
static void BlitNto1(SDL_BlitInfo *info)
Definition: SDL_blit_N.c:1991
SDL_BlitFunc
void(* SDL_BlitFunc)(SDL_BlitInfo *info)
Definition: SDL_blit.h:73
Uint16
uint16_t Uint16
Definition: SDL_stdinc.h:191
SDL_BlitCopy
void SDL_BlitCopy(SDL_BlitInfo *info)
Definition: SDL_blit_copy.c:91