SDL_blit.h
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2004 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
20
slouken@libsdl.org
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
*/
#ifdef SAVE_RCSID
static char rcsid =
"@(#) $Id$";
#endif
#ifndef _SDL_blit_h
#define _SDL_blit_h
#include "SDL_endian.h"
/* The structure passed to the low level blit functions */
typedef struct {
Uint8 *s_pixels;
int s_width;
int s_height;
int s_skip;
Uint8 *d_pixels;
int d_width;
int d_height;
int d_skip;
void *aux_data;
SDL_PixelFormat *src;
Uint8 *table;
SDL_PixelFormat *dst;
} SDL_BlitInfo;
/* The type definition for the low level blit functions */
typedef void (*SDL_loblit)(SDL_BlitInfo *info);
/* This is the private info structure for software accelerated blits */
struct private_swaccel {
SDL_loblit blit;
void *aux_data;
};
/* Blit mapping definition */
typedef struct SDL_BlitMap {
SDL_Surface *dst;
int identity;
Uint8 *table;
SDL_blit hw_blit;
SDL_blit sw_blit;
struct private_hwaccel *hw_data;
struct private_swaccel *sw_data;
/* the version count matches the destination; mismatch indicates
an invalid mapping */
unsigned int format_version;
} SDL_BlitMap;
/* Functions found in SDL_blit.c */
extern int SDL_CalculateBlit(SDL_Surface *surface);
/* Functions found in SDL_blit_{0,1,N,A}.c */
extern SDL_loblit SDL_CalculateBlit0(SDL_Surface *surface, int complex);
extern SDL_loblit SDL_CalculateBlit1(SDL_Surface *surface, int complex);
extern SDL_loblit SDL_CalculateBlitN(SDL_Surface *surface, int complex);
extern SDL_loblit SDL_CalculateAlphaBlit(SDL_Surface *surface, int complex);
/*
* Useful macros for blitting routines
*/
#define FORMAT_EQUAL(A, B) \
((A)->BitsPerPixel == (B)->BitsPerPixel \
&& ((A)->Rmask == (B)->Rmask) && ((A)->Amask == (B)->Amask))
/* Load pixel of the specified format from a buffer and get its R-G-B values */
/* FIXME: rescale values to 0..255 here? */
93
#define RGB_FROM_PIXEL(Pixel, fmt, r, g, b) \
94
{ \
95
96
97
r = (((Pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss); \
g = (((Pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss); \
b = (((Pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss); \
99
#define RGB_FROM_RGB565(Pixel, r, g, b) \
100
{ \
101
102
103
r = (((Pixel&0xF800)>>11)<<3); \
g = (((Pixel&0x07E0)>>5)<<2); \
b = ((Pixel&0x001F)<<3); \
104
}
105
#define RGB_FROM_RGB555(Pixel, r, g, b) \
106
{ \
107
108
109
r = (((Pixel&0x7C00)>>10)<<3); \
g = (((Pixel&0x03E0)>>5)<<3); \
b = ((Pixel&0x001F)<<3); \
110
}
111
#define RGB_FROM_RGB888(Pixel, r, g, b) \
112
{ \
113
114
115
r = ((Pixel&0xFF0000)>>16); \
g = ((Pixel&0xFF00)>>8); \
b = (Pixel&0xFF); \
116
}
117
#define RETRIEVE_RGB_PIXEL(buf, bpp, Pixel) \
118
119
120
do { \
switch (bpp) { \
case 2: \
121
Pixel = *((Uint16 *)(buf)); \
122
123
124
125
126
break; \
\
case 3: { \
Uint8 *B = (Uint8 *)(buf); \
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \
127
Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \
128
} else { \
129
Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \
130
131
132
133
134
} \
} \
break; \
\
case 4: \
135
Pixel = *((Uint32 *)(buf)); \
136
137
138
break; \
\
default: \
139
Pixel = 0; /* appease gcc */ \
140
141
142
143
break; \
} \
} while(0)
144
#define DISEMBLE_RGB(buf, bpp, fmt, Pixel, r, g, b) \
145
146
147
do { \
switch (bpp) { \
case 2: \
148
Pixel = *((Uint16 *)(buf)); \
149
150
151
152
153
break; \
\
case 3: { \
Uint8 *B = (Uint8 *)buf; \
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \
154
Pixel = B[0] + (B[1] << 8) + (B[2] << 16); \
155
} else { \
156
Pixel = (B[0] << 16) + (B[1] << 8) + B[2]; \
157
158
159
160
161
} \
} \
break; \
\
case 4: \
162
Pixel = *((Uint32 *)(buf)); \
163
164
165
break; \
\
default: \
166
Pixel = 0; /* prevent gcc from complaining */ \
167
168
break; \
} \
169
RGB_FROM_PIXEL(Pixel, fmt, r, g, b); \
170
171
172
} while(0)
/* Assemble R-G-B values into a specified pixel format and store them */
173
#define PIXEL_FROM_RGB(Pixel, fmt, r, g, b) \
174
{ \
175
Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \
176
177
178
((g>>fmt->Gloss)<<fmt->Gshift)| \
((b>>fmt->Bloss)<<fmt->Bshift); \
}
179
#define RGB565_FROM_RGB(Pixel, r, g, b) \
180
{ \
181
Pixel = ((r>>3)<<11)|((g>>2)<<5)|(b>>3); \
182
}
183
#define RGB555_FROM_RGB(Pixel, r, g, b) \
184
{ \
185
Pixel = ((r>>3)<<10)|((g>>3)<<5)|(b>>3); \
186
}
187
#define RGB888_FROM_RGB(Pixel, r, g, b) \
188
{ \
189
Pixel = (r<<16)|(g<<8)|b; \
190
191
192
193
194
}
#define ASSEMBLE_RGB(buf, bpp, fmt, r, g, b) \
{ \
switch (bpp) { \
case 2: { \
195
Uint16 Pixel; \
196
\
197
198
PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \
*((Uint16 *)(buf)) = Pixel; \
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
} \
break; \
\
case 3: { \
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \
*((buf)+fmt->Rshift/8) = r; \
*((buf)+fmt->Gshift/8) = g; \
*((buf)+fmt->Bshift/8) = b; \
} else { \
*((buf)+2-fmt->Rshift/8) = r; \
*((buf)+2-fmt->Gshift/8) = g; \
*((buf)+2-fmt->Bshift/8) = b; \
} \
} \
break; \
\
case 4: { \
216
Uint32 Pixel; \
217
\
218
219
PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \
*((Uint32 *)(buf)) = Pixel; \
220
221
222
223
224
225
226
227
228
} \
break; \
} \
}
#define ASSEMBLE_RGB_AMASK(buf, bpp, fmt, r, g, b, Amask) \
{ \
switch (bpp) { \
case 2: { \
Uint16 *bufp; \
229
Uint16 Pixel; \
230
231
\
bufp = (Uint16 *)buf; \
232
233
PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \
*bufp = Pixel | (*bufp & Amask); \
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
} \
break; \
\
case 3: { \
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \
*((buf)+fmt->Rshift/8) = r; \
*((buf)+fmt->Gshift/8) = g; \
*((buf)+fmt->Bshift/8) = b; \
} else { \
*((buf)+2-fmt->Rshift/8) = r; \
*((buf)+2-fmt->Gshift/8) = g; \
*((buf)+2-fmt->Bshift/8) = b; \
} \
} \
break; \
\
case 4: { \
Uint32 *bufp; \
252
Uint32 Pixel; \
253
254
\
bufp = (Uint32 *)buf; \
255
256
PIXEL_FROM_RGB(Pixel, fmt, r, g, b); \
*bufp = Pixel | (*bufp & Amask); \
257
258
259
260
261
262
} \
break; \
} \
}
/* FIXME: Should we rescale alpha into 0..255 here? */
263
#define RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a) \
264
{ \
265
266
267
268
r = ((Pixel&fmt->Rmask)>>fmt->Rshift)<<fmt->Rloss; \
g = ((Pixel&fmt->Gmask)>>fmt->Gshift)<<fmt->Gloss; \
b = ((Pixel&fmt->Bmask)>>fmt->Bshift)<<fmt->Bloss; \
a = ((Pixel&fmt->Amask)>>fmt->Ashift)<<fmt->Aloss; \
269
}
270
#define RGBA_FROM_8888(Pixel, fmt, r, g, b, a) \
271
{ \
272
273
274
275
r = (Pixel&fmt->Rmask)>>fmt->Rshift; \
g = (Pixel&fmt->Gmask)>>fmt->Gshift; \
b = (Pixel&fmt->Bmask)>>fmt->Bshift; \
a = (Pixel&fmt->Amask)>>fmt->Ashift; \
276
}
277
#define RGBA_FROM_RGBA8888(Pixel, r, g, b, a) \
278
{ \
279
280
281
282
r = (Pixel>>24); \
g = ((Pixel>>16)&0xFF); \
b = ((Pixel>>8)&0xFF); \
a = (Pixel&0xFF); \
283
}
284
#define RGBA_FROM_ARGB8888(Pixel, r, g, b, a) \
285
{ \
286
287
288
289
r = ((Pixel>>16)&0xFF); \
g = ((Pixel>>8)&0xFF); \
b = (Pixel&0xFF); \
a = (Pixel>>24); \
290
}
291
#define RGBA_FROM_ABGR8888(Pixel, r, g, b, a) \
292
{ \
293
294
295
296
r = (Pixel&0xFF); \
g = ((Pixel>>8)&0xFF); \
b = ((Pixel>>16)&0xFF); \
a = (Pixel>>24); \
297
}
298
#define DISEMBLE_RGBA(buf, bpp, fmt, Pixel, r, g, b, a) \
299
300
301
do { \
switch (bpp) { \
case 2: \
302
Pixel = *((Uint16 *)(buf)); \
303
304
305
306
307
break; \
\
case 3: {/* FIXME: broken code (no alpha) */ \
Uint8 *b = (Uint8 *)buf; \
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \
308
Pixel = b[0] + (b[1] << 8) + (b[2] << 16); \
309
} else { \
310
Pixel = (b[0] << 16) + (b[1] << 8) + b[2]; \
311
312
313
314
315
} \
} \
break; \
\
case 4: \
316
Pixel = *((Uint32 *)(buf)); \
317
318
319
break; \
\
default: \
320
Pixel = 0; /* stop gcc complaints */ \
321
322
break; \
} \
323
324
RGBA_FROM_PIXEL(Pixel, fmt, r, g, b, a); \
Pixel &= ~fmt->Amask; \
325
326
327
} while(0)
/* FIXME: this isn't correct, especially for Alpha (maximum != 255) */
328
#define PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a) \
329
{ \
330
Pixel = ((r>>fmt->Rloss)<<fmt->Rshift)| \
331
332
((g>>fmt->Gloss)<<fmt->Gshift)| \
((b>>fmt->Bloss)<<fmt->Bshift)| \
333
((a>>fmt->Aloss)<<fmt->Ashift); \
334
335
336
337
338
}
#define ASSEMBLE_RGBA(buf, bpp, fmt, r, g, b, a) \
{ \
switch (bpp) { \
case 2: { \
339
Uint16 Pixel; \
340
\
341
342
PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a); \
*((Uint16 *)(buf)) = Pixel; \
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
} \
break; \
\
case 3: { /* FIXME: broken code (no alpha) */ \
if(SDL_BYTEORDER == SDL_LIL_ENDIAN) { \
*((buf)+fmt->Rshift/8) = r; \
*((buf)+fmt->Gshift/8) = g; \
*((buf)+fmt->Bshift/8) = b; \
} else { \
*((buf)+2-fmt->Rshift/8) = r; \
*((buf)+2-fmt->Gshift/8) = g; \
*((buf)+2-fmt->Bshift/8) = b; \
} \
} \
break; \
\
case 4: { \
360
Uint32 Pixel; \
361
\
362
363
PIXEL_FROM_RGBA(Pixel, fmt, r, g, b, a); \
*((Uint32 *)(buf)) = Pixel; \
364
365
366
367
368
} \
break; \
} \
}
369
/* Blend the RGB values of two Pixels based on a source alpha value */
370
371
372
373
374
375
376
#define ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB) \
do { \
dR = (((sR-dR)*(A))>>8)+dR; \
dG = (((sG-dG)*(A))>>8)+dG; \
dB = (((sB-dB)*(A))>>8)+dB; \
} while(0)
377
/* Blend the RGB values of two Pixels based on a source alpha value */
378
379
380
381
382
383
384
385
386
387
388
389
390
#define ACCURATE_ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB) \
do { \
unsigned tR, tG, tB, tA; \
tA = 255 - sA; \
tR = 1 + (sR * sA) + (dR * tA); \
dR = (tR + (tR >> 8)) >> 8; \
tG = 1 + (sG * sA) + (dG * tA); \
dG = (tG + (tG >> 8)) >> 8; \
tB = 1 + (sB * sA) + (dB * tA); \
dB = (tB + (tB >> 8)) >> 8; \
} while(0)
391
/* This is a very useful loop for optimizing blitters */
392
393
394
#if defined(_MSC_VER) && (_MSC_VER == 1300)
/* There's a bug in the Visual C++ 7 optimizer when compiling this code */
#else
395
#define USE_DUFFS_LOOP
397
398
399
400
401
#ifdef USE_DUFFS_LOOP
/* 8-times unrolled loop */
#define DUFFS_LOOP8(pixel_copy_increment, width) \
{ int n = (width+7)/8; \
402
switch (width & 7) { \
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
case 0: do { pixel_copy_increment; \
case 7: pixel_copy_increment; \
case 6: pixel_copy_increment; \
case 5: pixel_copy_increment; \
case 4: pixel_copy_increment; \
case 3: pixel_copy_increment; \
case 2: pixel_copy_increment; \
case 1: pixel_copy_increment; \
} while ( --n > 0 ); \
} \
}
/* 4-times unrolled loop */
#define DUFFS_LOOP4(pixel_copy_increment, width) \
{ int n = (width+3)/4; \
418
switch (width & 3) { \
419
420
421
422
423
424
425
426
case 0: do { pixel_copy_increment; \
case 3: pixel_copy_increment; \
case 2: pixel_copy_increment; \
case 1: pixel_copy_increment; \
} while ( --n > 0 ); \
} \
}
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
/* 2 - times unrolled loop */
#define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \
double_pixel_copy_increment, width) \
{ int n, w = width; \
if( w & 1 ) { \
pixel_copy_increment; \
w--; \
} \
if ( w > 0 ) { \
n = ( w + 2) / 4; \
switch( w & 2 ) { \
case 0: do { double_pixel_copy_increment; \
case 2: double_pixel_copy_increment; \
} while ( --n > 0 ); \
} \
} \
}
/* 2 - times unrolled loop 4 pixels */
#define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \
double_pixel_copy_increment, \
quatro_pixel_copy_increment, width) \
{ int n, w = width; \
if(w & 1) { \
pixel_copy_increment; \
w--; \
} \
if(w & 2) { \
double_pixel_copy_increment; \
w -= 2; \
} \
if ( w > 0 ) { \
n = ( w + 7 ) / 8; \
switch( w & 4 ) { \
case 0: do { quatro_pixel_copy_increment; \
case 4: quatro_pixel_copy_increment; \
} while ( --n > 0 ); \
} \
} \
}
468
469
470
471
472
473
/* Use the 8-times version of the loop by default */
#define DUFFS_LOOP(pixel_copy_increment, width) \
DUFFS_LOOP8(pixel_copy_increment, width)
#else
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
/* Don't use Duff's device to unroll loops */
#define DUFFS_LOOP_DOUBLE2(pixel_copy_increment, \
double_pixel_copy_increment, width) \
{ int n = width; \
if( n & 1 ) { \
pixel_copy_increment; \
n--; \
} \
n=n>>1; \
for(; n > 0; --n) { \
double_pixel_copy_increment; \
} \
}
/* Don't use Duff's device to unroll loops */
#define DUFFS_LOOP_QUATRO2(pixel_copy_increment, \
double_pixel_copy_increment, \
quatro_pixel_copy_increment, width) \
{ int n = width; \
if(n & 1) { \
pixel_copy_increment; \
n--; \
} \
if(n & 2) { \
double_pixel_copy_increment; \
n -= 2; \
} \
n=n>>2; \
for(; n > 0; --n) { \
quatro_pixel_copy_increment; \
} \
}
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
/* Don't use Duff's device to unroll loops */
#define DUFFS_LOOP(pixel_copy_increment, width) \
{ int n; \
for ( n=width; n > 0; --n ) { \
pixel_copy_increment; \
} \
}
#define DUFFS_LOOP8(pixel_copy_increment, width) \
DUFFS_LOOP(pixel_copy_increment, width)
#define DUFFS_LOOP4(pixel_copy_increment, width) \
DUFFS_LOOP(pixel_copy_increment, width)
#endif /* USE_DUFFS_LOOP */
/* Prevent Visual C++ 6.0 from printing out stupid warnings */
#if defined(_MSC_VER) && (_MSC_VER >= 600)
#pragma warning(disable: 4550)
#endif
#endif /* _SDL_blit_h */