zenilib  0.5.3.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_blit_1.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "SDL_config.h"
22 
23 #include "SDL_video.h"
24 #include "SDL_blit.h"
25 #include "SDL_sysvideo.h"
26 #include "SDL_endian.h"
27 
28 /* Functions to blit from 8-bit surfaces to other surfaces */
29 
30 static void
31 Blit1to1(SDL_BlitInfo * info)
32 {
33 #ifndef USE_DUFFS_LOOP
34  int c;
35 #endif
36  int width, height;
37  Uint8 *src, *map, *dst;
38  int srcskip, dstskip;
39 
40  /* Set up some basic variables */
41  width = info->dst_w;
42  height = info->dst_h;
43  src = info->src;
44  srcskip = info->src_skip;
45  dst = info->dst;
46  dstskip = info->dst_skip;
47  map = info->table;
48 
49  while (height--) {
50 #ifdef USE_DUFFS_LOOP
51  /* *INDENT-OFF* */
52  DUFFS_LOOP(
53  {
54  *dst = map[*src];
55  }
56  dst++;
57  src++;
58  , width);
59  /* *INDENT-ON* */
60 #else
61  for (c = width; c; --c) {
62  *dst = map[*src];
63  dst++;
64  src++;
65  }
66 #endif
67  src += srcskip;
68  dst += dstskip;
69  }
70 }
71 
72 /* This is now endian dependent */
73 #if ( SDL_BYTEORDER == SDL_LIL_ENDIAN )
74 #define HI 1
75 #define LO 0
76 #else /* ( SDL_BYTEORDER == SDL_BIG_ENDIAN ) */
77 #define HI 0
78 #define LO 1
79 #endif
80 static void
81 Blit1to2(SDL_BlitInfo * info)
82 {
83 #ifndef USE_DUFFS_LOOP
84  int c;
85 #endif
86  int width, height;
87  Uint8 *src, *dst;
88  Uint16 *map;
89  int srcskip, dstskip;
90 
91  /* Set up some basic variables */
92  width = info->dst_w;
93  height = info->dst_h;
94  src = info->src;
95  srcskip = info->src_skip;
96  dst = info->dst;
97  dstskip = info->dst_skip;
98  map = (Uint16 *) info->table;
99 
100 #ifdef USE_DUFFS_LOOP
101  while (height--) {
102  /* *INDENT-OFF* */
103  DUFFS_LOOP(
104  {
105  *(Uint16 *)dst = map[*src++];
106  dst += 2;
107  },
108  width);
109  /* *INDENT-ON* */
110  src += srcskip;
111  dst += dstskip;
112  }
113 #else
114  /* Memory align at 4-byte boundary, if necessary */
115  if ((long) dst & 0x03) {
116  /* Don't do anything if width is 0 */
117  if (width == 0) {
118  return;
119  }
120  --width;
121 
122  while (height--) {
123  /* Perform copy alignment */
124  *(Uint16 *) dst = map[*src++];
125  dst += 2;
126 
127  /* Copy in 4 pixel chunks */
128  for (c = width / 4; c; --c) {
129  *(Uint32 *) dst = (map[src[HI]] << 16) | (map[src[LO]]);
130  src += 2;
131  dst += 4;
132  *(Uint32 *) dst = (map[src[HI]] << 16) | (map[src[LO]]);
133  src += 2;
134  dst += 4;
135  }
136  /* Get any leftovers */
137  switch (width & 3) {
138  case 3:
139  *(Uint16 *) dst = map[*src++];
140  dst += 2;
141  case 2:
142  *(Uint32 *) dst = (map[src[HI]] << 16) | (map[src[LO]]);
143  src += 2;
144  dst += 4;
145  break;
146  case 1:
147  *(Uint16 *) dst = map[*src++];
148  dst += 2;
149  break;
150  }
151  src += srcskip;
152  dst += dstskip;
153  }
154  } else {
155  while (height--) {
156  /* Copy in 4 pixel chunks */
157  for (c = width / 4; c; --c) {
158  *(Uint32 *) dst = (map[src[HI]] << 16) | (map[src[LO]]);
159  src += 2;
160  dst += 4;
161  *(Uint32 *) dst = (map[src[HI]] << 16) | (map[src[LO]]);
162  src += 2;
163  dst += 4;
164  }
165  /* Get any leftovers */
166  switch (width & 3) {
167  case 3:
168  *(Uint16 *) dst = map[*src++];
169  dst += 2;
170  case 2:
171  *(Uint32 *) dst = (map[src[HI]] << 16) | (map[src[LO]]);
172  src += 2;
173  dst += 4;
174  break;
175  case 1:
176  *(Uint16 *) dst = map[*src++];
177  dst += 2;
178  break;
179  }
180  src += srcskip;
181  dst += dstskip;
182  }
183  }
184 #endif /* USE_DUFFS_LOOP */
185 }
186 
187 static void
188 Blit1to3(SDL_BlitInfo * info)
189 {
190 #ifndef USE_DUFFS_LOOP
191  int c;
192 #endif
193  int o;
194  int width, height;
195  Uint8 *src, *map, *dst;
196  int srcskip, dstskip;
197 
198  /* Set up some basic variables */
199  width = info->dst_w;
200  height = info->dst_h;
201  src = info->src;
202  srcskip = info->src_skip;
203  dst = info->dst;
204  dstskip = info->dst_skip;
205  map = info->table;
206 
207  while (height--) {
208 #ifdef USE_DUFFS_LOOP
209  /* *INDENT-OFF* */
210  DUFFS_LOOP(
211  {
212  o = *src * 4;
213  dst[0] = map[o++];
214  dst[1] = map[o++];
215  dst[2] = map[o++];
216  }
217  src++;
218  dst += 3;
219  , width);
220  /* *INDENT-ON* */
221 #else
222  for (c = width; c; --c) {
223  o = *src * 4;
224  dst[0] = map[o++];
225  dst[1] = map[o++];
226  dst[2] = map[o++];
227  src++;
228  dst += 3;
229  }
230 #endif /* USE_DUFFS_LOOP */
231  src += srcskip;
232  dst += dstskip;
233  }
234 }
235 
236 static void
237 Blit1to4(SDL_BlitInfo * info)
238 {
239 #ifndef USE_DUFFS_LOOP
240  int c;
241 #endif
242  int width, height;
243  Uint8 *src;
244  Uint32 *map, *dst;
245  int srcskip, dstskip;
246 
247  /* Set up some basic variables */
248  width = info->dst_w;
249  height = info->dst_h;
250  src = info->src;
251  srcskip = info->src_skip;
252  dst = (Uint32 *) info->dst;
253  dstskip = info->dst_skip / 4;
254  map = (Uint32 *) info->table;
255 
256  while (height--) {
257 #ifdef USE_DUFFS_LOOP
258  /* *INDENT-OFF* */
259  DUFFS_LOOP(
260  *dst++ = map[*src++];
261  , width);
262  /* *INDENT-ON* */
263 #else
264  for (c = width / 4; c; --c) {
265  *dst++ = map[*src++];
266  *dst++ = map[*src++];
267  *dst++ = map[*src++];
268  *dst++ = map[*src++];
269  }
270  switch (width & 3) {
271  case 3:
272  *dst++ = map[*src++];
273  case 2:
274  *dst++ = map[*src++];
275  case 1:
276  *dst++ = map[*src++];
277  }
278 #endif /* USE_DUFFS_LOOP */
279  src += srcskip;
280  dst += dstskip;
281  }
282 }
283 
284 static void
285 Blit1to1Key(SDL_BlitInfo * info)
286 {
287  int width = info->dst_w;
288  int height = info->dst_h;
289  Uint8 *src = info->src;
290  int srcskip = info->src_skip;
291  Uint8 *dst = info->dst;
292  int dstskip = info->dst_skip;
293  Uint8 *palmap = info->table;
294  Uint32 ckey = info->colorkey;
295 
296  if (palmap) {
297  while (height--) {
298  /* *INDENT-OFF* */
299  DUFFS_LOOP(
300  {
301  if ( *src != ckey ) {
302  *dst = palmap[*src];
303  }
304  dst++;
305  src++;
306  },
307  width);
308  /* *INDENT-ON* */
309  src += srcskip;
310  dst += dstskip;
311  }
312  } else {
313  while (height--) {
314  /* *INDENT-OFF* */
315  DUFFS_LOOP(
316  {
317  if ( *src != ckey ) {
318  *dst = *src;
319  }
320  dst++;
321  src++;
322  },
323  width);
324  /* *INDENT-ON* */
325  src += srcskip;
326  dst += dstskip;
327  }
328  }
329 }
330 
331 static void
332 Blit1to2Key(SDL_BlitInfo * info)
333 {
334  int width = info->dst_w;
335  int height = info->dst_h;
336  Uint8 *src = info->src;
337  int srcskip = info->src_skip;
338  Uint16 *dstp = (Uint16 *) info->dst;
339  int dstskip = info->dst_skip;
340  Uint16 *palmap = (Uint16 *) info->table;
341  Uint32 ckey = info->colorkey;
342 
343  /* Set up some basic variables */
344  dstskip /= 2;
345 
346  while (height--) {
347  /* *INDENT-OFF* */
348  DUFFS_LOOP(
349  {
350  if ( *src != ckey ) {
351  *dstp=palmap[*src];
352  }
353  src++;
354  dstp++;
355  },
356  width);
357  /* *INDENT-ON* */
358  src += srcskip;
359  dstp += dstskip;
360  }
361 }
362 
363 static void
364 Blit1to3Key(SDL_BlitInfo * info)
365 {
366  int width = info->dst_w;
367  int height = info->dst_h;
368  Uint8 *src = info->src;
369  int srcskip = info->src_skip;
370  Uint8 *dst = info->dst;
371  int dstskip = info->dst_skip;
372  Uint8 *palmap = info->table;
373  Uint32 ckey = info->colorkey;
374  int o;
375 
376  while (height--) {
377  /* *INDENT-OFF* */
378  DUFFS_LOOP(
379  {
380  if ( *src != ckey ) {
381  o = *src * 4;
382  dst[0] = palmap[o++];
383  dst[1] = palmap[o++];
384  dst[2] = palmap[o++];
385  }
386  src++;
387  dst += 3;
388  },
389  width);
390  /* *INDENT-ON* */
391  src += srcskip;
392  dst += dstskip;
393  }
394 }
395 
396 static void
397 Blit1to4Key(SDL_BlitInfo * info)
398 {
399  int width = info->dst_w;
400  int height = info->dst_h;
401  Uint8 *src = info->src;
402  int srcskip = info->src_skip;
403  Uint32 *dstp = (Uint32 *) info->dst;
404  int dstskip = info->dst_skip;
405  Uint32 *palmap = (Uint32 *) info->table;
406  Uint32 ckey = info->colorkey;
407 
408  /* Set up some basic variables */
409  dstskip /= 4;
410 
411  while (height--) {
412  /* *INDENT-OFF* */
413  DUFFS_LOOP(
414  {
415  if ( *src != ckey ) {
416  *dstp = palmap[*src];
417  }
418  src++;
419  dstp++;
420  },
421  width);
422  /* *INDENT-ON* */
423  src += srcskip;
424  dstp += dstskip;
425  }
426 }
427 
428 static void
429 Blit1toNAlpha(SDL_BlitInfo * info)
430 {
431  int width = info->dst_w;
432  int height = info->dst_h;
433  Uint8 *src = info->src;
434  int srcskip = info->src_skip;
435  Uint8 *dst = info->dst;
436  int dstskip = info->dst_skip;
437  SDL_PixelFormat *dstfmt = info->dst_fmt;
438  const SDL_Color *srcpal = info->src_fmt->palette->colors;
439  int dstbpp;
440  Uint32 pixel;
441  unsigned sR, sG, sB;
442  unsigned dR, dG, dB, dA;
443  const unsigned A = info->a;
444 
445  /* Set up some basic variables */
446  dstbpp = dstfmt->BytesPerPixel;
447 
448  while (height--) {
449  /* *INDENT-OFF* */
450  DUFFS_LOOP4(
451  {
452  sR = srcpal[*src].r;
453  sG = srcpal[*src].g;
454  sB = srcpal[*src].b;
455  DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
456  ALPHA_BLEND_RGBA(sR, sG, sB, A, dR, dG, dB, dA);
457  ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
458  src++;
459  dst += dstbpp;
460  },
461  width);
462  /* *INDENT-ON* */
463  src += srcskip;
464  dst += dstskip;
465  }
466 }
467 
468 static void
469 Blit1toNAlphaKey(SDL_BlitInfo * info)
470 {
471  int width = info->dst_w;
472  int height = info->dst_h;
473  Uint8 *src = info->src;
474  int srcskip = info->src_skip;
475  Uint8 *dst = info->dst;
476  int dstskip = info->dst_skip;
477  SDL_PixelFormat *dstfmt = info->dst_fmt;
478  const SDL_Color *srcpal = info->src_fmt->palette->colors;
479  Uint32 ckey = info->colorkey;
480  int dstbpp;
481  Uint32 pixel;
482  unsigned sR, sG, sB;
483  unsigned dR, dG, dB, dA;
484  const unsigned A = info->a;
485 
486  /* Set up some basic variables */
487  dstbpp = dstfmt->BytesPerPixel;
488 
489  while (height--) {
490  /* *INDENT-OFF* */
491  DUFFS_LOOP(
492  {
493  if ( *src != ckey ) {
494  sR = srcpal[*src].r;
495  sG = srcpal[*src].g;
496  sB = srcpal[*src].b;
497  DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
498  ALPHA_BLEND_RGBA(sR, sG, sB, A, dR, dG, dB, dA);
499  ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
500  }
501  src++;
502  dst += dstbpp;
503  },
504  width);
505  /* *INDENT-ON* */
506  src += srcskip;
507  dst += dstskip;
508  }
509 }
510 
511 static const SDL_BlitFunc one_blit[] = {
512  (SDL_BlitFunc) NULL, Blit1to1, Blit1to2, Blit1to3, Blit1to4
513 };
514 
515 static const SDL_BlitFunc one_blitkey[] = {
516  (SDL_BlitFunc) NULL, Blit1to1Key, Blit1to2Key, Blit1to3Key, Blit1to4Key
517 };
518 
519 SDL_BlitFunc
520 SDL_CalculateBlit1(SDL_Surface * surface)
521 {
522  int which;
523  SDL_PixelFormat *dstfmt;
524 
525  dstfmt = surface->map->dst->format;
526  if (dstfmt->BitsPerPixel < 8) {
527  which = 0;
528  } else {
529  which = dstfmt->BytesPerPixel;
530  }
531  switch (surface->map->info.flags & ~SDL_COPY_RLE_MASK) {
532  case 0:
533  return one_blit[which];
534 
535  case SDL_COPY_COLORKEY:
536  return one_blitkey[which];
537 
538  case SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND:
539  /* Supporting 8bpp->8bpp alpha is doable but requires lots of
540  tables which consume space and takes time to precompute,
541  so is better left to the user */
542  return which >= 2 ? Blit1toNAlpha : (SDL_BlitFunc) NULL;
543 
544  case SDL_COPY_COLORKEY | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND:
545  return which >= 2 ? Blit1toNAlphaKey : (SDL_BlitFunc) NULL;
546  }
547  return (SDL_BlitFunc) NULL;
548 }
549 
550 /* vi: set ts=4 sw=4 expandtab: */
SDL_BlitInfo::table
Uint8 * table
Definition: SDL_blit.h:67
SDL_Color
Definition: SDL_pixels.h:252
SDL_COPY_COLORKEY
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_BlitInfo::src_skip
int src_skip
Definition: SDL_blit.h:60
SDL_Color::g
Uint8 g
Definition: SDL_pixels.h:255
NULL
#define NULL
Definition: ftobjs.h:61
ALPHA_BLEND_RGBA
#define ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA)
Definition: SDL_blit.h:453
SDL_PixelFormat::BytesPerPixel
Uint8 BytesPerPixel
Definition: SDL_pixels.h:277
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
Blit1to3Key
static void Blit1to3Key(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:364
SDL_BlitInfo::src_fmt
SDL_PixelFormat * src_fmt
Definition: SDL_blit.h:65
surface
EGLSurface surface
Definition: eglext.h:74
ASSEMBLE_RGBA
#define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a)
Definition: SDL_blit.h:401
SDL_Surface
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
one_blitkey
static const SDL_BlitFunc one_blitkey[]
Definition: SDL_blit_1.c:515
height
EGLSurface EGLint EGLint EGLint EGLint height
Definition: eglext.h:293
SDL_COPY_RLE_MASK
#define SDL_COPY_RLE_MASK
Definition: SDL_blit.h:44
SDL_Color::b
Uint8 b
Definition: SDL_pixels.h:256
SDL_BlitInfo::dst_skip
int dst_skip
Definition: SDL_blit.h:64
SDL_BlitInfo::dst_h
int dst_h
Definition: SDL_blit.h:62
SDL_config.h
SDL_BlitInfo::colorkey
Uint32 colorkey
Definition: SDL_blit.h:69
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
SDL_BlitInfo::dst
Uint8 * dst
Definition: SDL_blit.h:61
SDL_Surface::map
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
SDL_video.h
DISEMBLE_RGBA
#define DISEMBLE_RGBA(buf, bpp, fmt, Pixel, r, g, b, a)
Definition: SDL_blit.h:352
SDL_Color::r
Uint8 r
Definition: SDL_pixels.h:254
dst
GLenum GLenum dst
Definition: glew.h:2396
SDL_BlitInfo
Definition: SDL_blit.h:55
width
EGLSurface EGLint EGLint EGLint width
Definition: eglext.h:293
SDL_PixelFormat::BitsPerPixel
Uint8 BitsPerPixel
Definition: SDL_pixels.h:276
one_blit
static const SDL_BlitFunc one_blit[]
Definition: SDL_blit_1.c:511
Blit1to2Key
static void Blit1to2Key(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:332
LO
#define LO
Definition: SDL_blit_1.c:75
DUFFS_LOOP4
#define DUFFS_LOOP4(pixel_copy_increment, width)
Definition: SDL_blit.h:487
Blit1toNAlphaKey
static void Blit1toNAlphaKey(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:469
c
const GLfloat * c
Definition: glew.h:14913
DUFFS_LOOP
#define DUFFS_LOOP(pixel_copy_increment, width)
Definition: SDL_blit.h:499
Blit1to2
static void Blit1to2(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:81
SDL_BlitInfo::src
Uint8 * src
Definition: SDL_blit.h:57
SDL_sysvideo.h
SDL_BlitInfo::dst_fmt
SDL_PixelFormat * dst_fmt
Definition: SDL_blit.h:66
SDL_endian.h
Blit1to4Key
static void Blit1to4Key(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:397
SDL_BlitMap::dst
SDL_Surface * dst
Definition: SDL_blit.h:87
SDL_Palette::colors
SDL_Color * colors
Definition: SDL_pixels.h:264
SDL_Surface::format
SDL_PixelFormat * format
Definition: SDL_surface.h:72
SDL_blit.h
SDL_COPY_MODULATE_ALPHA
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
Uint8
uint8_t Uint8
An unsigned 8-bit integer type.
Definition: SDL_stdinc.h:129
Blit1to3
static void Blit1to3(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:188
SDL_CalculateBlit1
SDL_BlitFunc SDL_CalculateBlit1(SDL_Surface *surface)
Definition: SDL_blit_1.c:520
SDL_PixelFormat
Definition: SDL_pixels.h:272
Blit1toNAlpha
static void Blit1toNAlpha(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:429
Blit1to1Key
static void Blit1to1Key(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:285
Uint16
uint16_t Uint16
An unsigned 16-bit integer type.
Definition: SDL_stdinc.h:137
SDL_PixelFormat::palette
SDL_Palette * palette
Definition: SDL_pixels.h:275
src
GLenum src
Definition: glew.h:2396
SDL_BlitInfo::dst_w
int dst_w
Definition: SDL_blit.h:62
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:268
while
while(1)
Definition: glslang_lex.cpp:1063
USE_DUFFS_LOOP
#define USE_DUFFS_LOOP
Definition: SDL_blit.h:466
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitMap::info
SDL_BlitInfo info
Definition: SDL_blit.h:91
HI
#define HI
Definition: SDL_blit_1.c:74
Blit1to4
static void Blit1to4(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:237
SDL_BlitInfo::a
Uint8 a
Definition: SDL_blit.h:70
Blit1to1
static void Blit1to1(SDL_BlitInfo *info)
Definition: SDL_blit_1.c:31