|
0
|
1 /*
|
|
|
2 SDL - Simple DirectMedia Layer
|
|
|
3 Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
|
|
|
4
|
|
|
5 This library is free software; you can redistribute it and/or
|
|
|
6 modify it under the terms of the GNU Library General Public
|
|
|
7 License as published by the Free Software Foundation; either
|
|
|
8 version 2 of the License, or (at your option) any later version.
|
|
|
9
|
|
|
10 This library is distributed in the hope that it will be useful,
|
|
|
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
13 Library General Public License for more details.
|
|
|
14
|
|
|
15 You should have received a copy of the GNU Library General Public
|
|
|
16 License along with this library; if not, write to the Free
|
|
|
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
18
|
|
|
19 Sam Lantinga
|
|
|
20 slouken@devolution.com
|
|
|
21 */
|
|
|
22
|
|
|
23 #ifdef SAVE_RCSID
|
|
|
24 static char rcsid =
|
|
|
25 "@(#) $Id$";
|
|
|
26 #endif
|
|
|
27
|
|
|
28 #include <stdio.h>
|
|
|
29
|
|
|
30 #include "SDL_types.h"
|
|
|
31 #include "SDL_video.h"
|
|
|
32 #include "SDL_blit.h"
|
|
|
33
|
|
|
34 /* Functions to perform alpha blended blitting */
|
|
|
35
|
|
|
36 /* N->1 blending with per-surface alpha */
|
|
|
37 static void BlitNto1SurfaceAlpha(SDL_BlitInfo *info)
|
|
|
38 {
|
|
|
39 int width = info->d_width;
|
|
|
40 int height = info->d_height;
|
|
|
41 Uint8 *src = info->s_pixels;
|
|
|
42 int srcskip = info->s_skip;
|
|
|
43 Uint8 *dst = info->d_pixels;
|
|
|
44 int dstskip = info->d_skip;
|
|
|
45 Uint8 *palmap = info->table;
|
|
|
46 SDL_PixelFormat *srcfmt = info->src;
|
|
|
47 SDL_PixelFormat *dstfmt = info->dst;
|
|
|
48 int srcbpp = srcfmt->BytesPerPixel;
|
|
|
49
|
|
|
50 const unsigned A = srcfmt->alpha;
|
|
|
51
|
|
|
52 while ( height-- ) {
|
|
|
53 DUFFS_LOOP4(
|
|
|
54 {
|
|
|
55 Uint32 pixel;
|
|
|
56 unsigned sR;
|
|
|
57 unsigned sG;
|
|
|
58 unsigned sB;
|
|
|
59 unsigned dR;
|
|
|
60 unsigned dG;
|
|
|
61 unsigned dB;
|
|
|
62 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, sR, sG, sB);
|
|
|
63 dR = dstfmt->palette->colors[*dst].r;
|
|
|
64 dG = dstfmt->palette->colors[*dst].g;
|
|
|
65 dB = dstfmt->palette->colors[*dst].b;
|
|
|
66 ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);
|
|
|
67 dR &= 0xff;
|
|
|
68 dG &= 0xff;
|
|
|
69 dB &= 0xff;
|
|
|
70 /* Pack RGB into 8bit pixel */
|
|
|
71 if ( palmap == NULL ) {
|
|
|
72 *dst =((dR>>5)<<(3+2))|
|
|
|
73 ((dG>>5)<<(2))|
|
|
|
74 ((dB>>6)<<(0));
|
|
|
75 } else {
|
|
|
76 *dst = palmap[((dR>>5)<<(3+2))|
|
|
|
77 ((dG>>5)<<(2)) |
|
|
|
78 ((dB>>6)<<(0))];
|
|
|
79 }
|
|
|
80 dst++;
|
|
|
81 src += srcbpp;
|
|
|
82 },
|
|
|
83 width);
|
|
|
84 src += srcskip;
|
|
|
85 dst += dstskip;
|
|
|
86 }
|
|
|
87 }
|
|
|
88
|
|
|
89 /* N->1 blending with pixel alpha */
|
|
|
90 static void BlitNto1PixelAlpha(SDL_BlitInfo *info)
|
|
|
91 {
|
|
|
92 int width = info->d_width;
|
|
|
93 int height = info->d_height;
|
|
|
94 Uint8 *src = info->s_pixels;
|
|
|
95 int srcskip = info->s_skip;
|
|
|
96 Uint8 *dst = info->d_pixels;
|
|
|
97 int dstskip = info->d_skip;
|
|
|
98 Uint8 *palmap = info->table;
|
|
|
99 SDL_PixelFormat *srcfmt = info->src;
|
|
|
100 SDL_PixelFormat *dstfmt = info->dst;
|
|
|
101 int srcbpp = srcfmt->BytesPerPixel;
|
|
|
102
|
|
|
103 /* FIXME: fix alpha bit field expansion here too? */
|
|
|
104 while ( height-- ) {
|
|
|
105 DUFFS_LOOP4(
|
|
|
106 {
|
|
|
107 Uint32 pixel;
|
|
|
108 unsigned sR;
|
|
|
109 unsigned sG;
|
|
|
110 unsigned sB;
|
|
|
111 unsigned sA;
|
|
|
112 unsigned dR;
|
|
|
113 unsigned dG;
|
|
|
114 unsigned dB;
|
|
|
115 DISEMBLE_RGBA(src,srcbpp,srcfmt,pixel,sR,sG,sB,sA);
|
|
|
116 dR = dstfmt->palette->colors[*dst].r;
|
|
|
117 dG = dstfmt->palette->colors[*dst].g;
|
|
|
118 dB = dstfmt->palette->colors[*dst].b;
|
|
|
119 ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB);
|
|
|
120 dR &= 0xff;
|
|
|
121 dG &= 0xff;
|
|
|
122 dB &= 0xff;
|
|
|
123 /* Pack RGB into 8bit pixel */
|
|
|
124 if ( palmap == NULL ) {
|
|
|
125 *dst =((dR>>5)<<(3+2))|
|
|
|
126 ((dG>>5)<<(2))|
|
|
|
127 ((dB>>6)<<(0));
|
|
|
128 } else {
|
|
|
129 *dst = palmap[((dR>>5)<<(3+2))|
|
|
|
130 ((dG>>5)<<(2)) |
|
|
|
131 ((dB>>6)<<(0)) ];
|
|
|
132 }
|
|
|
133 dst++;
|
|
|
134 src += srcbpp;
|
|
|
135 },
|
|
|
136 width);
|
|
|
137 src += srcskip;
|
|
|
138 dst += dstskip;
|
|
|
139 }
|
|
|
140 }
|
|
|
141
|
|
|
142 /* colorkeyed N->1 blending with per-surface alpha */
|
|
|
143 static void BlitNto1SurfaceAlphaKey(SDL_BlitInfo *info)
|
|
|
144 {
|
|
|
145 int width = info->d_width;
|
|
|
146 int height = info->d_height;
|
|
|
147 Uint8 *src = info->s_pixels;
|
|
|
148 int srcskip = info->s_skip;
|
|
|
149 Uint8 *dst = info->d_pixels;
|
|
|
150 int dstskip = info->d_skip;
|
|
|
151 Uint8 *palmap = info->table;
|
|
|
152 SDL_PixelFormat *srcfmt = info->src;
|
|
|
153 SDL_PixelFormat *dstfmt = info->dst;
|
|
|
154 int srcbpp = srcfmt->BytesPerPixel;
|
|
|
155 Uint32 ckey = srcfmt->colorkey;
|
|
|
156
|
|
|
157 const int A = srcfmt->alpha;
|
|
|
158
|
|
|
159 while ( height-- ) {
|
|
|
160 DUFFS_LOOP(
|
|
|
161 {
|
|
|
162 Uint32 pixel;
|
|
|
163 unsigned sR;
|
|
|
164 unsigned sG;
|
|
|
165 unsigned sB;
|
|
|
166 unsigned dR;
|
|
|
167 unsigned dG;
|
|
|
168 unsigned dB;
|
|
|
169 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, sR, sG, sB);
|
|
|
170 if ( pixel != ckey ) {
|
|
|
171 dR = dstfmt->palette->colors[*dst].r;
|
|
|
172 dG = dstfmt->palette->colors[*dst].g;
|
|
|
173 dB = dstfmt->palette->colors[*dst].b;
|
|
|
174 ALPHA_BLEND(sR, sG, sB, A, dR, dG, dB);
|
|
|
175 dR &= 0xff;
|
|
|
176 dG &= 0xff;
|
|
|
177 dB &= 0xff;
|
|
|
178 /* Pack RGB into 8bit pixel */
|
|
|
179 if ( palmap == NULL ) {
|
|
|
180 *dst =((dR>>5)<<(3+2))|
|
|
|
181 ((dG>>5)<<(2)) |
|
|
|
182 ((dB>>6)<<(0));
|
|
|
183 } else {
|
|
|
184 *dst = palmap[((dR>>5)<<(3+2))|
|
|
|
185 ((dG>>5)<<(2)) |
|
|
|
186 ((dB>>6)<<(0)) ];
|
|
|
187 }
|
|
|
188 }
|
|
|
189 dst++;
|
|
|
190 src += srcbpp;
|
|
|
191 },
|
|
|
192 width);
|
|
|
193 src += srcskip;
|
|
|
194 dst += dstskip;
|
|
|
195 }
|
|
|
196 }
|
|
|
197
|
|
|
198 /* fast RGB888->(A)RGB888 blending with surface alpha */
|
|
|
199 static void BlitRGBtoRGBSurfaceAlpha(SDL_BlitInfo *info)
|
|
|
200 {
|
|
|
201 int width = info->d_width;
|
|
|
202 int height = info->d_height;
|
|
|
203 Uint32 *srcp = (Uint32 *)info->s_pixels;
|
|
|
204 int srcskip = info->s_skip >> 2;
|
|
|
205 Uint32 *dstp = (Uint32 *)info->d_pixels;
|
|
|
206 int dstskip = info->d_skip >> 2;
|
|
|
207 SDL_PixelFormat *srcfmt = info->src;
|
|
|
208 unsigned alpha = srcfmt->alpha;
|
|
|
209
|
|
|
210 while(height--) {
|
|
|
211 DUFFS_LOOP4({
|
|
|
212 Uint32 s;
|
|
|
213 Uint32 d;
|
|
|
214 Uint32 s1;
|
|
|
215 Uint32 d1;
|
|
|
216 s = *srcp;
|
|
|
217 d = *dstp;
|
|
|
218 s1 = s & 0xff00ff;
|
|
|
219 d1 = d & 0xff00ff;
|
|
|
220 d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff;
|
|
|
221 s &= 0xff00;
|
|
|
222 d &= 0xff00;
|
|
|
223 d = (d + ((s - d) * alpha >> 8)) & 0xff00;
|
|
|
224 *dstp = d1 | d | 0xff000000;
|
|
|
225 ++srcp;
|
|
|
226 ++dstp;
|
|
|
227 }, width);
|
|
|
228 srcp += srcskip;
|
|
|
229 dstp += dstskip;
|
|
|
230 }
|
|
|
231 }
|
|
|
232
|
|
|
233 /* fast ARGB888->(A)RGB888 blending with pixel alpha */
|
|
|
234 static void BlitRGBtoRGBPixelAlpha(SDL_BlitInfo *info)
|
|
|
235 {
|
|
|
236 int width = info->d_width;
|
|
|
237 int height = info->d_height;
|
|
|
238 Uint32 *srcp = (Uint32 *)info->s_pixels;
|
|
|
239 int srcskip = info->s_skip >> 2;
|
|
|
240 Uint32 *dstp = (Uint32 *)info->d_pixels;
|
|
|
241 int dstskip = info->d_skip >> 2;
|
|
|
242
|
|
|
243 while(height--) {
|
|
|
244 DUFFS_LOOP4({
|
|
|
245 Uint32 dalpha;
|
|
|
246 Uint32 d;
|
|
|
247 Uint32 s1;
|
|
|
248 Uint32 d1;
|
|
|
249 Uint32 s = *srcp;
|
|
|
250 Uint32 alpha = s >> 24;
|
|
|
251 /* FIXME: Here we special-case opaque alpha since the
|
|
|
252 compositioning used (>>8 instead of /255) doesn't handle
|
|
|
253 it correctly. Also special-case alpha=0 for speed?
|
|
|
254 Benchmark this! */
|
|
|
255 if(alpha == SDL_ALPHA_OPAQUE) {
|
|
|
256 *dstp = (s & 0x00ffffff) | (*dstp & 0xff000000);
|
|
|
257 } else {
|
|
|
258 /*
|
|
|
259 * take out the middle component (green), and process
|
|
|
260 * the other two in parallel. One multiply less.
|
|
|
261 */
|
|
|
262 d = *dstp;
|
|
|
263 dalpha = d & 0xff000000;
|
|
|
264 s1 = s & 0xff00ff;
|
|
|
265 d1 = d & 0xff00ff;
|
|
|
266 d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff;
|
|
|
267 s &= 0xff00;
|
|
|
268 d &= 0xff00;
|
|
|
269 d = (d + ((s - d) * alpha >> 8)) & 0xff00;
|
|
|
270 *dstp = d1 | d | dalpha;
|
|
|
271 }
|
|
|
272 ++srcp;
|
|
|
273 ++dstp;
|
|
|
274 }, width);
|
|
|
275 srcp += srcskip;
|
|
|
276 dstp += dstskip;
|
|
|
277 }
|
|
|
278 }
|
|
|
279
|
|
|
280 /* fast RGB565->RGB565 blending with surface alpha */
|
|
|
281 static void Blit565to565SurfaceAlpha(SDL_BlitInfo *info)
|
|
|
282 {
|
|
|
283 int width = info->d_width;
|
|
|
284 int height = info->d_height;
|
|
|
285 Uint16 *srcp = (Uint16 *)info->s_pixels;
|
|
|
286 int srcskip = info->s_skip >> 1;
|
|
|
287 Uint16 *dstp = (Uint16 *)info->d_pixels;
|
|
|
288 int dstskip = info->d_skip >> 1;
|
|
|
289 unsigned alpha = info->src->alpha >> 3; /* downscale alpha to 5 bits */
|
|
|
290
|
|
|
291 while(height--) {
|
|
|
292 DUFFS_LOOP4({
|
|
|
293 Uint32 s = *srcp++;
|
|
|
294 Uint32 d = *dstp;
|
|
|
295 /*
|
|
|
296 * shift out the middle component (green) to the high 16
|
|
|
297 * bits, and process all three RGB components at the same
|
|
|
298 * time.
|
|
|
299 */
|
|
|
300 s = (s | s << 16) & 0x07e0f81f;
|
|
|
301 d = (d | d << 16) & 0x07e0f81f;
|
|
|
302 d += (s - d) * alpha >> 5;
|
|
|
303 d &= 0x07e0f81f;
|
|
|
304 *dstp++ = d | d >> 16;
|
|
|
305 }, width);
|
|
|
306 srcp += srcskip;
|
|
|
307 dstp += dstskip;
|
|
|
308 }
|
|
|
309 }
|
|
|
310
|
|
|
311 /* fast RGB555->RGB555 blending with surface alpha */
|
|
|
312 static void Blit555to555SurfaceAlpha(SDL_BlitInfo *info)
|
|
|
313 {
|
|
|
314 int width = info->d_width;
|
|
|
315 int height = info->d_height;
|
|
|
316 Uint16 *srcp = (Uint16 *)info->s_pixels;
|
|
|
317 int srcskip = info->s_skip >> 1;
|
|
|
318 Uint16 *dstp = (Uint16 *)info->d_pixels;
|
|
|
319 int dstskip = info->d_skip >> 1;
|
|
|
320 unsigned alpha = info->src->alpha >> 3; /* downscale alpha to 5 bits */
|
|
|
321
|
|
|
322 while(height--) {
|
|
|
323 DUFFS_LOOP4({
|
|
|
324 Uint32 s = *srcp++;
|
|
|
325 Uint32 d = *dstp;
|
|
|
326 /*
|
|
|
327 * shift out the middle component (green) to the high 16
|
|
|
328 * bits, and process all three RGB components at the same
|
|
|
329 * time.
|
|
|
330 */
|
|
|
331 s = (s | s << 16) & 0x03e07c1f;
|
|
|
332 d = (d | d << 16) & 0x03e07c1f;
|
|
|
333 d += (s - d) * alpha >> 5;
|
|
|
334 d &= 0x03e07c1f;
|
|
|
335 *dstp++ = d | d >> 16;
|
|
|
336 }, width);
|
|
|
337 srcp += srcskip;
|
|
|
338 dstp += dstskip;
|
|
|
339 }
|
|
|
340 }
|
|
|
341
|
|
|
342 /* fast ARGB8888->RGB565 blending with pixel alpha */
|
|
|
343 static void BlitARGBto565PixelAlpha(SDL_BlitInfo *info)
|
|
|
344 {
|
|
|
345 int width = info->d_width;
|
|
|
346 int height = info->d_height;
|
|
|
347 Uint32 *srcp = (Uint32 *)info->s_pixels;
|
|
|
348 int srcskip = info->s_skip >> 2;
|
|
|
349 Uint16 *dstp = (Uint16 *)info->d_pixels;
|
|
|
350 int dstskip = info->d_skip >> 1;
|
|
|
351
|
|
|
352 while(height--) {
|
|
|
353 DUFFS_LOOP4({
|
|
|
354 Uint32 s = *srcp;
|
|
|
355 unsigned alpha = s >> 27; /* downscale alpha to 5 bits */
|
|
|
356 /* FIXME: Here we special-case opaque alpha since the
|
|
|
357 compositioning used (>>8 instead of /255) doesn't handle
|
|
|
358 it correctly. Also special-case alpha=0 for speed?
|
|
|
359 Benchmark this! */
|
|
|
360 if(alpha == (SDL_ALPHA_OPAQUE >> 3)) {
|
|
|
361 *dstp = (s >> 8 & 0xf800) + (s >> 5 & 0x7e0)
|
|
|
362 + (s >> 3 & 0x1f);
|
|
|
363 } else {
|
|
|
364 Uint32 d = *dstp;
|
|
|
365 /*
|
|
|
366 * convert source and destination to G0RAB65565
|
|
|
367 * and blend all components at the same time
|
|
|
368 */
|
|
|
369 s = ((s & 0xfc00) << 11) + (s >> 8 & 0xf800)
|
|
|
370 + (s >> 3 & 0x1f);
|
|
|
371 d = (d | d << 16) & 0x07e0f81f;
|
|
|
372 d += (s - d) * alpha >> 5;
|
|
|
373 d &= 0x07e0f81f;
|
|
|
374 *dstp = d | d >> 16;
|
|
|
375 }
|
|
|
376 srcp++;
|
|
|
377 dstp++;
|
|
|
378 }, width);
|
|
|
379 srcp += srcskip;
|
|
|
380 dstp += dstskip;
|
|
|
381 }
|
|
|
382 }
|
|
|
383
|
|
|
384 /* fast ARGB8888->RGB555 blending with pixel alpha */
|
|
|
385 static void BlitARGBto555PixelAlpha(SDL_BlitInfo *info)
|
|
|
386 {
|
|
|
387 int width = info->d_width;
|
|
|
388 int height = info->d_height;
|
|
|
389 Uint32 *srcp = (Uint32 *)info->s_pixels;
|
|
|
390 int srcskip = info->s_skip >> 2;
|
|
|
391 Uint16 *dstp = (Uint16 *)info->d_pixels;
|
|
|
392 int dstskip = info->d_skip >> 1;
|
|
|
393
|
|
|
394 while(height--) {
|
|
|
395 DUFFS_LOOP4({
|
|
|
396 unsigned alpha;
|
|
|
397 Uint32 s = *srcp;
|
|
|
398 alpha = s >> 27; /* downscale alpha to 5 bits */
|
|
|
399 /* FIXME: Here we special-case opaque alpha since the
|
|
|
400 compositioning used (>>8 instead of /255) doesn't handle
|
|
|
401 it correctly. Also special-case alpha=0 for speed?
|
|
|
402 Benchmark this! */
|
|
|
403 if(alpha == (SDL_ALPHA_OPAQUE >> 3)) {
|
|
|
404 *dstp = (s >> 9 & 0x7c00) + (s >> 6 & 0x3e0)
|
|
|
405 + (s >> 3 & 0x1f);
|
|
|
406 } else {
|
|
|
407 Uint32 d = *dstp;
|
|
|
408 /*
|
|
|
409 * convert source and destination to G0RAB65565
|
|
|
410 * and blend all components at the same time
|
|
|
411 */
|
|
|
412 s = ((s & 0xf800) << 10) + (s >> 9 & 0x7c00)
|
|
|
413 + (s >> 3 & 0x1f);
|
|
|
414 d = (d | d << 16) & 0x03e07c1f;
|
|
|
415 d += (s - d) * alpha >> 5;
|
|
|
416 d &= 0x03e07c1f;
|
|
|
417 *dstp = d | d >> 16;
|
|
|
418 }
|
|
|
419 srcp++;
|
|
|
420 dstp++;
|
|
|
421 }, width);
|
|
|
422 srcp += srcskip;
|
|
|
423 dstp += dstskip;
|
|
|
424 }
|
|
|
425 }
|
|
|
426
|
|
|
427 /* General (slow) N->N blending with per-surface alpha */
|
|
|
428 static void BlitNtoNSurfaceAlpha(SDL_BlitInfo *info)
|
|
|
429 {
|
|
|
430 int width = info->d_width;
|
|
|
431 int height = info->d_height;
|
|
|
432 Uint8 *src = info->s_pixels;
|
|
|
433 int srcskip = info->s_skip;
|
|
|
434 Uint8 *dst = info->d_pixels;
|
|
|
435 int dstskip = info->d_skip;
|
|
|
436 SDL_PixelFormat *srcfmt = info->src;
|
|
|
437 SDL_PixelFormat *dstfmt = info->dst;
|
|
|
438 int srcbpp = srcfmt->BytesPerPixel;
|
|
|
439 int dstbpp = dstfmt->BytesPerPixel;
|
|
|
440 unsigned sA = srcfmt->alpha;
|
|
|
441 unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
|
|
|
442
|
|
|
443 while ( height-- ) {
|
|
|
444 DUFFS_LOOP4(
|
|
|
445 {
|
|
|
446 Uint32 pixel;
|
|
|
447 unsigned sR;
|
|
|
448 unsigned sG;
|
|
|
449 unsigned sB;
|
|
|
450 unsigned dR;
|
|
|
451 unsigned dG;
|
|
|
452 unsigned dB;
|
|
|
453 DISEMBLE_RGB(src, srcbpp, srcfmt, pixel, sR, sG, sB);
|
|
|
454 DISEMBLE_RGB(dst, dstbpp, dstfmt, pixel, dR, dG, dB);
|
|
|
455 ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB);
|
|
|
456 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
|
|
|
457 src += srcbpp;
|
|
|
458 dst += dstbpp;
|
|
|
459 },
|
|
|
460 width);
|
|
|
461 src += srcskip;
|
|
|
462 dst += dstskip;
|
|
|
463 }
|
|
|
464 }
|
|
|
465
|
|
|
466 /* General (slow) colorkeyed N->N blending with per-surface alpha */
|
|
|
467 static void BlitNtoNSurfaceAlphaKey(SDL_BlitInfo *info)
|
|
|
468 {
|
|
|
469 int width = info->d_width;
|
|
|
470 int height = info->d_height;
|
|
|
471 Uint8 *src = info->s_pixels;
|
|
|
472 int srcskip = info->s_skip;
|
|
|
473 Uint8 *dst = info->d_pixels;
|
|
|
474 int dstskip = info->d_skip;
|
|
|
475 SDL_PixelFormat *srcfmt = info->src;
|
|
|
476 SDL_PixelFormat *dstfmt = info->dst;
|
|
|
477 Uint32 ckey = srcfmt->colorkey;
|
|
|
478 int srcbpp = srcfmt->BytesPerPixel;
|
|
|
479 int dstbpp = dstfmt->BytesPerPixel;
|
|
|
480 unsigned sA = srcfmt->alpha;
|
|
|
481 unsigned dA = dstfmt->Amask ? SDL_ALPHA_OPAQUE : 0;
|
|
|
482
|
|
|
483 while ( height-- ) {
|
|
|
484 DUFFS_LOOP4(
|
|
|
485 {
|
|
|
486 Uint32 pixel;
|
|
|
487 unsigned sR;
|
|
|
488 unsigned sG;
|
|
|
489 unsigned sB;
|
|
|
490 unsigned dR;
|
|
|
491 unsigned dG;
|
|
|
492 unsigned dB;
|
|
|
493 RETRIEVE_RGB_PIXEL(src, srcbpp, pixel);
|
|
|
494 if(pixel != ckey) {
|
|
|
495 RGB_FROM_PIXEL(pixel, srcfmt, sR, sG, sB);
|
|
|
496 DISEMBLE_RGB(dst, dstbpp, dstfmt, pixel, dR, dG, dB);
|
|
|
497 ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB);
|
|
|
498 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
|
|
|
499 }
|
|
|
500 src += srcbpp;
|
|
|
501 dst += dstbpp;
|
|
|
502 },
|
|
|
503 width);
|
|
|
504 src += srcskip;
|
|
|
505 dst += dstskip;
|
|
|
506 }
|
|
|
507 }
|
|
|
508
|
|
|
509 /* General (slow) N->N blending with pixel alpha */
|
|
|
510 static void BlitNtoNPixelAlpha(SDL_BlitInfo *info)
|
|
|
511 {
|
|
|
512 int width = info->d_width;
|
|
|
513 int height = info->d_height;
|
|
|
514 Uint8 *src = info->s_pixels;
|
|
|
515 int srcskip = info->s_skip;
|
|
|
516 Uint8 *dst = info->d_pixels;
|
|
|
517 int dstskip = info->d_skip;
|
|
|
518 SDL_PixelFormat *srcfmt = info->src;
|
|
|
519 SDL_PixelFormat *dstfmt = info->dst;
|
|
|
520
|
|
|
521 int srcbpp;
|
|
|
522 int dstbpp;
|
|
|
523
|
|
|
524 /* Set up some basic variables */
|
|
|
525 srcbpp = srcfmt->BytesPerPixel;
|
|
|
526 dstbpp = dstfmt->BytesPerPixel;
|
|
|
527
|
|
|
528 /* FIXME: for 8bpp source alpha, this doesn't get opaque values
|
|
|
529 quite right. for <8bpp source alpha, it gets them very wrong
|
|
|
530 (check all macros!)
|
|
|
531 It is unclear whether there is a good general solution that doesn't
|
|
|
532 need a branch (or a divide). */
|
|
|
533 while ( height-- ) {
|
|
|
534 DUFFS_LOOP4(
|
|
|
535 {
|
|
|
536 Uint32 pixel;
|
|
|
537 unsigned sR;
|
|
|
538 unsigned sG;
|
|
|
539 unsigned sB;
|
|
|
540 unsigned dR;
|
|
|
541 unsigned dG;
|
|
|
542 unsigned dB;
|
|
|
543 unsigned sA;
|
|
|
544 unsigned dA;
|
|
|
545 DISEMBLE_RGBA(src, srcbpp, srcfmt, pixel, sR, sG, sB, sA);
|
|
|
546 DISEMBLE_RGBA(dst, dstbpp, dstfmt, pixel, dR, dG, dB, dA);
|
|
|
547 ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB);
|
|
|
548 ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
|
|
|
549 src += srcbpp;
|
|
|
550 dst += dstbpp;
|
|
|
551 },
|
|
|
552 width);
|
|
|
553 src += srcskip;
|
|
|
554 dst += dstskip;
|
|
|
555 }
|
|
|
556 }
|
|
|
557
|
|
|
558
|
|
|
559 SDL_loblit SDL_CalculateAlphaBlit(SDL_Surface *surface, int blit_index)
|
|
|
560 {
|
|
|
561 SDL_PixelFormat *sf = surface->format;
|
|
|
562 SDL_PixelFormat *df = surface->map->dst->format;
|
|
|
563
|
|
|
564 if(sf->Amask == 0) {
|
|
|
565 if((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
|
|
|
566 if(df->BytesPerPixel == 1)
|
|
|
567 return BlitNto1SurfaceAlphaKey;
|
|
|
568 else
|
|
|
569 return BlitNtoNSurfaceAlphaKey;
|
|
|
570 } else {
|
|
|
571 /* Per-surface alpha blits */
|
|
|
572 switch(df->BytesPerPixel) {
|
|
|
573 case 1:
|
|
|
574 return BlitNto1SurfaceAlpha;
|
|
|
575
|
|
|
576 case 2:
|
|
|
577 if(surface->map->identity) {
|
|
|
578 if(df->Gmask == 0x7e0)
|
|
|
579 return Blit565to565SurfaceAlpha;
|
|
|
580 else if(df->Gmask == 0x3e0)
|
|
|
581 return Blit555to555SurfaceAlpha;
|
|
|
582 }
|
|
|
583 return BlitNtoNSurfaceAlpha;
|
|
|
584
|
|
|
585 case 4:
|
|
|
586 if(sf->Rmask == df->Rmask
|
|
|
587 && sf->Gmask == df->Gmask
|
|
|
588 && sf->Bmask == df->Bmask
|
|
|
589 && (sf->Rmask | sf->Gmask | sf->Bmask) == 0xffffff
|
|
|
590 && sf->BytesPerPixel == 4)
|
|
|
591 return BlitRGBtoRGBSurfaceAlpha;
|
|
|
592 else
|
|
|
593 return BlitNtoNSurfaceAlpha;
|
|
|
594
|
|
|
595 case 3:
|
|
|
596 default:
|
|
|
597 return BlitNtoNSurfaceAlpha;
|
|
|
598 }
|
|
|
599 }
|
|
|
600 } else {
|
|
|
601 /* Per-pixel alpha blits */
|
|
|
602 switch(df->BytesPerPixel) {
|
|
|
603 case 1:
|
|
|
604 return BlitNto1PixelAlpha;
|
|
|
605
|
|
|
606 case 2:
|
|
|
607 if(sf->BytesPerPixel == 4 && sf->Amask == 0xff000000
|
|
|
608 && sf->Gmask == 0xff00
|
|
|
609 && ((sf->Rmask == 0xff && df->Rmask == 0x1f)
|
|
|
610 || (sf->Bmask == 0xff && df->Bmask == 0x1f))) {
|
|
|
611 if(df->Gmask == 0x7e0)
|
|
|
612 return BlitARGBto565PixelAlpha;
|
|
|
613 else if(df->Gmask == 0x3e0)
|
|
|
614 return BlitARGBto555PixelAlpha;
|
|
|
615 }
|
|
|
616 return BlitNtoNPixelAlpha;
|
|
|
617
|
|
|
618 case 4:
|
|
|
619 if(sf->Amask == 0xff000000
|
|
|
620 && sf->Rmask == df->Rmask
|
|
|
621 && sf->Gmask == df->Gmask
|
|
|
622 && sf->Bmask == df->Bmask
|
|
|
623 && sf->BytesPerPixel == 4)
|
|
|
624 return BlitRGBtoRGBPixelAlpha;
|
|
|
625 return BlitNtoNPixelAlpha;
|
|
|
626
|
|
|
627 case 3:
|
|
|
628 default:
|
|
|
629 return BlitNtoNPixelAlpha;
|
|
|
630 }
|
|
|
631 }
|
|
|
632 }
|
|
|
633
|
