zenilib  0.5.3.0
 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 = (