zenilib: zenilib/jni/external/sdl/src/video/SDL_blit_auto.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
SDL_blit_auto.c
Go to the documentation of this file.
1 /* DO NOT EDIT! This file is generated by sdlgenblit.pl */
2 /*
3 Simple DirectMedia Layer
4 Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
5
6 This software is provided 'as-is', without any express or implied
7 warranty. In no event will the authors be held liable for any damages
8 arising from the use of this software.
9
10 Permission is granted to anyone to use this software for any purpose,
11 including commercial applications, and to alter it and redistribute it
12 freely, subject to the following restrictions:
13
14 1. The origin of this software must not be misrepresented; you must not
15 claim that you wrote the original software. If you use this software
16 in a product, an acknowledgment in the product documentation would be
17 appreciated but is not required.
18 2. Altered source versions must be plainly marked as such, and must not be
19 misrepresented as being the original software.
20 3. This notice may not be removed or altered from any source distribution.
21 */
22 #include "SDL_config.h"
23
24 /* *INDENT-OFF* */
25
26 #include "SDL_video.h"
27 #include "SDL_blit.h"
28 #include "SDL_blit_auto.h"
29
30 static void SDL_Blit_RGB888_RGB888_Scale(SDL_BlitInfo *info)
31 {
32 int srcy, srcx;
33 int posy, posx;
34 int incy, incx;
35
36 srcy = 0;
37 posy = 0;
38 incy = (info->src_h << 16) / info->dst_h;
39 incx = (info->src_w << 16) / info->dst_w;
40
41 while (info->dst_h--) {
42 Uint32 *src = 0;
43 Uint32 *dst = (Uint32 *)info->dst;
44 int n = info->dst_w;
45 srcx = -1;
46 posx = 0x10000L;
47 while (posy >= 0x10000L) {
48 ++srcy;
49 posy -= 0x10000L;
50 }
51 while (n--) {
52 if (posx >= 0x10000L) {
53 while (posx >= 0x10000L) {
54 ++srcx;
55 posx -= 0x10000L;
56 }
57 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
58 }
59 *dst = *src;
60 posx += incx;
61 ++dst;
62 }
63 posy += incy;
64 info->dst += info->dst_pitch;
65 }
66 }
67
68 static void SDL_Blit_RGB888_RGB888_Blend(SDL_BlitInfo *info)
69 {
70 const int flags = info->flags;
71 Uint32 srcpixel;
72 Uint32 srcR, srcG, srcB, srcA;
73 Uint32 dstpixel;
74 Uint32 dstR, dstG, dstB, dstA;
75
76 while (info->dst_h--) {
77 Uint32 *src = (Uint32 *)info->src;
78 Uint32 *dst = (Uint32 *)info->dst;
79 int n = info->dst_w;
80 while (n--) {
81 srcpixel = *src;
82 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
83 dstpixel = *dst;
84 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
85 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
86 /* This goes away if we ever use premultiplied alpha */
87 if (srcA < 255) {
88 srcR = (srcR * srcA) / 255;
89 srcG = (srcG * srcA) / 255;
90 srcB = (srcB * srcA) / 255;
91 }
92 }
93 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
94 case SDL_COPY_BLEND:
95 dstR = srcR + ((255 - srcA) * dstR) / 255;
96 dstG = srcG + ((255 - srcA) * dstG) / 255;
97 dstB = srcB + ((255 - srcA) * dstB) / 255;
98 dstA = srcA + ((255 - srcA) * dstA) / 255;
99 break;
100 case SDL_COPY_ADD:
101 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
102 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
103 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
104 break;
105 case SDL_COPY_MOD:
106 dstR = (srcR * dstR) / 255;
107 dstG = (srcG * dstG) / 255;
108 dstB = (srcB * dstB) / 255;
109 break;
110 }
111 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
112 *dst = dstpixel;
113 ++src;
114 ++dst;
115 }
116 info->src += info->src_pitch;
117 info->dst += info->dst_pitch;
118 }
119 }
120
121 static void SDL_Blit_RGB888_RGB888_Blend_Scale(SDL_BlitInfo *info)
122 {
123 const int flags = info->flags;
124 Uint32 srcpixel;
125 Uint32 srcR, srcG, srcB, srcA;
126 Uint32 dstpixel;
127 Uint32 dstR, dstG, dstB, dstA;
128 int srcy, srcx;
129 int posy, posx;
130 int incy, incx;
131
132 srcy = 0;
133 posy = 0;
134 incy = (info->src_h << 16) / info->dst_h;
135 incx = (info->src_w << 16) / info->dst_w;
136
137 while (info->dst_h--) {
138 Uint32 *src = 0;
139 Uint32 *dst = (Uint32 *)info->dst;
140 int n = info->dst_w;
141 srcx = -1;
142 posx = 0x10000L;
143 while (posy >= 0x10000L) {
144 ++srcy;
145 posy -= 0x10000L;
146 }
147 while (n--) {
148 if (posx >= 0x10000L) {
149 while (posx >= 0x10000L) {
150 ++srcx;
151 posx -= 0x10000L;
152 }
153 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
154 }
155 srcpixel = *src;
156 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
157 dstpixel = *dst;
158 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
159 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
160 /* This goes away if we ever use premultiplied alpha */
161 if (srcA < 255) {
162 srcR = (srcR * srcA) / 255;
163 srcG = (srcG * srcA) / 255;
164 srcB = (srcB * srcA) / 255;
165 }
166 }
167 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
168 case SDL_COPY_BLEND:
169 dstR = srcR + ((255 - srcA) * dstR) / 255;
170 dstG = srcG + ((255 - srcA) * dstG) / 255;
171 dstB = srcB + ((255 - srcA) * dstB) / 255;
172 dstA = srcA + ((255 - srcA) * dstA) / 255;
173 break;
174 case SDL_COPY_ADD:
175 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
176 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
177 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
178 break;
179 case SDL_COPY_MOD:
180 dstR = (srcR * dstR) / 255;
181 dstG = (srcG * dstG) / 255;
182 dstB = (srcB * dstB) / 255;
183 break;
184 }
185 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
186 *dst = dstpixel;
187 posx += incx;
188 ++dst;
189 }
190 posy += incy;
191 info->dst += info->dst_pitch;
192 }
193 }
194
195 static void SDL_Blit_RGB888_RGB888_Modulate(SDL_BlitInfo *info)
196 {
197 const int flags = info->flags;
198 const Uint32 modulateR = info->r;
199 const Uint32 modulateG = info->g;
200 const Uint32 modulateB = info->b;
201 const Uint32 modulateA = info->a;
202 Uint32 pixel;
203 Uint32 R, G, B, A;
204
205 while (info->dst_h--) {
206 Uint32 *src = (Uint32 *)info->src;
207 Uint32 *dst = (Uint32 *)info->dst;
208 int n = info->dst_w;
209 while (n--) {
210 pixel = *src;
211 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
212 if (flags & SDL_COPY_MODULATE_COLOR) {
213 R = (R * modulateR) / 255;
214 G = (G * modulateG) / 255;
215 B = (B * modulateB) / 255;
216 }
217 if (flags & SDL_COPY_MODULATE_ALPHA) {
218 A = (A * modulateA) / 255;
219 }
220 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
221 *dst = pixel;
222 ++src;
223 ++dst;
224 }
225 info->src += info->src_pitch;
226 info->dst += info->dst_pitch;
227 }
228 }
229
230 static void SDL_Blit_RGB888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
231 {
232 const int flags = info->flags;
233 const Uint32 modulateR = info->r;
234 const Uint32 modulateG = info->g;
235 const Uint32 modulateB = info->b;
236 const Uint32 modulateA = info->a;
237 Uint32 pixel;
238 Uint32 R, G, B, A;
239 int srcy, srcx;
240 int posy, posx;
241 int incy, incx;
242
243 srcy = 0;
244 posy = 0;
245 incy = (info->src_h << 16) / info->dst_h;
246 incx = (info->src_w << 16) / info->dst_w;
247
248 while (info->dst_h--) {
249 Uint32 *src = 0;
250 Uint32 *dst = (Uint32 *)info->dst;
251 int n = info->dst_w;
252 srcx = -1;
253 posx = 0x10000L;
254 while (posy >= 0x10000L) {
255 ++srcy;
256 posy -= 0x10000L;
257 }
258 while (n--) {
259 if (posx >= 0x10000L) {
260 while (posx >= 0x10000L) {
261 ++srcx;
262 posx -= 0x10000L;
263 }
264 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
265 }
266 pixel = *src;
267 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
268 if (flags & SDL_COPY_MODULATE_COLOR) {
269 R = (R * modulateR) / 255;
270 G = (G * modulateG) / 255;
271 B = (B * modulateB) / 255;
272 }
273 if (flags & SDL_COPY_MODULATE_ALPHA) {
274 A = (A * modulateA) / 255;
275 }
276 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
277 *dst = pixel;
278 posx += incx;
279 ++dst;
280 }
281 posy += incy;
282 info->dst += info->dst_pitch;
283 }
284 }
285
286 static void SDL_Blit_RGB888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
287 {
288 const int flags = info->flags;
289 const Uint32 modulateR = info->r;
290 const Uint32 modulateG = info->g;
291 const Uint32 modulateB = info->b;
292 const Uint32 modulateA = info->a;
293 Uint32 srcpixel;
294 Uint32 srcR, srcG, srcB, srcA;
295 Uint32 dstpixel;
296 Uint32 dstR, dstG, dstB, dstA;
297
298 while (info->dst_h--) {
299 Uint32 *src = (Uint32 *)info->src;
300 Uint32 *dst = (Uint32 *)info->dst;
301 int n = info->dst_w;
302 while (n--) {
303 srcpixel = *src;
304 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
305 dstpixel = *dst;
306 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
307 if (flags & SDL_COPY_MODULATE_COLOR) {
308 srcR = (srcR * modulateR) / 255;
309 srcG = (srcG * modulateG) / 255;
310 srcB = (srcB * modulateB) / 255;
311 }
312 if (flags & SDL_COPY_MODULATE_ALPHA) {
313 srcA = (srcA * modulateA) / 255;
314 }
315 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
316 /* This goes away if we ever use premultiplied alpha */
317 if (srcA < 255) {
318 srcR = (srcR * srcA) / 255;
319 srcG = (srcG * srcA) / 255;
320 srcB = (srcB * srcA) / 255;
321 }
322 }
323 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
324 case SDL_COPY_BLEND:
325 dstR = srcR + ((255 - srcA) * dstR) / 255;
326 dstG = srcG + ((255 - srcA) * dstG) / 255;
327 dstB = srcB + ((255 - srcA) * dstB) / 255;
328 dstA = srcA + ((255 - srcA) * dstA) / 255;
329 break;
330 case SDL_COPY_ADD:
331 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
332 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
333 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
334 break;
335 case SDL_COPY_MOD:
336 dstR = (srcR * dstR) / 255;
337 dstG = (srcG * dstG) / 255;
338 dstB = (srcB * dstB) / 255;
339 break;
340 }
341 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
342 *dst = dstpixel;
343 ++src;
344 ++dst;
345 }
346 info->src += info->src_pitch;
347 info->dst += info->dst_pitch;
348 }
349 }
350
351 static void SDL_Blit_RGB888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
352 {
353 const int flags = info->flags;
354 const Uint32 modulateR = info->r;
355 const Uint32 modulateG = info->g;
356 const Uint32 modulateB = info->b;
357 const Uint32 modulateA = info->a;
358 Uint32 srcpixel;
359 Uint32 srcR, srcG, srcB, srcA;
360 Uint32 dstpixel;
361 Uint32 dstR, dstG, dstB, dstA;
362 int srcy, srcx;
363 int posy, posx;
364 int incy, incx;
365
366 srcy = 0;
367 posy = 0;
368 incy = (info->src_h << 16) / info->dst_h;
369 incx = (info->src_w << 16) / info->dst_w;
370
371 while (info->dst_h--) {
372 Uint32 *src = 0;
373 Uint32 *dst = (Uint32 *)info->dst;
374 int n = info->dst_w;
375 srcx = -1;
376 posx = 0x10000L;
377 while (posy >= 0x10000L) {
378 ++srcy;
379 posy -= 0x10000L;
380 }
381 while (n--) {
382 if (posx >= 0x10000L) {
383 while (posx >= 0x10000L) {
384 ++srcx;
385 posx -= 0x10000L;
386 }
387 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
388 }
389 srcpixel = *src;
390 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
391 dstpixel = *dst;
392 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
393 if (flags & SDL_COPY_MODULATE_COLOR) {
394 srcR = (srcR * modulateR) / 255;
395 srcG = (srcG * modulateG) / 255;
396 srcB = (srcB * modulateB) / 255;
397 }
398 if (flags & SDL_COPY_MODULATE_ALPHA) {
399 srcA = (srcA * modulateA) / 255;
400 }
401 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
402 /* This goes away if we ever use premultiplied alpha */
403 if (srcA < 255) {
404 srcR = (srcR * srcA) / 255;
405 srcG = (srcG * srcA) / 255;
406 srcB = (srcB * srcA) / 255;
407 }
408 }
409 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
410 case SDL_COPY_BLEND:
411 dstR = srcR + ((255 - srcA) * dstR) / 255;
412 dstG = srcG + ((255 - srcA) * dstG) / 255;
413 dstB = srcB + ((255 - srcA) * dstB) / 255;
414 dstA = srcA + ((255 - srcA) * dstA) / 255;
415 break;
416 case SDL_COPY_ADD:
417 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
418 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
419 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
420 break;
421 case SDL_COPY_MOD:
422 dstR = (srcR * dstR) / 255;
423 dstG = (srcG * dstG) / 255;
424 dstB = (srcB * dstB) / 255;
425 break;
426 }
427 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
428 *dst = dstpixel;
429 posx += incx;
430 ++dst;
431 }
432 posy += incy;
433 info->dst += info->dst_pitch;
434 }
435 }
436
437 static void SDL_Blit_RGB888_BGR888_Scale(SDL_BlitInfo *info)
438 {
439 Uint32 pixel;
440 Uint32 R, G, B, A;
441 int srcy, srcx;
442 int posy, posx;
443 int incy, incx;
444
445 srcy = 0;
446 posy = 0;
447 incy = (info->src_h << 16) / info->dst_h;
448 incx = (info->src_w << 16) / info->dst_w;
449
450 while (info->dst_h--) {
451 Uint32 *src = 0;
452 Uint32 *dst = (Uint32 *)info->dst;
453 int n = info->dst_w;
454 srcx = -1;
455 posx = 0x10000L;
456 while (posy >= 0x10000L) {
457 ++srcy;
458 posy -= 0x10000L;
459 }
460 while (n--) {
461 if (posx >= 0x10000L) {
462 while (posx >= 0x10000L) {
463 ++srcx;
464 posx -= 0x10000L;
465 }
466 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
467 }
468 pixel = *src;
469 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
470 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
471 *dst = pixel;
472 posx += incx;
473 ++dst;
474 }
475 posy += incy;
476 info->dst += info->dst_pitch;
477 }
478 }
479
480 static void SDL_Blit_RGB888_BGR888_Blend(SDL_BlitInfo *info)
481 {
482 const int flags = info->flags;
483 Uint32 srcpixel;
484 Uint32 srcR, srcG, srcB, srcA;
485 Uint32 dstpixel;
486 Uint32 dstR, dstG, dstB, dstA;
487
488 while (info->dst_h--) {
489 Uint32 *src = (Uint32 *)info->src;
490 Uint32 *dst = (Uint32 *)info->dst;
491 int n = info->dst_w;
492 while (n--) {
493 srcpixel = *src;
494 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
495 dstpixel = *dst;
496 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
497 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
498 /* This goes away if we ever use premultiplied alpha */
499 if (srcA < 255) {
500 srcR = (srcR * srcA) / 255;
501 srcG = (srcG * srcA) / 255;
502 srcB = (srcB * srcA) / 255;
503 }
504 }
505 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
506 case SDL_COPY_BLEND:
507 dstR = srcR + ((255 - srcA) * dstR) / 255;
508 dstG = srcG + ((255 - srcA) * dstG) / 255;
509 dstB = srcB + ((255 - srcA) * dstB) / 255;
510 dstA = srcA + ((255 - srcA) * dstA) / 255;
511 break;
512 case SDL_COPY_ADD:
513 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
514 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
515 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
516 break;
517 case SDL_COPY_MOD:
518 dstR = (srcR * dstR) / 255;
519 dstG = (srcG * dstG) / 255;
520 dstB = (srcB * dstB) / 255;
521 break;
522 }
523 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
524 *dst = dstpixel;
525 ++src;
526 ++dst;
527 }
528 info->src += info->src_pitch;
529 info->dst += info->dst_pitch;
530 }
531 }
532
533 static void SDL_Blit_RGB888_BGR888_Blend_Scale(SDL_BlitInfo *info)
534 {
535 const int flags = info->flags;
536 Uint32 srcpixel;
537 Uint32 srcR, srcG, srcB, srcA;
538 Uint32 dstpixel;
539 Uint32 dstR, dstG, dstB, dstA;
540 int srcy, srcx;
541 int posy, posx;
542 int incy, incx;
543
544 srcy = 0;
545 posy = 0;
546 incy = (info->src_h << 16) / info->dst_h;
547 incx = (info->src_w << 16) / info->dst_w;
548
549 while (info->dst_h--) {
550 Uint32 *src = 0;
551 Uint32 *dst = (Uint32 *)info->dst;
552 int n = info->dst_w;
553 srcx = -1;
554 posx = 0x10000L;
555 while (posy >= 0x10000L) {
556 ++srcy;
557 posy -= 0x10000L;
558 }
559 while (n--) {
560 if (posx >= 0x10000L) {
561 while (posx >= 0x10000L) {
562 ++srcx;
563 posx -= 0x10000L;
564 }
565 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
566 }
567 srcpixel = *src;
568 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
569 dstpixel = *dst;
570 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
571 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
572 /* This goes away if we ever use premultiplied alpha */
573 if (srcA < 255) {
574 srcR = (srcR * srcA) / 255;
575 srcG = (srcG * srcA) / 255;
576 srcB = (srcB * srcA) / 255;
577 }
578 }
579 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
580 case SDL_COPY_BLEND:
581 dstR = srcR + ((255 - srcA) * dstR) / 255;
582 dstG = srcG + ((255 - srcA) * dstG) / 255;
583 dstB = srcB + ((255 - srcA) * dstB) / 255;
584 dstA = srcA + ((255 - srcA) * dstA) / 255;
585 break;
586 case SDL_COPY_ADD:
587 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
588 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
589 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
590 break;
591 case SDL_COPY_MOD:
592 dstR = (srcR * dstR) / 255;
593 dstG = (srcG * dstG) / 255;
594 dstB = (srcB * dstB) / 255;
595 break;
596 }
597 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
598 *dst = dstpixel;
599 posx += incx;
600 ++dst;
601 }
602 posy += incy;
603 info->dst += info->dst_pitch;
604 }
605 }
606
607 static void SDL_Blit_RGB888_BGR888_Modulate(SDL_BlitInfo *info)
608 {
609 const int flags = info->flags;
610 const Uint32 modulateR = info->r;
611 const Uint32 modulateG = info->g;
612 const Uint32 modulateB = info->b;
613 const Uint32 modulateA = info->a;
614 Uint32 pixel;
615 Uint32 R, G, B, A;
616
617 while (info->dst_h--) {
618 Uint32 *src = (Uint32 *)info->src;
619 Uint32 *dst = (Uint32 *)info->dst;
620 int n = info->dst_w;
621 while (n--) {
622 pixel = *src;
623 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
624 if (flags & SDL_COPY_MODULATE_COLOR) {
625 R = (R * modulateR) / 255;
626 G = (G * modulateG) / 255;
627 B = (B * modulateB) / 255;
628 }
629 if (flags & SDL_COPY_MODULATE_ALPHA) {
630 A = (A * modulateA) / 255;
631 }
632 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
633 *dst = pixel;
634 ++src;
635 ++dst;
636 }
637 info->src += info->src_pitch;
638 info->dst += info->dst_pitch;
639 }
640 }
641
642 static void SDL_Blit_RGB888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
643 {
644 const int flags = info->flags;
645 const Uint32 modulateR = info->r;
646 const Uint32 modulateG = info->g;
647 const Uint32 modulateB = info->b;
648 const Uint32 modulateA = info->a;
649 Uint32 pixel;
650 Uint32 R, G, B, A;
651 int srcy, srcx;
652 int posy, posx;
653 int incy, incx;
654
655 srcy = 0;
656 posy = 0;
657 incy = (info->src_h << 16) / info->dst_h;
658 incx = (info->src_w << 16) / info->dst_w;
659
660 while (info->dst_h--) {
661 Uint32 *src = 0;
662 Uint32 *dst = (Uint32 *)info->dst;
663 int n = info->dst_w;
664 srcx = -1;
665 posx = 0x10000L;
666 while (posy >= 0x10000L) {
667 ++srcy;
668 posy -= 0x10000L;
669 }
670 while (n--) {
671 if (posx >= 0x10000L) {
672 while (posx >= 0x10000L) {
673 ++srcx;
674 posx -= 0x10000L;
675 }
676 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
677 }
678 pixel = *src;
679 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
680 if (flags & SDL_COPY_MODULATE_COLOR) {
681 R = (R * modulateR) / 255;
682 G = (G * modulateG) / 255;
683 B = (B * modulateB) / 255;
684 }
685 if (flags & SDL_COPY_MODULATE_ALPHA) {
686 A = (A * modulateA) / 255;
687 }
688 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
689 *dst = pixel;
690 posx += incx;
691 ++dst;
692 }
693 posy += incy;
694 info->dst += info->dst_pitch;
695 }
696 }
697
698 static void SDL_Blit_RGB888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
699 {
700 const int flags = info->flags;
701 const Uint32 modulateR = info->r;
702 const Uint32 modulateG = info->g;
703 const Uint32 modulateB = info->b;
704 const Uint32 modulateA = info->a;
705 Uint32 srcpixel;
706 Uint32 srcR, srcG, srcB, srcA;
707 Uint32 dstpixel;
708 Uint32 dstR, dstG, dstB, dstA;
709
710 while (info->dst_h--) {
711 Uint32 *src = (Uint32 *)info->src;
712 Uint32 *dst = (Uint32 *)info->dst;
713 int n = info->dst_w;
714 while (n--) {
715 srcpixel = *src;
716 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
717 dstpixel = *dst;
718 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
719 if (flags & SDL_COPY_MODULATE_COLOR) {
720 srcR = (srcR * modulateR) / 255;
721 srcG = (srcG * modulateG) / 255;
722 srcB = (srcB * modulateB) / 255;
723 }
724 if (flags & SDL_COPY_MODULATE_ALPHA) {
725 srcA = (srcA * modulateA) / 255;
726 }
727 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
728 /* This goes away if we ever use premultiplied alpha */
729 if (srcA < 255) {
730 srcR = (srcR * srcA) / 255;
731 srcG = (srcG * srcA) / 255;
732 srcB = (srcB * srcA) / 255;
733 }
734 }
735 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
736 case SDL_COPY_BLEND:
737 dstR = srcR + ((255 - srcA) * dstR) / 255;
738 dstG = srcG + ((255 - srcA) * dstG) / 255;
739 dstB = srcB + ((255 - srcA) * dstB) / 255;
740 dstA = srcA + ((255 - srcA) * dstA) / 255;
741 break;
742 case SDL_COPY_ADD:
743 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
744 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
745 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
746 break;
747 case SDL_COPY_MOD:
748 dstR = (srcR * dstR) / 255;
749 dstG = (srcG * dstG) / 255;
750 dstB = (srcB * dstB) / 255;
751 break;
752 }
753 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
754 *dst = dstpixel;
755 ++src;
756 ++dst;
757 }
758 info->src += info->src_pitch;
759 info->dst += info->dst_pitch;
760 }
761 }
762
763 static void SDL_Blit_RGB888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
764 {
765 const int flags = info->flags;
766 const Uint32 modulateR = info->r;
767 const Uint32 modulateG = info->g;
768 const Uint32 modulateB = info->b;
769 const Uint32 modulateA = info->a;
770 Uint32 srcpixel;
771 Uint32 srcR, srcG, srcB, srcA;
772 Uint32 dstpixel;
773 Uint32 dstR, dstG, dstB, dstA;
774 int srcy, srcx;
775 int posy, posx;
776 int incy, incx;
777
778 srcy = 0;
779 posy = 0;
780 incy = (info->src_h << 16) / info->dst_h;
781 incx = (info->src_w << 16) / info->dst_w;
782
783 while (info->dst_h--) {
784 Uint32 *src = 0;
785 Uint32 *dst = (Uint32 *)info->dst;
786 int n = info->dst_w;
787 srcx = -1;
788 posx = 0x10000L;
789 while (posy >= 0x10000L) {
790 ++srcy;
791 posy -= 0x10000L;
792 }
793 while (n--) {
794 if (posx >= 0x10000L) {
795 while (posx >= 0x10000L) {
796 ++srcx;
797 posx -= 0x10000L;
798 }
799 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
800 }
801 srcpixel = *src;
802 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
803 dstpixel = *dst;
804 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
805 if (flags & SDL_COPY_MODULATE_COLOR) {
806 srcR = (srcR * modulateR) / 255;
807 srcG = (srcG * modulateG) / 255;
808 srcB = (srcB * modulateB) / 255;
809 }
810 if (flags & SDL_COPY_MODULATE_ALPHA) {
811 srcA = (srcA * modulateA) / 255;
812 }
813 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
814 /* This goes away if we ever use premultiplied alpha */
815 if (srcA < 255) {
816 srcR = (srcR * srcA) / 255;
817 srcG = (srcG * srcA) / 255;
818 srcB = (srcB * srcA) / 255;
819 }
820 }
821 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
822 case SDL_COPY_BLEND:
823 dstR = srcR + ((255 - srcA) * dstR) / 255;
824 dstG = srcG + ((255 - srcA) * dstG) / 255;
825 dstB = srcB + ((255 - srcA) * dstB) / 255;
826 dstA = srcA + ((255 - srcA) * dstA) / 255;
827 break;
828 case SDL_COPY_ADD:
829 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
830 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
831 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
832 break;
833 case SDL_COPY_MOD:
834 dstR = (srcR * dstR) / 255;
835 dstG = (srcG * dstG) / 255;
836 dstB = (srcB * dstB) / 255;
837 break;
838 }
839 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
840 *dst = dstpixel;
841 posx += incx;
842 ++dst;
843 }
844 posy += incy;
845 info->dst += info->dst_pitch;
846 }
847 }
848
849 static void SDL_Blit_RGB888_ARGB8888_Scale(SDL_BlitInfo *info)
850 {
851 Uint32 pixel;
852 Uint32 R, G, B, A;
853 int srcy, srcx;
854 int posy, posx;
855 int incy, incx;
856
857 srcy = 0;
858 posy = 0;
859 incy = (info->src_h << 16) / info->dst_h;
860 incx = (info->src_w << 16) / info->dst_w;
861
862 while (info->dst_h--) {
863 Uint32 *src = 0;
864 Uint32 *dst = (Uint32 *)info->dst;
865 int n = info->dst_w;
866 srcx = -1;
867 posx = 0x10000L;
868 while (posy >= 0x10000L) {
869 ++srcy;
870 posy -= 0x10000L;
871 }
872 while (n--) {
873 if (posx >= 0x10000L) {
874 while (posx >= 0x10000L) {
875 ++srcx;
876 posx -= 0x10000L;
877 }
878 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
879 }
880 pixel = *src;
881 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
882 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
883 *dst = pixel;
884 posx += incx;
885 ++dst;
886 }
887 posy += incy;
888 info->dst += info->dst_pitch;
889 }
890 }
891
892 static void SDL_Blit_RGB888_ARGB8888_Blend(SDL_BlitInfo *info)
893 {
894 const int flags = info->flags;
895 Uint32 srcpixel;
896 Uint32 srcR, srcG, srcB, srcA;
897 Uint32 dstpixel;
898 Uint32 dstR, dstG, dstB, dstA;
899
900 while (info->dst_h--) {
901 Uint32 *src = (Uint32 *)info->src;
902 Uint32 *dst = (Uint32 *)info->dst;
903 int n = info->dst_w;
904 while (n--) {
905 srcpixel = *src;
906 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
907 dstpixel = *dst;
908 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
909 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
910 /* This goes away if we ever use premultiplied alpha */
911 if (srcA < 255) {
912 srcR = (srcR * srcA) / 255;
913 srcG = (srcG * srcA) / 255;
914 srcB = (srcB * srcA) / 255;
915 }
916 }
917 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
918 case SDL_COPY_BLEND:
919 dstR = srcR + ((255 - srcA) * dstR) / 255;
920 dstG = srcG + ((255 - srcA) * dstG) / 255;
921 dstB = srcB + ((255 - srcA) * dstB) / 255;
922 dstA = srcA + ((255 - srcA) * dstA) / 255;
923 break;
924 case SDL_COPY_ADD:
925 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
926 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
927 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
928 break;
929 case SDL_COPY_MOD:
930 dstR = (srcR * dstR) / 255;
931 dstG = (srcG * dstG) / 255;
932 dstB = (srcB * dstB) / 255;
933 break;
934 }
935 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
936 *dst = dstpixel;
937 ++src;
938 ++dst;
939 }
940 info->src += info->src_pitch;
941 info->dst += info->dst_pitch;
942 }
943 }
944
945 static void SDL_Blit_RGB888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
946 {
947 const int flags = info->flags;
948 Uint32 srcpixel;
949 Uint32 srcR, srcG, srcB, srcA;
950 Uint32 dstpixel;
951 Uint32 dstR, dstG, dstB, dstA;
952 int srcy, srcx;
953 int posy, posx;
954 int incy, incx;
955
956 srcy = 0;
957 posy = 0;
958 incy = (info->src_h << 16) / info->dst_h;
959 incx = (info->src_w << 16) / info->dst_w;
960
961 while (info->dst_h--) {
962 Uint32 *src = 0;
963 Uint32 *dst = (Uint32 *)info->dst;
964 int n = info->dst_w;
965 srcx = -1;
966 posx = 0x10000L;
967 while (posy >= 0x10000L) {
968 ++srcy;
969 posy -= 0x10000L;
970 }
971 while (n--) {
972 if (posx >= 0x10000L) {
973 while (posx >= 0x10000L) {
974 ++srcx;
975 posx -= 0x10000L;
976 }
977 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
978 }
979 srcpixel = *src;
980 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
981 dstpixel = *dst;
982 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
983 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
984 /* This goes away if we ever use premultiplied alpha */
985 if (srcA < 255) {
986 srcR = (srcR * srcA) / 255;
987 srcG = (srcG * srcA) / 255;
988 srcB = (srcB * srcA) / 255;
989 }
990 }
991 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
992 case SDL_COPY_BLEND:
993 dstR = srcR + ((255 - srcA) * dstR) / 255;
994 dstG = srcG + ((255 - srcA) * dstG) / 255;
995 dstB = srcB + ((255 - srcA) * dstB) / 255;
996 dstA = srcA + ((255 - srcA) * dstA) / 255;
997 break;
998 case SDL_COPY_ADD:
999 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1000 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1001 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1002 break;
1003 case SDL_COPY_MOD:
1004 dstR = (srcR * dstR) / 255;
1005 dstG = (srcG * dstG) / 255;
1006 dstB = (srcB * dstB) / 255;
1007 break;
1008 }
1009 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1010 *dst = dstpixel;
1011 posx += incx;
1012 ++dst;
1013 }
1014 posy += incy;
1015 info->dst += info->dst_pitch;
1016 }
1017 }
1018
1019 static void SDL_Blit_RGB888_ARGB8888_Modulate(SDL_BlitInfo *info)
1020 {
1021 const int flags = info->flags;
1022 const Uint32 modulateR = info->r;
1023 const Uint32 modulateG = info->g;
1024 const Uint32 modulateB = info->b;
1025 const Uint32 modulateA = info->a;
1026 Uint32 pixel;
1027 Uint32 R, G, B, A;
1028
1029 while (info->dst_h--) {
1030 Uint32 *src = (Uint32 *)info->src;
1031 Uint32 *dst = (Uint32 *)info->dst;
1032 int n = info->dst_w;
1033 while (n--) {
1034 pixel = *src;
1035 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
1036 if (flags & SDL_COPY_MODULATE_COLOR) {
1037 R = (R * modulateR) / 255;
1038 G = (G * modulateG) / 255;
1039 B = (B * modulateB) / 255;
1040 }
1041 if (flags & SDL_COPY_MODULATE_ALPHA) {
1042 A = (A * modulateA) / 255;
1043 }
1044 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
1045 *dst = pixel;
1046 ++src;
1047 ++dst;
1048 }
1049 info->src += info->src_pitch;
1050 info->dst += info->dst_pitch;
1051 }
1052 }
1053
1054 static void SDL_Blit_RGB888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
1055 {
1056 const int flags = info->flags;
1057 const Uint32 modulateR = info->r;
1058 const Uint32 modulateG = info->g;
1059 const Uint32 modulateB = info->b;
1060 const Uint32 modulateA = info->a;
1061 Uint32 pixel;
1062 Uint32 R, G, B, A;
1063 int srcy, srcx;
1064 int posy, posx;
1065 int incy, incx;
1066
1067 srcy = 0;
1068 posy = 0;
1069 incy = (info->src_h << 16) / info->dst_h;
1070 incx = (info->src_w << 16) / info->dst_w;
1071
1072 while (info->dst_h--) {
1073 Uint32 *src = 0;
1074 Uint32 *dst = (Uint32 *)info->dst;
1075 int n = info->dst_w;
1076 srcx = -1;
1077 posx = 0x10000L;
1078 while (posy >= 0x10000L) {
1079 ++srcy;
1080 posy -= 0x10000L;
1081 }
1082 while (n--) {
1083 if (posx >= 0x10000L) {
1084 while (posx >= 0x10000L) {
1085 ++srcx;
1086 posx -= 0x10000L;
1087 }
1088 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1089 }
1090 pixel = *src;
1091 R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel; A = 0xFF;
1092 if (flags & SDL_COPY_MODULATE_COLOR) {
1093 R = (R * modulateR) / 255;
1094 G = (G * modulateG) / 255;
1095 B = (B * modulateB) / 255;
1096 }
1097 if (flags & SDL_COPY_MODULATE_ALPHA) {
1098 A = (A * modulateA) / 255;
1099 }
1100 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
1101 *dst = pixel;
1102 posx += incx;
1103 ++dst;
1104 }
1105 posy += incy;
1106 info->dst += info->dst_pitch;
1107 }
1108 }
1109
1110 static void SDL_Blit_RGB888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
1111 {
1112 const int flags = info->flags;
1113 const Uint32 modulateR = info->r;
1114 const Uint32 modulateG = info->g;
1115 const Uint32 modulateB = info->b;
1116 const Uint32 modulateA = info->a;
1117 Uint32 srcpixel;
1118 Uint32 srcR, srcG, srcB, srcA;
1119 Uint32 dstpixel;
1120 Uint32 dstR, dstG, dstB, dstA;
1121
1122 while (info->dst_h--) {
1123 Uint32 *src = (Uint32 *)info->src;
1124 Uint32 *dst = (Uint32 *)info->dst;
1125 int n = info->dst_w;
1126 while (n--) {
1127 srcpixel = *src;
1128 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
1129 dstpixel = *dst;
1130 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
1131 if (flags & SDL_COPY_MODULATE_COLOR) {
1132 srcR = (srcR * modulateR) / 255;
1133 srcG = (srcG * modulateG) / 255;
1134 srcB = (srcB * modulateB) / 255;
1135 }
1136 if (flags & SDL_COPY_MODULATE_ALPHA) {
1137 srcA = (srcA * modulateA) / 255;
1138 }
1139 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1140 /* This goes away if we ever use premultiplied alpha */
1141 if (srcA < 255) {
1142 srcR = (srcR * srcA) / 255;
1143 srcG = (srcG * srcA) / 255;
1144 srcB = (srcB * srcA) / 255;
1145 }
1146 }
1147 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1148 case SDL_COPY_BLEND:
1149 dstR = srcR + ((255 - srcA) * dstR) / 255;
1150 dstG = srcG + ((255 - srcA) * dstG) / 255;
1151 dstB = srcB + ((255 - srcA) * dstB) / 255;
1152 dstA = srcA + ((255 - srcA) * dstA) / 255;
1153 break;
1154 case SDL_COPY_ADD:
1155 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1156 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1157 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1158 break;
1159 case SDL_COPY_MOD:
1160 dstR = (srcR * dstR) / 255;
1161 dstG = (srcG * dstG) / 255;
1162 dstB = (srcB * dstB) / 255;
1163 break;
1164 }
1165 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1166 *dst = dstpixel;
1167 ++src;
1168 ++dst;
1169 }
1170 info->src += info->src_pitch;
1171 info->dst += info->dst_pitch;
1172 }
1173 }
1174
1175 static void SDL_Blit_RGB888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
1176 {
1177 const int flags = info->flags;
1178 const Uint32 modulateR = info->r;
1179 const Uint32 modulateG = info->g;
1180 const Uint32 modulateB = info->b;
1181 const Uint32 modulateA = info->a;
1182 Uint32 srcpixel;
1183 Uint32 srcR, srcG, srcB, srcA;
1184 Uint32 dstpixel;
1185 Uint32 dstR, dstG, dstB, dstA;
1186 int srcy, srcx;
1187 int posy, posx;
1188 int incy, incx;
1189
1190 srcy = 0;
1191 posy = 0;
1192 incy = (info->src_h << 16) / info->dst_h;
1193 incx = (info->src_w << 16) / info->dst_w;
1194
1195 while (info->dst_h--) {
1196 Uint32 *src = 0;
1197 Uint32 *dst = (Uint32 *)info->dst;
1198 int n = info->dst_w;
1199 srcx = -1;
1200 posx = 0x10000L;
1201 while (posy >= 0x10000L) {
1202 ++srcy;
1203 posy -= 0x10000L;
1204 }
1205 while (n--) {
1206 if (posx >= 0x10000L) {
1207 while (posx >= 0x10000L) {
1208 ++srcx;
1209 posx -= 0x10000L;
1210 }
1211 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1212 }
1213 srcpixel = *src;
1214 srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel; srcA = 0xFF;
1215 dstpixel = *dst;
1216 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
1217 if (flags & SDL_COPY_MODULATE_COLOR) {
1218 srcR = (srcR * modulateR) / 255;
1219 srcG = (srcG * modulateG) / 255;
1220 srcB = (srcB * modulateB) / 255;
1221 }
1222 if (flags & SDL_COPY_MODULATE_ALPHA) {
1223 srcA = (srcA * modulateA) / 255;
1224 }
1225 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1226 /* This goes away if we ever use premultiplied alpha */
1227 if (srcA < 255) {
1228 srcR = (srcR * srcA) / 255;
1229 srcG = (srcG * srcA) / 255;
1230 srcB = (srcB * srcA) / 255;
1231 }
1232 }
1233 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1234 case SDL_COPY_BLEND:
1235 dstR = srcR + ((255 - srcA) * dstR) / 255;
1236 dstG = srcG + ((255 - srcA) * dstG) / 255;
1237 dstB = srcB + ((255 - srcA) * dstB) / 255;
1238 dstA = srcA + ((255 - srcA) * dstA) / 255;
1239 break;
1240 case SDL_COPY_ADD:
1241 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1242 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1243 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1244 break;
1245 case SDL_COPY_MOD:
1246 dstR = (srcR * dstR) / 255;
1247 dstG = (srcG * dstG) / 255;
1248 dstB = (srcB * dstB) / 255;
1249 break;
1250 }
1251 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1252 *dst = dstpixel;
1253 posx += incx;
1254 ++dst;
1255 }
1256 posy += incy;
1257 info->dst += info->dst_pitch;
1258 }
1259 }
1260
1261 static void SDL_Blit_BGR888_RGB888_Scale(SDL_BlitInfo *info)
1262 {
1263 Uint32 pixel;
1264 Uint32 R, G, B, A;
1265 int srcy, srcx;
1266 int posy, posx;
1267 int incy, incx;
1268
1269 srcy = 0;
1270 posy = 0;
1271 incy = (info->src_h << 16) / info->dst_h;
1272 incx = (info->src_w << 16) / info->dst_w;
1273
1274 while (info->dst_h--) {
1275 Uint32 *src = 0;
1276 Uint32 *dst = (Uint32 *)info->dst;
1277 int n = info->dst_w;
1278 srcx = -1;
1279 posx = 0x10000L;
1280 while (posy >= 0x10000L) {
1281 ++srcy;
1282 posy -= 0x10000L;
1283 }
1284 while (n--) {
1285 if (posx >= 0x10000L) {
1286 while (posx >= 0x10000L) {
1287 ++srcx;
1288 posx -= 0x10000L;
1289 }
1290 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1291 }
1292 pixel = *src;
1293 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
1294 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
1295 *dst = pixel;
1296 posx += incx;
1297 ++dst;
1298 }
1299 posy += incy;
1300 info->dst += info->dst_pitch;
1301 }
1302 }
1303
1304 static void SDL_Blit_BGR888_RGB888_Blend(SDL_BlitInfo *info)
1305 {
1306 const int flags = info->flags;
1307 Uint32 srcpixel;
1308 Uint32 srcR, srcG, srcB, srcA;
1309 Uint32 dstpixel;
1310 Uint32 dstR, dstG, dstB, dstA;
1311
1312 while (info->dst_h--) {
1313 Uint32 *src = (Uint32 *)info->src;
1314 Uint32 *dst = (Uint32 *)info->dst;
1315 int n = info->dst_w;
1316 while (n--) {
1317 srcpixel = *src;
1318 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1319 dstpixel = *dst;
1320 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
1321 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1322 /* This goes away if we ever use premultiplied alpha */
1323 if (srcA < 255) {
1324 srcR = (srcR * srcA) / 255;
1325 srcG = (srcG * srcA) / 255;
1326 srcB = (srcB * srcA) / 255;
1327 }
1328 }
1329 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1330 case SDL_COPY_BLEND:
1331 dstR = srcR + ((255 - srcA) * dstR) / 255;
1332 dstG = srcG + ((255 - srcA) * dstG) / 255;
1333 dstB = srcB + ((255 - srcA) * dstB) / 255;
1334 dstA = srcA + ((255 - srcA) * dstA) / 255;
1335 break;
1336 case SDL_COPY_ADD:
1337 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1338 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1339 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1340 break;
1341 case SDL_COPY_MOD:
1342 dstR = (srcR * dstR) / 255;
1343 dstG = (srcG * dstG) / 255;
1344 dstB = (srcB * dstB) / 255;
1345 break;
1346 }
1347 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1348 *dst = dstpixel;
1349 ++src;
1350 ++dst;
1351 }
1352 info->src += info->src_pitch;
1353 info->dst += info->dst_pitch;
1354 }
1355 }
1356
1357 static void SDL_Blit_BGR888_RGB888_Blend_Scale(SDL_BlitInfo *info)
1358 {
1359 const int flags = info->flags;
1360 Uint32 srcpixel;
1361 Uint32 srcR, srcG, srcB, srcA;
1362 Uint32 dstpixel;
1363 Uint32 dstR, dstG, dstB, dstA;
1364 int srcy, srcx;
1365 int posy, posx;
1366 int incy, incx;
1367
1368 srcy = 0;
1369 posy = 0;
1370 incy = (info->src_h << 16) / info->dst_h;
1371 incx = (info->src_w << 16) / info->dst_w;
1372
1373 while (info->dst_h--) {
1374 Uint32 *src = 0;
1375 Uint32 *dst = (Uint32 *)info->dst;
1376 int n = info->dst_w;
1377 srcx = -1;
1378 posx = 0x10000L;
1379 while (posy >= 0x10000L) {
1380 ++srcy;
1381 posy -= 0x10000L;
1382 }
1383 while (n--) {
1384 if (posx >= 0x10000L) {
1385 while (posx >= 0x10000L) {
1386 ++srcx;
1387 posx -= 0x10000L;
1388 }
1389 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1390 }
1391 srcpixel = *src;
1392 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1393 dstpixel = *dst;
1394 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
1395 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1396 /* This goes away if we ever use premultiplied alpha */
1397 if (srcA < 255) {
1398 srcR = (srcR * srcA) / 255;
1399 srcG = (srcG * srcA) / 255;
1400 srcB = (srcB * srcA) / 255;
1401 }
1402 }
1403 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1404 case SDL_COPY_BLEND:
1405 dstR = srcR + ((255 - srcA) * dstR) / 255;
1406 dstG = srcG + ((255 - srcA) * dstG) / 255;
1407 dstB = srcB + ((255 - srcA) * dstB) / 255;
1408 dstA = srcA + ((255 - srcA) * dstA) / 255;
1409 break;
1410 case SDL_COPY_ADD:
1411 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1412 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1413 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1414 break;
1415 case SDL_COPY_MOD:
1416 dstR = (srcR * dstR) / 255;
1417 dstG = (srcG * dstG) / 255;
1418 dstB = (srcB * dstB) / 255;
1419 break;
1420 }
1421 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1422 *dst = dstpixel;
1423 posx += incx;
1424 ++dst;
1425 }
1426 posy += incy;
1427 info->dst += info->dst_pitch;
1428 }
1429 }
1430
1431 static void SDL_Blit_BGR888_RGB888_Modulate(SDL_BlitInfo *info)
1432 {
1433 const int flags = info->flags;
1434 const Uint32 modulateR = info->r;
1435 const Uint32 modulateG = info->g;
1436 const Uint32 modulateB = info->b;
1437 const Uint32 modulateA = info->a;
1438 Uint32 pixel;
1439 Uint32 R, G, B, A;
1440
1441 while (info->dst_h--) {
1442 Uint32 *src = (Uint32 *)info->src;
1443 Uint32 *dst = (Uint32 *)info->dst;
1444 int n = info->dst_w;
1445 while (n--) {
1446 pixel = *src;
1447 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
1448 if (flags & SDL_COPY_MODULATE_COLOR) {
1449 R = (R * modulateR) / 255;
1450 G = (G * modulateG) / 255;
1451 B = (B * modulateB) / 255;
1452 }
1453 if (flags & SDL_COPY_MODULATE_ALPHA) {
1454 A = (A * modulateA) / 255;
1455 }
1456 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
1457 *dst = pixel;
1458 ++src;
1459 ++dst;
1460 }
1461 info->src += info->src_pitch;
1462 info->dst += info->dst_pitch;
1463 }
1464 }
1465
1466 static void SDL_Blit_BGR888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
1467 {
1468 const int flags = info->flags;
1469 const Uint32 modulateR = info->r;
1470 const Uint32 modulateG = info->g;
1471 const Uint32 modulateB = info->b;
1472 const Uint32 modulateA = info->a;
1473 Uint32 pixel;
1474 Uint32 R, G, B, A;
1475 int srcy, srcx;
1476 int posy, posx;
1477 int incy, incx;
1478
1479 srcy = 0;
1480 posy = 0;
1481 incy = (info->src_h << 16) / info->dst_h;
1482 incx = (info->src_w << 16) / info->dst_w;
1483
1484 while (info->dst_h--) {
1485 Uint32 *src = 0;
1486 Uint32 *dst = (Uint32 *)info->dst;
1487 int n = info->dst_w;
1488 srcx = -1;
1489 posx = 0x10000L;
1490 while (posy >= 0x10000L) {
1491 ++srcy;
1492 posy -= 0x10000L;
1493 }
1494 while (n--) {
1495 if (posx >= 0x10000L) {
1496 while (posx >= 0x10000L) {
1497 ++srcx;
1498 posx -= 0x10000L;
1499 }
1500 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1501 }
1502 pixel = *src;
1503 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
1504 if (flags & SDL_COPY_MODULATE_COLOR) {
1505 R = (R * modulateR) / 255;
1506 G = (G * modulateG) / 255;
1507 B = (B * modulateB) / 255;
1508 }
1509 if (flags & SDL_COPY_MODULATE_ALPHA) {
1510 A = (A * modulateA) / 255;
1511 }
1512 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
1513 *dst = pixel;
1514 posx += incx;
1515 ++dst;
1516 }
1517 posy += incy;
1518 info->dst += info->dst_pitch;
1519 }
1520 }
1521
1522 static void SDL_Blit_BGR888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
1523 {
1524 const int flags = info->flags;
1525 const Uint32 modulateR = info->r;
1526 const Uint32 modulateG = info->g;
1527 const Uint32 modulateB = info->b;
1528 const Uint32 modulateA = info->a;
1529 Uint32 srcpixel;
1530 Uint32 srcR, srcG, srcB, srcA;
1531 Uint32 dstpixel;
1532 Uint32 dstR, dstG, dstB, dstA;
1533
1534 while (info->dst_h--) {
1535 Uint32 *src = (Uint32 *)info->src;
1536 Uint32 *dst = (Uint32 *)info->dst;
1537 int n = info->dst_w;
1538 while (n--) {
1539 srcpixel = *src;
1540 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1541 dstpixel = *dst;
1542 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
1543 if (flags & SDL_COPY_MODULATE_COLOR) {
1544 srcR = (srcR * modulateR) / 255;
1545 srcG = (srcG * modulateG) / 255;
1546 srcB = (srcB * modulateB) / 255;
1547 }
1548 if (flags & SDL_COPY_MODULATE_ALPHA) {
1549 srcA = (srcA * modulateA) / 255;
1550 }
1551 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1552 /* This goes away if we ever use premultiplied alpha */
1553 if (srcA < 255) {
1554 srcR = (srcR * srcA) / 255;
1555 srcG = (srcG * srcA) / 255;
1556 srcB = (srcB * srcA) / 255;
1557 }
1558 }
1559 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1560 case SDL_COPY_BLEND:
1561 dstR = srcR + ((255 - srcA) * dstR) / 255;
1562 dstG = srcG + ((255 - srcA) * dstG) / 255;
1563 dstB = srcB + ((255 - srcA) * dstB) / 255;
1564 dstA = srcA + ((255 - srcA) * dstA) / 255;
1565 break;
1566 case SDL_COPY_ADD:
1567 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1568 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1569 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1570 break;
1571 case SDL_COPY_MOD:
1572 dstR = (srcR * dstR) / 255;
1573 dstG = (srcG * dstG) / 255;
1574 dstB = (srcB * dstB) / 255;
1575 break;
1576 }
1577 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1578 *dst = dstpixel;
1579 ++src;
1580 ++dst;
1581 }
1582 info->src += info->src_pitch;
1583 info->dst += info->dst_pitch;
1584 }
1585 }
1586
1587 static void SDL_Blit_BGR888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
1588 {
1589 const int flags = info->flags;
1590 const Uint32 modulateR = info->r;
1591 const Uint32 modulateG = info->g;
1592 const Uint32 modulateB = info->b;
1593 const Uint32 modulateA = info->a;
1594 Uint32 srcpixel;
1595 Uint32 srcR, srcG, srcB, srcA;
1596 Uint32 dstpixel;
1597 Uint32 dstR, dstG, dstB, dstA;
1598 int srcy, srcx;
1599 int posy, posx;
1600 int incy, incx;
1601
1602 srcy = 0;
1603 posy = 0;
1604 incy = (info->src_h << 16) / info->dst_h;
1605 incx = (info->src_w << 16) / info->dst_w;
1606
1607 while (info->dst_h--) {
1608 Uint32 *src = 0;
1609 Uint32 *dst = (Uint32 *)info->dst;
1610 int n = info->dst_w;
1611 srcx = -1;
1612 posx = 0x10000L;
1613 while (posy >= 0x10000L) {
1614 ++srcy;
1615 posy -= 0x10000L;
1616 }
1617 while (n--) {
1618 if (posx >= 0x10000L) {
1619 while (posx >= 0x10000L) {
1620 ++srcx;
1621 posx -= 0x10000L;
1622 }
1623 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1624 }
1625 srcpixel = *src;
1626 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1627 dstpixel = *dst;
1628 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
1629 if (flags & SDL_COPY_MODULATE_COLOR) {
1630 srcR = (srcR * modulateR) / 255;
1631 srcG = (srcG * modulateG) / 255;
1632 srcB = (srcB * modulateB) / 255;
1633 }
1634 if (flags & SDL_COPY_MODULATE_ALPHA) {
1635 srcA = (srcA * modulateA) / 255;
1636 }
1637 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1638 /* This goes away if we ever use premultiplied alpha */
1639 if (srcA < 255) {
1640 srcR = (srcR * srcA) / 255;
1641 srcG = (srcG * srcA) / 255;
1642 srcB = (srcB * srcA) / 255;
1643 }
1644 }
1645 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1646 case SDL_COPY_BLEND:
1647 dstR = srcR + ((255 - srcA) * dstR) / 255;
1648 dstG = srcG + ((255 - srcA) * dstG) / 255;
1649 dstB = srcB + ((255 - srcA) * dstB) / 255;
1650 dstA = srcA + ((255 - srcA) * dstA) / 255;
1651 break;
1652 case SDL_COPY_ADD:
1653 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1654 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1655 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1656 break;
1657 case SDL_COPY_MOD:
1658 dstR = (srcR * dstR) / 255;
1659 dstG = (srcG * dstG) / 255;
1660 dstB = (srcB * dstB) / 255;
1661 break;
1662 }
1663 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
1664 *dst = dstpixel;
1665 posx += incx;
1666 ++dst;
1667 }
1668 posy += incy;
1669 info->dst += info->dst_pitch;
1670 }
1671 }
1672
1673 static void SDL_Blit_BGR888_BGR888_Scale(SDL_BlitInfo *info)
1674 {
1675 int srcy, srcx;
1676 int posy, posx;
1677 int incy, incx;
1678
1679 srcy = 0;
1680 posy = 0;
1681 incy = (info->src_h << 16) / info->dst_h;
1682 incx = (info->src_w << 16) / info->dst_w;
1683
1684 while (info->dst_h--) {
1685 Uint32 *src = 0;
1686 Uint32 *dst = (Uint32 *)info->dst;
1687 int n = info->dst_w;
1688 srcx = -1;
1689 posx = 0x10000L;
1690 while (posy >= 0x10000L) {
1691 ++srcy;
1692 posy -= 0x10000L;
1693 }
1694 while (n--) {
1695 if (posx >= 0x10000L) {
1696 while (posx >= 0x10000L) {
1697 ++srcx;
1698 posx -= 0x10000L;
1699 }
1700 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1701 }
1702 *dst = *src;
1703 posx += incx;
1704 ++dst;
1705 }
1706 posy += incy;
1707 info->dst += info->dst_pitch;
1708 }
1709 }
1710
1711 static void SDL_Blit_BGR888_BGR888_Blend(SDL_BlitInfo *info)
1712 {
1713 const int flags = info->flags;
1714 Uint32 srcpixel;
1715 Uint32 srcR, srcG, srcB, srcA;
1716 Uint32 dstpixel;
1717 Uint32 dstR, dstG, dstB, dstA;
1718
1719 while (info->dst_h--) {
1720 Uint32 *src = (Uint32 *)info->src;
1721 Uint32 *dst = (Uint32 *)info->dst;
1722 int n = info->dst_w;
1723 while (n--) {
1724 srcpixel = *src;
1725 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1726 dstpixel = *dst;
1727 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
1728 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1729 /* This goes away if we ever use premultiplied alpha */
1730 if (srcA < 255) {
1731 srcR = (srcR * srcA) / 255;
1732 srcG = (srcG * srcA) / 255;
1733 srcB = (srcB * srcA) / 255;
1734 }
1735 }
1736 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1737 case SDL_COPY_BLEND:
1738 dstR = srcR + ((255 - srcA) * dstR) / 255;
1739 dstG = srcG + ((255 - srcA) * dstG) / 255;
1740 dstB = srcB + ((255 - srcA) * dstB) / 255;
1741 dstA = srcA + ((255 - srcA) * dstA) / 255;
1742 break;
1743 case SDL_COPY_ADD:
1744 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1745 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1746 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1747 break;
1748 case SDL_COPY_MOD:
1749 dstR = (srcR * dstR) / 255;
1750 dstG = (srcG * dstG) / 255;
1751 dstB = (srcB * dstB) / 255;
1752 break;
1753 }
1754 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
1755 *dst = dstpixel;
1756 ++src;
1757 ++dst;
1758 }
1759 info->src += info->src_pitch;
1760 info->dst += info->dst_pitch;
1761 }
1762 }
1763
1764 static void SDL_Blit_BGR888_BGR888_Blend_Scale(SDL_BlitInfo *info)
1765 {
1766 const int flags = info->flags;
1767 Uint32 srcpixel;
1768 Uint32 srcR, srcG, srcB, srcA;
1769 Uint32 dstpixel;
1770 Uint32 dstR, dstG, dstB, dstA;
1771 int srcy, srcx;
1772 int posy, posx;
1773 int incy, incx;
1774
1775 srcy = 0;
1776 posy = 0;
1777 incy = (info->src_h << 16) / info->dst_h;
1778 incx = (info->src_w << 16) / info->dst_w;
1779
1780 while (info->dst_h--) {
1781 Uint32 *src = 0;
1782 Uint32 *dst = (Uint32 *)info->dst;
1783 int n = info->dst_w;
1784 srcx = -1;
1785 posx = 0x10000L;
1786 while (posy >= 0x10000L) {
1787 ++srcy;
1788 posy -= 0x10000L;
1789 }
1790 while (n--) {
1791 if (posx >= 0x10000L) {
1792 while (posx >= 0x10000L) {
1793 ++srcx;
1794 posx -= 0x10000L;
1795 }
1796 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1797 }
1798 srcpixel = *src;
1799 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1800 dstpixel = *dst;
1801 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
1802 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1803 /* This goes away if we ever use premultiplied alpha */
1804 if (srcA < 255) {
1805 srcR = (srcR * srcA) / 255;
1806 srcG = (srcG * srcA) / 255;
1807 srcB = (srcB * srcA) / 255;
1808 }
1809 }
1810 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1811 case SDL_COPY_BLEND:
1812 dstR = srcR + ((255 - srcA) * dstR) / 255;
1813 dstG = srcG + ((255 - srcA) * dstG) / 255;
1814 dstB = srcB + ((255 - srcA) * dstB) / 255;
1815 dstA = srcA + ((255 - srcA) * dstA) / 255;
1816 break;
1817 case SDL_COPY_ADD:
1818 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1819 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1820 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1821 break;
1822 case SDL_COPY_MOD:
1823 dstR = (srcR * dstR) / 255;
1824 dstG = (srcG * dstG) / 255;
1825 dstB = (srcB * dstB) / 255;
1826 break;
1827 }
1828 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
1829 *dst = dstpixel;
1830 posx += incx;
1831 ++dst;
1832 }
1833 posy += incy;
1834 info->dst += info->dst_pitch;
1835 }
1836 }
1837
1838 static void SDL_Blit_BGR888_BGR888_Modulate(SDL_BlitInfo *info)
1839 {
1840 const int flags = info->flags;
1841 const Uint32 modulateR = info->r;
1842 const Uint32 modulateG = info->g;
1843 const Uint32 modulateB = info->b;
1844 const Uint32 modulateA = info->a;
1845 Uint32 pixel;
1846 Uint32 R, G, B, A;
1847
1848 while (info->dst_h--) {
1849 Uint32 *src = (Uint32 *)info->src;
1850 Uint32 *dst = (Uint32 *)info->dst;
1851 int n = info->dst_w;
1852 while (n--) {
1853 pixel = *src;
1854 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
1855 if (flags & SDL_COPY_MODULATE_COLOR) {
1856 R = (R * modulateR) / 255;
1857 G = (G * modulateG) / 255;
1858 B = (B * modulateB) / 255;
1859 }
1860 if (flags & SDL_COPY_MODULATE_ALPHA) {
1861 A = (A * modulateA) / 255;
1862 }
1863 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
1864 *dst = pixel;
1865 ++src;
1866 ++dst;
1867 }
1868 info->src += info->src_pitch;
1869 info->dst += info->dst_pitch;
1870 }
1871 }
1872
1873 static void SDL_Blit_BGR888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
1874 {
1875 const int flags = info->flags;
1876 const Uint32 modulateR = info->r;
1877 const Uint32 modulateG = info->g;
1878 const Uint32 modulateB = info->b;
1879 const Uint32 modulateA = info->a;
1880 Uint32 pixel;
1881 Uint32 R, G, B, A;
1882 int srcy, srcx;
1883 int posy, posx;
1884 int incy, incx;
1885
1886 srcy = 0;
1887 posy = 0;
1888 incy = (info->src_h << 16) / info->dst_h;
1889 incx = (info->src_w << 16) / info->dst_w;
1890
1891 while (info->dst_h--) {
1892 Uint32 *src = 0;
1893 Uint32 *dst = (Uint32 *)info->dst;
1894 int n = info->dst_w;
1895 srcx = -1;
1896 posx = 0x10000L;
1897 while (posy >= 0x10000L) {
1898 ++srcy;
1899 posy -= 0x10000L;
1900 }
1901 while (n--) {
1902 if (posx >= 0x10000L) {
1903 while (posx >= 0x10000L) {
1904 ++srcx;
1905 posx -= 0x10000L;
1906 }
1907 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
1908 }
1909 pixel = *src;
1910 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
1911 if (flags & SDL_COPY_MODULATE_COLOR) {
1912 R = (R * modulateR) / 255;
1913 G = (G * modulateG) / 255;
1914 B = (B * modulateB) / 255;
1915 }
1916 if (flags & SDL_COPY_MODULATE_ALPHA) {
1917 A = (A * modulateA) / 255;
1918 }
1919 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
1920 *dst = pixel;
1921 posx += incx;
1922 ++dst;
1923 }
1924 posy += incy;
1925 info->dst += info->dst_pitch;
1926 }
1927 }
1928
1929 static void SDL_Blit_BGR888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
1930 {
1931 const int flags = info->flags;
1932 const Uint32 modulateR = info->r;
1933 const Uint32 modulateG = info->g;
1934 const Uint32 modulateB = info->b;
1935 const Uint32 modulateA = info->a;
1936 Uint32 srcpixel;
1937 Uint32 srcR, srcG, srcB, srcA;
1938 Uint32 dstpixel;
1939 Uint32 dstR, dstG, dstB, dstA;
1940
1941 while (info->dst_h--) {
1942 Uint32 *src = (Uint32 *)info->src;
1943 Uint32 *dst = (Uint32 *)info->dst;
1944 int n = info->dst_w;
1945 while (n--) {
1946 srcpixel = *src;
1947 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
1948 dstpixel = *dst;
1949 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
1950 if (flags & SDL_COPY_MODULATE_COLOR) {
1951 srcR = (srcR * modulateR) / 255;
1952 srcG = (srcG * modulateG) / 255;
1953 srcB = (srcB * modulateB) / 255;
1954 }
1955 if (flags & SDL_COPY_MODULATE_ALPHA) {
1956 srcA = (srcA * modulateA) / 255;
1957 }
1958 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
1959 /* This goes away if we ever use premultiplied alpha */
1960 if (srcA < 255) {
1961 srcR = (srcR * srcA) / 255;
1962 srcG = (srcG * srcA) / 255;
1963 srcB = (srcB * srcA) / 255;
1964 }
1965 }
1966 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
1967 case SDL_COPY_BLEND:
1968 dstR = srcR + ((255 - srcA) * dstR) / 255;
1969 dstG = srcG + ((255 - srcA) * dstG) / 255;
1970 dstB = srcB + ((255 - srcA) * dstB) / 255;
1971 dstA = srcA + ((255 - srcA) * dstA) / 255;
1972 break;
1973 case SDL_COPY_ADD:
1974 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
1975 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
1976 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
1977 break;
1978 case SDL_COPY_MOD:
1979 dstR = (srcR * dstR) / 255;
1980 dstG = (srcG * dstG) / 255;
1981 dstB = (srcB * dstB) / 255;
1982 break;
1983 }
1984 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
1985 *dst = dstpixel;
1986 ++src;
1987 ++dst;
1988 }
1989 info->src += info->src_pitch;
1990 info->dst += info->dst_pitch;
1991 }
1992 }
1993
1994 static void SDL_Blit_BGR888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
1995 {
1996 const int flags = info->flags;
1997 const Uint32 modulateR = info->r;
1998 const Uint32 modulateG = info->g;
1999 const Uint32 modulateB = info->b;
2000 const Uint32 modulateA = info->a;
2001 Uint32 srcpixel;
2002 Uint32 srcR, srcG, srcB, srcA;
2003 Uint32 dstpixel;
2004 Uint32 dstR, dstG, dstB, dstA;
2005 int srcy, srcx;
2006 int posy, posx;
2007 int incy, incx;
2008
2009 srcy = 0;
2010 posy = 0;
2011 incy = (info->src_h << 16) / info->dst_h;
2012 incx = (info->src_w << 16) / info->dst_w;
2013
2014 while (info->dst_h--) {
2015 Uint32 *src = 0;
2016 Uint32 *dst = (Uint32 *)info->dst;
2017 int n = info->dst_w;
2018 srcx = -1;
2019 posx = 0x10000L;
2020 while (posy >= 0x10000L) {
2021 ++srcy;
2022 posy -= 0x10000L;
2023 }
2024 while (n--) {
2025 if (posx >= 0x10000L) {
2026 while (posx >= 0x10000L) {
2027 ++srcx;
2028 posx -= 0x10000L;
2029 }
2030 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2031 }
2032 srcpixel = *src;
2033 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
2034 dstpixel = *dst;
2035 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
2036 if (flags & SDL_COPY_MODULATE_COLOR) {
2037 srcR = (srcR * modulateR) / 255;
2038 srcG = (srcG * modulateG) / 255;
2039 srcB = (srcB * modulateB) / 255;
2040 }
2041 if (flags & SDL_COPY_MODULATE_ALPHA) {
2042 srcA = (srcA * modulateA) / 255;
2043 }
2044 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2045 /* This goes away if we ever use premultiplied alpha */
2046 if (srcA < 255) {
2047 srcR = (srcR * srcA) / 255;
2048 srcG = (srcG * srcA) / 255;
2049 srcB = (srcB * srcA) / 255;
2050 }
2051 }
2052 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2053 case SDL_COPY_BLEND:
2054 dstR = srcR + ((255 - srcA) * dstR) / 255;
2055 dstG = srcG + ((255 - srcA) * dstG) / 255;
2056 dstB = srcB + ((255 - srcA) * dstB) / 255;
2057 dstA = srcA + ((255 - srcA) * dstA) / 255;
2058 break;
2059 case SDL_COPY_ADD:
2060 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2061 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2062 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2063 break;
2064 case SDL_COPY_MOD:
2065 dstR = (srcR * dstR) / 255;
2066 dstG = (srcG * dstG) / 255;
2067 dstB = (srcB * dstB) / 255;
2068 break;
2069 }
2070 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
2071 *dst = dstpixel;
2072 posx += incx;
2073 ++dst;
2074 }
2075 posy += incy;
2076 info->dst += info->dst_pitch;
2077 }
2078 }
2079
2080 static void SDL_Blit_BGR888_ARGB8888_Scale(SDL_BlitInfo *info)
2081 {
2082 Uint32 pixel;
2083 Uint32 R, G, B, A;
2084 int srcy, srcx;
2085 int posy, posx;
2086 int incy, incx;
2087
2088 srcy = 0;
2089 posy = 0;
2090 incy = (info->src_h << 16) / info->dst_h;
2091 incx = (info->src_w << 16) / info->dst_w;
2092
2093 while (info->dst_h--) {
2094 Uint32 *src = 0;
2095 Uint32 *dst = (Uint32 *)info->dst;
2096 int n = info->dst_w;
2097 srcx = -1;
2098 posx = 0x10000L;
2099 while (posy >= 0x10000L) {
2100 ++srcy;
2101 posy -= 0x10000L;
2102 }
2103 while (n--) {
2104 if (posx >= 0x10000L) {
2105 while (posx >= 0x10000L) {
2106 ++srcx;
2107 posx -= 0x10000L;
2108 }
2109 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2110 }
2111 pixel = *src;
2112 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
2113 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
2114 *dst = pixel;
2115 posx += incx;
2116 ++dst;
2117 }
2118 posy += incy;
2119 info->dst += info->dst_pitch;
2120 }
2121 }
2122
2123 static void SDL_Blit_BGR888_ARGB8888_Blend(SDL_BlitInfo *info)
2124 {
2125 const int flags = info->flags;
2126 Uint32 srcpixel;
2127 Uint32 srcR, srcG, srcB, srcA;
2128 Uint32 dstpixel;
2129 Uint32 dstR, dstG, dstB, dstA;
2130
2131 while (info->dst_h--) {
2132 Uint32 *src = (Uint32 *)info->src;
2133 Uint32 *dst = (Uint32 *)info->dst;
2134 int n = info->dst_w;
2135 while (n--) {
2136 srcpixel = *src;
2137 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
2138 dstpixel = *dst;
2139 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
2140 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2141 /* This goes away if we ever use premultiplied alpha */
2142 if (srcA < 255) {
2143 srcR = (srcR * srcA) / 255;
2144 srcG = (srcG * srcA) / 255;
2145 srcB = (srcB * srcA) / 255;
2146 }
2147 }
2148 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2149 case SDL_COPY_BLEND:
2150 dstR = srcR + ((255 - srcA) * dstR) / 255;
2151 dstG = srcG + ((255 - srcA) * dstG) / 255;
2152 dstB = srcB + ((255 - srcA) * dstB) / 255;
2153 dstA = srcA + ((255 - srcA) * dstA) / 255;
2154 break;
2155 case SDL_COPY_ADD:
2156 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2157 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2158 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2159 break;
2160 case SDL_COPY_MOD:
2161 dstR = (srcR * dstR) / 255;
2162 dstG = (srcG * dstG) / 255;
2163 dstB = (srcB * dstB) / 255;
2164 break;
2165 }
2166 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2167 *dst = dstpixel;
2168 ++src;
2169 ++dst;
2170 }
2171 info->src += info->src_pitch;
2172 info->dst += info->dst_pitch;
2173 }
2174 }
2175
2176 static void SDL_Blit_BGR888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
2177 {
2178 const int flags = info->flags;
2179 Uint32 srcpixel;
2180 Uint32 srcR, srcG, srcB, srcA;
2181 Uint32 dstpixel;
2182 Uint32 dstR, dstG, dstB, dstA;
2183 int srcy, srcx;
2184 int posy, posx;
2185 int incy, incx;
2186
2187 srcy = 0;
2188 posy = 0;
2189 incy = (info->src_h << 16) / info->dst_h;
2190 incx = (info->src_w << 16) / info->dst_w;
2191
2192 while (info->dst_h--) {
2193 Uint32 *src = 0;
2194 Uint32 *dst = (Uint32 *)info->dst;
2195 int n = info->dst_w;
2196 srcx = -1;
2197 posx = 0x10000L;
2198 while (posy >= 0x10000L) {
2199 ++srcy;
2200 posy -= 0x10000L;
2201 }
2202 while (n--) {
2203 if (posx >= 0x10000L) {
2204 while (posx >= 0x10000L) {
2205 ++srcx;
2206 posx -= 0x10000L;
2207 }
2208 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2209 }
2210 srcpixel = *src;
2211 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
2212 dstpixel = *dst;
2213 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
2214 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2215 /* This goes away if we ever use premultiplied alpha */
2216 if (srcA < 255) {
2217 srcR = (srcR * srcA) / 255;
2218 srcG = (srcG * srcA) / 255;
2219 srcB = (srcB * srcA) / 255;
2220 }
2221 }
2222 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2223 case SDL_COPY_BLEND:
2224 dstR = srcR + ((255 - srcA) * dstR) / 255;
2225 dstG = srcG + ((255 - srcA) * dstG) / 255;
2226 dstB = srcB + ((255 - srcA) * dstB) / 255;
2227 dstA = srcA + ((255 - srcA) * dstA) / 255;
2228 break;
2229 case SDL_COPY_ADD:
2230 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2231 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2232 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2233 break;
2234 case SDL_COPY_MOD:
2235 dstR = (srcR * dstR) / 255;
2236 dstG = (srcG * dstG) / 255;
2237 dstB = (srcB * dstB) / 255;
2238 break;
2239 }
2240 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2241 *dst = dstpixel;
2242 posx += incx;
2243 ++dst;
2244 }
2245 posy += incy;
2246 info->dst += info->dst_pitch;
2247 }
2248 }
2249
2250 static void SDL_Blit_BGR888_ARGB8888_Modulate(SDL_BlitInfo *info)
2251 {
2252 const int flags = info->flags;
2253 const Uint32 modulateR = info->r;
2254 const Uint32 modulateG = info->g;
2255 const Uint32 modulateB = info->b;
2256 const Uint32 modulateA = info->a;
2257 Uint32 pixel;
2258 Uint32 R, G, B, A;
2259
2260 while (info->dst_h--) {
2261 Uint32 *src = (Uint32 *)info->src;
2262 Uint32 *dst = (Uint32 *)info->dst;
2263 int n = info->dst_w;
2264 while (n--) {
2265 pixel = *src;
2266 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
2267 if (flags & SDL_COPY_MODULATE_COLOR) {
2268 R = (R * modulateR) / 255;
2269 G = (G * modulateG) / 255;
2270 B = (B * modulateB) / 255;
2271 }
2272 if (flags & SDL_COPY_MODULATE_ALPHA) {
2273 A = (A * modulateA) / 255;
2274 }
2275 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
2276 *dst = pixel;
2277 ++src;
2278 ++dst;
2279 }
2280 info->src += info->src_pitch;
2281 info->dst += info->dst_pitch;
2282 }
2283 }
2284
2285 static void SDL_Blit_BGR888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
2286 {
2287 const int flags = info->flags;
2288 const Uint32 modulateR = info->r;
2289 const Uint32 modulateG = info->g;
2290 const Uint32 modulateB = info->b;
2291 const Uint32 modulateA = info->a;
2292 Uint32 pixel;
2293 Uint32 R, G, B, A;
2294 int srcy, srcx;
2295 int posy, posx;
2296 int incy, incx;
2297
2298 srcy = 0;
2299 posy = 0;
2300 incy = (info->src_h << 16) / info->dst_h;
2301 incx = (info->src_w << 16) / info->dst_w;
2302
2303 while (info->dst_h--) {
2304 Uint32 *src = 0;
2305 Uint32 *dst = (Uint32 *)info->dst;
2306 int n = info->dst_w;
2307 srcx = -1;
2308 posx = 0x10000L;
2309 while (posy >= 0x10000L) {
2310 ++srcy;
2311 posy -= 0x10000L;
2312 }
2313 while (n--) {
2314 if (posx >= 0x10000L) {
2315 while (posx >= 0x10000L) {
2316 ++srcx;
2317 posx -= 0x10000L;
2318 }
2319 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2320 }
2321 pixel = *src;
2322 B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel; A = 0xFF;
2323 if (flags & SDL_COPY_MODULATE_COLOR) {
2324 R = (R * modulateR) / 255;
2325 G = (G * modulateG) / 255;
2326 B = (B * modulateB) / 255;
2327 }
2328 if (flags & SDL_COPY_MODULATE_ALPHA) {
2329 A = (A * modulateA) / 255;
2330 }
2331 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
2332 *dst = pixel;
2333 posx += incx;
2334 ++dst;
2335 }
2336 posy += incy;
2337 info->dst += info->dst_pitch;
2338 }
2339 }
2340
2341 static void SDL_Blit_BGR888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
2342 {
2343 const int flags = info->flags;
2344 const Uint32 modulateR = info->r;
2345 const Uint32 modulateG = info->g;
2346 const Uint32 modulateB = info->b;
2347 const Uint32 modulateA = info->a;
2348 Uint32 srcpixel;
2349 Uint32 srcR, srcG, srcB, srcA;
2350 Uint32 dstpixel;
2351 Uint32 dstR, dstG, dstB, dstA;
2352
2353 while (info->dst_h--) {
2354 Uint32 *src = (Uint32 *)info->src;
2355 Uint32 *dst = (Uint32 *)info->dst;
2356 int n = info->dst_w;
2357 while (n--) {
2358 srcpixel = *src;
2359 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
2360 dstpixel = *dst;
2361 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
2362 if (flags & SDL_COPY_MODULATE_COLOR) {
2363 srcR = (srcR * modulateR) / 255;
2364 srcG = (srcG * modulateG) / 255;
2365 srcB = (srcB * modulateB) / 255;
2366 }
2367 if (flags & SDL_COPY_MODULATE_ALPHA) {
2368 srcA = (srcA * modulateA) / 255;
2369 }
2370 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2371 /* This goes away if we ever use premultiplied alpha */
2372 if (srcA < 255) {
2373 srcR = (srcR * srcA) / 255;
2374 srcG = (srcG * srcA) / 255;
2375 srcB = (srcB * srcA) / 255;
2376 }
2377 }
2378 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2379 case SDL_COPY_BLEND:
2380 dstR = srcR + ((255 - srcA) * dstR) / 255;
2381 dstG = srcG + ((255 - srcA) * dstG) / 255;
2382 dstB = srcB + ((255 - srcA) * dstB) / 255;
2383 dstA = srcA + ((255 - srcA) * dstA) / 255;
2384 break;
2385 case SDL_COPY_ADD:
2386 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2387 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2388 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2389 break;
2390 case SDL_COPY_MOD:
2391 dstR = (srcR * dstR) / 255;
2392 dstG = (srcG * dstG) / 255;
2393 dstB = (srcB * dstB) / 255;
2394 break;
2395 }
2396 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2397 *dst = dstpixel;
2398 ++src;
2399 ++dst;
2400 }
2401 info->src += info->src_pitch;
2402 info->dst += info->dst_pitch;
2403 }
2404 }
2405
2406 static void SDL_Blit_BGR888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
2407 {
2408 const int flags = info->flags;
2409 const Uint32 modulateR = info->r;
2410 const Uint32 modulateG = info->g;
2411 const Uint32 modulateB = info->b;
2412 const Uint32 modulateA = info->a;
2413 Uint32 srcpixel;
2414 Uint32 srcR, srcG, srcB, srcA;
2415 Uint32 dstpixel;
2416 Uint32 dstR, dstG, dstB, dstA;
2417 int srcy, srcx;
2418 int posy, posx;
2419 int incy, incx;
2420
2421 srcy = 0;
2422 posy = 0;
2423 incy = (info->src_h << 16) / info->dst_h;
2424 incx = (info->src_w << 16) / info->dst_w;
2425
2426 while (info->dst_h--) {
2427 Uint32 *src = 0;
2428 Uint32 *dst = (Uint32 *)info->dst;
2429 int n = info->dst_w;
2430 srcx = -1;
2431 posx = 0x10000L;
2432 while (posy >= 0x10000L) {
2433 ++srcy;
2434 posy -= 0x10000L;
2435 }
2436 while (n--) {
2437 if (posx >= 0x10000L) {
2438 while (posx >= 0x10000L) {
2439 ++srcx;
2440 posx -= 0x10000L;
2441 }
2442 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2443 }
2444 srcpixel = *src;
2445 srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel; srcA = 0xFF;
2446 dstpixel = *dst;
2447 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
2448 if (flags & SDL_COPY_MODULATE_COLOR) {
2449 srcR = (srcR * modulateR) / 255;
2450 srcG = (srcG * modulateG) / 255;
2451 srcB = (srcB * modulateB) / 255;
2452 }
2453 if (flags & SDL_COPY_MODULATE_ALPHA) {
2454 srcA = (srcA * modulateA) / 255;
2455 }
2456 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2457 /* This goes away if we ever use premultiplied alpha */
2458 if (srcA < 255) {
2459 srcR = (srcR * srcA) / 255;
2460 srcG = (srcG * srcA) / 255;
2461 srcB = (srcB * srcA) / 255;
2462 }
2463 }
2464 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2465 case SDL_COPY_BLEND:
2466 dstR = srcR + ((255 - srcA) * dstR) / 255;
2467 dstG = srcG + ((255 - srcA) * dstG) / 255;
2468 dstB = srcB + ((255 - srcA) * dstB) / 255;
2469 dstA = srcA + ((255 - srcA) * dstA) / 255;
2470 break;
2471 case SDL_COPY_ADD:
2472 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2473 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2474 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2475 break;
2476 case SDL_COPY_MOD:
2477 dstR = (srcR * dstR) / 255;
2478 dstG = (srcG * dstG) / 255;
2479 dstB = (srcB * dstB) / 255;
2480 break;
2481 }
2482 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2483 *dst = dstpixel;
2484 posx += incx;
2485 ++dst;
2486 }
2487 posy += incy;
2488 info->dst += info->dst_pitch;
2489 }
2490 }
2491
2492 static void SDL_Blit_ARGB8888_RGB888_Scale(SDL_BlitInfo *info)
2493 {
2494 Uint32 pixel;
2495 Uint32 R, G, B, A;
2496 int srcy, srcx;
2497 int posy, posx;
2498 int incy, incx;
2499
2500 srcy = 0;
2501 posy = 0;
2502 incy = (info->src_h << 16) / info->dst_h;
2503 incx = (info->src_w << 16) / info->dst_w;
2504
2505 while (info->dst_h--) {
2506 Uint32 *src = 0;
2507 Uint32 *dst = (Uint32 *)info->dst;
2508 int n = info->dst_w;
2509 srcx = -1;
2510 posx = 0x10000L;
2511 while (posy >= 0x10000L) {
2512 ++srcy;
2513 posy -= 0x10000L;
2514 }
2515 while (n--) {
2516 if (posx >= 0x10000L) {
2517 while (posx >= 0x10000L) {
2518 ++srcx;
2519 posx -= 0x10000L;
2520 }
2521 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2522 }
2523 pixel = *src;
2524 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
2525 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
2526 *dst = pixel;
2527 posx += incx;
2528 ++dst;
2529 }
2530 posy += incy;
2531 info->dst += info->dst_pitch;
2532 }
2533 }
2534
2535 static void SDL_Blit_ARGB8888_RGB888_Blend(SDL_BlitInfo *info)
2536 {
2537 const int flags = info->flags;
2538 Uint32 srcpixel;
2539 Uint32 srcR, srcG, srcB, srcA;
2540 Uint32 dstpixel;
2541 Uint32 dstR, dstG, dstB, dstA;
2542
2543 while (info->dst_h--) {
2544 Uint32 *src = (Uint32 *)info->src;
2545 Uint32 *dst = (Uint32 *)info->dst;
2546 int n = info->dst_w;
2547 while (n--) {
2548 srcpixel = *src;
2549 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
2550 dstpixel = *dst;
2551 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
2552 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2553 /* This goes away if we ever use premultiplied alpha */
2554 if (srcA < 255) {
2555 srcR = (srcR * srcA) / 255;
2556 srcG = (srcG * srcA) / 255;
2557 srcB = (srcB * srcA) / 255;
2558 }
2559 }
2560 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2561 case SDL_COPY_BLEND:
2562 dstR = srcR + ((255 - srcA) * dstR) / 255;
2563 dstG = srcG + ((255 - srcA) * dstG) / 255;
2564 dstB = srcB + ((255 - srcA) * dstB) / 255;
2565 dstA = srcA + ((255 - srcA) * dstA) / 255;
2566 break;
2567 case SDL_COPY_ADD:
2568 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2569 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2570 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2571 break;
2572 case SDL_COPY_MOD:
2573 dstR = (srcR * dstR) / 255;
2574 dstG = (srcG * dstG) / 255;
2575 dstB = (srcB * dstB) / 255;
2576 break;
2577 }
2578 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2579 *dst = dstpixel;
2580 ++src;
2581 ++dst;
2582 }
2583 info->src += info->src_pitch;
2584 info->dst += info->dst_pitch;
2585 }
2586 }
2587
2588 static void SDL_Blit_ARGB8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
2589 {
2590 const int flags = info->flags;
2591 Uint32 srcpixel;
2592 Uint32 srcR, srcG, srcB, srcA;
2593 Uint32 dstpixel;
2594 Uint32 dstR, dstG, dstB, dstA;
2595 int srcy, srcx;
2596 int posy, posx;
2597 int incy, incx;
2598
2599 srcy = 0;
2600 posy = 0;
2601 incy = (info->src_h << 16) / info->dst_h;
2602 incx = (info->src_w << 16) / info->dst_w;
2603
2604 while (info->dst_h--) {
2605 Uint32 *src = 0;
2606 Uint32 *dst = (Uint32 *)info->dst;
2607 int n = info->dst_w;
2608 srcx = -1;
2609 posx = 0x10000L;
2610 while (posy >= 0x10000L) {
2611 ++srcy;
2612 posy -= 0x10000L;
2613 }
2614 while (n--) {
2615 if (posx >= 0x10000L) {
2616 while (posx >= 0x10000L) {
2617 ++srcx;
2618 posx -= 0x10000L;
2619 }
2620 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2621 }
2622 srcpixel = *src;
2623 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
2624 dstpixel = *dst;
2625 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
2626 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2627 /* This goes away if we ever use premultiplied alpha */
2628 if (srcA < 255) {
2629 srcR = (srcR * srcA) / 255;
2630 srcG = (srcG * srcA) / 255;
2631 srcB = (srcB * srcA) / 255;
2632 }
2633 }
2634 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2635 case SDL_COPY_BLEND:
2636 dstR = srcR + ((255 - srcA) * dstR) / 255;
2637 dstG = srcG + ((255 - srcA) * dstG) / 255;
2638 dstB = srcB + ((255 - srcA) * dstB) / 255;
2639 dstA = srcA + ((255 - srcA) * dstA) / 255;
2640 break;
2641 case SDL_COPY_ADD:
2642 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2643 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2644 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2645 break;
2646 case SDL_COPY_MOD:
2647 dstR = (srcR * dstR) / 255;
2648 dstG = (srcG * dstG) / 255;
2649 dstB = (srcB * dstB) / 255;
2650 break;
2651 }
2652 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2653 *dst = dstpixel;
2654 posx += incx;
2655 ++dst;
2656 }
2657 posy += incy;
2658 info->dst += info->dst_pitch;
2659 }
2660 }
2661
2662 static void SDL_Blit_ARGB8888_RGB888_Modulate(SDL_BlitInfo *info)
2663 {
2664 const int flags = info->flags;
2665 const Uint32 modulateR = info->r;
2666 const Uint32 modulateG = info->g;
2667 const Uint32 modulateB = info->b;
2668 const Uint32 modulateA = info->a;
2669 Uint32 pixel;
2670 Uint32 R, G, B, A;
2671
2672 while (info->dst_h--) {
2673 Uint32 *src = (Uint32 *)info->src;
2674 Uint32 *dst = (Uint32 *)info->dst;
2675 int n = info->dst_w;
2676 while (n--) {
2677 pixel = *src;
2678 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
2679 if (flags & SDL_COPY_MODULATE_COLOR) {
2680 R = (R * modulateR) / 255;
2681 G = (G * modulateG) / 255;
2682 B = (B * modulateB) / 255;
2683 }
2684 if (flags & SDL_COPY_MODULATE_ALPHA) {
2685 A = (A * modulateA) / 255;
2686 }
2687 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
2688 *dst = pixel;
2689 ++src;
2690 ++dst;
2691 }
2692 info->src += info->src_pitch;
2693 info->dst += info->dst_pitch;
2694 }
2695 }
2696
2697 static void SDL_Blit_ARGB8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
2698 {
2699 const int flags = info->flags;
2700 const Uint32 modulateR = info->r;
2701 const Uint32 modulateG = info->g;
2702 const Uint32 modulateB = info->b;
2703 const Uint32 modulateA = info->a;
2704 Uint32 pixel;
2705 Uint32 R, G, B, A;
2706 int srcy, srcx;
2707 int posy, posx;
2708 int incy, incx;
2709
2710 srcy = 0;
2711 posy = 0;
2712 incy = (info->src_h << 16) / info->dst_h;
2713 incx = (info->src_w << 16) / info->dst_w;
2714
2715 while (info->dst_h--) {
2716 Uint32 *src = 0;
2717 Uint32 *dst = (Uint32 *)info->dst;
2718 int n = info->dst_w;
2719 srcx = -1;
2720 posx = 0x10000L;
2721 while (posy >= 0x10000L) {
2722 ++srcy;
2723 posy -= 0x10000L;
2724 }
2725 while (n--) {
2726 if (posx >= 0x10000L) {
2727 while (posx >= 0x10000L) {
2728 ++srcx;
2729 posx -= 0x10000L;
2730 }
2731 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2732 }
2733 pixel = *src;
2734 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
2735 if (flags & SDL_COPY_MODULATE_COLOR) {
2736 R = (R * modulateR) / 255;
2737 G = (G * modulateG) / 255;
2738 B = (B * modulateB) / 255;
2739 }
2740 if (flags & SDL_COPY_MODULATE_ALPHA) {
2741 A = (A * modulateA) / 255;
2742 }
2743 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
2744 *dst = pixel;
2745 posx += incx;
2746 ++dst;
2747 }
2748 posy += incy;
2749 info->dst += info->dst_pitch;
2750 }
2751 }
2752
2753 static void SDL_Blit_ARGB8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
2754 {
2755 const int flags = info->flags;
2756 const Uint32 modulateR = info->r;
2757 const Uint32 modulateG = info->g;
2758 const Uint32 modulateB = info->b;
2759 const Uint32 modulateA = info->a;
2760 Uint32 srcpixel;
2761 Uint32 srcR, srcG, srcB, srcA;
2762 Uint32 dstpixel;
2763 Uint32 dstR, dstG, dstB, dstA;
2764
2765 while (info->dst_h--) {
2766 Uint32 *src = (Uint32 *)info->src;
2767 Uint32 *dst = (Uint32 *)info->dst;
2768 int n = info->dst_w;
2769 while (n--) {
2770 srcpixel = *src;
2771 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
2772 dstpixel = *dst;
2773 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
2774 if (flags & SDL_COPY_MODULATE_COLOR) {
2775 srcR = (srcR * modulateR) / 255;
2776 srcG = (srcG * modulateG) / 255;
2777 srcB = (srcB * modulateB) / 255;
2778 }
2779 if (flags & SDL_COPY_MODULATE_ALPHA) {
2780 srcA = (srcA * modulateA) / 255;
2781 }
2782 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2783 /* This goes away if we ever use premultiplied alpha */
2784 if (srcA < 255) {
2785 srcR = (srcR * srcA) / 255;
2786 srcG = (srcG * srcA) / 255;
2787 srcB = (srcB * srcA) / 255;
2788 }
2789 }
2790 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2791 case SDL_COPY_BLEND:
2792 dstR = srcR + ((255 - srcA) * dstR) / 255;
2793 dstG = srcG + ((255 - srcA) * dstG) / 255;
2794 dstB = srcB + ((255 - srcA) * dstB) / 255;
2795 dstA = srcA + ((255 - srcA) * dstA) / 255;
2796 break;
2797 case SDL_COPY_ADD:
2798 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2799 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2800 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2801 break;
2802 case SDL_COPY_MOD:
2803 dstR = (srcR * dstR) / 255;
2804 dstG = (srcG * dstG) / 255;
2805 dstB = (srcB * dstB) / 255;
2806 break;
2807 }
2808 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2809 *dst = dstpixel;
2810 ++src;
2811 ++dst;
2812 }
2813 info->src += info->src_pitch;
2814 info->dst += info->dst_pitch;
2815 }
2816 }
2817
2818 static void SDL_Blit_ARGB8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
2819 {
2820 const int flags = info->flags;
2821 const Uint32 modulateR = info->r;
2822 const Uint32 modulateG = info->g;
2823 const Uint32 modulateB = info->b;
2824 const Uint32 modulateA = info->a;
2825 Uint32 srcpixel;
2826 Uint32 srcR, srcG, srcB, srcA;
2827 Uint32 dstpixel;
2828 Uint32 dstR, dstG, dstB, dstA;
2829 int srcy, srcx;
2830 int posy, posx;
2831 int incy, incx;
2832
2833 srcy = 0;
2834 posy = 0;
2835 incy = (info->src_h << 16) / info->dst_h;
2836 incx = (info->src_w << 16) / info->dst_w;
2837
2838 while (info->dst_h--) {
2839 Uint32 *src = 0;
2840 Uint32 *dst = (Uint32 *)info->dst;
2841 int n = info->dst_w;
2842 srcx = -1;
2843 posx = 0x10000L;
2844 while (posy >= 0x10000L) {
2845 ++srcy;
2846 posy -= 0x10000L;
2847 }
2848 while (n--) {
2849 if (posx >= 0x10000L) {
2850 while (posx >= 0x10000L) {
2851 ++srcx;
2852 posx -= 0x10000L;
2853 }
2854 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2855 }
2856 srcpixel = *src;
2857 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
2858 dstpixel = *dst;
2859 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
2860 if (flags & SDL_COPY_MODULATE_COLOR) {
2861 srcR = (srcR * modulateR) / 255;
2862 srcG = (srcG * modulateG) / 255;
2863 srcB = (srcB * modulateB) / 255;
2864 }
2865 if (flags & SDL_COPY_MODULATE_ALPHA) {
2866 srcA = (srcA * modulateA) / 255;
2867 }
2868 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2869 /* This goes away if we ever use premultiplied alpha */
2870 if (srcA < 255) {
2871 srcR = (srcR * srcA) / 255;
2872 srcG = (srcG * srcA) / 255;
2873 srcB = (srcB * srcA) / 255;
2874 }
2875 }
2876 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2877 case SDL_COPY_BLEND:
2878 dstR = srcR + ((255 - srcA) * dstR) / 255;
2879 dstG = srcG + ((255 - srcA) * dstG) / 255;
2880 dstB = srcB + ((255 - srcA) * dstB) / 255;
2881 dstA = srcA + ((255 - srcA) * dstA) / 255;
2882 break;
2883 case SDL_COPY_ADD:
2884 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2885 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2886 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2887 break;
2888 case SDL_COPY_MOD:
2889 dstR = (srcR * dstR) / 255;
2890 dstG = (srcG * dstG) / 255;
2891 dstB = (srcB * dstB) / 255;
2892 break;
2893 }
2894 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
2895 *dst = dstpixel;
2896 posx += incx;
2897 ++dst;
2898 }
2899 posy += incy;
2900 info->dst += info->dst_pitch;
2901 }
2902 }
2903
2904 static void SDL_Blit_ARGB8888_BGR888_Scale(SDL_BlitInfo *info)
2905 {
2906 Uint32 pixel;
2907 Uint32 R, G, B, A;
2908 int srcy, srcx;
2909 int posy, posx;
2910 int incy, incx;
2911
2912 srcy = 0;
2913 posy = 0;
2914 incy = (info->src_h << 16) / info->dst_h;
2915 incx = (info->src_w << 16) / info->dst_w;
2916
2917 while (info->dst_h--) {
2918 Uint32 *src = 0;
2919 Uint32 *dst = (Uint32 *)info->dst;
2920 int n = info->dst_w;
2921 srcx = -1;
2922 posx = 0x10000L;
2923 while (posy >= 0x10000L) {
2924 ++srcy;
2925 posy -= 0x10000L;
2926 }
2927 while (n--) {
2928 if (posx >= 0x10000L) {
2929 while (posx >= 0x10000L) {
2930 ++srcx;
2931 posx -= 0x10000L;
2932 }
2933 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
2934 }
2935 pixel = *src;
2936 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
2937 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
2938 *dst = pixel;
2939 posx += incx;
2940 ++dst;
2941 }
2942 posy += incy;
2943 info->dst += info->dst_pitch;
2944 }
2945 }
2946
2947 static void SDL_Blit_ARGB8888_BGR888_Blend(SDL_BlitInfo *info)
2948 {
2949 const int flags = info->flags;
2950 Uint32 srcpixel;
2951 Uint32 srcR, srcG, srcB, srcA;
2952 Uint32 dstpixel;
2953 Uint32 dstR, dstG, dstB, dstA;
2954
2955 while (info->dst_h--) {
2956 Uint32 *src = (Uint32 *)info->src;
2957 Uint32 *dst = (Uint32 *)info->dst;
2958 int n = info->dst_w;
2959 while (n--) {
2960 srcpixel = *src;
2961 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
2962 dstpixel = *dst;
2963 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
2964 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
2965 /* This goes away if we ever use premultiplied alpha */
2966 if (srcA < 255) {
2967 srcR = (srcR * srcA) / 255;
2968 srcG = (srcG * srcA) / 255;
2969 srcB = (srcB * srcA) / 255;
2970 }
2971 }
2972 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
2973 case SDL_COPY_BLEND:
2974 dstR = srcR + ((255 - srcA) * dstR) / 255;
2975 dstG = srcG + ((255 - srcA) * dstG) / 255;
2976 dstB = srcB + ((255 - srcA) * dstB) / 255;
2977 dstA = srcA + ((255 - srcA) * dstA) / 255;
2978 break;
2979 case SDL_COPY_ADD:
2980 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
2981 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
2982 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
2983 break;
2984 case SDL_COPY_MOD:
2985 dstR = (srcR * dstR) / 255;
2986 dstG = (srcG * dstG) / 255;
2987 dstB = (srcB * dstB) / 255;
2988 break;
2989 }
2990 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
2991 *dst = dstpixel;
2992 ++src;
2993 ++dst;
2994 }
2995 info->src += info->src_pitch;
2996 info->dst += info->dst_pitch;
2997 }
2998 }
2999
3000 static void SDL_Blit_ARGB8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
3001 {
3002 const int flags = info->flags;
3003 Uint32 srcpixel;
3004 Uint32 srcR, srcG, srcB, srcA;
3005 Uint32 dstpixel;
3006 Uint32 dstR, dstG, dstB, dstA;
3007 int srcy, srcx;
3008 int posy, posx;
3009 int incy, incx;
3010
3011 srcy = 0;
3012 posy = 0;
3013 incy = (info->src_h << 16) / info->dst_h;
3014 incx = (info->src_w << 16) / info->dst_w;
3015
3016 while (info->dst_h--) {
3017 Uint32 *src = 0;
3018 Uint32 *dst = (Uint32 *)info->dst;
3019 int n = info->dst_w;
3020 srcx = -1;
3021 posx = 0x10000L;
3022 while (posy >= 0x10000L) {
3023 ++srcy;
3024 posy -= 0x10000L;
3025 }
3026 while (n--) {
3027 if (posx >= 0x10000L) {
3028 while (posx >= 0x10000L) {
3029 ++srcx;
3030 posx -= 0x10000L;
3031 }
3032 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3033 }
3034 srcpixel = *src;
3035 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3036 dstpixel = *dst;
3037 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
3038 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3039 /* This goes away if we ever use premultiplied alpha */
3040 if (srcA < 255) {
3041 srcR = (srcR * srcA) / 255;
3042 srcG = (srcG * srcA) / 255;
3043 srcB = (srcB * srcA) / 255;
3044 }
3045 }
3046 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3047 case SDL_COPY_BLEND:
3048 dstR = srcR + ((255 - srcA) * dstR) / 255;
3049 dstG = srcG + ((255 - srcA) * dstG) / 255;
3050 dstB = srcB + ((255 - srcA) * dstB) / 255;
3051 dstA = srcA + ((255 - srcA) * dstA) / 255;
3052 break;
3053 case SDL_COPY_ADD:
3054 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3055 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3056 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3057 break;
3058 case SDL_COPY_MOD:
3059 dstR = (srcR * dstR) / 255;
3060 dstG = (srcG * dstG) / 255;
3061 dstB = (srcB * dstB) / 255;
3062 break;
3063 }
3064 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
3065 *dst = dstpixel;
3066 posx += incx;
3067 ++dst;
3068 }
3069 posy += incy;
3070 info->dst += info->dst_pitch;
3071 }
3072 }
3073
3074 static void SDL_Blit_ARGB8888_BGR888_Modulate(SDL_BlitInfo *info)
3075 {
3076 const int flags = info->flags;
3077 const Uint32 modulateR = info->r;
3078 const Uint32 modulateG = info->g;
3079 const Uint32 modulateB = info->b;
3080 const Uint32 modulateA = info->a;
3081 Uint32 pixel;
3082 Uint32 R, G, B, A;
3083
3084 while (info->dst_h--) {
3085 Uint32 *src = (Uint32 *)info->src;
3086 Uint32 *dst = (Uint32 *)info->dst;
3087 int n = info->dst_w;
3088 while (n--) {
3089 pixel = *src;
3090 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
3091 if (flags & SDL_COPY_MODULATE_COLOR) {
3092 R = (R * modulateR) / 255;
3093 G = (G * modulateG) / 255;
3094 B = (B * modulateB) / 255;
3095 }
3096 if (flags & SDL_COPY_MODULATE_ALPHA) {
3097 A = (A * modulateA) / 255;
3098 }
3099 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
3100 *dst = pixel;
3101 ++src;
3102 ++dst;
3103 }
3104 info->src += info->src_pitch;
3105 info->dst += info->dst_pitch;
3106 }
3107 }
3108
3109 static void SDL_Blit_ARGB8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
3110 {
3111 const int flags = info->flags;
3112 const Uint32 modulateR = info->r;
3113 const Uint32 modulateG = info->g;
3114 const Uint32 modulateB = info->b;
3115 const Uint32 modulateA = info->a;
3116 Uint32 pixel;
3117 Uint32 R, G, B, A;
3118 int srcy, srcx;
3119 int posy, posx;
3120 int incy, incx;
3121
3122 srcy = 0;
3123 posy = 0;
3124 incy = (info->src_h << 16) / info->dst_h;
3125 incx = (info->src_w << 16) / info->dst_w;
3126
3127 while (info->dst_h--) {
3128 Uint32 *src = 0;
3129 Uint32 *dst = (Uint32 *)info->dst;
3130 int n = info->dst_w;
3131 srcx = -1;
3132 posx = 0x10000L;
3133 while (posy >= 0x10000L) {
3134 ++srcy;
3135 posy -= 0x10000L;
3136 }
3137 while (n--) {
3138 if (posx >= 0x10000L) {
3139 while (posx >= 0x10000L) {
3140 ++srcx;
3141 posx -= 0x10000L;
3142 }
3143 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3144 }
3145 pixel = *src;
3146 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
3147 if (flags & SDL_COPY_MODULATE_COLOR) {
3148 R = (R * modulateR) / 255;
3149 G = (G * modulateG) / 255;
3150 B = (B * modulateB) / 255;
3151 }
3152 if (flags & SDL_COPY_MODULATE_ALPHA) {
3153 A = (A * modulateA) / 255;
3154 }
3155 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
3156 *dst = pixel;
3157 posx += incx;
3158 ++dst;
3159 }
3160 posy += incy;
3161 info->dst += info->dst_pitch;
3162 }
3163 }
3164
3165 static void SDL_Blit_ARGB8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
3166 {
3167 const int flags = info->flags;
3168 const Uint32 modulateR = info->r;
3169 const Uint32 modulateG = info->g;
3170 const Uint32 modulateB = info->b;
3171 const Uint32 modulateA = info->a;
3172 Uint32 srcpixel;
3173 Uint32 srcR, srcG, srcB, srcA;
3174 Uint32 dstpixel;
3175 Uint32 dstR, dstG, dstB, dstA;
3176
3177 while (info->dst_h--) {
3178 Uint32 *src = (Uint32 *)info->src;
3179 Uint32 *dst = (Uint32 *)info->dst;
3180 int n = info->dst_w;
3181 while (n--) {
3182 srcpixel = *src;
3183 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3184 dstpixel = *dst;
3185 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
3186 if (flags & SDL_COPY_MODULATE_COLOR) {
3187 srcR = (srcR * modulateR) / 255;
3188 srcG = (srcG * modulateG) / 255;
3189 srcB = (srcB * modulateB) / 255;
3190 }
3191 if (flags & SDL_COPY_MODULATE_ALPHA) {
3192 srcA = (srcA * modulateA) / 255;
3193 }
3194 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3195 /* This goes away if we ever use premultiplied alpha */
3196 if (srcA < 255) {
3197 srcR = (srcR * srcA) / 255;
3198 srcG = (srcG * srcA) / 255;
3199 srcB = (srcB * srcA) / 255;
3200 }
3201 }
3202 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3203 case SDL_COPY_BLEND:
3204 dstR = srcR + ((255 - srcA) * dstR) / 255;
3205 dstG = srcG + ((255 - srcA) * dstG) / 255;
3206 dstB = srcB + ((255 - srcA) * dstB) / 255;
3207 dstA = srcA + ((255 - srcA) * dstA) / 255;
3208 break;
3209 case SDL_COPY_ADD:
3210 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3211 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3212 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3213 break;
3214 case SDL_COPY_MOD:
3215 dstR = (srcR * dstR) / 255;
3216 dstG = (srcG * dstG) / 255;
3217 dstB = (srcB * dstB) / 255;
3218 break;
3219 }
3220 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
3221 *dst = dstpixel;
3222 ++src;
3223 ++dst;
3224 }
3225 info->src += info->src_pitch;
3226 info->dst += info->dst_pitch;
3227 }
3228 }
3229
3230 static void SDL_Blit_ARGB8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
3231 {
3232 const int flags = info->flags;
3233 const Uint32 modulateR = info->r;
3234 const Uint32 modulateG = info->g;
3235 const Uint32 modulateB = info->b;
3236 const Uint32 modulateA = info->a;
3237 Uint32 srcpixel;
3238 Uint32 srcR, srcG, srcB, srcA;
3239 Uint32 dstpixel;
3240 Uint32 dstR, dstG, dstB, dstA;
3241 int srcy, srcx;
3242 int posy, posx;
3243 int incy, incx;
3244
3245 srcy = 0;
3246 posy = 0;
3247 incy = (info->src_h << 16) / info->dst_h;
3248 incx = (info->src_w << 16) / info->dst_w;
3249
3250 while (info->dst_h--) {
3251 Uint32 *src = 0;
3252 Uint32 *dst = (Uint32 *)info->dst;
3253 int n = info->dst_w;
3254 srcx = -1;
3255 posx = 0x10000L;
3256 while (posy >= 0x10000L) {
3257 ++srcy;
3258 posy -= 0x10000L;
3259 }
3260 while (n--) {
3261 if (posx >= 0x10000L) {
3262 while (posx >= 0x10000L) {
3263 ++srcx;
3264 posx -= 0x10000L;
3265 }
3266 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3267 }
3268 srcpixel = *src;
3269 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3270 dstpixel = *dst;
3271 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
3272 if (flags & SDL_COPY_MODULATE_COLOR) {
3273 srcR = (srcR * modulateR) / 255;
3274 srcG = (srcG * modulateG) / 255;
3275 srcB = (srcB * modulateB) / 255;
3276 }
3277 if (flags & SDL_COPY_MODULATE_ALPHA) {
3278 srcA = (srcA * modulateA) / 255;
3279 }
3280 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3281 /* This goes away if we ever use premultiplied alpha */
3282 if (srcA < 255) {
3283 srcR = (srcR * srcA) / 255;
3284 srcG = (srcG * srcA) / 255;
3285 srcB = (srcB * srcA) / 255;
3286 }
3287 }
3288 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3289 case SDL_COPY_BLEND:
3290 dstR = srcR + ((255 - srcA) * dstR) / 255;
3291 dstG = srcG + ((255 - srcA) * dstG) / 255;
3292 dstB = srcB + ((255 - srcA) * dstB) / 255;
3293 dstA = srcA + ((255 - srcA) * dstA) / 255;
3294 break;
3295 case SDL_COPY_ADD:
3296 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3297 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3298 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3299 break;
3300 case SDL_COPY_MOD:
3301 dstR = (srcR * dstR) / 255;
3302 dstG = (srcG * dstG) / 255;
3303 dstB = (srcB * dstB) / 255;
3304 break;
3305 }
3306 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
3307 *dst = dstpixel;
3308 posx += incx;
3309 ++dst;
3310 }
3311 posy += incy;
3312 info->dst += info->dst_pitch;
3313 }
3314 }
3315
3316 static void SDL_Blit_ARGB8888_ARGB8888_Scale(SDL_BlitInfo *info)
3317 {
3318 int srcy, srcx;
3319 int posy, posx;
3320 int incy, incx;
3321
3322 srcy = 0;
3323 posy = 0;
3324 incy = (info->src_h << 16) / info->dst_h;
3325 incx = (info->src_w << 16) / info->dst_w;
3326
3327 while (info->dst_h--) {
3328 Uint32 *src = 0;
3329 Uint32 *dst = (Uint32 *)info->dst;
3330 int n = info->dst_w;
3331 srcx = -1;
3332 posx = 0x10000L;
3333 while (posy >= 0x10000L) {
3334 ++srcy;
3335 posy -= 0x10000L;
3336 }
3337 while (n--) {
3338 if (posx >= 0x10000L) {
3339 while (posx >= 0x10000L) {
3340 ++srcx;
3341 posx -= 0x10000L;
3342 }
3343 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3344 }
3345 *dst = *src;
3346 posx += incx;
3347 ++dst;
3348 }
3349 posy += incy;
3350 info->dst += info->dst_pitch;
3351 }
3352 }
3353
3354 static void SDL_Blit_ARGB8888_ARGB8888_Blend(SDL_BlitInfo *info)
3355 {
3356 const int flags = info->flags;
3357 Uint32 srcpixel;
3358 Uint32 srcR, srcG, srcB, srcA;
3359 Uint32 dstpixel;
3360 Uint32 dstR, dstG, dstB, dstA;
3361
3362 while (info->dst_h--) {
3363 Uint32 *src = (Uint32 *)info->src;
3364 Uint32 *dst = (Uint32 *)info->dst;
3365 int n = info->dst_w;
3366 while (n--) {
3367 srcpixel = *src;
3368 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3369 dstpixel = *dst;
3370 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
3371 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3372 /* This goes away if we ever use premultiplied alpha */
3373 if (srcA < 255) {
3374 srcR = (srcR * srcA) / 255;
3375 srcG = (srcG * srcA) / 255;
3376 srcB = (srcB * srcA) / 255;
3377 }
3378 }
3379 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3380 case SDL_COPY_BLEND:
3381 dstR = srcR + ((255 - srcA) * dstR) / 255;
3382 dstG = srcG + ((255 - srcA) * dstG) / 255;
3383 dstB = srcB + ((255 - srcA) * dstB) / 255;
3384 dstA = srcA + ((255 - srcA) * dstA) / 255;
3385 break;
3386 case SDL_COPY_ADD:
3387 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3388 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3389 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3390 break;
3391 case SDL_COPY_MOD:
3392 dstR = (srcR * dstR) / 255;
3393 dstG = (srcG * dstG) / 255;
3394 dstB = (srcB * dstB) / 255;
3395 break;
3396 }
3397 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
3398 *dst = dstpixel;
3399 ++src;
3400 ++dst;
3401 }
3402 info->src += info->src_pitch;
3403 info->dst += info->dst_pitch;
3404 }
3405 }
3406
3407 static void SDL_Blit_ARGB8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
3408 {
3409 const int flags = info->flags;
3410 Uint32 srcpixel;
3411 Uint32 srcR, srcG, srcB, srcA;
3412 Uint32 dstpixel;
3413 Uint32 dstR, dstG, dstB, dstA;
3414 int srcy, srcx;
3415 int posy, posx;
3416 int incy, incx;
3417
3418 srcy = 0;
3419 posy = 0;
3420 incy = (info->src_h << 16) / info->dst_h;
3421 incx = (info->src_w << 16) / info->dst_w;
3422
3423 while (info->dst_h--) {
3424 Uint32 *src = 0;
3425 Uint32 *dst = (Uint32 *)info->dst;
3426 int n = info->dst_w;
3427 srcx = -1;
3428 posx = 0x10000L;
3429 while (posy >= 0x10000L) {
3430 ++srcy;
3431 posy -= 0x10000L;
3432 }
3433 while (n--) {
3434 if (posx >= 0x10000L) {
3435 while (posx >= 0x10000L) {
3436 ++srcx;
3437 posx -= 0x10000L;
3438 }
3439 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3440 }
3441 srcpixel = *src;
3442 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3443 dstpixel = *dst;
3444 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
3445 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3446 /* This goes away if we ever use premultiplied alpha */
3447 if (srcA < 255) {
3448 srcR = (srcR * srcA) / 255;
3449 srcG = (srcG * srcA) / 255;
3450 srcB = (srcB * srcA) / 255;
3451 }
3452 }
3453 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3454 case SDL_COPY_BLEND:
3455 dstR = srcR + ((255 - srcA) * dstR) / 255;
3456 dstG = srcG + ((255 - srcA) * dstG) / 255;
3457 dstB = srcB + ((255 - srcA) * dstB) / 255;
3458 dstA = srcA + ((255 - srcA) * dstA) / 255;
3459 break;
3460 case SDL_COPY_ADD:
3461 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3462 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3463 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3464 break;
3465 case SDL_COPY_MOD:
3466 dstR = (srcR * dstR) / 255;
3467 dstG = (srcG * dstG) / 255;
3468 dstB = (srcB * dstB) / 255;
3469 break;
3470 }
3471 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
3472 *dst = dstpixel;
3473 posx += incx;
3474 ++dst;
3475 }
3476 posy += incy;
3477 info->dst += info->dst_pitch;
3478 }
3479 }
3480
3481 static void SDL_Blit_ARGB8888_ARGB8888_Modulate(SDL_BlitInfo *info)
3482 {
3483 const int flags = info->flags;
3484 const Uint32 modulateR = info->r;
3485 const Uint32 modulateG = info->g;
3486 const Uint32 modulateB = info->b;
3487 const Uint32 modulateA = info->a;
3488 Uint32 pixel;
3489 Uint32 R, G, B, A;
3490
3491 while (info->dst_h--) {
3492 Uint32 *src = (Uint32 *)info->src;
3493 Uint32 *dst = (Uint32 *)info->dst;
3494 int n = info->dst_w;
3495 while (n--) {
3496 pixel = *src;
3497 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
3498 if (flags & SDL_COPY_MODULATE_COLOR) {
3499 R = (R * modulateR) / 255;
3500 G = (G * modulateG) / 255;
3501 B = (B * modulateB) / 255;
3502 }
3503 if (flags & SDL_COPY_MODULATE_ALPHA) {
3504 A = (A * modulateA) / 255;
3505 }
3506 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
3507 *dst = pixel;
3508 ++src;
3509 ++dst;
3510 }
3511 info->src += info->src_pitch;
3512 info->dst += info->dst_pitch;
3513 }
3514 }
3515
3516 static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
3517 {
3518 const int flags = info->flags;
3519 const Uint32 modulateR = info->r;
3520 const Uint32 modulateG = info->g;
3521 const Uint32 modulateB = info->b;
3522 const Uint32 modulateA = info->a;
3523 Uint32 pixel;
3524 Uint32 R, G, B, A;
3525 int srcy, srcx;
3526 int posy, posx;
3527 int incy, incx;
3528
3529 srcy = 0;
3530 posy = 0;
3531 incy = (info->src_h << 16) / info->dst_h;
3532 incx = (info->src_w << 16) / info->dst_w;
3533
3534 while (info->dst_h--) {
3535 Uint32 *src = 0;
3536 Uint32 *dst = (Uint32 *)info->dst;
3537 int n = info->dst_w;
3538 srcx = -1;
3539 posx = 0x10000L;
3540 while (posy >= 0x10000L) {
3541 ++srcy;
3542 posy -= 0x10000L;
3543 }
3544 while (n--) {
3545 if (posx >= 0x10000L) {
3546 while (posx >= 0x10000L) {
3547 ++srcx;
3548 posx -= 0x10000L;
3549 }
3550 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3551 }
3552 pixel = *src;
3553 A = (Uint8)(pixel >> 24); R = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); B = (Uint8)pixel;
3554 if (flags & SDL_COPY_MODULATE_COLOR) {
3555 R = (R * modulateR) / 255;
3556 G = (G * modulateG) / 255;
3557 B = (B * modulateB) / 255;
3558 }
3559 if (flags & SDL_COPY_MODULATE_ALPHA) {
3560 A = (A * modulateA) / 255;
3561 }
3562 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
3563 *dst = pixel;
3564 posx += incx;
3565 ++dst;
3566 }
3567 posy += incy;
3568 info->dst += info->dst_pitch;
3569 }
3570 }
3571
3572 static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
3573 {
3574 const int flags = info->flags;
3575 const Uint32 modulateR = info->r;
3576 const Uint32 modulateG = info->g;
3577 const Uint32 modulateB = info->b;
3578 const Uint32 modulateA = info->a;
3579 Uint32 srcpixel;
3580 Uint32 srcR, srcG, srcB, srcA;
3581 Uint32 dstpixel;
3582 Uint32 dstR, dstG, dstB, dstA;
3583
3584 while (info->dst_h--) {
3585 Uint32 *src = (Uint32 *)info->src;
3586 Uint32 *dst = (Uint32 *)info->dst;
3587 int n = info->dst_w;
3588 while (n--) {
3589 srcpixel = *src;
3590 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3591 dstpixel = *dst;
3592 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
3593 if (flags & SDL_COPY_MODULATE_COLOR) {
3594 srcR = (srcR * modulateR) / 255;
3595 srcG = (srcG * modulateG) / 255;
3596 srcB = (srcB * modulateB) / 255;
3597 }
3598 if (flags & SDL_COPY_MODULATE_ALPHA) {
3599 srcA = (srcA * modulateA) / 255;
3600 }
3601 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3602 /* This goes away if we ever use premultiplied alpha */
3603 if (srcA < 255) {
3604 srcR = (srcR * srcA) / 255;
3605 srcG = (srcG * srcA) / 255;
3606 srcB = (srcB * srcA) / 255;
3607 }
3608 }
3609 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3610 case SDL_COPY_BLEND:
3611 dstR = srcR + ((255 - srcA) * dstR) / 255;
3612 dstG = srcG + ((255 - srcA) * dstG) / 255;
3613 dstB = srcB + ((255 - srcA) * dstB) / 255;
3614 dstA = srcA + ((255 - srcA) * dstA) / 255;
3615 break;
3616 case SDL_COPY_ADD:
3617 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3618 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3619 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3620 break;
3621 case SDL_COPY_MOD:
3622 dstR = (srcR * dstR) / 255;
3623 dstG = (srcG * dstG) / 255;
3624 dstB = (srcB * dstB) / 255;
3625 break;
3626 }
3627 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
3628 *dst = dstpixel;
3629 ++src;
3630 ++dst;
3631 }
3632 info->src += info->src_pitch;
3633 info->dst += info->dst_pitch;
3634 }
3635 }
3636
3637 static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
3638 {
3639 const int flags = info->flags;
3640 const Uint32 modulateR = info->r;
3641 const Uint32 modulateG = info->g;
3642 const Uint32 modulateB = info->b;
3643 const Uint32 modulateA = info->a;
3644 Uint32 srcpixel;
3645 Uint32 srcR, srcG, srcB, srcA;
3646 Uint32 dstpixel;
3647 Uint32 dstR, dstG, dstB, dstA;
3648 int srcy, srcx;
3649 int posy, posx;
3650 int incy, incx;
3651
3652 srcy = 0;
3653 posy = 0;
3654 incy = (info->src_h << 16) / info->dst_h;
3655 incx = (info->src_w << 16) / info->dst_w;
3656
3657 while (info->dst_h--) {
3658 Uint32 *src = 0;
3659 Uint32 *dst = (Uint32 *)info->dst;
3660 int n = info->dst_w;
3661 srcx = -1;
3662 posx = 0x10000L;
3663 while (posy >= 0x10000L) {
3664 ++srcy;
3665 posy -= 0x10000L;
3666 }
3667 while (n--) {
3668 if (posx >= 0x10000L) {
3669 while (posx >= 0x10000L) {
3670 ++srcx;
3671 posx -= 0x10000L;
3672 }
3673 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3674 }
3675 srcpixel = *src;
3676 srcA = (Uint8)(srcpixel >> 24); srcR = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcB = (Uint8)srcpixel;
3677 dstpixel = *dst;
3678 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
3679 if (flags & SDL_COPY_MODULATE_COLOR) {
3680 srcR = (srcR * modulateR) / 255;
3681 srcG = (srcG * modulateG) / 255;
3682 srcB = (srcB * modulateB) / 255;
3683 }
3684 if (flags & SDL_COPY_MODULATE_ALPHA) {
3685 srcA = (srcA * modulateA) / 255;
3686 }
3687 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3688 /* This goes away if we ever use premultiplied alpha */
3689 if (srcA < 255) {
3690 srcR = (srcR * srcA) / 255;
3691 srcG = (srcG * srcA) / 255;
3692 srcB = (srcB * srcA) / 255;
3693 }
3694 }
3695 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3696 case SDL_COPY_BLEND:
3697 dstR = srcR + ((255 - srcA) * dstR) / 255;
3698 dstG = srcG + ((255 - srcA) * dstG) / 255;
3699 dstB = srcB + ((255 - srcA) * dstB) / 255;
3700 dstA = srcA + ((255 - srcA) * dstA) / 255;
3701 break;
3702 case SDL_COPY_ADD:
3703 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3704 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3705 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3706 break;
3707 case SDL_COPY_MOD:
3708 dstR = (srcR * dstR) / 255;
3709 dstG = (srcG * dstG) / 255;
3710 dstB = (srcB * dstB) / 255;
3711 break;
3712 }
3713 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
3714 *dst = dstpixel;
3715 posx += incx;
3716 ++dst;
3717 }
3718 posy += incy;
3719 info->dst += info->dst_pitch;
3720 }
3721 }
3722
3723 static void SDL_Blit_RGBA8888_RGB888_Scale(SDL_BlitInfo *info)
3724 {
3725 Uint32 pixel;
3726 Uint32 R, G, B, A;
3727 int srcy, srcx;
3728 int posy, posx;
3729 int incy, incx;
3730
3731 srcy = 0;
3732 posy = 0;
3733 incy = (info->src_h << 16) / info->dst_h;
3734 incx = (info->src_w << 16) / info->dst_w;
3735
3736 while (info->dst_h--) {
3737 Uint32 *src = 0;
3738 Uint32 *dst = (Uint32 *)info->dst;
3739 int n = info->dst_w;
3740 srcx = -1;
3741 posx = 0x10000L;
3742 while (posy >= 0x10000L) {
3743 ++srcy;
3744 posy -= 0x10000L;
3745 }
3746 while (n--) {
3747 if (posx >= 0x10000L) {
3748 while (posx >= 0x10000L) {
3749 ++srcx;
3750 posx -= 0x10000L;
3751 }
3752 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3753 }
3754 pixel = *src;
3755 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
3756 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
3757 *dst = pixel;
3758 posx += incx;
3759 ++dst;
3760 }
3761 posy += incy;
3762 info->dst += info->dst_pitch;
3763 }
3764 }
3765
3766 static void SDL_Blit_RGBA8888_RGB888_Blend(SDL_BlitInfo *info)
3767 {
3768 const int flags = info->flags;
3769 Uint32 srcpixel;
3770 Uint32 srcR, srcG, srcB, srcA;
3771 Uint32 dstpixel;
3772 Uint32 dstR, dstG, dstB, dstA;
3773
3774 while (info->dst_h--) {
3775 Uint32 *src = (Uint32 *)info->src;
3776 Uint32 *dst = (Uint32 *)info->dst;
3777 int n = info->dst_w;
3778 while (n--) {
3779 srcpixel = *src;
3780 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
3781 dstpixel = *dst;
3782 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
3783 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3784 /* This goes away if we ever use premultiplied alpha */
3785 if (srcA < 255) {
3786 srcR = (srcR * srcA) / 255;
3787 srcG = (srcG * srcA) / 255;
3788 srcB = (srcB * srcA) / 255;
3789 }
3790 }
3791 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3792 case SDL_COPY_BLEND:
3793 dstR = srcR + ((255 - srcA) * dstR) / 255;
3794 dstG = srcG + ((255 - srcA) * dstG) / 255;
3795 dstB = srcB + ((255 - srcA) * dstB) / 255;
3796 dstA = srcA + ((255 - srcA) * dstA) / 255;
3797 break;
3798 case SDL_COPY_ADD:
3799 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3800 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3801 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3802 break;
3803 case SDL_COPY_MOD:
3804 dstR = (srcR * dstR) / 255;
3805 dstG = (srcG * dstG) / 255;
3806 dstB = (srcB * dstB) / 255;
3807 break;
3808 }
3809 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
3810 *dst = dstpixel;
3811 ++src;
3812 ++dst;
3813 }
3814 info->src += info->src_pitch;
3815 info->dst += info->dst_pitch;
3816 }
3817 }
3818
3819 static void SDL_Blit_RGBA8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
3820 {
3821 const int flags = info->flags;
3822 Uint32 srcpixel;
3823 Uint32 srcR, srcG, srcB, srcA;
3824 Uint32 dstpixel;
3825 Uint32 dstR, dstG, dstB, dstA;
3826 int srcy, srcx;
3827 int posy, posx;
3828 int incy, incx;
3829
3830 srcy = 0;
3831 posy = 0;
3832 incy = (info->src_h << 16) / info->dst_h;
3833 incx = (info->src_w << 16) / info->dst_w;
3834
3835 while (info->dst_h--) {
3836 Uint32 *src = 0;
3837 Uint32 *dst = (Uint32 *)info->dst;
3838 int n = info->dst_w;
3839 srcx = -1;
3840 posx = 0x10000L;
3841 while (posy >= 0x10000L) {
3842 ++srcy;
3843 posy -= 0x10000L;
3844 }
3845 while (n--) {
3846 if (posx >= 0x10000L) {
3847 while (posx >= 0x10000L) {
3848 ++srcx;
3849 posx -= 0x10000L;
3850 }
3851 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3852 }
3853 srcpixel = *src;
3854 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
3855 dstpixel = *dst;
3856 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
3857 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
3858 /* This goes away if we ever use premultiplied alpha */
3859 if (srcA < 255) {
3860 srcR = (srcR * srcA) / 255;
3861 srcG = (srcG * srcA) / 255;
3862 srcB = (srcB * srcA) / 255;
3863 }
3864 }
3865 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
3866 case SDL_COPY_BLEND:
3867 dstR = srcR + ((255 - srcA) * dstR) / 255;
3868 dstG = srcG + ((255 - srcA) * dstG) / 255;
3869 dstB = srcB + ((255 - srcA) * dstB) / 255;
3870 dstA = srcA + ((255 - srcA) * dstA) / 255;
3871 break;
3872 case SDL_COPY_ADD:
3873 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
3874 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
3875 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
3876 break;
3877 case SDL_COPY_MOD:
3878 dstR = (srcR * dstR) / 255;
3879 dstG = (srcG * dstG) / 255;
3880 dstB = (srcB * dstB) / 255;
3881 break;
3882 }
3883 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
3884 *dst = dstpixel;
3885 posx += incx;
3886 ++dst;
3887 }
3888 posy += incy;
3889 info->dst += info->dst_pitch;
3890 }
3891 }
3892
3893 static void SDL_Blit_RGBA8888_RGB888_Modulate(SDL_BlitInfo *info)
3894 {
3895 const int flags = info->flags;
3896 const Uint32 modulateR = info->r;
3897 const Uint32 modulateG = info->g;
3898 const Uint32 modulateB = info->b;
3899 const Uint32 modulateA = info->a;
3900 Uint32 pixel;
3901 Uint32 R, G, B, A;
3902
3903 while (info->dst_h--) {
3904 Uint32 *src = (Uint32 *)info->src;
3905 Uint32 *dst = (Uint32 *)info->dst;
3906 int n = info->dst_w;
3907 while (n--) {
3908 pixel = *src;
3909 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
3910 if (flags & SDL_COPY_MODULATE_COLOR) {
3911 R = (R * modulateR) / 255;
3912 G = (G * modulateG) / 255;
3913 B = (B * modulateB) / 255;
3914 }
3915 if (flags & SDL_COPY_MODULATE_ALPHA) {
3916 A = (A * modulateA) / 255;
3917 }
3918 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
3919 *dst = pixel;
3920 ++src;
3921 ++dst;
3922 }
3923 info->src += info->src_pitch;
3924 info->dst += info->dst_pitch;
3925 }
3926 }
3927
3928 static void SDL_Blit_RGBA8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
3929 {
3930 const int flags = info->flags;
3931 const Uint32 modulateR = info->r;
3932 const Uint32 modulateG = info->g;
3933 const Uint32 modulateB = info->b;
3934 const Uint32 modulateA = info->a;
3935 Uint32 pixel;
3936 Uint32 R, G, B, A;
3937 int srcy, srcx;
3938 int posy, posx;
3939 int incy, incx;
3940
3941 srcy = 0;
3942 posy = 0;
3943 incy = (info->src_h << 16) / info->dst_h;
3944 incx = (info->src_w << 16) / info->dst_w;
3945
3946 while (info->dst_h--) {
3947 Uint32 *src = 0;
3948 Uint32 *dst = (Uint32 *)info->dst;
3949 int n = info->dst_w;
3950 srcx = -1;
3951 posx = 0x10000L;
3952 while (posy >= 0x10000L) {
3953 ++srcy;
3954 posy -= 0x10000L;
3955 }
3956 while (n--) {
3957 if (posx >= 0x10000L) {
3958 while (posx >= 0x10000L) {
3959 ++srcx;
3960 posx -= 0x10000L;
3961 }
3962 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
3963 }
3964 pixel = *src;
3965 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
3966 if (flags & SDL_COPY_MODULATE_COLOR) {
3967 R = (R * modulateR) / 255;
3968 G = (G * modulateG) / 255;
3969 B = (B * modulateB) / 255;
3970 }
3971 if (flags & SDL_COPY_MODULATE_ALPHA) {
3972 A = (A * modulateA) / 255;
3973 }
3974 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
3975 *dst = pixel;
3976 posx += incx;
3977 ++dst;
3978 }
3979 posy += incy;
3980 info->dst += info->dst_pitch;
3981 }
3982 }
3983
3984 static void SDL_Blit_RGBA8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
3985 {
3986 const int flags = info->flags;
3987 const Uint32 modulateR = info->r;
3988 const Uint32 modulateG = info->g;
3989 const Uint32 modulateB = info->b;
3990 const Uint32 modulateA = info->a;
3991 Uint32 srcpixel;
3992 Uint32 srcR, srcG, srcB, srcA;
3993 Uint32 dstpixel;
3994 Uint32 dstR, dstG, dstB, dstA;
3995
3996 while (info->dst_h--) {
3997 Uint32 *src = (Uint32 *)info->src;
3998 Uint32 *dst = (Uint32 *)info->dst;
3999 int n = info->dst_w;
4000 while (n--) {
4001 srcpixel = *src;
4002 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4003 dstpixel = *dst;
4004 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
4005 if (flags & SDL_COPY_MODULATE_COLOR) {
4006 srcR = (srcR * modulateR) / 255;
4007 srcG = (srcG * modulateG) / 255;
4008 srcB = (srcB * modulateB) / 255;
4009 }
4010 if (flags & SDL_COPY_MODULATE_ALPHA) {
4011 srcA = (srcA * modulateA) / 255;
4012 }
4013 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4014 /* This goes away if we ever use premultiplied alpha */
4015 if (srcA < 255) {
4016 srcR = (srcR * srcA) / 255;
4017 srcG = (srcG * srcA) / 255;
4018 srcB = (srcB * srcA) / 255;
4019 }
4020 }
4021 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4022 case SDL_COPY_BLEND:
4023 dstR = srcR + ((255 - srcA) * dstR) / 255;
4024 dstG = srcG + ((255 - srcA) * dstG) / 255;
4025 dstB = srcB + ((255 - srcA) * dstB) / 255;
4026 dstA = srcA + ((255 - srcA) * dstA) / 255;
4027 break;
4028 case SDL_COPY_ADD:
4029 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4030 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4031 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4032 break;
4033 case SDL_COPY_MOD:
4034 dstR = (srcR * dstR) / 255;
4035 dstG = (srcG * dstG) / 255;
4036 dstB = (srcB * dstB) / 255;
4037 break;
4038 }
4039 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
4040 *dst = dstpixel;
4041 ++src;
4042 ++dst;
4043 }
4044 info->src += info->src_pitch;
4045 info->dst += info->dst_pitch;
4046 }
4047 }
4048
4049 static void SDL_Blit_RGBA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
4050 {
4051 const int flags = info->flags;
4052 const Uint32 modulateR = info->r;
4053 const Uint32 modulateG = info->g;
4054 const Uint32 modulateB = info->b;
4055 const Uint32 modulateA = info->a;
4056 Uint32 srcpixel;
4057 Uint32 srcR, srcG, srcB, srcA;
4058 Uint32 dstpixel;
4059 Uint32 dstR, dstG, dstB, dstA;
4060 int srcy, srcx;
4061 int posy, posx;
4062 int incy, incx;
4063
4064 srcy = 0;
4065 posy = 0;
4066 incy = (info->src_h << 16) / info->dst_h;
4067 incx = (info->src_w << 16) / info->dst_w;
4068
4069 while (info->dst_h--) {
4070 Uint32 *src = 0;
4071 Uint32 *dst = (Uint32 *)info->dst;
4072 int n = info->dst_w;
4073 srcx = -1;
4074 posx = 0x10000L;
4075 while (posy >= 0x10000L) {
4076 ++srcy;
4077 posy -= 0x10000L;
4078 }
4079 while (n--) {
4080 if (posx >= 0x10000L) {
4081 while (posx >= 0x10000L) {
4082 ++srcx;
4083 posx -= 0x10000L;
4084 }
4085 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4086 }
4087 srcpixel = *src;
4088 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4089 dstpixel = *dst;
4090 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
4091 if (flags & SDL_COPY_MODULATE_COLOR) {
4092 srcR = (srcR * modulateR) / 255;
4093 srcG = (srcG * modulateG) / 255;
4094 srcB = (srcB * modulateB) / 255;
4095 }
4096 if (flags & SDL_COPY_MODULATE_ALPHA) {
4097 srcA = (srcA * modulateA) / 255;
4098 }
4099 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4100 /* This goes away if we ever use premultiplied alpha */
4101 if (srcA < 255) {
4102 srcR = (srcR * srcA) / 255;
4103 srcG = (srcG * srcA) / 255;
4104 srcB = (srcB * srcA) / 255;
4105 }
4106 }
4107 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4108 case SDL_COPY_BLEND:
4109 dstR = srcR + ((255 - srcA) * dstR) / 255;
4110 dstG = srcG + ((255 - srcA) * dstG) / 255;
4111 dstB = srcB + ((255 - srcA) * dstB) / 255;
4112 dstA = srcA + ((255 - srcA) * dstA) / 255;
4113 break;
4114 case SDL_COPY_ADD:
4115 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4116 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4117 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4118 break;
4119 case SDL_COPY_MOD:
4120 dstR = (srcR * dstR) / 255;
4121 dstG = (srcG * dstG) / 255;
4122 dstB = (srcB * dstB) / 255;
4123 break;
4124 }
4125 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
4126 *dst = dstpixel;
4127 posx += incx;
4128 ++dst;
4129 }
4130 posy += incy;
4131 info->dst += info->dst_pitch;
4132 }
4133 }
4134
4135 static void SDL_Blit_RGBA8888_BGR888_Scale(SDL_BlitInfo *info)
4136 {
4137 Uint32 pixel;
4138 Uint32 R, G, B, A;
4139 int srcy, srcx;
4140 int posy, posx;
4141 int incy, incx;
4142
4143 srcy = 0;
4144 posy = 0;
4145 incy = (info->src_h << 16) / info->dst_h;
4146 incx = (info->src_w << 16) / info->dst_w;
4147
4148 while (info->dst_h--) {
4149 Uint32 *src = 0;
4150 Uint32 *dst = (Uint32 *)info->dst;
4151 int n = info->dst_w;
4152 srcx = -1;
4153 posx = 0x10000L;
4154 while (posy >= 0x10000L) {
4155 ++srcy;
4156 posy -= 0x10000L;
4157 }
4158 while (n--) {
4159 if (posx >= 0x10000L) {
4160 while (posx >= 0x10000L) {
4161 ++srcx;
4162 posx -= 0x10000L;
4163 }
4164 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4165 }
4166 pixel = *src;
4167 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
4168 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
4169 *dst = pixel;
4170 posx += incx;
4171 ++dst;
4172 }
4173 posy += incy;
4174 info->dst += info->dst_pitch;
4175 }
4176 }
4177
4178 static void SDL_Blit_RGBA8888_BGR888_Blend(SDL_BlitInfo *info)
4179 {
4180 const int flags = info->flags;
4181 Uint32 srcpixel;
4182 Uint32 srcR, srcG, srcB, srcA;
4183 Uint32 dstpixel;
4184 Uint32 dstR, dstG, dstB, dstA;
4185
4186 while (info->dst_h--) {
4187 Uint32 *src = (Uint32 *)info->src;
4188 Uint32 *dst = (Uint32 *)info->dst;
4189 int n = info->dst_w;
4190 while (n--) {
4191 srcpixel = *src;
4192 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4193 dstpixel = *dst;
4194 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
4195 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4196 /* This goes away if we ever use premultiplied alpha */
4197 if (srcA < 255) {
4198 srcR = (srcR * srcA) / 255;
4199 srcG = (srcG * srcA) / 255;
4200 srcB = (srcB * srcA) / 255;
4201 }
4202 }
4203 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4204 case SDL_COPY_BLEND:
4205 dstR = srcR + ((255 - srcA) * dstR) / 255;
4206 dstG = srcG + ((255 - srcA) * dstG) / 255;
4207 dstB = srcB + ((255 - srcA) * dstB) / 255;
4208 dstA = srcA + ((255 - srcA) * dstA) / 255;
4209 break;
4210 case SDL_COPY_ADD:
4211 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4212 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4213 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4214 break;
4215 case SDL_COPY_MOD:
4216 dstR = (srcR * dstR) / 255;
4217 dstG = (srcG * dstG) / 255;
4218 dstB = (srcB * dstB) / 255;
4219 break;
4220 }
4221 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
4222 *dst = dstpixel;
4223 ++src;
4224 ++dst;
4225 }
4226 info->src += info->src_pitch;
4227 info->dst += info->dst_pitch;
4228 }
4229 }
4230
4231 static void SDL_Blit_RGBA8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
4232 {
4233 const int flags = info->flags;
4234 Uint32 srcpixel;
4235 Uint32 srcR, srcG, srcB, srcA;
4236 Uint32 dstpixel;
4237 Uint32 dstR, dstG, dstB, dstA;
4238 int srcy, srcx;
4239 int posy, posx;
4240 int incy, incx;
4241
4242 srcy = 0;
4243 posy = 0;
4244 incy = (info->src_h << 16) / info->dst_h;
4245 incx = (info->src_w << 16) / info->dst_w;
4246
4247 while (info->dst_h--) {
4248 Uint32 *src = 0;
4249 Uint32 *dst = (Uint32 *)info->dst;
4250 int n = info->dst_w;
4251 srcx = -1;
4252 posx = 0x10000L;
4253 while (posy >= 0x10000L) {
4254 ++srcy;
4255 posy -= 0x10000L;
4256 }
4257 while (n--) {
4258 if (posx >= 0x10000L) {
4259 while (posx >= 0x10000L) {
4260 ++srcx;
4261 posx -= 0x10000L;
4262 }
4263 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4264 }
4265 srcpixel = *src;
4266 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4267 dstpixel = *dst;
4268 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
4269 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4270 /* This goes away if we ever use premultiplied alpha */
4271 if (srcA < 255) {
4272 srcR = (srcR * srcA) / 255;
4273 srcG = (srcG * srcA) / 255;
4274 srcB = (srcB * srcA) / 255;
4275 }
4276 }
4277 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4278 case SDL_COPY_BLEND:
4279 dstR = srcR + ((255 - srcA) * dstR) / 255;
4280 dstG = srcG + ((255 - srcA) * dstG) / 255;
4281 dstB = srcB + ((255 - srcA) * dstB) / 255;
4282 dstA = srcA + ((255 - srcA) * dstA) / 255;
4283 break;
4284 case SDL_COPY_ADD:
4285 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4286 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4287 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4288 break;
4289 case SDL_COPY_MOD:
4290 dstR = (srcR * dstR) / 255;
4291 dstG = (srcG * dstG) / 255;
4292 dstB = (srcB * dstB) / 255;
4293 break;
4294 }
4295 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
4296 *dst = dstpixel;
4297 posx += incx;
4298 ++dst;
4299 }
4300 posy += incy;
4301 info->dst += info->dst_pitch;
4302 }
4303 }
4304
4305 static void SDL_Blit_RGBA8888_BGR888_Modulate(SDL_BlitInfo *info)
4306 {
4307 const int flags = info->flags;
4308 const Uint32 modulateR = info->r;
4309 const Uint32 modulateG = info->g;
4310 const Uint32 modulateB = info->b;
4311 const Uint32 modulateA = info->a;
4312 Uint32 pixel;
4313 Uint32 R, G, B, A;
4314
4315 while (info->dst_h--) {
4316 Uint32 *src = (Uint32 *)info->src;
4317 Uint32 *dst = (Uint32 *)info->dst;
4318 int n = info->dst_w;
4319 while (n--) {
4320 pixel = *src;
4321 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
4322 if (flags & SDL_COPY_MODULATE_COLOR) {
4323 R = (R * modulateR) / 255;
4324 G = (G * modulateG) / 255;
4325 B = (B * modulateB) / 255;
4326 }
4327 if (flags & SDL_COPY_MODULATE_ALPHA) {
4328 A = (A * modulateA) / 255;
4329 }
4330 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
4331 *dst = pixel;
4332 ++src;
4333 ++dst;
4334 }
4335 info->src += info->src_pitch;
4336 info->dst += info->dst_pitch;
4337 }
4338 }
4339
4340 static void SDL_Blit_RGBA8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
4341 {
4342 const int flags = info->flags;
4343 const Uint32 modulateR = info->r;
4344 const Uint32 modulateG = info->g;
4345 const Uint32 modulateB = info->b;
4346 const Uint32 modulateA = info->a;
4347 Uint32 pixel;
4348 Uint32 R, G, B, A;
4349 int srcy, srcx;
4350 int posy, posx;
4351 int incy, incx;
4352
4353 srcy = 0;
4354 posy = 0;
4355 incy = (info->src_h << 16) / info->dst_h;
4356 incx = (info->src_w << 16) / info->dst_w;
4357
4358 while (info->dst_h--) {
4359 Uint32 *src = 0;
4360 Uint32 *dst = (Uint32 *)info->dst;
4361 int n = info->dst_w;
4362 srcx = -1;
4363 posx = 0x10000L;
4364 while (posy >= 0x10000L) {
4365 ++srcy;
4366 posy -= 0x10000L;
4367 }
4368 while (n--) {
4369 if (posx >= 0x10000L) {
4370 while (posx >= 0x10000L) {
4371 ++srcx;
4372 posx -= 0x10000L;
4373 }
4374 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4375 }
4376 pixel = *src;
4377 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
4378 if (flags & SDL_COPY_MODULATE_COLOR) {
4379 R = (R * modulateR) / 255;
4380 G = (G * modulateG) / 255;
4381 B = (B * modulateB) / 255;
4382 }
4383 if (flags & SDL_COPY_MODULATE_ALPHA) {
4384 A = (A * modulateA) / 255;
4385 }
4386 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
4387 *dst = pixel;
4388 posx += incx;
4389 ++dst;
4390 }
4391 posy += incy;
4392 info->dst += info->dst_pitch;
4393 }
4394 }
4395
4396 static void SDL_Blit_RGBA8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
4397 {
4398 const int flags = info->flags;
4399 const Uint32 modulateR = info->r;
4400 const Uint32 modulateG = info->g;
4401 const Uint32 modulateB = info->b;
4402 const Uint32 modulateA = info->a;
4403 Uint32 srcpixel;
4404 Uint32 srcR, srcG, srcB, srcA;
4405 Uint32 dstpixel;
4406 Uint32 dstR, dstG, dstB, dstA;
4407
4408 while (info->dst_h--) {
4409 Uint32 *src = (Uint32 *)info->src;
4410 Uint32 *dst = (Uint32 *)info->dst;
4411 int n = info->dst_w;
4412 while (n--) {
4413 srcpixel = *src;
4414 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4415 dstpixel = *dst;
4416 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
4417 if (flags & SDL_COPY_MODULATE_COLOR) {
4418 srcR = (srcR * modulateR) / 255;
4419 srcG = (srcG * modulateG) / 255;
4420 srcB = (srcB * modulateB) / 255;
4421 }
4422 if (flags & SDL_COPY_MODULATE_ALPHA) {
4423 srcA = (srcA * modulateA) / 255;
4424 }
4425 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4426 /* This goes away if we ever use premultiplied alpha */
4427 if (srcA < 255) {
4428 srcR = (srcR * srcA) / 255;
4429 srcG = (srcG * srcA) / 255;
4430 srcB = (srcB * srcA) / 255;
4431 }
4432 }
4433 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4434 case SDL_COPY_BLEND:
4435 dstR = srcR + ((255 - srcA) * dstR) / 255;
4436 dstG = srcG + ((255 - srcA) * dstG) / 255;
4437 dstB = srcB + ((255 - srcA) * dstB) / 255;
4438 dstA = srcA + ((255 - srcA) * dstA) / 255;
4439 break;
4440 case SDL_COPY_ADD:
4441 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4442 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4443 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4444 break;
4445 case SDL_COPY_MOD:
4446 dstR = (srcR * dstR) / 255;
4447 dstG = (srcG * dstG) / 255;
4448 dstB = (srcB * dstB) / 255;
4449 break;
4450 }
4451 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
4452 *dst = dstpixel;
4453 ++src;
4454 ++dst;
4455 }
4456 info->src += info->src_pitch;
4457 info->dst += info->dst_pitch;
4458 }
4459 }
4460
4461 static void SDL_Blit_RGBA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
4462 {
4463 const int flags = info->flags;
4464 const Uint32 modulateR = info->r;
4465 const Uint32 modulateG = info->g;
4466 const Uint32 modulateB = info->b;
4467 const Uint32 modulateA = info->a;
4468 Uint32 srcpixel;
4469 Uint32 srcR, srcG, srcB, srcA;
4470 Uint32 dstpixel;
4471 Uint32 dstR, dstG, dstB, dstA;
4472 int srcy, srcx;
4473 int posy, posx;
4474 int incy, incx;
4475
4476 srcy = 0;
4477 posy = 0;
4478 incy = (info->src_h << 16) / info->dst_h;
4479 incx = (info->src_w << 16) / info->dst_w;
4480
4481 while (info->dst_h--) {
4482 Uint32 *src = 0;
4483 Uint32 *dst = (Uint32 *)info->dst;
4484 int n = info->dst_w;
4485 srcx = -1;
4486 posx = 0x10000L;
4487 while (posy >= 0x10000L) {
4488 ++srcy;
4489 posy -= 0x10000L;
4490 }
4491 while (n--) {
4492 if (posx >= 0x10000L) {
4493 while (posx >= 0x10000L) {
4494 ++srcx;
4495 posx -= 0x10000L;
4496 }
4497 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4498 }
4499 srcpixel = *src;
4500 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4501 dstpixel = *dst;
4502 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
4503 if (flags & SDL_COPY_MODULATE_COLOR) {
4504 srcR = (srcR * modulateR) / 255;
4505 srcG = (srcG * modulateG) / 255;
4506 srcB = (srcB * modulateB) / 255;
4507 }
4508 if (flags & SDL_COPY_MODULATE_ALPHA) {
4509 srcA = (srcA * modulateA) / 255;
4510 }
4511 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4512 /* This goes away if we ever use premultiplied alpha */
4513 if (srcA < 255) {
4514 srcR = (srcR * srcA) / 255;
4515 srcG = (srcG * srcA) / 255;
4516 srcB = (srcB * srcA) / 255;
4517 }
4518 }
4519 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4520 case SDL_COPY_BLEND:
4521 dstR = srcR + ((255 - srcA) * dstR) / 255;
4522 dstG = srcG + ((255 - srcA) * dstG) / 255;
4523 dstB = srcB + ((255 - srcA) * dstB) / 255;
4524 dstA = srcA + ((255 - srcA) * dstA) / 255;
4525 break;
4526 case SDL_COPY_ADD:
4527 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4528 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4529 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4530 break;
4531 case SDL_COPY_MOD:
4532 dstR = (srcR * dstR) / 255;
4533 dstG = (srcG * dstG) / 255;
4534 dstB = (srcB * dstB) / 255;
4535 break;
4536 }
4537 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
4538 *dst = dstpixel;
4539 posx += incx;
4540 ++dst;
4541 }
4542 posy += incy;
4543 info->dst += info->dst_pitch;
4544 }
4545 }
4546
4547 static void SDL_Blit_RGBA8888_ARGB8888_Scale(SDL_BlitInfo *info)
4548 {
4549 Uint32 pixel;
4550 Uint32 R, G, B, A;
4551 int srcy, srcx;
4552 int posy, posx;
4553 int incy, incx;
4554
4555 srcy = 0;
4556 posy = 0;
4557 incy = (info->src_h << 16) / info->dst_h;
4558 incx = (info->src_w << 16) / info->dst_w;
4559
4560 while (info->dst_h--) {
4561 Uint32 *src = 0;
4562 Uint32 *dst = (Uint32 *)info->dst;
4563 int n = info->dst_w;
4564 srcx = -1;
4565 posx = 0x10000L;
4566 while (posy >= 0x10000L) {
4567 ++srcy;
4568 posy -= 0x10000L;
4569 }
4570 while (n--) {
4571 if (posx >= 0x10000L) {
4572 while (posx >= 0x10000L) {
4573 ++srcx;
4574 posx -= 0x10000L;
4575 }
4576 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4577 }
4578 pixel = *src;
4579 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
4580 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
4581 *dst = pixel;
4582 posx += incx;
4583 ++dst;
4584 }
4585 posy += incy;
4586 info->dst += info->dst_pitch;
4587 }
4588 }
4589
4590 static void SDL_Blit_RGBA8888_ARGB8888_Blend(SDL_BlitInfo *info)
4591 {
4592 const int flags = info->flags;
4593 Uint32 srcpixel;
4594 Uint32 srcR, srcG, srcB, srcA;
4595 Uint32 dstpixel;
4596 Uint32 dstR, dstG, dstB, dstA;
4597
4598 while (info->dst_h--) {
4599 Uint32 *src = (Uint32 *)info->src;
4600 Uint32 *dst = (Uint32 *)info->dst;
4601 int n = info->dst_w;
4602 while (n--) {
4603 srcpixel = *src;
4604 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4605 dstpixel = *dst;
4606 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
4607 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4608 /* This goes away if we ever use premultiplied alpha */
4609 if (srcA < 255) {
4610 srcR = (srcR * srcA) / 255;
4611 srcG = (srcG * srcA) / 255;
4612 srcB = (srcB * srcA) / 255;
4613 }
4614 }
4615 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4616 case SDL_COPY_BLEND:
4617 dstR = srcR + ((255 - srcA) * dstR) / 255;
4618 dstG = srcG + ((255 - srcA) * dstG) / 255;
4619 dstB = srcB + ((255 - srcA) * dstB) / 255;
4620 dstA = srcA + ((255 - srcA) * dstA) / 255;
4621 break;
4622 case SDL_COPY_ADD:
4623 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4624 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4625 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4626 break;
4627 case SDL_COPY_MOD:
4628 dstR = (srcR * dstR) / 255;
4629 dstG = (srcG * dstG) / 255;
4630 dstB = (srcB * dstB) / 255;
4631 break;
4632 }
4633 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
4634 *dst = dstpixel;
4635 ++src;
4636 ++dst;
4637 }
4638 info->src += info->src_pitch;
4639 info->dst += info->dst_pitch;
4640 }
4641 }
4642
4643 static void SDL_Blit_RGBA8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
4644 {
4645 const int flags = info->flags;
4646 Uint32 srcpixel;
4647 Uint32 srcR, srcG, srcB, srcA;
4648 Uint32 dstpixel;
4649 Uint32 dstR, dstG, dstB, dstA;
4650 int srcy, srcx;
4651 int posy, posx;
4652 int incy, incx;
4653
4654 srcy = 0;
4655 posy = 0;
4656 incy = (info->src_h << 16) / info->dst_h;
4657 incx = (info->src_w << 16) / info->dst_w;
4658
4659 while (info->dst_h--) {
4660 Uint32 *src = 0;
4661 Uint32 *dst = (Uint32 *)info->dst;
4662 int n = info->dst_w;
4663 srcx = -1;
4664 posx = 0x10000L;
4665 while (posy >= 0x10000L) {
4666 ++srcy;
4667 posy -= 0x10000L;
4668 }
4669 while (n--) {
4670 if (posx >= 0x10000L) {
4671 while (posx >= 0x10000L) {
4672 ++srcx;
4673 posx -= 0x10000L;
4674 }
4675 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4676 }
4677 srcpixel = *src;
4678 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4679 dstpixel = *dst;
4680 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
4681 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4682 /* This goes away if we ever use premultiplied alpha */
4683 if (srcA < 255) {
4684 srcR = (srcR * srcA) / 255;
4685 srcG = (srcG * srcA) / 255;
4686 srcB = (srcB * srcA) / 255;
4687 }
4688 }
4689 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4690 case SDL_COPY_BLEND:
4691 dstR = srcR + ((255 - srcA) * dstR) / 255;
4692 dstG = srcG + ((255 - srcA) * dstG) / 255;
4693 dstB = srcB + ((255 - srcA) * dstB) / 255;
4694 dstA = srcA + ((255 - srcA) * dstA) / 255;
4695 break;
4696 case SDL_COPY_ADD:
4697 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4698 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4699 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4700 break;
4701 case SDL_COPY_MOD:
4702 dstR = (srcR * dstR) / 255;
4703 dstG = (srcG * dstG) / 255;
4704 dstB = (srcB * dstB) / 255;
4705 break;
4706 }
4707 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
4708 *dst = dstpixel;
4709 posx += incx;
4710 ++dst;
4711 }
4712 posy += incy;
4713 info->dst += info->dst_pitch;
4714 }
4715 }
4716
4717 static void SDL_Blit_RGBA8888_ARGB8888_Modulate(SDL_BlitInfo *info)
4718 {
4719 const int flags = info->flags;
4720 const Uint32 modulateR = info->r;
4721 const Uint32 modulateG = info->g;
4722 const Uint32 modulateB = info->b;
4723 const Uint32 modulateA = info->a;
4724 Uint32 pixel;
4725 Uint32 R, G, B, A;
4726
4727 while (info->dst_h--) {
4728 Uint32 *src = (Uint32 *)info->src;
4729 Uint32 *dst = (Uint32 *)info->dst;
4730 int n = info->dst_w;
4731 while (n--) {
4732 pixel = *src;
4733 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
4734 if (flags & SDL_COPY_MODULATE_COLOR) {
4735 R = (R * modulateR) / 255;
4736 G = (G * modulateG) / 255;
4737 B = (B * modulateB) / 255;
4738 }
4739 if (flags & SDL_COPY_MODULATE_ALPHA) {
4740 A = (A * modulateA) / 255;
4741 }
4742 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
4743 *dst = pixel;
4744 ++src;
4745 ++dst;
4746 }
4747 info->src += info->src_pitch;
4748 info->dst += info->dst_pitch;
4749 }
4750 }
4751
4752 static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
4753 {
4754 const int flags = info->flags;
4755 const Uint32 modulateR = info->r;
4756 const Uint32 modulateG = info->g;
4757 const Uint32 modulateB = info->b;
4758 const Uint32 modulateA = info->a;
4759 Uint32 pixel;
4760 Uint32 R, G, B, A;
4761 int srcy, srcx;
4762 int posy, posx;
4763 int incy, incx;
4764
4765 srcy = 0;
4766 posy = 0;
4767 incy = (info->src_h << 16) / info->dst_h;
4768 incx = (info->src_w << 16) / info->dst_w;
4769
4770 while (info->dst_h--) {
4771 Uint32 *src = 0;
4772 Uint32 *dst = (Uint32 *)info->dst;
4773 int n = info->dst_w;
4774 srcx = -1;
4775 posx = 0x10000L;
4776 while (posy >= 0x10000L) {
4777 ++srcy;
4778 posy -= 0x10000L;
4779 }
4780 while (n--) {
4781 if (posx >= 0x10000L) {
4782 while (posx >= 0x10000L) {
4783 ++srcx;
4784 posx -= 0x10000L;
4785 }
4786 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4787 }
4788 pixel = *src;
4789 R = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); B = (Uint8)(pixel >> 8); A = (Uint8)pixel;
4790 if (flags & SDL_COPY_MODULATE_COLOR) {
4791 R = (R * modulateR) / 255;
4792 G = (G * modulateG) / 255;
4793 B = (B * modulateB) / 255;
4794 }
4795 if (flags & SDL_COPY_MODULATE_ALPHA) {
4796 A = (A * modulateA) / 255;
4797 }
4798 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
4799 *dst = pixel;
4800 posx += incx;
4801 ++dst;
4802 }
4803 posy += incy;
4804 info->dst += info->dst_pitch;
4805 }
4806 }
4807
4808 static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
4809 {
4810 const int flags = info->flags;
4811 const Uint32 modulateR = info->r;
4812 const Uint32 modulateG = info->g;
4813 const Uint32 modulateB = info->b;
4814 const Uint32 modulateA = info->a;
4815 Uint32 srcpixel;
4816 Uint32 srcR, srcG, srcB, srcA;
4817 Uint32 dstpixel;
4818 Uint32 dstR, dstG, dstB, dstA;
4819
4820 while (info->dst_h--) {
4821 Uint32 *src = (Uint32 *)info->src;
4822 Uint32 *dst = (Uint32 *)info->dst;
4823 int n = info->dst_w;
4824 while (n--) {
4825 srcpixel = *src;
4826 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4827 dstpixel = *dst;
4828 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
4829 if (flags & SDL_COPY_MODULATE_COLOR) {
4830 srcR = (srcR * modulateR) / 255;
4831 srcG = (srcG * modulateG) / 255;
4832 srcB = (srcB * modulateB) / 255;
4833 }
4834 if (flags & SDL_COPY_MODULATE_ALPHA) {
4835 srcA = (srcA * modulateA) / 255;
4836 }
4837 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4838 /* This goes away if we ever use premultiplied alpha */
4839 if (srcA < 255) {
4840 srcR = (srcR * srcA) / 255;
4841 srcG = (srcG * srcA) / 255;
4842 srcB = (srcB * srcA) / 255;
4843 }
4844 }
4845 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4846 case SDL_COPY_BLEND:
4847 dstR = srcR + ((255 - srcA) * dstR) / 255;
4848 dstG = srcG + ((255 - srcA) * dstG) / 255;
4849 dstB = srcB + ((255 - srcA) * dstB) / 255;
4850 dstA = srcA + ((255 - srcA) * dstA) / 255;
4851 break;
4852 case SDL_COPY_ADD:
4853 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4854 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4855 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4856 break;
4857 case SDL_COPY_MOD:
4858 dstR = (srcR * dstR) / 255;
4859 dstG = (srcG * dstG) / 255;
4860 dstB = (srcB * dstB) / 255;
4861 break;
4862 }
4863 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
4864 *dst = dstpixel;
4865 ++src;
4866 ++dst;
4867 }
4868 info->src += info->src_pitch;
4869 info->dst += info->dst_pitch;
4870 }
4871 }
4872
4873 static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
4874 {
4875 const int flags = info->flags;
4876 const Uint32 modulateR = info->r;
4877 const Uint32 modulateG = info->g;
4878 const Uint32 modulateB = info->b;
4879 const Uint32 modulateA = info->a;
4880 Uint32 srcpixel;
4881 Uint32 srcR, srcG, srcB, srcA;
4882 Uint32 dstpixel;
4883 Uint32 dstR, dstG, dstB, dstA;
4884 int srcy, srcx;
4885 int posy, posx;
4886 int incy, incx;
4887
4888 srcy = 0;
4889 posy = 0;
4890 incy = (info->src_h << 16) / info->dst_h;
4891 incx = (info->src_w << 16) / info->dst_w;
4892
4893 while (info->dst_h--) {
4894 Uint32 *src = 0;
4895 Uint32 *dst = (Uint32 *)info->dst;
4896 int n = info->dst_w;
4897 srcx = -1;
4898 posx = 0x10000L;
4899 while (posy >= 0x10000L) {
4900 ++srcy;
4901 posy -= 0x10000L;
4902 }
4903 while (n--) {
4904 if (posx >= 0x10000L) {
4905 while (posx >= 0x10000L) {
4906 ++srcx;
4907 posx -= 0x10000L;
4908 }
4909 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4910 }
4911 srcpixel = *src;
4912 srcR = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcB = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
4913 dstpixel = *dst;
4914 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
4915 if (flags & SDL_COPY_MODULATE_COLOR) {
4916 srcR = (srcR * modulateR) / 255;
4917 srcG = (srcG * modulateG) / 255;
4918 srcB = (srcB * modulateB) / 255;
4919 }
4920 if (flags & SDL_COPY_MODULATE_ALPHA) {
4921 srcA = (srcA * modulateA) / 255;
4922 }
4923 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
4924 /* This goes away if we ever use premultiplied alpha */
4925 if (srcA < 255) {
4926 srcR = (srcR * srcA) / 255;
4927 srcG = (srcG * srcA) / 255;
4928 srcB = (srcB * srcA) / 255;
4929 }
4930 }
4931 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
4932 case SDL_COPY_BLEND:
4933 dstR = srcR + ((255 - srcA) * dstR) / 255;
4934 dstG = srcG + ((255 - srcA) * dstG) / 255;
4935 dstB = srcB + ((255 - srcA) * dstB) / 255;
4936 dstA = srcA + ((255 - srcA) * dstA) / 255;
4937 break;
4938 case SDL_COPY_ADD:
4939 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
4940 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
4941 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
4942 break;
4943 case SDL_COPY_MOD:
4944 dstR = (srcR * dstR) / 255;
4945 dstG = (srcG * dstG) / 255;
4946 dstB = (srcB * dstB) / 255;
4947 break;
4948 }
4949 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
4950 *dst = dstpixel;
4951 posx += incx;
4952 ++dst;
4953 }
4954 posy += incy;
4955 info->dst += info->dst_pitch;
4956 }
4957 }
4958
4959 static void SDL_Blit_ABGR8888_RGB888_Scale(SDL_BlitInfo *info)
4960 {
4961 Uint32 pixel;
4962 Uint32 R, G, B, A;
4963 int srcy, srcx;
4964 int posy, posx;
4965 int incy, incx;
4966
4967 srcy = 0;
4968 posy = 0;
4969 incy = (info->src_h << 16) / info->dst_h;
4970 incx = (info->src_w << 16) / info->dst_w;
4971
4972 while (info->dst_h--) {
4973 Uint32 *src = 0;
4974 Uint32 *dst = (Uint32 *)info->dst;
4975 int n = info->dst_w;
4976 srcx = -1;
4977 posx = 0x10000L;
4978 while (posy >= 0x10000L) {
4979 ++srcy;
4980 posy -= 0x10000L;
4981 }
4982 while (n--) {
4983 if (posx >= 0x10000L) {
4984 while (posx >= 0x10000L) {
4985 ++srcx;
4986 posx -= 0x10000L;
4987 }
4988 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
4989 }
4990 pixel = *src;
4991 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
4992 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
4993 *dst = pixel;
4994 posx += incx;
4995 ++dst;
4996 }
4997 posy += incy;
4998 info->dst += info->dst_pitch;
4999 }
5000 }
5001
5002 static void SDL_Blit_ABGR8888_RGB888_Blend(SDL_BlitInfo *info)
5003 {
5004 const int flags = info->flags;
5005 Uint32 srcpixel;
5006 Uint32 srcR, srcG, srcB, srcA;
5007 Uint32 dstpixel;
5008 Uint32 dstR, dstG, dstB, dstA;
5009
5010 while (info->dst_h--) {
5011 Uint32 *src = (Uint32 *)info->src;
5012 Uint32 *dst = (Uint32 *)info->dst;
5013 int n = info->dst_w;
5014 while (n--) {
5015 srcpixel = *src;
5016 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5017 dstpixel = *dst;
5018 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
5019 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5020 /* This goes away if we ever use premultiplied alpha */
5021 if (srcA < 255) {
5022 srcR = (srcR * srcA) / 255;
5023 srcG = (srcG * srcA) / 255;
5024 srcB = (srcB * srcA) / 255;
5025 }
5026 }
5027 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5028 case SDL_COPY_BLEND:
5029 dstR = srcR + ((255 - srcA) * dstR) / 255;
5030 dstG = srcG + ((255 - srcA) * dstG) / 255;
5031 dstB = srcB + ((255 - srcA) * dstB) / 255;
5032 dstA = srcA + ((255 - srcA) * dstA) / 255;
5033 break;
5034 case SDL_COPY_ADD:
5035 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5036 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5037 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5038 break;
5039 case SDL_COPY_MOD:
5040 dstR = (srcR * dstR) / 255;
5041 dstG = (srcG * dstG) / 255;
5042 dstB = (srcB * dstB) / 255;
5043 break;
5044 }
5045 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
5046 *dst = dstpixel;
5047 ++src;
5048 ++dst;
5049 }
5050 info->src += info->src_pitch;
5051 info->dst += info->dst_pitch;
5052 }
5053 }
5054
5055 static void SDL_Blit_ABGR8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
5056 {
5057 const int flags = info->flags;
5058 Uint32 srcpixel;
5059 Uint32 srcR, srcG, srcB, srcA;
5060 Uint32 dstpixel;
5061 Uint32 dstR, dstG, dstB, dstA;
5062 int srcy, srcx;
5063 int posy, posx;
5064 int incy, incx;
5065
5066 srcy = 0;
5067 posy = 0;
5068 incy = (info->src_h << 16) / info->dst_h;
5069 incx = (info->src_w << 16) / info->dst_w;
5070
5071 while (info->dst_h--) {
5072 Uint32 *src = 0;
5073 Uint32 *dst = (Uint32 *)info->dst;
5074 int n = info->dst_w;
5075 srcx = -1;
5076 posx = 0x10000L;
5077 while (posy >= 0x10000L) {
5078 ++srcy;
5079 posy -= 0x10000L;
5080 }
5081 while (n--) {
5082 if (posx >= 0x10000L) {
5083 while (posx >= 0x10000L) {
5084 ++srcx;
5085 posx -= 0x10000L;
5086 }
5087 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5088 }
5089 srcpixel = *src;
5090 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5091 dstpixel = *dst;
5092 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
5093 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5094 /* This goes away if we ever use premultiplied alpha */
5095 if (srcA < 255) {
5096 srcR = (srcR * srcA) / 255;
5097 srcG = (srcG * srcA) / 255;
5098 srcB = (srcB * srcA) / 255;
5099 }
5100 }
5101 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5102 case SDL_COPY_BLEND:
5103 dstR = srcR + ((255 - srcA) * dstR) / 255;
5104 dstG = srcG + ((255 - srcA) * dstG) / 255;
5105 dstB = srcB + ((255 - srcA) * dstB) / 255;
5106 dstA = srcA + ((255 - srcA) * dstA) / 255;
5107 break;
5108 case SDL_COPY_ADD:
5109 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5110 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5111 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5112 break;
5113 case SDL_COPY_MOD:
5114 dstR = (srcR * dstR) / 255;
5115 dstG = (srcG * dstG) / 255;
5116 dstB = (srcB * dstB) / 255;
5117 break;
5118 }
5119 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
5120 *dst = dstpixel;
5121 posx += incx;
5122 ++dst;
5123 }
5124 posy += incy;
5125 info->dst += info->dst_pitch;
5126 }
5127 }
5128
5129 static void SDL_Blit_ABGR8888_RGB888_Modulate(SDL_BlitInfo *info)
5130 {
5131 const int flags = info->flags;
5132 const Uint32 modulateR = info->r;
5133 const Uint32 modulateG = info->g;
5134 const Uint32 modulateB = info->b;
5135 const Uint32 modulateA = info->a;
5136 Uint32 pixel;
5137 Uint32 R, G, B, A;
5138
5139 while (info->dst_h--) {
5140 Uint32 *src = (Uint32 *)info->src;
5141 Uint32 *dst = (Uint32 *)info->dst;
5142 int n = info->dst_w;
5143 while (n--) {
5144 pixel = *src;
5145 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5146 if (flags & SDL_COPY_MODULATE_COLOR) {
5147 R = (R * modulateR) / 255;
5148 G = (G * modulateG) / 255;
5149 B = (B * modulateB) / 255;
5150 }
5151 if (flags & SDL_COPY_MODULATE_ALPHA) {
5152 A = (A * modulateA) / 255;
5153 }
5154 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
5155 *dst = pixel;
5156 ++src;
5157 ++dst;
5158 }
5159 info->src += info->src_pitch;
5160 info->dst += info->dst_pitch;
5161 }
5162 }
5163
5164 static void SDL_Blit_ABGR8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
5165 {
5166 const int flags = info->flags;
5167 const Uint32 modulateR = info->r;
5168 const Uint32 modulateG = info->g;
5169 const Uint32 modulateB = info->b;
5170 const Uint32 modulateA = info->a;
5171 Uint32 pixel;
5172 Uint32 R, G, B, A;
5173 int srcy, srcx;
5174 int posy, posx;
5175 int incy, incx;
5176
5177 srcy = 0;
5178 posy = 0;
5179 incy = (info->src_h << 16) / info->dst_h;
5180 incx = (info->src_w << 16) / info->dst_w;
5181
5182 while (info->dst_h--) {
5183 Uint32 *src = 0;
5184 Uint32 *dst = (Uint32 *)info->dst;
5185 int n = info->dst_w;
5186 srcx = -1;
5187 posx = 0x10000L;
5188 while (posy >= 0x10000L) {
5189 ++srcy;
5190 posy -= 0x10000L;
5191 }
5192 while (n--) {
5193 if (posx >= 0x10000L) {
5194 while (posx >= 0x10000L) {
5195 ++srcx;
5196 posx -= 0x10000L;
5197 }
5198 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5199 }
5200 pixel = *src;
5201 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5202 if (flags & SDL_COPY_MODULATE_COLOR) {
5203 R = (R * modulateR) / 255;
5204 G = (G * modulateG) / 255;
5205 B = (B * modulateB) / 255;
5206 }
5207 if (flags & SDL_COPY_MODULATE_ALPHA) {
5208 A = (A * modulateA) / 255;
5209 }
5210 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
5211 *dst = pixel;
5212 posx += incx;
5213 ++dst;
5214 }
5215 posy += incy;
5216 info->dst += info->dst_pitch;
5217 }
5218 }
5219
5220 static void SDL_Blit_ABGR8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
5221 {
5222 const int flags = info->flags;
5223 const Uint32 modulateR = info->r;
5224 const Uint32 modulateG = info->g;
5225 const Uint32 modulateB = info->b;
5226 const Uint32 modulateA = info->a;
5227 Uint32 srcpixel;
5228 Uint32 srcR, srcG, srcB, srcA;
5229 Uint32 dstpixel;
5230 Uint32 dstR, dstG, dstB, dstA;
5231
5232 while (info->dst_h--) {
5233 Uint32 *src = (Uint32 *)info->src;
5234 Uint32 *dst = (Uint32 *)info->dst;
5235 int n = info->dst_w;
5236 while (n--) {
5237 srcpixel = *src;
5238 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5239 dstpixel = *dst;
5240 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
5241 if (flags & SDL_COPY_MODULATE_COLOR) {
5242 srcR = (srcR * modulateR) / 255;
5243 srcG = (srcG * modulateG) / 255;
5244 srcB = (srcB * modulateB) / 255;
5245 }
5246 if (flags & SDL_COPY_MODULATE_ALPHA) {
5247 srcA = (srcA * modulateA) / 255;
5248 }
5249 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5250 /* This goes away if we ever use premultiplied alpha */
5251 if (srcA < 255) {
5252 srcR = (srcR * srcA) / 255;
5253 srcG = (srcG * srcA) / 255;
5254 srcB = (srcB * srcA) / 255;
5255 }
5256 }
5257 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5258 case SDL_COPY_BLEND:
5259 dstR = srcR + ((255 - srcA) * dstR) / 255;
5260 dstG = srcG + ((255 - srcA) * dstG) / 255;
5261 dstB = srcB + ((255 - srcA) * dstB) / 255;
5262 dstA = srcA + ((255 - srcA) * dstA) / 255;
5263 break;
5264 case SDL_COPY_ADD:
5265 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5266 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5267 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5268 break;
5269 case SDL_COPY_MOD:
5270 dstR = (srcR * dstR) / 255;
5271 dstG = (srcG * dstG) / 255;
5272 dstB = (srcB * dstB) / 255;
5273 break;
5274 }
5275 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
5276 *dst = dstpixel;
5277 ++src;
5278 ++dst;
5279 }
5280 info->src += info->src_pitch;
5281 info->dst += info->dst_pitch;
5282 }
5283 }
5284
5285 static void SDL_Blit_ABGR8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
5286 {
5287 const int flags = info->flags;
5288 const Uint32 modulateR = info->r;
5289 const Uint32 modulateG = info->g;
5290 const Uint32 modulateB = info->b;
5291 const Uint32 modulateA = info->a;
5292 Uint32 srcpixel;
5293 Uint32 srcR, srcG, srcB, srcA;
5294 Uint32 dstpixel;
5295 Uint32 dstR, dstG, dstB, dstA;
5296 int srcy, srcx;
5297 int posy, posx;
5298 int incy, incx;
5299
5300 srcy = 0;
5301 posy = 0;
5302 incy = (info->src_h << 16) / info->dst_h;
5303 incx = (info->src_w << 16) / info->dst_w;
5304
5305 while (info->dst_h--) {
5306 Uint32 *src = 0;
5307 Uint32 *dst = (Uint32 *)info->dst;
5308 int n = info->dst_w;
5309 srcx = -1;
5310 posx = 0x10000L;
5311 while (posy >= 0x10000L) {
5312 ++srcy;
5313 posy -= 0x10000L;
5314 }
5315 while (n--) {
5316 if (posx >= 0x10000L) {
5317 while (posx >= 0x10000L) {
5318 ++srcx;
5319 posx -= 0x10000L;
5320 }
5321 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5322 }
5323 srcpixel = *src;
5324 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5325 dstpixel = *dst;
5326 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
5327 if (flags & SDL_COPY_MODULATE_COLOR) {
5328 srcR = (srcR * modulateR) / 255;
5329 srcG = (srcG * modulateG) / 255;
5330 srcB = (srcB * modulateB) / 255;
5331 }
5332 if (flags & SDL_COPY_MODULATE_ALPHA) {
5333 srcA = (srcA * modulateA) / 255;
5334 }
5335 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5336 /* This goes away if we ever use premultiplied alpha */
5337 if (srcA < 255) {
5338 srcR = (srcR * srcA) / 255;
5339 srcG = (srcG * srcA) / 255;
5340 srcB = (srcB * srcA) / 255;
5341 }
5342 }
5343 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5344 case SDL_COPY_BLEND:
5345 dstR = srcR + ((255 - srcA) * dstR) / 255;
5346 dstG = srcG + ((255 - srcA) * dstG) / 255;
5347 dstB = srcB + ((255 - srcA) * dstB) / 255;
5348 dstA = srcA + ((255 - srcA) * dstA) / 255;
5349 break;
5350 case SDL_COPY_ADD:
5351 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5352 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5353 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5354 break;
5355 case SDL_COPY_MOD:
5356 dstR = (srcR * dstR) / 255;
5357 dstG = (srcG * dstG) / 255;
5358 dstB = (srcB * dstB) / 255;
5359 break;
5360 }
5361 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
5362 *dst = dstpixel;
5363 posx += incx;
5364 ++dst;
5365 }
5366 posy += incy;
5367 info->dst += info->dst_pitch;
5368 }
5369 }
5370
5371 static void SDL_Blit_ABGR8888_BGR888_Scale(SDL_BlitInfo *info)
5372 {
5373 Uint32 pixel;
5374 Uint32 R, G, B, A;
5375 int srcy, srcx;
5376 int posy, posx;
5377 int incy, incx;
5378
5379 srcy = 0;
5380 posy = 0;
5381 incy = (info->src_h << 16) / info->dst_h;
5382 incx = (info->src_w << 16) / info->dst_w;
5383
5384 while (info->dst_h--) {
5385 Uint32 *src = 0;
5386 Uint32 *dst = (Uint32 *)info->dst;
5387 int n = info->dst_w;
5388 srcx = -1;
5389 posx = 0x10000L;
5390 while (posy >= 0x10000L) {
5391 ++srcy;
5392 posy -= 0x10000L;
5393 }
5394 while (n--) {
5395 if (posx >= 0x10000L) {
5396 while (posx >= 0x10000L) {
5397 ++srcx;
5398 posx -= 0x10000L;
5399 }
5400 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5401 }
5402 pixel = *src;
5403 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5404 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
5405 *dst = pixel;
5406 posx += incx;
5407 ++dst;
5408 }
5409 posy += incy;
5410 info->dst += info->dst_pitch;
5411 }
5412 }
5413
5414 static void SDL_Blit_ABGR8888_BGR888_Blend(SDL_BlitInfo *info)
5415 {
5416 const int flags = info->flags;
5417 Uint32 srcpixel;
5418 Uint32 srcR, srcG, srcB, srcA;
5419 Uint32 dstpixel;
5420 Uint32 dstR, dstG, dstB, dstA;
5421
5422 while (info->dst_h--) {
5423 Uint32 *src = (Uint32 *)info->src;
5424 Uint32 *dst = (Uint32 *)info->dst;
5425 int n = info->dst_w;
5426 while (n--) {
5427 srcpixel = *src;
5428 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5429 dstpixel = *dst;
5430 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
5431 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5432 /* This goes away if we ever use premultiplied alpha */
5433 if (srcA < 255) {
5434 srcR = (srcR * srcA) / 255;
5435 srcG = (srcG * srcA) / 255;
5436 srcB = (srcB * srcA) / 255;
5437 }
5438 }
5439 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5440 case SDL_COPY_BLEND:
5441 dstR = srcR + ((255 - srcA) * dstR) / 255;
5442 dstG = srcG + ((255 - srcA) * dstG) / 255;
5443 dstB = srcB + ((255 - srcA) * dstB) / 255;
5444 dstA = srcA + ((255 - srcA) * dstA) / 255;
5445 break;
5446 case SDL_COPY_ADD:
5447 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5448 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5449 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5450 break;
5451 case SDL_COPY_MOD:
5452 dstR = (srcR * dstR) / 255;
5453 dstG = (srcG * dstG) / 255;
5454 dstB = (srcB * dstB) / 255;
5455 break;
5456 }
5457 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
5458 *dst = dstpixel;
5459 ++src;
5460 ++dst;
5461 }
5462 info->src += info->src_pitch;
5463 info->dst += info->dst_pitch;
5464 }
5465 }
5466
5467 static void SDL_Blit_ABGR8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
5468 {
5469 const int flags = info->flags;
5470 Uint32 srcpixel;
5471 Uint32 srcR, srcG, srcB, srcA;
5472 Uint32 dstpixel;
5473 Uint32 dstR, dstG, dstB, dstA;
5474 int srcy, srcx;
5475 int posy, posx;
5476 int incy, incx;
5477
5478 srcy = 0;
5479 posy = 0;
5480 incy = (info->src_h << 16) / info->dst_h;
5481 incx = (info->src_w << 16) / info->dst_w;
5482
5483 while (info->dst_h--) {
5484 Uint32 *src = 0;
5485 Uint32 *dst = (Uint32 *)info->dst;
5486 int n = info->dst_w;
5487 srcx = -1;
5488 posx = 0x10000L;
5489 while (posy >= 0x10000L) {
5490 ++srcy;
5491 posy -= 0x10000L;
5492 }
5493 while (n--) {
5494 if (posx >= 0x10000L) {
5495 while (posx >= 0x10000L) {
5496 ++srcx;
5497 posx -= 0x10000L;
5498 }
5499 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5500 }
5501 srcpixel = *src;
5502 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5503 dstpixel = *dst;
5504 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
5505 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5506 /* This goes away if we ever use premultiplied alpha */
5507 if (srcA < 255) {
5508 srcR = (srcR * srcA) / 255;
5509 srcG = (srcG * srcA) / 255;
5510 srcB = (srcB * srcA) / 255;
5511 }
5512 }
5513 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5514 case SDL_COPY_BLEND:
5515 dstR = srcR + ((255 - srcA) * dstR) / 255;
5516 dstG = srcG + ((255 - srcA) * dstG) / 255;
5517 dstB = srcB + ((255 - srcA) * dstB) / 255;
5518 dstA = srcA + ((255 - srcA) * dstA) / 255;
5519 break;
5520 case SDL_COPY_ADD:
5521 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5522 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5523 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5524 break;
5525 case SDL_COPY_MOD:
5526 dstR = (srcR * dstR) / 255;
5527 dstG = (srcG * dstG) / 255;
5528 dstB = (srcB * dstB) / 255;
5529 break;
5530 }
5531 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
5532 *dst = dstpixel;
5533 posx += incx;
5534 ++dst;
5535 }
5536 posy += incy;
5537 info->dst += info->dst_pitch;
5538 }
5539 }
5540
5541 static void SDL_Blit_ABGR8888_BGR888_Modulate(SDL_BlitInfo *info)
5542 {
5543 const int flags = info->flags;
5544 const Uint32 modulateR = info->r;
5545 const Uint32 modulateG = info->g;
5546 const Uint32 modulateB = info->b;
5547 const Uint32 modulateA = info->a;
5548 Uint32 pixel;
5549 Uint32 R, G, B, A;
5550
5551 while (info->dst_h--) {
5552 Uint32 *src = (Uint32 *)info->src;
5553 Uint32 *dst = (Uint32 *)info->dst;
5554 int n = info->dst_w;
5555 while (n--) {
5556 pixel = *src;
5557 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5558 if (flags & SDL_COPY_MODULATE_COLOR) {
5559 R = (R * modulateR) / 255;
5560 G = (G * modulateG) / 255;
5561 B = (B * modulateB) / 255;
5562 }
5563 if (flags & SDL_COPY_MODULATE_ALPHA) {
5564 A = (A * modulateA) / 255;
5565 }
5566 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
5567 *dst = pixel;
5568 ++src;
5569 ++dst;
5570 }
5571 info->src += info->src_pitch;
5572 info->dst += info->dst_pitch;
5573 }
5574 }
5575
5576 static void SDL_Blit_ABGR8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
5577 {
5578 const int flags = info->flags;
5579 const Uint32 modulateR = info->r;
5580 const Uint32 modulateG = info->g;
5581 const Uint32 modulateB = info->b;
5582 const Uint32 modulateA = info->a;
5583 Uint32 pixel;
5584 Uint32 R, G, B, A;
5585 int srcy, srcx;
5586 int posy, posx;
5587 int incy, incx;
5588
5589 srcy = 0;
5590 posy = 0;
5591 incy = (info->src_h << 16) / info->dst_h;
5592 incx = (info->src_w << 16) / info->dst_w;
5593
5594 while (info->dst_h--) {
5595 Uint32 *src = 0;
5596 Uint32 *dst = (Uint32 *)info->dst;
5597 int n = info->dst_w;
5598 srcx = -1;
5599 posx = 0x10000L;
5600 while (posy >= 0x10000L) {
5601 ++srcy;
5602 posy -= 0x10000L;
5603 }
5604 while (n--) {
5605 if (posx >= 0x10000L) {
5606 while (posx >= 0x10000L) {
5607 ++srcx;
5608 posx -= 0x10000L;
5609 }
5610 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5611 }
5612 pixel = *src;
5613 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5614 if (flags & SDL_COPY_MODULATE_COLOR) {
5615 R = (R * modulateR) / 255;
5616 G = (G * modulateG) / 255;
5617 B = (B * modulateB) / 255;
5618 }
5619 if (flags & SDL_COPY_MODULATE_ALPHA) {
5620 A = (A * modulateA) / 255;
5621 }
5622 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
5623 *dst = pixel;
5624 posx += incx;
5625 ++dst;
5626 }
5627 posy += incy;
5628 info->dst += info->dst_pitch;
5629 }
5630 }
5631
5632 static void SDL_Blit_ABGR8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
5633 {
5634 const int flags = info->flags;
5635 const Uint32 modulateR = info->r;
5636 const Uint32 modulateG = info->g;
5637 const Uint32 modulateB = info->b;
5638 const Uint32 modulateA = info->a;
5639 Uint32 srcpixel;
5640 Uint32 srcR, srcG, srcB, srcA;
5641 Uint32 dstpixel;
5642 Uint32 dstR, dstG, dstB, dstA;
5643
5644 while (info->dst_h--) {
5645 Uint32 *src = (Uint32 *)info->src;
5646 Uint32 *dst = (Uint32 *)info->dst;
5647 int n = info->dst_w;
5648 while (n--) {
5649 srcpixel = *src;
5650 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5651 dstpixel = *dst;
5652 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
5653 if (flags & SDL_COPY_MODULATE_COLOR) {
5654 srcR = (srcR * modulateR) / 255;
5655 srcG = (srcG * modulateG) / 255;
5656 srcB = (srcB * modulateB) / 255;
5657 }
5658 if (flags & SDL_COPY_MODULATE_ALPHA) {
5659 srcA = (srcA * modulateA) / 255;
5660 }
5661 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5662 /* This goes away if we ever use premultiplied alpha */
5663 if (srcA < 255) {
5664 srcR = (srcR * srcA) / 255;
5665 srcG = (srcG * srcA) / 255;
5666 srcB = (srcB * srcA) / 255;
5667 }
5668 }
5669 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5670 case SDL_COPY_BLEND:
5671 dstR = srcR + ((255 - srcA) * dstR) / 255;
5672 dstG = srcG + ((255 - srcA) * dstG) / 255;
5673 dstB = srcB + ((255 - srcA) * dstB) / 255;
5674 dstA = srcA + ((255 - srcA) * dstA) / 255;
5675 break;
5676 case SDL_COPY_ADD:
5677 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5678 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5679 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5680 break;
5681 case SDL_COPY_MOD:
5682 dstR = (srcR * dstR) / 255;
5683 dstG = (srcG * dstG) / 255;
5684 dstB = (srcB * dstB) / 255;
5685 break;
5686 }
5687 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
5688 *dst = dstpixel;
5689 ++src;
5690 ++dst;
5691 }
5692 info->src += info->src_pitch;
5693 info->dst += info->dst_pitch;
5694 }
5695 }
5696
5697 static void SDL_Blit_ABGR8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
5698 {
5699 const int flags = info->flags;
5700 const Uint32 modulateR = info->r;
5701 const Uint32 modulateG = info->g;
5702 const Uint32 modulateB = info->b;
5703 const Uint32 modulateA = info->a;
5704 Uint32 srcpixel;
5705 Uint32 srcR, srcG, srcB, srcA;
5706 Uint32 dstpixel;
5707 Uint32 dstR, dstG, dstB, dstA;
5708 int srcy, srcx;
5709 int posy, posx;
5710 int incy, incx;
5711
5712 srcy = 0;
5713 posy = 0;
5714 incy = (info->src_h << 16) / info->dst_h;
5715 incx = (info->src_w << 16) / info->dst_w;
5716
5717 while (info->dst_h--) {
5718 Uint32 *src = 0;
5719 Uint32 *dst = (Uint32 *)info->dst;
5720 int n = info->dst_w;
5721 srcx = -1;
5722 posx = 0x10000L;
5723 while (posy >= 0x10000L) {
5724 ++srcy;
5725 posy -= 0x10000L;
5726 }
5727 while (n--) {
5728 if (posx >= 0x10000L) {
5729 while (posx >= 0x10000L) {
5730 ++srcx;
5731 posx -= 0x10000L;
5732 }
5733 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5734 }
5735 srcpixel = *src;
5736 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5737 dstpixel = *dst;
5738 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
5739 if (flags & SDL_COPY_MODULATE_COLOR) {
5740 srcR = (srcR * modulateR) / 255;
5741 srcG = (srcG * modulateG) / 255;
5742 srcB = (srcB * modulateB) / 255;
5743 }
5744 if (flags & SDL_COPY_MODULATE_ALPHA) {
5745 srcA = (srcA * modulateA) / 255;
5746 }
5747 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5748 /* This goes away if we ever use premultiplied alpha */
5749 if (srcA < 255) {
5750 srcR = (srcR * srcA) / 255;
5751 srcG = (srcG * srcA) / 255;
5752 srcB = (srcB * srcA) / 255;
5753 }
5754 }
5755 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5756 case SDL_COPY_BLEND:
5757 dstR = srcR + ((255 - srcA) * dstR) / 255;
5758 dstG = srcG + ((255 - srcA) * dstG) / 255;
5759 dstB = srcB + ((255 - srcA) * dstB) / 255;
5760 dstA = srcA + ((255 - srcA) * dstA) / 255;
5761 break;
5762 case SDL_COPY_ADD:
5763 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5764 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5765 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5766 break;
5767 case SDL_COPY_MOD:
5768 dstR = (srcR * dstR) / 255;
5769 dstG = (srcG * dstG) / 255;
5770 dstB = (srcB * dstB) / 255;
5771 break;
5772 }
5773 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
5774 *dst = dstpixel;
5775 posx += incx;
5776 ++dst;
5777 }
5778 posy += incy;
5779 info->dst += info->dst_pitch;
5780 }
5781 }
5782
5783 static void SDL_Blit_ABGR8888_ARGB8888_Scale(SDL_BlitInfo *info)
5784 {
5785 Uint32 pixel;
5786 Uint32 R, G, B, A;
5787 int srcy, srcx;
5788 int posy, posx;
5789 int incy, incx;
5790
5791 srcy = 0;
5792 posy = 0;
5793 incy = (info->src_h << 16) / info->dst_h;
5794 incx = (info->src_w << 16) / info->dst_w;
5795
5796 while (info->dst_h--) {
5797 Uint32 *src = 0;
5798 Uint32 *dst = (Uint32 *)info->dst;
5799 int n = info->dst_w;
5800 srcx = -1;
5801 posx = 0x10000L;
5802 while (posy >= 0x10000L) {
5803 ++srcy;
5804 posy -= 0x10000L;
5805 }
5806 while (n--) {
5807 if (posx >= 0x10000L) {
5808 while (posx >= 0x10000L) {
5809 ++srcx;
5810 posx -= 0x10000L;
5811 }
5812 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5813 }
5814 pixel = *src;
5815 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5816 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
5817 *dst = pixel;
5818 posx += incx;
5819 ++dst;
5820 }
5821 posy += incy;
5822 info->dst += info->dst_pitch;
5823 }
5824 }
5825
5826 static void SDL_Blit_ABGR8888_ARGB8888_Blend(SDL_BlitInfo *info)
5827 {
5828 const int flags = info->flags;
5829 Uint32 srcpixel;
5830 Uint32 srcR, srcG, srcB, srcA;
5831 Uint32 dstpixel;
5832 Uint32 dstR, dstG, dstB, dstA;
5833
5834 while (info->dst_h--) {
5835 Uint32 *src = (Uint32 *)info->src;
5836 Uint32 *dst = (Uint32 *)info->dst;
5837 int n = info->dst_w;
5838 while (n--) {
5839 srcpixel = *src;
5840 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5841 dstpixel = *dst;
5842 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
5843 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5844 /* This goes away if we ever use premultiplied alpha */
5845 if (srcA < 255) {
5846 srcR = (srcR * srcA) / 255;
5847 srcG = (srcG * srcA) / 255;
5848 srcB = (srcB * srcA) / 255;
5849 }
5850 }
5851 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5852 case SDL_COPY_BLEND:
5853 dstR = srcR + ((255 - srcA) * dstR) / 255;
5854 dstG = srcG + ((255 - srcA) * dstG) / 255;
5855 dstB = srcB + ((255 - srcA) * dstB) / 255;
5856 dstA = srcA + ((255 - srcA) * dstA) / 255;
5857 break;
5858 case SDL_COPY_ADD:
5859 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5860 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5861 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5862 break;
5863 case SDL_COPY_MOD:
5864 dstR = (srcR * dstR) / 255;
5865 dstG = (srcG * dstG) / 255;
5866 dstB = (srcB * dstB) / 255;
5867 break;
5868 }
5869 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
5870 *dst = dstpixel;
5871 ++src;
5872 ++dst;
5873 }
5874 info->src += info->src_pitch;
5875 info->dst += info->dst_pitch;
5876 }
5877 }
5878
5879 static void SDL_Blit_ABGR8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
5880 {
5881 const int flags = info->flags;
5882 Uint32 srcpixel;
5883 Uint32 srcR, srcG, srcB, srcA;
5884 Uint32 dstpixel;
5885 Uint32 dstR, dstG, dstB, dstA;
5886 int srcy, srcx;
5887 int posy, posx;
5888 int incy, incx;
5889
5890 srcy = 0;
5891 posy = 0;
5892 incy = (info->src_h << 16) / info->dst_h;
5893 incx = (info->src_w << 16) / info->dst_w;
5894
5895 while (info->dst_h--) {
5896 Uint32 *src = 0;
5897 Uint32 *dst = (Uint32 *)info->dst;
5898 int n = info->dst_w;
5899 srcx = -1;
5900 posx = 0x10000L;
5901 while (posy >= 0x10000L) {
5902 ++srcy;
5903 posy -= 0x10000L;
5904 }
5905 while (n--) {
5906 if (posx >= 0x10000L) {
5907 while (posx >= 0x10000L) {
5908 ++srcx;
5909 posx -= 0x10000L;
5910 }
5911 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
5912 }
5913 srcpixel = *src;
5914 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
5915 dstpixel = *dst;
5916 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
5917 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
5918 /* This goes away if we ever use premultiplied alpha */
5919 if (srcA < 255) {
5920 srcR = (srcR * srcA) / 255;
5921 srcG = (srcG * srcA) / 255;
5922 srcB = (srcB * srcA) / 255;
5923 }
5924 }
5925 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
5926 case SDL_COPY_BLEND:
5927 dstR = srcR + ((255 - srcA) * dstR) / 255;
5928 dstG = srcG + ((255 - srcA) * dstG) / 255;
5929 dstB = srcB + ((255 - srcA) * dstB) / 255;
5930 dstA = srcA + ((255 - srcA) * dstA) / 255;
5931 break;
5932 case SDL_COPY_ADD:
5933 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
5934 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
5935 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
5936 break;
5937 case SDL_COPY_MOD:
5938 dstR = (srcR * dstR) / 255;
5939 dstG = (srcG * dstG) / 255;
5940 dstB = (srcB * dstB) / 255;
5941 break;
5942 }
5943 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
5944 *dst = dstpixel;
5945 posx += incx;
5946 ++dst;
5947 }
5948 posy += incy;
5949 info->dst += info->dst_pitch;
5950 }
5951 }
5952
5953 static void SDL_Blit_ABGR8888_ARGB8888_Modulate(SDL_BlitInfo *info)
5954 {
5955 const int flags = info->flags;
5956 const Uint32 modulateR = info->r;
5957 const Uint32 modulateG = info->g;
5958 const Uint32 modulateB = info->b;
5959 const Uint32 modulateA = info->a;
5960 Uint32 pixel;
5961 Uint32 R, G, B, A;
5962
5963 while (info->dst_h--) {
5964 Uint32 *src = (Uint32 *)info->src;
5965 Uint32 *dst = (Uint32 *)info->dst;
5966 int n = info->dst_w;
5967 while (n--) {
5968 pixel = *src;
5969 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
5970 if (flags & SDL_COPY_MODULATE_COLOR) {
5971 R = (R * modulateR) / 255;
5972 G = (G * modulateG) / 255;
5973 B = (B * modulateB) / 255;
5974 }
5975 if (flags & SDL_COPY_MODULATE_ALPHA) {
5976 A = (A * modulateA) / 255;
5977 }
5978 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
5979 *dst = pixel;
5980 ++src;
5981 ++dst;
5982 }
5983 info->src += info->src_pitch;
5984 info->dst += info->dst_pitch;
5985 }
5986 }
5987
5988 static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
5989 {
5990 const int flags = info->flags;
5991 const Uint32 modulateR = info->r;
5992 const Uint32 modulateG = info->g;
5993 const Uint32 modulateB = info->b;
5994 const Uint32 modulateA = info->a;
5995 Uint32 pixel;
5996 Uint32 R, G, B, A;
5997 int srcy, srcx;
5998 int posy, posx;
5999 int incy, incx;
6000
6001 srcy = 0;
6002 posy = 0;
6003 incy = (info->src_h << 16) / info->dst_h;
6004 incx = (info->src_w << 16) / info->dst_w;
6005
6006 while (info->dst_h--) {
6007 Uint32 *src = 0;
6008 Uint32 *dst = (Uint32 *)info->dst;
6009 int n = info->dst_w;
6010 srcx = -1;
6011 posx = 0x10000L;
6012 while (posy >= 0x10000L) {
6013 ++srcy;
6014 posy -= 0x10000L;
6015 }
6016 while (n--) {
6017 if (posx >= 0x10000L) {
6018 while (posx >= 0x10000L) {
6019 ++srcx;
6020 posx -= 0x10000L;
6021 }
6022 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6023 }
6024 pixel = *src;
6025 A = (Uint8)(pixel >> 24); B = (Uint8)(pixel >> 16); G = (Uint8)(pixel >> 8); R = (Uint8)pixel;
6026 if (flags & SDL_COPY_MODULATE_COLOR) {
6027 R = (R * modulateR) / 255;
6028 G = (G * modulateG) / 255;
6029 B = (B * modulateB) / 255;
6030 }
6031 if (flags & SDL_COPY_MODULATE_ALPHA) {
6032 A = (A * modulateA) / 255;
6033 }
6034 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
6035 *dst = pixel;
6036 posx += incx;
6037 ++dst;
6038 }
6039 posy += incy;
6040 info->dst += info->dst_pitch;
6041 }
6042 }
6043
6044 static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
6045 {
6046 const int flags = info->flags;
6047 const Uint32 modulateR = info->r;
6048 const Uint32 modulateG = info->g;
6049 const Uint32 modulateB = info->b;
6050 const Uint32 modulateA = info->a;
6051 Uint32 srcpixel;
6052 Uint32 srcR, srcG, srcB, srcA;
6053 Uint32 dstpixel;
6054 Uint32 dstR, dstG, dstB, dstA;
6055
6056 while (info->dst_h--) {
6057 Uint32 *src = (Uint32 *)info->src;
6058 Uint32 *dst = (Uint32 *)info->dst;
6059 int n = info->dst_w;
6060 while (n--) {
6061 srcpixel = *src;
6062 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
6063 dstpixel = *dst;
6064 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
6065 if (flags & SDL_COPY_MODULATE_COLOR) {
6066 srcR = (srcR * modulateR) / 255;
6067 srcG = (srcG * modulateG) / 255;
6068 srcB = (srcB * modulateB) / 255;
6069 }
6070 if (flags & SDL_COPY_MODULATE_ALPHA) {
6071 srcA = (srcA * modulateA) / 255;
6072 }
6073 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6074 /* This goes away if we ever use premultiplied alpha */
6075 if (srcA < 255) {
6076 srcR = (srcR * srcA) / 255;
6077 srcG = (srcG * srcA) / 255;
6078 srcB = (srcB * srcA) / 255;
6079 }
6080 }
6081 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6082 case SDL_COPY_BLEND:
6083 dstR = srcR + ((255 - srcA) * dstR) / 255;
6084 dstG = srcG + ((255 - srcA) * dstG) / 255;
6085 dstB = srcB + ((255 - srcA) * dstB) / 255;
6086 dstA = srcA + ((255 - srcA) * dstA) / 255;
6087 break;
6088 case SDL_COPY_ADD:
6089 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6090 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6091 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6092 break;
6093 case SDL_COPY_MOD:
6094 dstR = (srcR * dstR) / 255;
6095 dstG = (srcG * dstG) / 255;
6096 dstB = (srcB * dstB) / 255;
6097 break;
6098 }
6099 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
6100 *dst = dstpixel;
6101 ++src;
6102 ++dst;
6103 }
6104 info->src += info->src_pitch;
6105 info->dst += info->dst_pitch;
6106 }
6107 }
6108
6109 static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
6110 {
6111 const int flags = info->flags;
6112 const Uint32 modulateR = info->r;
6113 const Uint32 modulateG = info->g;
6114 const Uint32 modulateB = info->b;
6115 const Uint32 modulateA = info->a;
6116 Uint32 srcpixel;
6117 Uint32 srcR, srcG, srcB, srcA;
6118 Uint32 dstpixel;
6119 Uint32 dstR, dstG, dstB, dstA;
6120 int srcy, srcx;
6121 int posy, posx;
6122 int incy, incx;
6123
6124 srcy = 0;
6125 posy = 0;
6126 incy = (info->src_h << 16) / info->dst_h;
6127 incx = (info->src_w << 16) / info->dst_w;
6128
6129 while (info->dst_h--) {
6130 Uint32 *src = 0;
6131 Uint32 *dst = (Uint32 *)info->dst;
6132 int n = info->dst_w;
6133 srcx = -1;
6134 posx = 0x10000L;
6135 while (posy >= 0x10000L) {
6136 ++srcy;
6137 posy -= 0x10000L;
6138 }
6139 while (n--) {
6140 if (posx >= 0x10000L) {
6141 while (posx >= 0x10000L) {
6142 ++srcx;
6143 posx -= 0x10000L;
6144 }
6145 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6146 }
6147 srcpixel = *src;
6148 srcA = (Uint8)(srcpixel >> 24); srcB = (Uint8)(srcpixel >> 16); srcG = (Uint8)(srcpixel >> 8); srcR = (Uint8)srcpixel;
6149 dstpixel = *dst;
6150 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
6151 if (flags & SDL_COPY_MODULATE_COLOR) {
6152 srcR = (srcR * modulateR) / 255;
6153 srcG = (srcG * modulateG) / 255;
6154 srcB = (srcB * modulateB) / 255;
6155 }
6156 if (flags & SDL_COPY_MODULATE_ALPHA) {
6157 srcA = (srcA * modulateA) / 255;
6158 }
6159 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6160 /* This goes away if we ever use premultiplied alpha */
6161 if (srcA < 255) {
6162 srcR = (srcR * srcA) / 255;
6163 srcG = (srcG * srcA) / 255;
6164 srcB = (srcB * srcA) / 255;
6165 }
6166 }
6167 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6168 case SDL_COPY_BLEND:
6169 dstR = srcR + ((255 - srcA) * dstR) / 255;
6170 dstG = srcG + ((255 - srcA) * dstG) / 255;
6171 dstB = srcB + ((255 - srcA) * dstB) / 255;
6172 dstA = srcA + ((255 - srcA) * dstA) / 255;
6173 break;
6174 case SDL_COPY_ADD:
6175 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6176 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6177 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6178 break;
6179 case SDL_COPY_MOD:
6180 dstR = (srcR * dstR) / 255;
6181 dstG = (srcG * dstG) / 255;
6182 dstB = (srcB * dstB) / 255;
6183 break;
6184 }
6185 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
6186 *dst = dstpixel;
6187 posx += incx;
6188 ++dst;
6189 }
6190 posy += incy;
6191 info->dst += info->dst_pitch;
6192 }
6193 }
6194
6195 static void SDL_Blit_BGRA8888_RGB888_Scale(SDL_BlitInfo *info)
6196 {
6197 Uint32 pixel;
6198 Uint32 R, G, B, A;
6199 int srcy, srcx;
6200 int posy, posx;
6201 int incy, incx;
6202
6203 srcy = 0;
6204 posy = 0;
6205 incy = (info->src_h << 16) / info->dst_h;
6206 incx = (info->src_w << 16) / info->dst_w;
6207
6208 while (info->dst_h--) {
6209 Uint32 *src = 0;
6210 Uint32 *dst = (Uint32 *)info->dst;
6211 int n = info->dst_w;
6212 srcx = -1;
6213 posx = 0x10000L;
6214 while (posy >= 0x10000L) {
6215 ++srcy;
6216 posy -= 0x10000L;
6217 }
6218 while (n--) {
6219 if (posx >= 0x10000L) {
6220 while (posx >= 0x10000L) {
6221 ++srcx;
6222 posx -= 0x10000L;
6223 }
6224 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6225 }
6226 pixel = *src;
6227 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
6228 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
6229 *dst = pixel;
6230 posx += incx;
6231 ++dst;
6232 }
6233 posy += incy;
6234 info->dst += info->dst_pitch;
6235 }
6236 }
6237
6238 static void SDL_Blit_BGRA8888_RGB888_Blend(SDL_BlitInfo *info)
6239 {
6240 const int flags = info->flags;
6241 Uint32 srcpixel;
6242 Uint32 srcR, srcG, srcB, srcA;
6243 Uint32 dstpixel;
6244 Uint32 dstR, dstG, dstB, dstA;
6245
6246 while (info->dst_h--) {
6247 Uint32 *src = (Uint32 *)info->src;
6248 Uint32 *dst = (Uint32 *)info->dst;
6249 int n = info->dst_w;
6250 while (n--) {
6251 srcpixel = *src;
6252 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6253 dstpixel = *dst;
6254 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
6255 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6256 /* This goes away if we ever use premultiplied alpha */
6257 if (srcA < 255) {
6258 srcR = (srcR * srcA) / 255;
6259 srcG = (srcG * srcA) / 255;
6260 srcB = (srcB * srcA) / 255;
6261 }
6262 }
6263 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6264 case SDL_COPY_BLEND:
6265 dstR = srcR + ((255 - srcA) * dstR) / 255;
6266 dstG = srcG + ((255 - srcA) * dstG) / 255;
6267 dstB = srcB + ((255 - srcA) * dstB) / 255;
6268 dstA = srcA + ((255 - srcA) * dstA) / 255;
6269 break;
6270 case SDL_COPY_ADD:
6271 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6272 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6273 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6274 break;
6275 case SDL_COPY_MOD:
6276 dstR = (srcR * dstR) / 255;
6277 dstG = (srcG * dstG) / 255;
6278 dstB = (srcB * dstB) / 255;
6279 break;
6280 }
6281 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
6282 *dst = dstpixel;
6283 ++src;
6284 ++dst;
6285 }
6286 info->src += info->src_pitch;
6287 info->dst += info->dst_pitch;
6288 }
6289 }
6290
6291 static void SDL_Blit_BGRA8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
6292 {
6293 const int flags = info->flags;
6294 Uint32 srcpixel;
6295 Uint32 srcR, srcG, srcB, srcA;
6296 Uint32 dstpixel;
6297 Uint32 dstR, dstG, dstB, dstA;
6298 int srcy, srcx;
6299 int posy, posx;
6300 int incy, incx;
6301
6302 srcy = 0;
6303 posy = 0;
6304 incy = (info->src_h << 16) / info->dst_h;
6305 incx = (info->src_w << 16) / info->dst_w;
6306
6307 while (info->dst_h--) {
6308 Uint32 *src = 0;
6309 Uint32 *dst = (Uint32 *)info->dst;
6310 int n = info->dst_w;
6311 srcx = -1;
6312 posx = 0x10000L;
6313 while (posy >= 0x10000L) {
6314 ++srcy;
6315 posy -= 0x10000L;
6316 }
6317 while (n--) {
6318 if (posx >= 0x10000L) {
6319 while (posx >= 0x10000L) {
6320 ++srcx;
6321 posx -= 0x10000L;
6322 }
6323 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6324 }
6325 srcpixel = *src;
6326 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6327 dstpixel = *dst;
6328 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
6329 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6330 /* This goes away if we ever use premultiplied alpha */
6331 if (srcA < 255) {
6332 srcR = (srcR * srcA) / 255;
6333 srcG = (srcG * srcA) / 255;
6334 srcB = (srcB * srcA) / 255;
6335 }
6336 }
6337 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6338 case SDL_COPY_BLEND:
6339 dstR = srcR + ((255 - srcA) * dstR) / 255;
6340 dstG = srcG + ((255 - srcA) * dstG) / 255;
6341 dstB = srcB + ((255 - srcA) * dstB) / 255;
6342 dstA = srcA + ((255 - srcA) * dstA) / 255;
6343 break;
6344 case SDL_COPY_ADD:
6345 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6346 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6347 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6348 break;
6349 case SDL_COPY_MOD:
6350 dstR = (srcR * dstR) / 255;
6351 dstG = (srcG * dstG) / 255;
6352 dstB = (srcB * dstB) / 255;
6353 break;
6354 }
6355 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
6356 *dst = dstpixel;
6357 posx += incx;
6358 ++dst;
6359 }
6360 posy += incy;
6361 info->dst += info->dst_pitch;
6362 }
6363 }
6364
6365 static void SDL_Blit_BGRA8888_RGB888_Modulate(SDL_BlitInfo *info)
6366 {
6367 const int flags = info->flags;
6368 const Uint32 modulateR = info->r;
6369 const Uint32 modulateG = info->g;
6370 const Uint32 modulateB = info->b;
6371 const Uint32 modulateA = info->a;
6372 Uint32 pixel;
6373 Uint32 R, G, B, A;
6374
6375 while (info->dst_h--) {
6376 Uint32 *src = (Uint32 *)info->src;
6377 Uint32 *dst = (Uint32 *)info->dst;
6378 int n = info->dst_w;
6379 while (n--) {
6380 pixel = *src;
6381 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
6382 if (flags & SDL_COPY_MODULATE_COLOR) {
6383 R = (R * modulateR) / 255;
6384 G = (G * modulateG) / 255;
6385 B = (B * modulateB) / 255;
6386 }
6387 if (flags & SDL_COPY_MODULATE_ALPHA) {
6388 A = (A * modulateA) / 255;
6389 }
6390 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
6391 *dst = pixel;
6392 ++src;
6393 ++dst;
6394 }
6395 info->src += info->src_pitch;
6396 info->dst += info->dst_pitch;
6397 }
6398 }
6399
6400 static void SDL_Blit_BGRA8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
6401 {
6402 const int flags = info->flags;
6403 const Uint32 modulateR = info->r;
6404 const Uint32 modulateG = info->g;
6405 const Uint32 modulateB = info->b;
6406 const Uint32 modulateA = info->a;
6407 Uint32 pixel;
6408 Uint32 R, G, B, A;
6409 int srcy, srcx;
6410 int posy, posx;
6411 int incy, incx;
6412
6413 srcy = 0;
6414 posy = 0;
6415 incy = (info->src_h << 16) / info->dst_h;
6416 incx = (info->src_w << 16) / info->dst_w;
6417
6418 while (info->dst_h--) {
6419 Uint32 *src = 0;
6420 Uint32 *dst = (Uint32 *)info->dst;
6421 int n = info->dst_w;
6422 srcx = -1;
6423 posx = 0x10000L;
6424 while (posy >= 0x10000L) {
6425 ++srcy;
6426 posy -= 0x10000L;
6427 }
6428 while (n--) {
6429 if (posx >= 0x10000L) {
6430 while (posx >= 0x10000L) {
6431 ++srcx;
6432 posx -= 0x10000L;
6433 }
6434 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6435 }
6436 pixel = *src;
6437 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
6438 if (flags & SDL_COPY_MODULATE_COLOR) {
6439 R = (R * modulateR) / 255;
6440 G = (G * modulateG) / 255;
6441 B = (B * modulateB) / 255;
6442 }
6443 if (flags & SDL_COPY_MODULATE_ALPHA) {
6444 A = (A * modulateA) / 255;
6445 }
6446 pixel = ((Uint32)R << 16) | ((Uint32)G << 8) | B;
6447 *dst = pixel;
6448 posx += incx;
6449 ++dst;
6450 }
6451 posy += incy;
6452 info->dst += info->dst_pitch;
6453 }
6454 }
6455
6456 static void SDL_Blit_BGRA8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
6457 {
6458 const int flags = info->flags;
6459 const Uint32 modulateR = info->r;
6460 const Uint32 modulateG = info->g;
6461 const Uint32 modulateB = info->b;
6462 const Uint32 modulateA = info->a;
6463 Uint32 srcpixel;
6464 Uint32 srcR, srcG, srcB, srcA;
6465 Uint32 dstpixel;
6466 Uint32 dstR, dstG, dstB, dstA;
6467
6468 while (info->dst_h--) {
6469 Uint32 *src = (Uint32 *)info->src;
6470 Uint32 *dst = (Uint32 *)info->dst;
6471 int n = info->dst_w;
6472 while (n--) {
6473 srcpixel = *src;
6474 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6475 dstpixel = *dst;
6476 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
6477 if (flags & SDL_COPY_MODULATE_COLOR) {
6478 srcR = (srcR * modulateR) / 255;
6479 srcG = (srcG * modulateG) / 255;
6480 srcB = (srcB * modulateB) / 255;
6481 }
6482 if (flags & SDL_COPY_MODULATE_ALPHA) {
6483 srcA = (srcA * modulateA) / 255;
6484 }
6485 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6486 /* This goes away if we ever use premultiplied alpha */
6487 if (srcA < 255) {
6488 srcR = (srcR * srcA) / 255;
6489 srcG = (srcG * srcA) / 255;
6490 srcB = (srcB * srcA) / 255;
6491 }
6492 }
6493 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6494 case SDL_COPY_BLEND:
6495 dstR = srcR + ((255 - srcA) * dstR) / 255;
6496 dstG = srcG + ((255 - srcA) * dstG) / 255;
6497 dstB = srcB + ((255 - srcA) * dstB) / 255;
6498 dstA = srcA + ((255 - srcA) * dstA) / 255;
6499 break;
6500 case SDL_COPY_ADD:
6501 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6502 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6503 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6504 break;
6505 case SDL_COPY_MOD:
6506 dstR = (srcR * dstR) / 255;
6507 dstG = (srcG * dstG) / 255;
6508 dstB = (srcB * dstB) / 255;
6509 break;
6510 }
6511 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
6512 *dst = dstpixel;
6513 ++src;
6514 ++dst;
6515 }
6516 info->src += info->src_pitch;
6517 info->dst += info->dst_pitch;
6518 }
6519 }
6520
6521 static void SDL_Blit_BGRA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
6522 {
6523 const int flags = info->flags;
6524 const Uint32 modulateR = info->r;
6525 const Uint32 modulateG = info->g;
6526 const Uint32 modulateB = info->b;
6527 const Uint32 modulateA = info->a;
6528 Uint32 srcpixel;
6529 Uint32 srcR, srcG, srcB, srcA;
6530 Uint32 dstpixel;
6531 Uint32 dstR, dstG, dstB, dstA;
6532 int srcy, srcx;
6533 int posy, posx;
6534 int incy, incx;
6535
6536 srcy = 0;
6537 posy = 0;
6538 incy = (info->src_h << 16) / info->dst_h;
6539 incx = (info->src_w << 16) / info->dst_w;
6540
6541 while (info->dst_h--) {
6542 Uint32 *src = 0;
6543 Uint32 *dst = (Uint32 *)info->dst;
6544 int n = info->dst_w;
6545 srcx = -1;
6546 posx = 0x10000L;
6547 while (posy >= 0x10000L) {
6548 ++srcy;
6549 posy -= 0x10000L;
6550 }
6551 while (n--) {
6552 if (posx >= 0x10000L) {
6553 while (posx >= 0x10000L) {
6554 ++srcx;
6555 posx -= 0x10000L;
6556 }
6557 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6558 }
6559 srcpixel = *src;
6560 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6561 dstpixel = *dst;
6562 dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel; dstA = 0xFF;
6563 if (flags & SDL_COPY_MODULATE_COLOR) {
6564 srcR = (srcR * modulateR) / 255;
6565 srcG = (srcG * modulateG) / 255;
6566 srcB = (srcB * modulateB) / 255;
6567 }
6568 if (flags & SDL_COPY_MODULATE_ALPHA) {
6569 srcA = (srcA * modulateA) / 255;
6570 }
6571 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6572 /* This goes away if we ever use premultiplied alpha */
6573 if (srcA < 255) {
6574 srcR = (srcR * srcA) / 255;
6575 srcG = (srcG * srcA) / 255;
6576 srcB = (srcB * srcA) / 255;
6577 }
6578 }
6579 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6580 case SDL_COPY_BLEND:
6581 dstR = srcR + ((255 - srcA) * dstR) / 255;
6582 dstG = srcG + ((255 - srcA) * dstG) / 255;
6583 dstB = srcB + ((255 - srcA) * dstB) / 255;
6584 dstA = srcA + ((255 - srcA) * dstA) / 255;
6585 break;
6586 case SDL_COPY_ADD:
6587 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6588 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6589 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6590 break;
6591 case SDL_COPY_MOD:
6592 dstR = (srcR * dstR) / 255;
6593 dstG = (srcG * dstG) / 255;
6594 dstB = (srcB * dstB) / 255;
6595 break;
6596 }
6597 dstpixel = ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
6598 *dst = dstpixel;
6599 posx += incx;
6600 ++dst;
6601 }
6602 posy += incy;
6603 info->dst += info->dst_pitch;
6604 }
6605 }
6606
6607 static void SDL_Blit_BGRA8888_BGR888_Scale(SDL_BlitInfo *info)
6608 {
6609 Uint32 pixel;
6610 Uint32 R, G, B, A;
6611 int srcy, srcx;
6612 int posy, posx;
6613 int incy, incx;
6614
6615 srcy = 0;
6616 posy = 0;
6617 incy = (info->src_h << 16) / info->dst_h;
6618 incx = (info->src_w << 16) / info->dst_w;
6619
6620 while (info->dst_h--) {
6621 Uint32 *src = 0;
6622 Uint32 *dst = (Uint32 *)info->dst;
6623 int n = info->dst_w;
6624 srcx = -1;
6625 posx = 0x10000L;
6626 while (posy >= 0x10000L) {
6627 ++srcy;
6628 posy -= 0x10000L;
6629 }
6630 while (n--) {
6631 if (posx >= 0x10000L) {
6632 while (posx >= 0x10000L) {
6633 ++srcx;
6634 posx -= 0x10000L;
6635 }
6636 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6637 }
6638 pixel = *src;
6639 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
6640 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
6641 *dst = pixel;
6642 posx += incx;
6643 ++dst;
6644 }
6645 posy += incy;
6646 info->dst += info->dst_pitch;
6647 }
6648 }
6649
6650 static void SDL_Blit_BGRA8888_BGR888_Blend(SDL_BlitInfo *info)
6651 {
6652 const int flags = info->flags;
6653 Uint32 srcpixel;
6654 Uint32 srcR, srcG, srcB, srcA;
6655 Uint32 dstpixel;
6656 Uint32 dstR, dstG, dstB, dstA;
6657
6658 while (info->dst_h--) {
6659 Uint32 *src = (Uint32 *)info->src;
6660 Uint32 *dst = (Uint32 *)info->dst;
6661 int n = info->dst_w;
6662 while (n--) {
6663 srcpixel = *src;
6664 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6665 dstpixel = *dst;
6666 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
6667 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6668 /* This goes away if we ever use premultiplied alpha */
6669 if (srcA < 255) {
6670 srcR = (srcR * srcA) / 255;
6671 srcG = (srcG * srcA) / 255;
6672 srcB = (srcB * srcA) / 255;
6673 }
6674 }
6675 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6676 case SDL_COPY_BLEND:
6677 dstR = srcR + ((255 - srcA) * dstR) / 255;
6678 dstG = srcG + ((255 - srcA) * dstG) / 255;
6679 dstB = srcB + ((255 - srcA) * dstB) / 255;
6680 dstA = srcA + ((255 - srcA) * dstA) / 255;
6681 break;
6682 case SDL_COPY_ADD:
6683 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6684 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6685 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6686 break;
6687 case SDL_COPY_MOD:
6688 dstR = (srcR * dstR) / 255;
6689 dstG = (srcG * dstG) / 255;
6690 dstB = (srcB * dstB) / 255;
6691 break;
6692 }
6693 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
6694 *dst = dstpixel;
6695 ++src;
6696 ++dst;
6697 }
6698 info->src += info->src_pitch;
6699 info->dst += info->dst_pitch;
6700 }
6701 }
6702
6703 static void SDL_Blit_BGRA8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
6704 {
6705 const int flags = info->flags;
6706 Uint32 srcpixel;
6707 Uint32 srcR, srcG, srcB, srcA;
6708 Uint32 dstpixel;
6709 Uint32 dstR, dstG, dstB, dstA;
6710 int srcy, srcx;
6711 int posy, posx;
6712 int incy, incx;
6713
6714 srcy = 0;
6715 posy = 0;
6716 incy = (info->src_h << 16) / info->dst_h;
6717 incx = (info->src_w << 16) / info->dst_w;
6718
6719 while (info->dst_h--) {
6720 Uint32 *src = 0;
6721 Uint32 *dst = (Uint32 *)info->dst;
6722 int n = info->dst_w;
6723 srcx = -1;
6724 posx = 0x10000L;
6725 while (posy >= 0x10000L) {
6726 ++srcy;
6727 posy -= 0x10000L;
6728 }
6729 while (n--) {
6730 if (posx >= 0x10000L) {
6731 while (posx >= 0x10000L) {
6732 ++srcx;
6733 posx -= 0x10000L;
6734 }
6735 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6736 }
6737 srcpixel = *src;
6738 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6739 dstpixel = *dst;
6740 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
6741 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6742 /* This goes away if we ever use premultiplied alpha */
6743 if (srcA < 255) {
6744 srcR = (srcR * srcA) / 255;
6745 srcG = (srcG * srcA) / 255;
6746 srcB = (srcB * srcA) / 255;
6747 }
6748 }
6749 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6750 case SDL_COPY_BLEND:
6751 dstR = srcR + ((255 - srcA) * dstR) / 255;
6752 dstG = srcG + ((255 - srcA) * dstG) / 255;
6753 dstB = srcB + ((255 - srcA) * dstB) / 255;
6754 dstA = srcA + ((255 - srcA) * dstA) / 255;
6755 break;
6756 case SDL_COPY_ADD:
6757 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6758 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6759 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6760 break;
6761 case SDL_COPY_MOD:
6762 dstR = (srcR * dstR) / 255;
6763 dstG = (srcG * dstG) / 255;
6764 dstB = (srcB * dstB) / 255;
6765 break;
6766 }
6767 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
6768 *dst = dstpixel;
6769 posx += incx;
6770 ++dst;
6771 }
6772 posy += incy;
6773 info->dst += info->dst_pitch;
6774 }
6775 }
6776
6777 static void SDL_Blit_BGRA8888_BGR888_Modulate(SDL_BlitInfo *info)
6778 {
6779 const int flags = info->flags;
6780 const Uint32 modulateR = info->r;
6781 const Uint32 modulateG = info->g;
6782 const Uint32 modulateB = info->b;
6783 const Uint32 modulateA = info->a;
6784 Uint32 pixel;
6785 Uint32 R, G, B, A;
6786
6787 while (info->dst_h--) {
6788 Uint32 *src = (Uint32 *)info->src;
6789 Uint32 *dst = (Uint32 *)info->dst;
6790 int n = info->dst_w;
6791 while (n--) {
6792 pixel = *src;
6793 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
6794 if (flags & SDL_COPY_MODULATE_COLOR) {
6795 R = (R * modulateR) / 255;
6796 G = (G * modulateG) / 255;
6797 B = (B * modulateB) / 255;
6798 }
6799 if (flags & SDL_COPY_MODULATE_ALPHA) {
6800 A = (A * modulateA) / 255;
6801 }
6802 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
6803 *dst = pixel;
6804 ++src;
6805 ++dst;
6806 }
6807 info->src += info->src_pitch;
6808 info->dst += info->dst_pitch;
6809 }
6810 }
6811
6812 static void SDL_Blit_BGRA8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
6813 {
6814 const int flags = info->flags;
6815 const Uint32 modulateR = info->r;
6816 const Uint32 modulateG = info->g;
6817 const Uint32 modulateB = info->b;
6818 const Uint32 modulateA = info->a;
6819 Uint32 pixel;
6820 Uint32 R, G, B, A;
6821 int srcy, srcx;
6822 int posy, posx;
6823 int incy, incx;
6824
6825 srcy = 0;
6826 posy = 0;
6827 incy = (info->src_h << 16) / info->dst_h;
6828 incx = (info->src_w << 16) / info->dst_w;
6829
6830 while (info->dst_h--) {
6831 Uint32 *src = 0;
6832 Uint32 *dst = (Uint32 *)info->dst;
6833 int n = info->dst_w;
6834 srcx = -1;
6835 posx = 0x10000L;
6836 while (posy >= 0x10000L) {
6837 ++srcy;
6838 posy -= 0x10000L;
6839 }
6840 while (n--) {
6841 if (posx >= 0x10000L) {
6842 while (posx >= 0x10000L) {
6843 ++srcx;
6844 posx -= 0x10000L;
6845 }
6846 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6847 }
6848 pixel = *src;
6849 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
6850 if (flags & SDL_COPY_MODULATE_COLOR) {
6851 R = (R * modulateR) / 255;
6852 G = (G * modulateG) / 255;
6853 B = (B * modulateB) / 255;
6854 }
6855 if (flags & SDL_COPY_MODULATE_ALPHA) {
6856 A = (A * modulateA) / 255;
6857 }
6858 pixel = ((Uint32)B << 16) | ((Uint32)G << 8) | R;
6859 *dst = pixel;
6860 posx += incx;
6861 ++dst;
6862 }
6863 posy += incy;
6864 info->dst += info->dst_pitch;
6865 }
6866 }
6867
6868 static void SDL_Blit_BGRA8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
6869 {
6870 const int flags = info->flags;
6871 const Uint32 modulateR = info->r;
6872 const Uint32 modulateG = info->g;
6873 const Uint32 modulateB = info->b;
6874 const Uint32 modulateA = info->a;
6875 Uint32 srcpixel;
6876 Uint32 srcR, srcG, srcB, srcA;
6877 Uint32 dstpixel;
6878 Uint32 dstR, dstG, dstB, dstA;
6879
6880 while (info->dst_h--) {
6881 Uint32 *src = (Uint32 *)info->src;
6882 Uint32 *dst = (Uint32 *)info->dst;
6883 int n = info->dst_w;
6884 while (n--) {
6885 srcpixel = *src;
6886 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6887 dstpixel = *dst;
6888 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
6889 if (flags & SDL_COPY_MODULATE_COLOR) {
6890 srcR = (srcR * modulateR) / 255;
6891 srcG = (srcG * modulateG) / 255;
6892 srcB = (srcB * modulateB) / 255;
6893 }
6894 if (flags & SDL_COPY_MODULATE_ALPHA) {
6895 srcA = (srcA * modulateA) / 255;
6896 }
6897 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6898 /* This goes away if we ever use premultiplied alpha */
6899 if (srcA < 255) {
6900 srcR = (srcR * srcA) / 255;
6901 srcG = (srcG * srcA) / 255;
6902 srcB = (srcB * srcA) / 255;
6903 }
6904 }
6905 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6906 case SDL_COPY_BLEND:
6907 dstR = srcR + ((255 - srcA) * dstR) / 255;
6908 dstG = srcG + ((255 - srcA) * dstG) / 255;
6909 dstB = srcB + ((255 - srcA) * dstB) / 255;
6910 dstA = srcA + ((255 - srcA) * dstA) / 255;
6911 break;
6912 case SDL_COPY_ADD:
6913 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
6914 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
6915 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
6916 break;
6917 case SDL_COPY_MOD:
6918 dstR = (srcR * dstR) / 255;
6919 dstG = (srcG * dstG) / 255;
6920 dstB = (srcB * dstB) / 255;
6921 break;
6922 }
6923 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
6924 *dst = dstpixel;
6925 ++src;
6926 ++dst;
6927 }
6928 info->src += info->src_pitch;
6929 info->dst += info->dst_pitch;
6930 }
6931 }
6932
6933 static void SDL_Blit_BGRA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
6934 {
6935 const int flags = info->flags;
6936 const Uint32 modulateR = info->r;
6937 const Uint32 modulateG = info->g;
6938 const Uint32 modulateB = info->b;
6939 const Uint32 modulateA = info->a;
6940 Uint32 srcpixel;
6941 Uint32 srcR, srcG, srcB, srcA;
6942 Uint32 dstpixel;
6943 Uint32 dstR, dstG, dstB, dstA;
6944 int srcy, srcx;
6945 int posy, posx;
6946 int incy, incx;
6947
6948 srcy = 0;
6949 posy = 0;
6950 incy = (info->src_h << 16) / info->dst_h;
6951 incx = (info->src_w << 16) / info->dst_w;
6952
6953 while (info->dst_h--) {
6954 Uint32 *src = 0;
6955 Uint32 *dst = (Uint32 *)info->dst;
6956 int n = info->dst_w;
6957 srcx = -1;
6958 posx = 0x10000L;
6959 while (posy >= 0x10000L) {
6960 ++srcy;
6961 posy -= 0x10000L;
6962 }
6963 while (n--) {
6964 if (posx >= 0x10000L) {
6965 while (posx >= 0x10000L) {
6966 ++srcx;
6967 posx -= 0x10000L;
6968 }
6969 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
6970 }
6971 srcpixel = *src;
6972 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
6973 dstpixel = *dst;
6974 dstB = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstR = (Uint8)dstpixel; dstA = 0xFF;
6975 if (flags & SDL_COPY_MODULATE_COLOR) {
6976 srcR = (srcR * modulateR) / 255;
6977 srcG = (srcG * modulateG) / 255;
6978 srcB = (srcB * modulateB) / 255;
6979 }
6980 if (flags & SDL_COPY_MODULATE_ALPHA) {
6981 srcA = (srcA * modulateA) / 255;
6982 }
6983 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
6984 /* This goes away if we ever use premultiplied alpha */
6985 if (srcA < 255) {
6986 srcR = (srcR * srcA) / 255;
6987 srcG = (srcG * srcA) / 255;
6988 srcB = (srcB * srcA) / 255;
6989 }
6990 }
6991 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
6992 case SDL_COPY_BLEND:
6993 dstR = srcR + ((255 - srcA) * dstR) / 255;
6994 dstG = srcG + ((255 - srcA) * dstG) / 255;
6995 dstB = srcB + ((255 - srcA) * dstB) / 255;
6996 dstA = srcA + ((255 - srcA) * dstA) / 255;
6997 break;
6998 case SDL_COPY_ADD:
6999 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
7000 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
7001 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
7002 break;
7003 case SDL_COPY_MOD:
7004 dstR = (srcR * dstR) / 255;
7005 dstG = (srcG * dstG) / 255;
7006 dstB = (srcB * dstB) / 255;
7007 break;
7008 }
7009 dstpixel = ((Uint32)dstB << 16) | ((Uint32)dstG << 8) | dstR;
7010 *dst = dstpixel;
7011 posx += incx;
7012 ++dst;
7013 }
7014 posy += incy;
7015 info->dst += info->dst_pitch;
7016 }
7017 }
7018
7019 static void SDL_Blit_BGRA8888_ARGB8888_Scale(SDL_BlitInfo *info)
7020 {
7021 Uint32 pixel;
7022 Uint32 R, G, B, A;
7023 int srcy, srcx;
7024 int posy, posx;
7025 int incy, incx;
7026
7027 srcy = 0;
7028 posy = 0;
7029 incy = (info->src_h << 16) / info->dst_h;
7030 incx = (info->src_w << 16) / info->dst_w;
7031
7032 while (info->dst_h--) {
7033 Uint32 *src = 0;
7034 Uint32 *dst = (Uint32 *)info->dst;
7035 int n = info->dst_w;
7036 srcx = -1;
7037 posx = 0x10000L;
7038 while (posy >= 0x10000L) {
7039 ++srcy;
7040 posy -= 0x10000L;
7041 }
7042 while (n--) {
7043 if (posx >= 0x10000L) {
7044 while (posx >= 0x10000L) {
7045 ++srcx;
7046 posx -= 0x10000L;
7047 }
7048 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
7049 }
7050 pixel = *src;
7051 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
7052 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
7053 *dst = pixel;
7054 posx += incx;
7055 ++dst;
7056 }
7057 posy += incy;
7058 info->dst += info->dst_pitch;
7059 }
7060 }
7061
7062 static void SDL_Blit_BGRA8888_ARGB8888_Blend(SDL_BlitInfo *info)
7063 {
7064 const int flags = info->flags;
7065 Uint32 srcpixel;
7066 Uint32 srcR, srcG, srcB, srcA;
7067 Uint32 dstpixel;
7068 Uint32 dstR, dstG, dstB, dstA;
7069
7070 while (info->dst_h--) {
7071 Uint32 *src = (Uint32 *)info->src;
7072 Uint32 *dst = (Uint32 *)info->dst;
7073 int n = info->dst_w;
7074 while (n--) {
7075 srcpixel = *src;
7076 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
7077 dstpixel = *dst;
7078 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
7079 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
7080 /* This goes away if we ever use premultiplied alpha */
7081 if (srcA < 255) {
7082 srcR = (srcR * srcA) / 255;
7083 srcG = (srcG * srcA) / 255;
7084 srcB = (srcB * srcA) / 255;
7085 }
7086 }
7087 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
7088 case SDL_COPY_BLEND:
7089 dstR = srcR + ((255 - srcA) * dstR) / 255;
7090 dstG = srcG + ((255 - srcA) * dstG) / 255;
7091 dstB = srcB + ((255 - srcA) * dstB) / 255;
7092 dstA = srcA + ((255 - srcA) * dstA) / 255;
7093 break;
7094 case SDL_COPY_ADD:
7095 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
7096 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
7097 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
7098 break;
7099 case SDL_COPY_MOD:
7100 dstR = (srcR * dstR) / 255;
7101 dstG = (srcG * dstG) / 255;
7102 dstB = (srcB * dstB) / 255;
7103 break;
7104 }
7105 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
7106 *dst = dstpixel;
7107 ++src;
7108 ++dst;
7109 }
7110 info->src += info->src_pitch;
7111 info->dst += info->dst_pitch;
7112 }
7113 }
7114
7115 static void SDL_Blit_BGRA8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
7116 {
7117 const int flags = info->flags;
7118 Uint32 srcpixel;
7119 Uint32 srcR, srcG, srcB, srcA;
7120 Uint32 dstpixel;
7121 Uint32 dstR, dstG, dstB, dstA;
7122 int srcy, srcx;
7123 int posy, posx;
7124 int incy, incx;
7125
7126 srcy = 0;
7127 posy = 0;
7128 incy = (info->src_h << 16) / info->dst_h;
7129 incx = (info->src_w << 16) / info->dst_w;
7130
7131 while (info->dst_h--) {
7132 Uint32 *src = 0;
7133 Uint32 *dst = (Uint32 *)info->dst;
7134 int n = info->dst_w;
7135 srcx = -1;
7136 posx = 0x10000L;
7137 while (posy >= 0x10000L) {
7138 ++srcy;
7139 posy -= 0x10000L;
7140 }
7141 while (n--) {
7142 if (posx >= 0x10000L) {
7143 while (posx >= 0x10000L) {
7144 ++srcx;
7145 posx -= 0x10000L;
7146 }
7147 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
7148 }
7149 srcpixel = *src;
7150 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
7151 dstpixel = *dst;
7152 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
7153 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
7154 /* This goes away if we ever use premultiplied alpha */
7155 if (srcA < 255) {
7156 srcR = (srcR * srcA) / 255;
7157 srcG = (srcG * srcA) / 255;
7158 srcB = (srcB * srcA) / 255;
7159 }
7160 }
7161 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
7162 case SDL_COPY_BLEND:
7163 dstR = srcR + ((255 - srcA) * dstR) / 255;
7164 dstG = srcG + ((255 - srcA) * dstG) / 255;
7165 dstB = srcB + ((255 - srcA) * dstB) / 255;
7166 dstA = srcA + ((255 - srcA) * dstA) / 255;
7167 break;
7168 case SDL_COPY_ADD:
7169 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
7170 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
7171 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
7172 break;
7173 case SDL_COPY_MOD:
7174 dstR = (srcR * dstR) / 255;
7175 dstG = (srcG * dstG) / 255;
7176 dstB = (srcB * dstB) / 255;
7177 break;
7178 }
7179 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
7180 *dst = dstpixel;
7181 posx += incx;
7182 ++dst;
7183 }
7184 posy += incy;
7185 info->dst += info->dst_pitch;
7186 }
7187 }
7188
7189 static void SDL_Blit_BGRA8888_ARGB8888_Modulate(SDL_BlitInfo *info)
7190 {
7191 const int flags = info->flags;
7192 const Uint32 modulateR = info->r;
7193 const Uint32 modulateG = info->g;
7194 const Uint32 modulateB = info->b;
7195 const Uint32 modulateA = info->a;
7196 Uint32 pixel;
7197 Uint32 R, G, B, A;
7198
7199 while (info->dst_h--) {
7200 Uint32 *src = (Uint32 *)info->src;
7201 Uint32 *dst = (Uint32 *)info->dst;
7202 int n = info->dst_w;
7203 while (n--) {
7204 pixel = *src;
7205 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
7206 if (flags & SDL_COPY_MODULATE_COLOR) {
7207 R = (R * modulateR) / 255;
7208 G = (G * modulateG) / 255;
7209 B = (B * modulateB) / 255;
7210 }
7211 if (flags & SDL_COPY_MODULATE_ALPHA) {
7212 A = (A * modulateA) / 255;
7213 }
7214 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
7215 *dst = pixel;
7216 ++src;
7217 ++dst;
7218 }
7219 info->src += info->src_pitch;
7220 info->dst += info->dst_pitch;
7221 }
7222 }
7223
7224 static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
7225 {
7226 const int flags = info->flags;
7227 const Uint32 modulateR = info->r;
7228 const Uint32 modulateG = info->g;
7229 const Uint32 modulateB = info->b;
7230 const Uint32 modulateA = info->a;
7231 Uint32 pixel;
7232 Uint32 R, G, B, A;
7233 int srcy, srcx;
7234 int posy, posx;
7235 int incy, incx;
7236
7237 srcy = 0;
7238 posy = 0;
7239 incy = (info->src_h << 16) / info->dst_h;
7240 incx = (info->src_w << 16) / info->dst_w;
7241
7242 while (info->dst_h--) {
7243 Uint32 *src = 0;
7244 Uint32 *dst = (Uint32 *)info->dst;
7245 int n = info->dst_w;
7246 srcx = -1;
7247 posx = 0x10000L;
7248 while (posy >= 0x10000L) {
7249 ++srcy;
7250 posy -= 0x10000L;
7251 }
7252 while (n--) {
7253 if (posx >= 0x10000L) {
7254 while (posx >= 0x10000L) {
7255 ++srcx;
7256 posx -= 0x10000L;
7257 }
7258 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
7259 }
7260 pixel = *src;
7261 B = (Uint8)(pixel >> 24); G = (Uint8)(pixel >> 16); R = (Uint8)(pixel >> 8); A = (Uint8)pixel;
7262 if (flags & SDL_COPY_MODULATE_COLOR) {
7263 R = (R * modulateR) / 255;
7264 G = (G * modulateG) / 255;
7265 B = (B * modulateB) / 255;
7266 }
7267 if (flags & SDL_COPY_MODULATE_ALPHA) {
7268 A = (A * modulateA) / 255;
7269 }
7270 pixel = ((Uint32)A << 24) | ((Uint32)R << 16) | ((Uint32)G << 8) | B;
7271 *dst = pixel;
7272 posx += incx;
7273 ++dst;
7274 }
7275 posy += incy;
7276 info->dst += info->dst_pitch;
7277 }
7278 }
7279
7280 static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
7281 {
7282 const int flags = info->flags;
7283 const Uint32 modulateR = info->r;
7284 const Uint32 modulateG = info->g;
7285 const Uint32 modulateB = info->b;
7286 const Uint32 modulateA = info->a;
7287 Uint32 srcpixel;
7288 Uint32 srcR, srcG, srcB, srcA;
7289 Uint32 dstpixel;
7290 Uint32 dstR, dstG, dstB, dstA;
7291
7292 while (info->dst_h--) {
7293 Uint32 *src = (Uint32 *)info->src;
7294 Uint32 *dst = (Uint32 *)info->dst;
7295 int n = info->dst_w;
7296 while (n--) {
7297 srcpixel = *src;
7298 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
7299 dstpixel = *dst;
7300 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
7301 if (flags & SDL_COPY_MODULATE_COLOR) {
7302 srcR = (srcR * modulateR) / 255;
7303 srcG = (srcG * modulateG) / 255;
7304 srcB = (srcB * modulateB) / 255;
7305 }
7306 if (flags & SDL_COPY_MODULATE_ALPHA) {
7307 srcA = (srcA * modulateA) / 255;
7308 }
7309 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
7310 /* This goes away if we ever use premultiplied alpha */
7311 if (srcA < 255) {
7312 srcR = (srcR * srcA) / 255;
7313 srcG = (srcG * srcA) / 255;
7314 srcB = (srcB * srcA) / 255;
7315 }
7316 }
7317 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
7318 case SDL_COPY_BLEND:
7319 dstR = srcR + ((255 - srcA) * dstR) / 255;
7320 dstG = srcG + ((255 - srcA) * dstG) / 255;
7321 dstB = srcB + ((255 - srcA) * dstB) / 255;
7322 dstA = srcA + ((255 - srcA) * dstA) / 255;
7323 break;
7324 case SDL_COPY_ADD:
7325 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
7326 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
7327 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
7328 break;
7329 case SDL_COPY_MOD:
7330 dstR = (srcR * dstR) / 255;
7331 dstG = (srcG * dstG) / 255;
7332 dstB = (srcB * dstB) / 255;
7333 break;
7334 }
7335 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
7336 *dst = dstpixel;
7337 ++src;
7338 ++dst;
7339 }
7340 info->src += info->src_pitch;
7341 info->dst += info->dst_pitch;
7342 }
7343 }
7344
7345 static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
7346 {
7347 const int flags = info->flags;
7348 const Uint32 modulateR = info->r;
7349 const Uint32 modulateG = info->g;
7350 const Uint32 modulateB = info->b;
7351 const Uint32 modulateA = info->a;
7352 Uint32 srcpixel;
7353 Uint32 srcR, srcG, srcB, srcA;
7354 Uint32 dstpixel;
7355 Uint32 dstR, dstG, dstB, dstA;
7356 int srcy, srcx;
7357 int posy, posx;
7358 int incy, incx;
7359
7360 srcy = 0;
7361 posy = 0;
7362 incy = (info->src_h << 16) / info->dst_h;
7363 incx = (info->src_w << 16) / info->dst_w;
7364
7365 while (info->dst_h--) {
7366 Uint32 *src = 0;
7367 Uint32 *dst = (Uint32 *)info->dst;
7368 int n = info->dst_w;
7369 srcx = -1;
7370 posx = 0x10000L;
7371 while (posy >= 0x10000L) {
7372 ++srcy;
7373 posy -= 0x10000L;
7374 }
7375 while (n--) {
7376 if (posx >= 0x10000L) {
7377 while (posx >= 0x10000L) {
7378 ++srcx;
7379 posx -= 0x10000L;
7380 }
7381 src = (Uint32 *)(info->src + (srcy * info->src_pitch) + (srcx * 4));
7382 }
7383 srcpixel = *src;
7384 srcB = (Uint8)(srcpixel >> 24); srcG = (Uint8)(srcpixel >> 16); srcR = (Uint8)(srcpixel >> 8); srcA = (Uint8)srcpixel;
7385 dstpixel = *dst;
7386 dstA = (Uint8)(dstpixel >> 24); dstR = (Uint8)(dstpixel >> 16); dstG = (Uint8)(dstpixel >> 8); dstB = (Uint8)dstpixel;
7387 if (flags & SDL_COPY_MODULATE_COLOR) {
7388 srcR = (srcR * modulateR) / 255;
7389 srcG = (srcG * modulateG) / 255;
7390 srcB = (srcB * modulateB) / 255;
7391 }
7392 if (flags & SDL_COPY_MODULATE_ALPHA) {
7393 srcA = (srcA * modulateA) / 255;
7394 }
7395 if (flags & (SDL_COPY_BLEND|SDL_COPY_ADD)) {
7396 /* This goes away if we ever use premultiplied alpha */
7397 if (srcA < 255) {
7398 srcR = (srcR * srcA) / 255;
7399 srcG = (srcG * srcA) / 255;
7400 srcB = (srcB * srcA) / 255;
7401 }
7402 }
7403 switch (flags & (SDL_COPY_BLEND|SDL_COPY_ADD|SDL_COPY_MOD)) {
7404 case SDL_COPY_BLEND:
7405 dstR = srcR + ((255 - srcA) * dstR) / 255;
7406 dstG = srcG + ((255 - srcA) * dstG) / 255;
7407 dstB = srcB + ((255 - srcA) * dstB) / 255;
7408 dstA = srcA + ((255 - srcA) * dstA) / 255;
7409 break;
7410 case SDL_COPY_ADD:
7411 dstR = srcR + dstR; if (dstR > 255) dstR = 255;
7412 dstG = srcG + dstG; if (dstG > 255) dstG = 255;
7413 dstB = srcB + dstB; if (dstB > 255) dstB = 255;
7414 break;
7415 case SDL_COPY_MOD:
7416 dstR = (srcR * dstR) / 255;
7417 dstG = (srcG * dstG) / 255;
7418 dstB = (srcB * dstB) / 255;
7419 break;
7420 }
7421 dstpixel = ((Uint32)dstA << 24) | ((Uint32)dstR << 16) | ((Uint32)dstG << 8) | dstB;
7422 *dst = dstpixel;
7423 posx += incx;
7424 ++dst;
7425 }
7426 posy += incy;
7427 info->dst += info->dst_pitch;
7428 }
7429 }
7430
7431 SDL_BlitFuncEntry SDL_GeneratedBlitFuncTable[] = {
7432 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Scale },
7433 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Blend },
7434 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Blend_Scale },
7435 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Modulate },
7436 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Modulate_Scale },
7437 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Modulate_Blend },
7438 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_RGB888_Modulate_Blend_Scale },
7439 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Scale },
7440 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Blend },
7441 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Blend_Scale },
7442 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Modulate },
7443 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Modulate_Scale },
7444 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Modulate_Blend },
7445 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_BGR888_Modulate_Blend_Scale },
7446 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Scale },
7447 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Blend },
7448 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Blend_Scale },
7449 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Modulate },
7450 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Modulate_Scale },
7451 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Modulate_Blend },
7452 { SDL_PIXELFORMAT_RGB888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGB888_ARGB8888_Modulate_Blend_Scale },
7453 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Scale },
7454 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Blend },
7455 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Blend_Scale },
7456 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Modulate },
7457 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Modulate_Scale },
7458 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Modulate_Blend },
7459 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_RGB888_Modulate_Blend_Scale },
7460 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Scale },
7461 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Blend },
7462 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Blend_Scale },
7463 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Modulate },
7464 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Modulate_Scale },
7465 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Modulate_Blend },
7466 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_BGR888_Modulate_Blend_Scale },
7467 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Scale },
7468 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Blend },
7469 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Blend_Scale },
7470 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Modulate },
7471 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Modulate_Scale },
7472 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Modulate_Blend },
7473 { SDL_PIXELFORMAT_BGR888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGR888_ARGB8888_Modulate_Blend_Scale },
7474 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Scale },
7475 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Blend },
7476 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Blend_Scale },
7477 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Modulate },
7478 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Modulate_Scale },
7479 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Modulate_Blend },
7480 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_RGB888_Modulate_Blend_Scale },
7481 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Scale },
7482 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Blend },
7483 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Blend_Scale },
7484 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Modulate },
7485 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Modulate_Scale },
7486 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Modulate_Blend },
7487 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_BGR888_Modulate_Blend_Scale },
7488 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Scale },
7489 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Blend },
7490 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Blend_Scale },
7491 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Modulate },
7492 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Modulate_Scale },
7493 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend },
7494 { SDL_PIXELFORMAT_ARGB8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend_Scale },
7495 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Scale },
7496 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Blend },
7497 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Blend_Scale },
7498 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Modulate },
7499 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Modulate_Scale },
7500 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Modulate_Blend },
7501 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_RGB888_Modulate_Blend_Scale },
7502 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Scale },
7503 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Blend },
7504 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Blend_Scale },
7505 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Modulate },
7506 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Modulate_Scale },
7507 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Modulate_Blend },
7508 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_BGR888_Modulate_Blend_Scale },
7509 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Scale },
7510 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Blend },
7511 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Blend_Scale },
7512 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Modulate },
7513 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Modulate_Scale },
7514 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend },
7515 { SDL_PIXELFORMAT_RGBA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend_Scale },
7516 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Scale },
7517 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Blend },
7518 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Blend_Scale },
7519 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Modulate },
7520 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Modulate_Scale },
7521 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Modulate_Blend },
7522 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_RGB888_Modulate_Blend_Scale },
7523 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Scale },
7524 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Blend },
7525 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Blend_Scale },
7526 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Modulate },
7527 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Modulate_Scale },
7528 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Modulate_Blend },
7529 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_BGR888_Modulate_Blend_Scale },
7530 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Scale },
7531 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Blend },
7532 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Blend_Scale },
7533 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Modulate },
7534 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Modulate_Scale },
7535 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend },
7536 { SDL_PIXELFORMAT_ABGR8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend_Scale },
7537 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Scale },
7538 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Blend },
7539 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Blend_Scale },
7540 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Modulate },
7541 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Modulate_Scale },
7542 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Modulate_Blend },
7543 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_RGB888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_RGB888_Modulate_Blend_Scale },
7544 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Scale },
7545 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Blend },
7546 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Blend_Scale },
7547 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Modulate },
7548 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Modulate_Scale },
7549 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Modulate_Blend },
7550 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_BGR888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_BGR888_Modulate_Blend_Scale },
7551 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Scale },
7552 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Blend },
7553 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Blend_Scale },
7554 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Modulate },
7555 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Modulate_Scale },
7556 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend },
7557 { SDL_PIXELFORMAT_BGRA8888, SDL_PIXELFORMAT_ARGB8888, (SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA | SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_NEAREST), SDL_CPU_ANY, SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend_Scale },
7558 { 0, 0, 0, 0, NULL }
7559 };
7560
7561 /* *INDENT-ON* */
7562
7563 /* vi: set ts=4 sw=4 expandtab: */
SDL_Blit_BGR888_ARGB8888_Blend
static void SDL_Blit_BGR888_ARGB8888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2123
SDL_Blit_RGB888_BGR888_Blend
static void SDL_Blit_RGB888_BGR888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:480
SDL_BlitInfo::r
Uint8 r
Definition: SDL_blit.h:70
SDL_COPY_MODULATE_COLOR
#define SDL_COPY_MODULATE_COLOR
Definition: SDL_blit.h:34
SDL_Blit_BGRA8888_BGR888_Modulate_Blend_Scale
static void SDL_Blit_BGRA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6933
SDL_Blit_ARGB8888_BGR888_Blend_Scale
static void SDL_Blit_ARGB8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3000
SDL_Blit_RGBA8888_RGB888_Blend
static void SDL_Blit_RGBA8888_RGB888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3766
SDL_Blit_RGB888_BGR888_Modulate_Blend_Scale
static void SDL_Blit_RGB888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:763
SDL_BlitInfo::b
Uint8 b
Definition: SDL_blit.h:70
SDL_Blit_BGRA8888_ARGB8888_Modulate_Scale
static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7224
SDL_Blit_RGB888_ARGB8888_Modulate_Scale
static void SDL_Blit_RGB888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1054
SDL_Blit_BGRA8888_ARGB8888_Blend_Scale
static void SDL_Blit_BGRA8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7115
SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend_Scale
static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7345
SDL_Blit_RGBA8888_ARGB8888_Blend_Scale
static void SDL_Blit_RGBA8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4643
SDL_Blit_BGRA8888_BGR888_Modulate_Scale
static void SDL_Blit_BGRA8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6812
SDL_Blit_RGB888_ARGB8888_Modulate
static void SDL_Blit_RGB888_ARGB8888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1019
SDL_Blit_BGRA8888_RGB888_Scale
static void SDL_Blit_BGRA8888_RGB888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6195
SDL_PIXELFORMAT_ABGR8888
Definition: SDL_pixels.h:230
SDL_Blit_BGRA8888_BGR888_Blend
static void SDL_Blit_BGRA8888_BGR888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6650
SDL_Blit_BGR888_BGR888_Modulate_Blend
static void SDL_Blit_BGR888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1929
SDL_Blit_ARGB8888_RGB888_Blend
static void SDL_Blit_ARGB8888_RGB888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2535
SDL_Blit_RGBA8888_ARGB8888_Scale
static void SDL_Blit_RGBA8888_ARGB8888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4547
NULL
#define NULL
Definition: ftobjs.h:61
SDL_Blit_BGR888_ARGB8888_Modulate_Scale
static void SDL_Blit_BGR888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2285
SDL_Blit_BGRA8888_ARGB8888_Scale
static void SDL_Blit_BGRA8888_ARGB8888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7019
SDL_Blit_ARGB8888_ARGB8888_Modulate_Scale
static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3516
SDL_Blit_ARGB8888_RGB888_Scale
static void SDL_Blit_ARGB8888_RGB888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2492
SDL_Blit_ARGB8888_RGB888_Blend_Scale
static void SDL_Blit_ARGB8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2588
SDL_BlitInfo::flags
int flags
Definition: SDL_blit.h:68
SDL_Blit_ARGB8888_RGB888_Modulate_Scale
static void SDL_Blit_ARGB8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2697
SDL_BlitInfo::g
Uint8 g
Definition: SDL_blit.h:70
n
GLclampd n
Definition: glew.h:7287
SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend
static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4808
SDL_Blit_ARGB8888_BGR888_Modulate
static void SDL_Blit_ARGB8888_BGR888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3074
SDL_COPY_MOD
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
SDL_BlitInfo::src_h
int src_h
Definition: SDL_blit.h:58
SDL_Blit_RGBA8888_ARGB8888_Modulate
static void SDL_Blit_RGBA8888_ARGB8888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4717
SDL_Blit_BGR888_RGB888_Blend
static void SDL_Blit_BGR888_RGB888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1304
SDL_Blit_RGB888_BGR888_Scale
static void SDL_Blit_RGB888_BGR888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:437
SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend_Scale
static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4873
SDL_Blit_RGBA8888_BGR888_Modulate
static void SDL_Blit_RGBA8888_BGR888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4305
SDL_Blit_BGRA8888_RGB888_Modulate_Scale
static void SDL_Blit_BGRA8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6400
SDL_BlitInfo::dst_pitch
int dst_pitch
Definition: SDL_blit.h:63
SDL_Blit_BGRA8888_RGB888_Modulate_Blend_Scale
static void SDL_Blit_BGRA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6521
SDL_BlitInfo::src_w
int src_w
Definition: SDL_blit.h:58
SDL_Blit_BGRA8888_ARGB8888_Modulate
static void SDL_Blit_BGRA8888_ARGB8888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7189
SDL_BlitInfo::dst_h
int dst_h
Definition: SDL_blit.h:62
SDL_Blit_BGR888_ARGB8888_Modulate
static void SDL_Blit_BGR888_ARGB8888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2250
SDL_Blit_BGR888_ARGB8888_Modulate_Blend
static void SDL_Blit_BGR888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2341
SDL_config.h
SDL_Blit_BGR888_ARGB8888_Scale
static void SDL_Blit_BGR888_ARGB8888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2080
SDL_Blit_ABGR8888_RGB888_Modulate
static void SDL_Blit_ABGR8888_RGB888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5129
SDL_Blit_BGR888_RGB888_Blend_Scale
static void SDL_Blit_BGR888_RGB888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1357
SDL_Blit_ABGR8888_BGR888_Blend
static void SDL_Blit_ABGR8888_BGR888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5414
SDL_Blit_ABGR8888_RGB888_Modulate_Blend
static void SDL_Blit_ABGR8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5220
SDL_Blit_ARGB8888_ARGB8888_Scale
static void SDL_Blit_ARGB8888_ARGB8888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3316
SDL_COPY_ADD
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
SDL_Blit_RGB888_RGB888_Modulate_Scale
static void SDL_Blit_RGB888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:230
SDL_Blit_RGBA8888_RGB888_Modulate_Blend
static void SDL_Blit_RGBA8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3984
SDL_Blit_RGBA8888_RGB888_Blend_Scale
static void SDL_Blit_RGBA8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3819
Uint32
uint32_t Uint32
An unsigned 32-bit integer type.
Definition: SDL_stdinc.h:145
SDL_Blit_BGR888_RGB888_Modulate_Scale
static void SDL_Blit_BGR888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1466
SDL_Blit_BGR888_BGR888_Blend_Scale
static void SDL_Blit_BGR888_BGR888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1764
SDL_Blit_RGB888_ARGB8888_Modulate_Blend_Scale
static void SDL_Blit_RGB888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1175
SDL_COPY_NEAREST
#define SDL_COPY_NEAREST
Definition: SDL_blit.h:40
SDL_Blit_RGB888_BGR888_Modulate_Scale
static void SDL_Blit_RGB888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:642
SDL_Blit_BGR888_BGR888_Modulate_Blend_Scale
static void SDL_Blit_BGR888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1994
SDL_Blit_RGBA8888_BGR888_Modulate_Scale
static void SDL_Blit_RGBA8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4340
SDL_BlitInfo::dst
Uint8 * dst
Definition: SDL_blit.h:61
SDL_Blit_BGR888_BGR888_Modulate
static void SDL_Blit_BGR888_BGR888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1838
SDL_Blit_ABGR8888_BGR888_Modulate_Blend_Scale
static void SDL_Blit_ABGR8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5697
SDL_video.h
SDL_blit_auto.h
SDL_Blit_ABGR8888_RGB888_Scale
static void SDL_Blit_ABGR8888_RGB888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4959
SDL_Blit_BGRA8888_ARGB8888_Blend
static void SDL_Blit_BGRA8888_ARGB8888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7062
dst
GLenum GLenum dst
Definition: glew.h:2396
SDL_BlitInfo
Definition: SDL_blit.h:55
SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend_Scale
static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3637
SDL_Blit_ARGB8888_BGR888_Modulate_Blend_Scale
static void SDL_Blit_ARGB8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3230
SDL_PIXELFORMAT_BGRA8888
Definition: SDL_pixels.h:233
SDL_Blit_RGB888_RGB888_Modulate_Blend
static void SDL_Blit_RGB888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:286
SDL_Blit_RGB888_RGB888_Scale
static void SDL_Blit_RGB888_RGB888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:30
SDL_Blit_RGB888_ARGB8888_Blend
static void SDL_Blit_RGB888_ARGB8888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:892
SDL_Blit_ABGR8888_BGR888_Scale
static void SDL_Blit_ABGR8888_BGR888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5371
SDL_Blit_ARGB8888_ARGB8888_Blend_Scale
static void SDL_Blit_ARGB8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3407
SDL_Blit_ARGB8888_ARGB8888_Modulate
static void SDL_Blit_ARGB8888_ARGB8888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3481
SDL_Blit_RGBA8888_RGB888_Modulate
static void SDL_Blit_RGBA8888_RGB888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3893
SDL_Blit_RGB888_RGB888_Blend_Scale
static void SDL_Blit_RGB888_RGB888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:121
SDL_Blit_ABGR8888_BGR888_Blend_Scale
static void SDL_Blit_ABGR8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5467
SDL_Blit_ARGB8888_ARGB8888_Blend
static void SDL_Blit_ARGB8888_ARGB8888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3354
SDL_Blit_BGR888_BGR888_Blend
static void SDL_Blit_BGR888_BGR888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1711
SDL_Blit_ABGR8888_RGB888_Modulate_Blend_Scale
static void SDL_Blit_ABGR8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5285
SDL_BlitInfo::src
Uint8 * src
Definition: SDL_blit.h:57
SDL_Blit_ABGR8888_BGR888_Modulate_Blend
static void SDL_Blit_ABGR8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5632
SDL_Blit_RGB888_RGB888_Modulate
static void SDL_Blit_RGB888_RGB888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:195
SDL_Blit_BGR888_ARGB8888_Modulate_Blend_Scale
static void SDL_Blit_BGR888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2406
SDL_Blit_ABGR8888_RGB888_Blend
static void SDL_Blit_ABGR8888_RGB888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5002
SDL_BlitFuncEntry
Definition: SDL_blit.h:75
SDL_Blit_ARGB8888_BGR888_Modulate_Blend
static void SDL_Blit_ARGB8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3165
SDL_GeneratedBlitFuncTable
SDL_BlitFuncEntry SDL_GeneratedBlitFuncTable[]
Definition: SDL_blit_auto.c:7431
SDL_BlitInfo::src_pitch
int src_pitch
Definition: SDL_blit.h:59
SDL_Blit_ABGR8888_ARGB8888_Modulate_Scale
static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5988
SDL_Blit_BGR888_ARGB8888_Blend_Scale
static void SDL_Blit_BGR888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2176
SDL_Blit_RGBA8888_BGR888_Modulate_Blend
static void SDL_Blit_RGBA8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4396
SDL_Blit_BGRA8888_RGB888_Blend_Scale
static void SDL_Blit_BGRA8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6291
SDL_Blit_BGR888_BGR888_Modulate_Scale
static void SDL_Blit_BGR888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1873
SDL_Blit_BGRA8888_RGB888_Blend
static void SDL_Blit_BGRA8888_RGB888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6238
SDL_PIXELFORMAT_ARGB8888
Definition: SDL_pixels.h:224
SDL_Blit_ABGR8888_BGR888_Modulate_Scale
static void SDL_Blit_ABGR8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5576
SDL_Blit_BGR888_RGB888_Scale
static void SDL_Blit_BGR888_RGB888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1261
SDL_Blit_ABGR8888_ARGB8888_Blend
static void SDL_Blit_ABGR8888_ARGB8888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5826
SDL_Blit_ARGB8888_RGB888_Modulate_Blend_Scale
static void SDL_Blit_ARGB8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2818
SDL_Blit_RGB888_BGR888_Modulate_Blend
static void SDL_Blit_RGB888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:698
SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend
static void SDL_Blit_ARGB8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3572
SDL_Blit_ARGB8888_BGR888_Modulate_Scale
static void SDL_Blit_ARGB8888_BGR888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3109
SDL_Blit_BGR888_RGB888_Modulate
static void SDL_Blit_BGR888_RGB888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1431
SDL_blit.h
flags
GLenum GLsizei GLsizei GLsizei GLsizei GLbitfield flags
Definition: glew.h:2767
SDL_Blit_BGRA8888_BGR888_Modulate
static void SDL_Blit_BGRA8888_BGR888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6777
SDL_Blit_BGRA8888_BGR888_Modulate_Blend
static void SDL_Blit_BGRA8888_BGR888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6868
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
SDL_Blit_BGR888_RGB888_Modulate_Blend_Scale
static void SDL_Blit_BGR888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1587
SDL_Blit_ABGR8888_RGB888_Modulate_Scale
static void SDL_Blit_ABGR8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5164
SDL_Blit_ARGB8888_RGB888_Modulate_Blend
static void SDL_Blit_ARGB8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2753
SDL_PIXELFORMAT_RGBA8888
Definition: SDL_pixels.h:227
G
#define G(x, y, z)
Definition: SDL_test_md5.c:74
SDL_Blit_BGR888_BGR888_Scale
static void SDL_Blit_BGR888_BGR888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1673
SDL_Blit_BGR888_RGB888_Modulate_Blend
static void SDL_Blit_BGR888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1522
SDL_Blit_RGBA8888_ARGB8888_Blend
static void SDL_Blit_RGBA8888_ARGB8888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4590
SDL_Blit_RGB888_RGB888_Modulate_Blend_Scale
static void SDL_Blit_RGB888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:351
SDL_Blit_RGB888_BGR888_Modulate
static void SDL_Blit_RGB888_BGR888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:607
SDL_Blit_BGRA8888_BGR888_Blend_Scale
static void SDL_Blit_BGRA8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6703
SDL_PIXELFORMAT_RGB888
Definition: SDL_pixels.h:212
SDL_PIXELFORMAT_BGR888
Definition: SDL_pixels.h:218
SDL_Blit_ARGB8888_BGR888_Blend
static void SDL_Blit_ARGB8888_BGR888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2947
SDL_Blit_ABGR8888_BGR888_Modulate
static void SDL_Blit_ABGR8888_BGR888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5541
SDL_Blit_RGBA8888_RGB888_Modulate_Scale
static void SDL_Blit_RGBA8888_RGB888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3928
SDL_Blit_RGB888_ARGB8888_Blend_Scale
static void SDL_Blit_RGB888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:945
SDL_Blit_ABGR8888_ARGB8888_Blend_Scale
static void SDL_Blit_ABGR8888_ARGB8888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5879
SDL_CPU_ANY
#define SDL_CPU_ANY
Definition: SDL_blit.h:47
src
GLenum src
Definition: glew.h:2396
SDL_Blit_RGBA8888_RGB888_Scale
static void SDL_Blit_RGBA8888_RGB888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:3723
R
R
Definition: e_log.c:153
SDL_BlitInfo::dst_w
int dst_w
Definition: SDL_blit.h:62
SDL_Blit_RGB888_ARGB8888_Scale
static void SDL_Blit_RGB888_ARGB8888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:849
while
while(1)
Definition: glslang_lex.cpp:1063
SDL_Blit_RGBA8888_BGR888_Scale
static void SDL_Blit_RGBA8888_BGR888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4135
SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend
static void SDL_Blit_BGRA8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:7280
SDL_Blit_ABGR8888_ARGB8888_Scale
static void SDL_Blit_ABGR8888_ARGB8888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5783
SDL_Blit_RGBA8888_BGR888_Blend_Scale
static void SDL_Blit_RGBA8888_BGR888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4231
SDL_Blit_BGRA8888_RGB888_Modulate_Blend
static void SDL_Blit_BGRA8888_RGB888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6456
SDL_Blit_BGRA8888_RGB888_Modulate
static void SDL_Blit_BGRA8888_RGB888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6365
SDL_Blit_ABGR8888_RGB888_Blend_Scale
static void SDL_Blit_ABGR8888_RGB888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5055
SDL_Blit_BGRA8888_BGR888_Scale
static void SDL_Blit_BGRA8888_BGR888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6607
SDL_Blit_RGB888_ARGB8888_Modulate_Blend
static void SDL_Blit_RGB888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:1110
SDL_Blit_RGBA8888_RGB888_Modulate_Blend_Scale
static void SDL_Blit_RGBA8888_RGB888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4049
SDL_Blit_RGBA8888_ARGB8888_Modulate_Scale
static void SDL_Blit_RGBA8888_ARGB8888_Modulate_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4752
SDL_COPY_BLEND
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_Blit_RGB888_BGR888_Blend_Scale
static void SDL_Blit_RGB888_BGR888_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:533
SDL_Blit_ARGB8888_RGB888_Modulate
static void SDL_Blit_ARGB8888_RGB888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2662
SDL_Blit_ABGR8888_ARGB8888_Modulate
static void SDL_Blit_ABGR8888_ARGB8888_Modulate(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:5953
SDL_Blit_RGBA8888_BGR888_Blend
static void SDL_Blit_RGBA8888_BGR888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4178
SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend_Scale
static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6109
SDL_BlitInfo::a
Uint8 a
Definition: SDL_blit.h:70
SDL_Blit_RGB888_RGB888_Blend
static void SDL_Blit_RGB888_RGB888_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:68
SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend
static void SDL_Blit_ABGR8888_ARGB8888_Modulate_Blend(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:6044
SDL_Blit_RGBA8888_BGR888_Modulate_Blend_Scale
static void SDL_Blit_RGBA8888_BGR888_Modulate_Blend_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:4461
SDL_Blit_ARGB8888_BGR888_Scale
static void SDL_Blit_ARGB8888_BGR888_Scale(SDL_BlitInfo *info)
Definition: SDL_blit_auto.c:2904