SDL  2.0
SDL_surface.c
Go to the documentation of this file.
1 /*
2  Simple DirectMedia Layer
3  Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4 
5  This software is provided 'as-is', without any express or implied
6  warranty. In no event will the authors be held liable for any damages
7  arising from the use of this software.
8 
9  Permission is granted to anyone to use this software for any purpose,
10  including commercial applications, and to alter it and redistribute it
11  freely, subject to the following restrictions:
12 
13  1. The origin of this software must not be misrepresented; you must not
14  claim that you wrote the original software. If you use this software
15  in a product, an acknowledgment in the product documentation would be
16  appreciated but is not required.
17  2. Altered source versions must be plainly marked as such, and must not be
18  misrepresented as being the original software.
19  3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "../SDL_internal.h"
22 
23 #include "SDL_video.h"
24 #include "SDL_sysvideo.h"
25 #include "SDL_blit.h"
26 #include "SDL_RLEaccel_c.h"
27 #include "SDL_pixels_c.h"
28 #include "SDL_yuv_c.h"
29 
30 
31 /* Check to make sure we can safely check multiplication of surface w and pitch and it won't overflow size_t */
32 SDL_COMPILE_TIME_ASSERT(surface_size_assumptions,
33  sizeof(int) == sizeof(Sint32) && sizeof(size_t) >= sizeof(Sint32));
34 
35 /* Public routines */
36 
37 /*
38  * Calculate the pad-aligned scanline width of a surface
39  */
40 static int
42 {
43  int pitch;
44 
45  /* Surface should be 4-byte aligned for speed */
46  pitch = width * SDL_BYTESPERPIXEL(format);
47  switch (SDL_BITSPERPIXEL(format)) {
48  case 1:
49  pitch = (pitch + 7) / 8;
50  break;
51  case 4:
52  pitch = (pitch + 1) / 2;
53  break;
54  default:
55  break;
56  }
57  pitch = (pitch + 3) & ~3; /* 4-byte aligning */
58  return pitch;
59 }
60 
61 /*
62  * Create an empty RGB surface of the appropriate depth using the given
63  * enum SDL_PIXELFORMAT_* format
64  */
67  Uint32 format)
68 {
70 
71  /* The flags are no longer used, make the compiler happy */
72  (void)flags;
73 
74  /* Allocate the surface */
75  surface = (SDL_Surface *) SDL_calloc(1, sizeof(*surface));
76  if (surface == NULL) {
78  return NULL;
79  }
80 
81  surface->format = SDL_AllocFormat(format);
82  if (!surface->format) {
83  SDL_FreeSurface(surface);
84  return NULL;
85  }
86  surface->w = width;
87  surface->h = height;
88  surface->pitch = SDL_CalculatePitch(format, width);
89  SDL_SetClipRect(surface, NULL);
90 
91  if (SDL_ISPIXELFORMAT_INDEXED(surface->format->format)) {
92  SDL_Palette *palette =
93  SDL_AllocPalette((1 << surface->format->BitsPerPixel));
94  if (!palette) {
95  SDL_FreeSurface(surface);
96  return NULL;
97  }
98  if (palette->ncolors == 2) {
99  /* Create a black and white bitmap palette */
100  palette->colors[0].r = 0xFF;
101  palette->colors[0].g = 0xFF;
102  palette->colors[0].b = 0xFF;
103  palette->colors[1].r = 0x00;
104  palette->colors[1].g = 0x00;
105  palette->colors[1].b = 0x00;
106  }
107  SDL_SetSurfacePalette(surface, palette);
108  SDL_FreePalette(palette);
109  }
110 
111  /* Get the pixels */
112  if (surface->w && surface->h) {
113  /* Assumptions checked in surface_size_assumptions assert above */
114  Sint64 size = ((Sint64)surface->h * surface->pitch);
116  /* Overflow... */
117  SDL_FreeSurface(surface);
118  SDL_OutOfMemory();
119  return NULL;
120  }
121 
122  surface->pixels = SDL_malloc((size_t)size);
123  if (!surface->pixels) {
124  SDL_FreeSurface(surface);
125  SDL_OutOfMemory();
126  return NULL;
127  }
128  /* This is important for bitmaps */
129  SDL_memset(surface->pixels, 0, surface->h * surface->pitch);
130  }
131 
132  /* Allocate an empty mapping */
133  surface->map = SDL_AllocBlitMap();
134  if (!surface->map) {
135  SDL_FreeSurface(surface);
136  return NULL;
137  }
138 
139  /* By default surface with an alpha mask are set up for blending */
140  if (surface->format->Amask) {
142  }
143 
144  /* The surface is ready to go */
145  surface->refcount = 1;
146  return surface;
147 }
148 
149 /*
150  * Create an empty RGB surface of the appropriate depth
151  */
152 SDL_Surface *
154  int width, int height, int depth,
155  Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
156 {
157  Uint32 format;
158 
159  /* Get the pixel format */
160  format = SDL_MasksToPixelFormatEnum(depth, Rmask, Gmask, Bmask, Amask);
161  if (format == SDL_PIXELFORMAT_UNKNOWN) {
162  SDL_SetError("Unknown pixel format");
163  return NULL;
164  }
165 
166  return SDL_CreateRGBSurfaceWithFormat(flags, width, height, depth, format);
167 }
168 
169 /*
170  * Create an RGB surface from an existing memory buffer
171  */
172 SDL_Surface *
174  int width, int height, int depth, int pitch,
175  Uint32 Rmask, Uint32 Gmask, Uint32 Bmask,
176  Uint32 Amask)
177 {
179 
180  surface = SDL_CreateRGBSurface(0, 0, 0, depth, Rmask, Gmask, Bmask, Amask);
181  if (surface != NULL) {
182  surface->flags |= SDL_PREALLOC;
183  surface->pixels = pixels;
184  surface->w = width;
185  surface->h = height;
186  surface->pitch = pitch;
187  SDL_SetClipRect(surface, NULL);
188  }
189  return surface;
190 }
191 
192 /*
193  * Create an RGB surface from an existing memory buffer using the given given
194  * enum SDL_PIXELFORMAT_* format
195  */
196 SDL_Surface *
198  int width, int height, int depth, int pitch,
199  Uint32 format)
200 {
202 
203  surface = SDL_CreateRGBSurfaceWithFormat(0, 0, 0, depth, format);
204  if (surface != NULL) {
205  surface->flags |= SDL_PREALLOC;
206  surface->pixels = pixels;
207  surface->w = width;
208  surface->h = height;
209  surface->pitch = pitch;
210  SDL_SetClipRect(surface, NULL);
211  }
212  return surface;
213 }
214 
215 int
217 {
218  if (!surface) {
219  return SDL_SetError("SDL_SetSurfacePalette() passed a NULL surface");
220  }
221  if (SDL_SetPixelFormatPalette(surface->format, palette) < 0) {
222  return -1;
223  }
224  SDL_InvalidateMap(surface->map);
225 
226  return 0;
227 }
228 
229 int
231 {
232  int flags;
233 
234  if (!surface) {
235  return -1;
236  }
237 
238  flags = surface->map->info.flags;
239  if (flag) {
240  surface->map->info.flags |= SDL_COPY_RLE_DESIRED;
241  } else {
242  surface->map->info.flags &= ~SDL_COPY_RLE_DESIRED;
243  }
244  if (surface->map->info.flags != flags) {
245  SDL_InvalidateMap(surface->map);
246  }
247  return 0;
248 }
249 
250 int
252 {
253  int flags;
254 
255  if (!surface) {
256  return SDL_InvalidParamError("surface");
257  }
258 
259  if (surface->format->palette && key >= ((Uint32) surface->format->palette->ncolors)) {
260  return SDL_InvalidParamError("key");
261  }
262 
263  if (flag & SDL_RLEACCEL) {
264  SDL_SetSurfaceRLE(surface, 1);
265  }
266 
267  flags = surface->map->info.flags;
268  if (flag) {
269  surface->map->info.flags |= SDL_COPY_COLORKEY;
270  surface->map->info.colorkey = key;
271  if (surface->format->palette) {
272  surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_TRANSPARENT;
273  ++surface->format->palette->version;
274  if (!surface->format->palette->version) {
275  surface->format->palette->version = 1;
276  }
277  }
278  } else {
279  if (surface->format->palette) {
280  surface->format->palette->colors[surface->map->info.colorkey].a = SDL_ALPHA_OPAQUE;
281  ++surface->format->palette->version;
282  if (!surface->format->palette->version) {
283  surface->format->palette->version = 1;
284  }
285  }
286  surface->map->info.flags &= ~SDL_COPY_COLORKEY;
287  }
288  if (surface->map->info.flags != flags) {
289  SDL_InvalidateMap(surface->map);
290  }
291 
292  return 0;
293 }
294 
295 SDL_bool
297 {
298  if (!surface) {
299  return SDL_FALSE;
300  }
301 
302  if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
303  return SDL_FALSE;
304  }
305 
306  return SDL_TRUE;
307 }
308 
309 int
311 {
312  if (!surface) {
313  return SDL_InvalidParamError("surface");
314  }
315 
316  if (!(surface->map->info.flags & SDL_COPY_COLORKEY)) {
317  return SDL_SetError("Surface doesn't have a colorkey");
318  }
319 
320  if (key) {
321  *key = surface->map->info.colorkey;
322  }
323  return 0;
324 }
325 
326 /* This is a fairly slow function to switch from colorkey to alpha */
327 static void
329 {
330  int x, y;
331 
332  if (!surface) {
333  return;
334  }
335 
336  if (!(surface->map->info.flags & SDL_COPY_COLORKEY) ||
337  !surface->format->Amask) {
338  return;
339  }
340 
341  SDL_LockSurface(surface);
342 
343  switch (surface->format->BytesPerPixel) {
344  case 2:
345  {
346  Uint16 *row, *spot;
347  Uint16 ckey = (Uint16) surface->map->info.colorkey;
348  Uint16 mask = (Uint16) (~surface->format->Amask);
349 
350  /* Ignore alpha in colorkey comparison */
351  ckey &= mask;
352  row = (Uint16 *) surface->pixels;
353  for (y = surface->h; y--;) {
354  spot = row;
355  for (x = surface->w; x--;) {
356  if ((*spot & mask) == ckey) {
357  *spot &= mask;
358  }
359  ++spot;
360  }
361  row += surface->pitch / 2;
362  }
363  }
364  break;
365  case 3:
366  /* FIXME */
367  break;
368  case 4:
369  {
370  Uint32 *row, *spot;
371  Uint32 ckey = surface->map->info.colorkey;
372  Uint32 mask = ~surface->format->Amask;
373 
374  /* Ignore alpha in colorkey comparison */
375  ckey &= mask;
376  row = (Uint32 *) surface->pixels;
377  for (y = surface->h; y--;) {
378  spot = row;
379  for (x = surface->w; x--;) {
380  if ((*spot & mask) == ckey) {
381  *spot &= mask;
382  }
383  ++spot;
384  }
385  row += surface->pitch / 4;
386  }
387  }
388  break;
389  }
390 
391  SDL_UnlockSurface(surface);
392 
393  SDL_SetColorKey(surface, 0, 0);
395 }
396 
397 int
399 {
400  int flags;
401 
402  if (!surface) {
403  return -1;
404  }
405 
406  surface->map->info.r = r;
407  surface->map->info.g = g;
408  surface->map->info.b = b;
409 
410  flags = surface->map->info.flags;
411  if (r != 0xFF || g != 0xFF || b != 0xFF) {
412  surface->map->info.flags |= SDL_COPY_MODULATE_COLOR;
413  } else {
414  surface->map->info.flags &= ~SDL_COPY_MODULATE_COLOR;
415  }
416  if (surface->map->info.flags != flags) {
417  SDL_InvalidateMap(surface->map);
418  }
419  return 0;
420 }
421 
422 
423 int
425 {
426  if (!surface) {
427  return -1;
428  }
429 
430  if (r) {
431  *r = surface->map->info.r;
432  }
433  if (g) {
434  *g = surface->map->info.g;
435  }
436  if (b) {
437  *b = surface->map->info.b;
438  }
439  return 0;
440 }
441 
442 int
444 {
445  int flags;
446 
447  if (!surface) {
448  return -1;
449  }
450 
451  surface->map->info.a = alpha;
452 
453  flags = surface->map->info.flags;
454  if (alpha != 0xFF) {
455  surface->map->info.flags |= SDL_COPY_MODULATE_ALPHA;
456  } else {
457  surface->map->info.flags &= ~SDL_COPY_MODULATE_ALPHA;
458  }
459  if (surface->map->info.flags != flags) {
460  SDL_InvalidateMap(surface->map);
461  }
462  return 0;
463 }
464 
465 int
467 {
468  if (!surface) {
469  return -1;
470  }
471 
472  if (alpha) {
473  *alpha = surface->map->info.a;
474  }
475  return 0;
476 }
477 
478 int
480 {
481  int flags, status;
482 
483  if (!surface) {
484  return -1;
485  }
486 
487  status = 0;
488  flags = surface->map->info.flags;
489  surface->map->info.flags &=
491  switch (blendMode) {
492  case SDL_BLENDMODE_NONE:
493  break;
494  case SDL_BLENDMODE_BLEND:
495  surface->map->info.flags |= SDL_COPY_BLEND;
496  break;
497  case SDL_BLENDMODE_ADD:
498  surface->map->info.flags |= SDL_COPY_ADD;
499  break;
500  case SDL_BLENDMODE_MOD:
501  surface->map->info.flags |= SDL_COPY_MOD;
502  break;
503  default:
504  status = SDL_Unsupported();
505  break;
506  }
507 
508  if (surface->map->info.flags != flags) {
509  SDL_InvalidateMap(surface->map);
510  }
511 
512  return status;
513 }
514 
515 int
517 {
518  if (!surface) {
519  return -1;
520  }
521 
522  if (!blendMode) {
523  return 0;
524  }
525 
526  switch (surface->map->
527  info.flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD)) {
528  case SDL_COPY_BLEND:
529  *blendMode = SDL_BLENDMODE_BLEND;
530  break;
531  case SDL_COPY_ADD:
532  *blendMode = SDL_BLENDMODE_ADD;
533  break;
534  case SDL_COPY_MOD:
535  *blendMode = SDL_BLENDMODE_MOD;
536  break;
537  default:
538  *blendMode = SDL_BLENDMODE_NONE;
539  break;
540  }
541  return 0;
542 }
543 
544 SDL_bool
546 {
547  SDL_Rect full_rect;
548 
549  /* Don't do anything if there's no surface to act on */
550  if (!surface) {
551  return SDL_FALSE;
552  }
553 
554  /* Set up the full surface rectangle */
555  full_rect.x = 0;
556  full_rect.y = 0;
557  full_rect.w = surface->w;
558  full_rect.h = surface->h;
559 
560  /* Set the clipping rectangle */
561  if (!rect) {
562  surface->clip_rect = full_rect;
563  return SDL_TRUE;
564  }
565  return SDL_IntersectRect(rect, &full_rect, &surface->clip_rect);
566 }
567 
568 void
570 {
571  if (surface && rect) {
572  *rect = surface->clip_rect;
573  }
574 }
575 
576 /*
577  * Set up a blit between two surfaces -- split into three parts:
578  * The upper part, SDL_UpperBlit(), performs clipping and rectangle
579  * verification. The lower part is a pointer to a low level
580  * accelerated blitting function.
581  *
582  * These parts are separated out and each used internally by this
583  * library in the optimimum places. They are exported so that if
584  * you know exactly what you are doing, you can optimize your code
585  * by calling the one(s) you need.
586  */
587 int
589  SDL_Surface * dst, SDL_Rect * dstrect)
590 {
591  /* Check to make sure the blit mapping is valid */
592  if ((src->map->dst != dst) ||
593  (dst->format->palette &&
594  src->map->dst_palette_version != dst->format->palette->version) ||
595  (src->format->palette &&
596  src->map->src_palette_version != src->format->palette->version)) {
597  if (SDL_MapSurface(src, dst) < 0) {
598  return (-1);
599  }
600  /* just here for debugging */
601 /* printf */
602 /* ("src = 0x%08X src->flags = %08X src->map->info.flags = %08x\ndst = 0x%08X dst->flags = %08X dst->map->info.flags = %08X\nsrc->map->blit = 0x%08x\n", */
603 /* src, dst->flags, src->map->info.flags, dst, dst->flags, */
604 /* dst->map->info.flags, src->map->blit); */
605  }
606  return (src->map->blit(src, srcrect, dst, dstrect));
607 }
608 
609 
610 int
612  SDL_Surface * dst, SDL_Rect * dstrect)
613 {
614  SDL_Rect fulldst;
615  int srcx, srcy, w, h;
616 
617  /* Make sure the surfaces aren't locked */
618  if (!src || !dst) {
619  return SDL_SetError("SDL_UpperBlit: passed a NULL surface");
620  }
621  if (src->locked || dst->locked) {
622  return SDL_SetError("Surfaces must not be locked during blit");
623  }
624 
625  /* If the destination rectangle is NULL, use the entire dest surface */
626  if (dstrect == NULL) {
627  fulldst.x = fulldst.y = 0;
628  fulldst.w = dst->w;
629  fulldst.h = dst->h;
630  dstrect = &fulldst;
631  }
632 
633  /* clip the source rectangle to the source surface */
634  if (srcrect) {
635  int maxw, maxh;
636 
637  srcx = srcrect->x;
638  w = srcrect->w;
639  if (srcx < 0) {
640  w += srcx;
641  dstrect->x -= srcx;
642  srcx = 0;
643  }
644  maxw = src->w - srcx;
645  if (maxw < w)
646  w = maxw;
647 
648  srcy = srcrect->y;
649  h = srcrect->h;
650  if (srcy < 0) {
651  h += srcy;
652  dstrect->y -= srcy;
653  srcy = 0;
654  }
655  maxh = src->h - srcy;
656  if (maxh < h)
657  h = maxh;
658 
659  } else {
660  srcx = srcy = 0;
661  w = src->w;
662  h = src->h;
663  }
664 
665  /* clip the destination rectangle against the clip rectangle */
666  {
667  SDL_Rect *clip = &dst->clip_rect;
668  int dx, dy;
669 
670  dx = clip->x - dstrect->x;
671  if (dx > 0) {
672  w -= dx;
673  dstrect->x += dx;
674  srcx += dx;
675  }
676  dx = dstrect->x + w - clip->x - clip->w;
677  if (dx > 0)
678  w -= dx;
679 
680  dy = clip->y - dstrect->y;
681  if (dy > 0) {
682  h -= dy;
683  dstrect->y += dy;
684  srcy += dy;
685  }
686  dy = dstrect->y + h - clip->y - clip->h;
687  if (dy > 0)
688  h -= dy;
689  }
690 
691  /* Switch back to a fast blit if we were previously stretching */
692  if (src->map->info.flags & SDL_COPY_NEAREST) {
693  src->map->info.flags &= ~SDL_COPY_NEAREST;
694  SDL_InvalidateMap(src->map);
695  }
696 
697  if (w > 0 && h > 0) {
698  SDL_Rect sr;
699  sr.x = srcx;
700  sr.y = srcy;
701  sr.w = dstrect->w = w;
702  sr.h = dstrect->h = h;
703  return SDL_LowerBlit(src, &sr, dst, dstrect);
704  }
705  dstrect->w = dstrect->h = 0;
706  return 0;
707 }
708 
709 int
711  SDL_Surface * dst, SDL_Rect * dstrect)
712 {
713  double src_x0, src_y0, src_x1, src_y1;
714  double dst_x0, dst_y0, dst_x1, dst_y1;
715  SDL_Rect final_src, final_dst;
716  double scaling_w, scaling_h;
717  int src_w, src_h;
718  int dst_w, dst_h;
719 
720  /* Make sure the surfaces aren't locked */
721  if (!src || !dst) {
722  return SDL_SetError("SDL_UpperBlitScaled: passed a NULL surface");
723  }
724  if (src->locked || dst->locked) {
725  return SDL_SetError("Surfaces must not be locked during blit");
726  }
727 
728  if (NULL == srcrect) {
729  src_w = src->w;
730  src_h = src->h;
731  } else {
732  src_w = srcrect->w;
733  src_h = srcrect->h;
734  }
735 
736  if (NULL == dstrect) {
737  dst_w = dst->w;
738  dst_h = dst->h;
739  } else {
740  dst_w = dstrect->w;
741  dst_h = dstrect->h;
742  }
743 
744  if (dst_w == src_w && dst_h == src_h) {
745  /* No scaling, defer to regular blit */
746  return SDL_BlitSurface(src, srcrect, dst, dstrect);
747  }
748 
749  scaling_w = (double)dst_w / src_w;
750  scaling_h = (double)dst_h / src_h;
751 
752  if (NULL == dstrect) {
753  dst_x0 = 0;
754  dst_y0 = 0;
755  dst_x1 = dst_w - 1;
756  dst_y1 = dst_h - 1;
757  } else {
758  dst_x0 = dstrect->x;
759  dst_y0 = dstrect->y;
760  dst_x1 = dst_x0 + dst_w - 1;
761  dst_y1 = dst_y0 + dst_h - 1;
762  }
763 
764  if (NULL == srcrect) {
765  src_x0 = 0;
766  src_y0 = 0;
767  src_x1 = src_w - 1;
768  src_y1 = src_h - 1;
769  } else {
770  src_x0 = srcrect->x;
771  src_y0 = srcrect->y;
772  src_x1 = src_x0 + src_w - 1;
773  src_y1 = src_y0 + src_h - 1;
774 
775  /* Clip source rectangle to the source surface */
776 
777  if (src_x0 < 0) {
778  dst_x0 -= src_x0 * scaling_w;
779  src_x0 = 0;
780  }
781 
782  if (src_x1 >= src->w) {
783  dst_x1 -= (src_x1 - src->w + 1) * scaling_w;
784  src_x1 = src->w - 1;
785  }
786 
787  if (src_y0 < 0) {
788  dst_y0 -= src_y0 * scaling_h;
789  src_y0 = 0;
790  }
791 
792  if (src_y1 >= src->h) {
793  dst_y1 -= (src_y1 - src->h + 1) * scaling_h;
794  src_y1 = src->h - 1;
795  }
796  }
797 
798  /* Clip destination rectangle to the clip rectangle */
799 
800  /* Translate to clip space for easier calculations */
801  dst_x0 -= dst->clip_rect.x;
802  dst_x1 -= dst->clip_rect.x;
803  dst_y0 -= dst->clip_rect.y;
804  dst_y1 -= dst->clip_rect.y;
805 
806  if (dst_x0 < 0) {
807  src_x0 -= dst_x0 / scaling_w;
808  dst_x0 = 0;
809  }
810 
811  if (dst_x1 >= dst->clip_rect.w) {
812  src_x1 -= (dst_x1 - dst->clip_rect.w + 1) / scaling_w;
813  dst_x1 = dst->clip_rect.w - 1;
814  }
815 
816  if (dst_y0 < 0) {
817  src_y0 -= dst_y0 / scaling_h;
818  dst_y0 = 0;
819  }
820 
821  if (dst_y1 >= dst->clip_rect.h) {
822  src_y1 -= (dst_y1 - dst->clip_rect.h + 1) / scaling_h;
823  dst_y1 = dst->clip_rect.h - 1;
824  }
825 
826  /* Translate back to surface coordinates */
827  dst_x0 += dst->clip_rect.x;
828  dst_x1 += dst->clip_rect.x;
829  dst_y0 += dst->clip_rect.y;
830  dst_y1 += dst->clip_rect.y;
831 
832  final_src.x = (int)SDL_floor(src_x0 + 0.5);
833  final_src.y = (int)SDL_floor(src_y0 + 0.5);
834  final_src.w = (int)SDL_floor(src_x1 + 1 + 0.5) - (int)SDL_floor(src_x0 + 0.5);
835  final_src.h = (int)SDL_floor(src_y1 + 1 + 0.5) - (int)SDL_floor(src_y0 + 0.5);
836 
837  final_dst.x = (int)SDL_floor(dst_x0 + 0.5);
838  final_dst.y = (int)SDL_floor(dst_y0 + 0.5);
839  final_dst.w = (int)SDL_floor(dst_x1 - dst_x0 + 1.5);
840  final_dst.h = (int)SDL_floor(dst_y1 - dst_y0 + 1.5);
841 
842  if (final_dst.w < 0)
843  final_dst.w = 0;
844  if (final_dst.h < 0)
845  final_dst.h = 0;
846 
847  if (dstrect)
848  *dstrect = final_dst;
849 
850  if (final_dst.w == 0 || final_dst.h == 0 ||
851  final_src.w <= 0 || final_src.h <= 0) {
852  /* No-op. */
853  return 0;
854  }
855 
856  return SDL_LowerBlitScaled(src, &final_src, dst, &final_dst);
857 }
858 
859 /**
860  * This is a semi-private blit function and it performs low-level surface
861  * scaled blitting only.
862  */
863 int
865  SDL_Surface * dst, SDL_Rect * dstrect)
866 {
867  static const Uint32 complex_copy_flags = (
871  );
872 
873  if (!(src->map->info.flags & SDL_COPY_NEAREST)) {
874  src->map->info.flags |= SDL_COPY_NEAREST;
875  SDL_InvalidateMap(src->map);
876  }
877 
878  if ( !(src->map->info.flags & complex_copy_flags) &&
879  src->format->format == dst->format->format &&
881  return SDL_SoftStretch( src, srcrect, dst, dstrect );
882  } else {
883  return SDL_LowerBlit( src, srcrect, dst, dstrect );
884  }
885 }
886 
887 /*
888  * Lock a surface to directly access the pixels
889  */
890 int
892 {
893  if (!surface->locked) {
894  /* Perform the lock */
895  if (surface->flags & SDL_RLEACCEL) {
896  SDL_UnRLESurface(surface, 1);
897  surface->flags |= SDL_RLEACCEL; /* save accel'd state */
898  }
899  }
900 
901  /* Increment the surface lock count, for recursive locks */
902  ++surface->locked;
903 
904  /* Ready to go.. */
905  return (0);
906 }
907 
908 /*
909  * Unlock a previously locked surface
910  */
911 void
913 {
914  /* Only perform an unlock if we are locked */
915  if (!surface->locked || (--surface->locked > 0)) {
916  return;
917  }
918 
919  /* Update RLE encoded surface with new data */
920  if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
921  surface->flags &= ~SDL_RLEACCEL; /* stop lying */
922  SDL_RLESurface(surface);
923  }
924 }
925 
926 /*
927  * Creates a new surface identical to the existing surface
928  */
929 SDL_Surface *
931 {
932  return SDL_ConvertSurface(surface, surface->format, surface->flags);
933 }
934 
935 /*
936  * Convert a surface into the specified pixel format.
937  */
938 SDL_Surface *
940  Uint32 flags)
941 {
942  SDL_Surface *convert;
943  Uint32 copy_flags;
944  SDL_Color copy_color;
945  SDL_Rect bounds;
946 
947  if (!surface) {
948  SDL_InvalidParamError("surface");
949  return NULL;
950  }
951  if (!format) {
952  SDL_InvalidParamError("format");
953  return NULL;
954  }
955 
956  /* Check for empty destination palette! (results in empty image) */
957  if (format->palette != NULL) {
958  int i;
959  for (i = 0; i < format->palette->ncolors; ++i) {
960  if ((format->palette->colors[i].r != 0xFF) ||
961  (format->palette->colors[i].g != 0xFF) ||
962  (format->palette->colors[i].b != 0xFF))
963  break;
964  }
965  if (i == format->palette->ncolors) {
966  SDL_SetError("Empty destination palette");
967  return (NULL);
968  }
969  }
970 
971  /* Create a new surface with the desired format */
972  convert = SDL_CreateRGBSurface(flags, surface->w, surface->h,
973  format->BitsPerPixel, format->Rmask,
974  format->Gmask, format->Bmask,
975  format->Amask);
976  if (convert == NULL) {
977  return (NULL);
978  }
979 
980  /* Copy the palette if any */
981  if (format->palette && convert->format->palette) {
982  SDL_memcpy(convert->format->palette->colors,
983  format->palette->colors,
984  format->palette->ncolors * sizeof(SDL_Color));
985  convert->format->palette->ncolors = format->palette->ncolors;
986  }
987 
988  /* Save the original copy flags */
989  copy_flags = surface->map->info.flags;
990  copy_color.r = surface->map->info.r;
991  copy_color.g = surface->map->info.g;
992  copy_color.b = surface->map->info.b;
993  copy_color.a = surface->map->info.a;
994  surface->map->info.r = 0xFF;
995  surface->map->info.g = 0xFF;
996  surface->map->info.b = 0xFF;
997  surface->map->info.a = 0xFF;
998  surface->map->info.flags = 0;
999  SDL_InvalidateMap(surface->map);
1000 
1001  /* Copy over the image data */
1002  bounds.x = 0;
1003  bounds.y = 0;
1004  bounds.w = surface->w;
1005  bounds.h = surface->h;
1006  SDL_LowerBlit(surface, &bounds, convert, &bounds);
1007 
1008  /* Clean up the original surface, and update converted surface */
1009  convert->map->info.r = copy_color.r;
1010  convert->map->info.g = copy_color.g;
1011  convert->map->info.b = copy_color.b;
1012  convert->map->info.a = copy_color.a;
1013  convert->map->info.flags =
1014  (copy_flags &
1018  surface->map->info.r = copy_color.r;
1019  surface->map->info.g = copy_color.g;
1020  surface->map->info.b = copy_color.b;
1021  surface->map->info.a = copy_color.a;
1022  surface->map->info.flags = copy_flags;
1023  SDL_InvalidateMap(surface->map);
1024  if (copy_flags & SDL_COPY_COLORKEY) {
1025  SDL_bool set_colorkey_by_color = SDL_FALSE;
1026 
1027  if (surface->format->palette) {
1028  if (format->palette &&
1029  surface->format->palette->ncolors <= format->palette->ncolors &&
1030  (SDL_memcmp(surface->format->palette->colors, format->palette->colors,
1031  surface->format->palette->ncolors * sizeof(SDL_Color)) == 0)) {
1032  /* The palette is identical, just set the same colorkey */
1033  SDL_SetColorKey(convert, 1, surface->map->info.colorkey);
1034  } else if (format->Amask) {
1035  /* The alpha was set in the destination from the palette */
1036  } else {
1037  set_colorkey_by_color = SDL_TRUE;
1038  }
1039  } else {
1040  set_colorkey_by_color = SDL_TRUE;
1041  }
1042 
1043  if (set_colorkey_by_color) {
1044  SDL_Surface *tmp;
1045  SDL_Surface *tmp2;
1046  int converted_colorkey = 0;
1047 
1048  /* Create a dummy surface to get the colorkey converted */
1049  tmp = SDL_CreateRGBSurface(0, 1, 1,
1050  surface->format->BitsPerPixel, surface->format->Rmask,
1051  surface->format->Gmask, surface->format->Bmask,
1052  surface->format->Amask);
1053 
1054  /* Share the palette, if any */
1055  if (surface->format->palette) {
1056  SDL_SetSurfacePalette(tmp, surface->format->palette);
1057  }
1058 
1059  SDL_FillRect(tmp, NULL, surface->map->info.colorkey);
1060 
1061  tmp->map->info.flags &= ~SDL_COPY_COLORKEY;
1062 
1063  /* Convertion of the colorkey */
1064  tmp2 = SDL_ConvertSurface(tmp, format, 0);
1065 
1066  /* Get the converted colorkey */
1067  SDL_memcpy(&converted_colorkey, tmp2->pixels, tmp2->format->BytesPerPixel);
1068 
1069  SDL_FreeSurface(tmp);
1070  SDL_FreeSurface(tmp2);
1071 
1072  /* Set the converted colorkey on the new surface */
1073  SDL_SetColorKey(convert, 1, converted_colorkey);
1074 
1075  /* This is needed when converting for 3D texture upload */
1076  SDL_ConvertColorkeyToAlpha(convert);
1077  }
1078  }
1079  SDL_SetClipRect(convert, &surface->clip_rect);
1080 
1081  /* Enable alpha blending by default if the new surface has an
1082  * alpha channel or alpha modulation */
1083  if ((surface->format->Amask && format->Amask) ||
1084  (copy_flags & SDL_COPY_MODULATE_ALPHA)) {
1086  }
1087  if ((copy_flags & SDL_COPY_RLE_DESIRED) || (flags & SDL_RLEACCEL)) {
1088  SDL_SetSurfaceRLE(convert, SDL_RLEACCEL);
1089  }
1090 
1091  /* We're ready to go! */
1092  return (convert);
1093 }
1094 
1095 SDL_Surface *
1097  Uint32 flags)
1098 {
1099  SDL_PixelFormat *fmt;
1100  SDL_Surface *convert = NULL;
1101 
1102  fmt = SDL_AllocFormat(pixel_format);
1103  if (fmt) {
1104  convert = SDL_ConvertSurface(surface, fmt, flags);
1105  SDL_FreeFormat(fmt);
1106  }
1107  return convert;
1108 }
1109 
1110 /*
1111  * Create a surface on the stack for quick blit operations
1112  */
1113 static SDL_INLINE SDL_bool
1115  void * pixels, int pitch, SDL_Surface * surface,
1116  SDL_PixelFormat * format, SDL_BlitMap * blitmap)
1117 {
1118  if (SDL_ISPIXELFORMAT_INDEXED(pixel_format)) {
1119  SDL_SetError("Indexed pixel formats not supported");
1120  return SDL_FALSE;
1121  }
1122  if (SDL_InitFormat(format, pixel_format) < 0) {
1123  return SDL_FALSE;
1124  }
1125 
1126  SDL_zerop(surface);
1127  surface->flags = SDL_PREALLOC;
1128  surface->format = format;
1129  surface->pixels = pixels;
1130  surface->w = width;
1131  surface->h = height;
1132  surface->pitch = pitch;
1133  /* We don't actually need to set up the clip rect for our purposes */
1134  /* SDL_SetClipRect(surface, NULL); */
1135 
1136  /* Allocate an empty mapping */
1137  SDL_zerop(blitmap);
1138  blitmap->info.r = 0xFF;
1139  blitmap->info.g = 0xFF;
1140  blitmap->info.b = 0xFF;
1141  blitmap->info.a = 0xFF;
1142  surface->map = blitmap;
1143 
1144  /* The surface is ready to go */
1145  surface->refcount = 1;
1146  return SDL_TRUE;
1147 }
1148 
1149 /*
1150  * Copy a block of pixels of one format to another format
1151  */
1153  Uint32 src_format, const void * src, int src_pitch,
1154  Uint32 dst_format, void * dst, int dst_pitch)
1155 {
1156  SDL_Surface src_surface, dst_surface;
1157  SDL_PixelFormat src_fmt, dst_fmt;
1158  SDL_BlitMap src_blitmap, dst_blitmap;
1159  SDL_Rect rect;
1160  void *nonconst_src = (void *) src;
1161 
1162  /* Check to make sure we are blitting somewhere, so we don't crash */
1163  if (!dst) {
1164  return SDL_InvalidParamError("dst");
1165  }
1166  if (!dst_pitch) {
1167  return SDL_InvalidParamError("dst_pitch");
1168  }
1169 
1170  if (SDL_ISPIXELFORMAT_FOURCC(src_format) && SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
1171  return SDL_ConvertPixels_YUV_to_YUV(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
1172  } else if (SDL_ISPIXELFORMAT_FOURCC(src_format)) {
1173  return SDL_ConvertPixels_YUV_to_RGB(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
1174  } else if (SDL_ISPIXELFORMAT_FOURCC(dst_format)) {
1175  return SDL_ConvertPixels_RGB_to_YUV(width, height, src_format, src, src_pitch, dst_format, dst, dst_pitch);
1176  }
1177 
1178  /* Fast path for same format copy */
1179  if (src_format == dst_format) {
1180  int i;
1181  const int bpp = SDL_BYTESPERPIXEL(src_format);
1182  width *= bpp;
1183  for (i = height; i--;) {
1184  SDL_memcpy(dst, src, width);
1185  src = (const Uint8*)src + src_pitch;
1186  dst = (Uint8*)dst + dst_pitch;
1187  }
1188  return 0;
1189  }
1190 
1191  if (!SDL_CreateSurfaceOnStack(width, height, src_format, nonconst_src,
1192  src_pitch,
1193  &src_surface, &src_fmt, &src_blitmap)) {
1194  return -1;
1195  }
1196  if (!SDL_CreateSurfaceOnStack(width, height, dst_format, dst, dst_pitch,
1197  &dst_surface, &dst_fmt, &dst_blitmap)) {
1198  return -1;
1199  }
1200 
1201  /* Set up the rect and go! */
1202  rect.x = 0;
1203  rect.y = 0;
1204  rect.w = width;
1205  rect.h = height;
1206  return SDL_LowerBlit(&src_surface, &rect, &dst_surface, &rect);
1207 }
1208 
1209 /*
1210  * Free a surface created by the above function.
1211  */
1212 void
1214 {
1215  if (surface == NULL) {
1216  return;
1217  }
1218  if (surface->flags & SDL_DONTFREE) {
1219  return;
1220  }
1221  SDL_InvalidateMap(surface->map);
1222 
1223  if (--surface->refcount > 0) {
1224  return;
1225  }
1226  while (surface->locked > 0) {
1227  SDL_UnlockSurface(surface);
1228  }
1229  if (surface->flags & SDL_RLEACCEL) {
1230  SDL_UnRLESurface(surface, 0);
1231  }
1232  if (surface->format) {
1233  SDL_SetSurfacePalette(surface, NULL);
1234  SDL_FreeFormat(surface->format);
1235  surface->format = NULL;
1236  }
1237  if (!(surface->flags & SDL_PREALLOC)) {
1238  SDL_free(surface->pixels);
1239  }
1240  if (surface->map) {
1241  SDL_FreeBlitMap(surface->map);
1242  }
1243  SDL_free(surface);
1244 }
1245 
1246 /* vi: set ts=4 sw=4 expandtab: */
int SDL_GetColorKey(SDL_Surface *surface, Uint32 *key)
Gets the color key (transparent pixel) in a blittable surface.
Definition: SDL_surface.c:310
int SDL_ConvertPixels_YUV_to_YUV(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Definition: SDL_yuv.c:1902
Uint8 r
Definition: SDL_blit.h:70
#define SDL_COPY_MODULATE_COLOR
Definition: SDL_blit.h:34
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
void SDL_UnlockSurface(SDL_Surface *surface)
Definition: SDL_surface.c:912
Uint32 version
Definition: SDL_pixels.h:308
Uint8 b
Definition: SDL_blit.h:70
SDL_bool SDL_SetClipRect(SDL_Surface *surface, const SDL_Rect *rect)
Definition: SDL_surface.c:545
#define SDL_COPY_COLORKEY
Definition: SDL_blit.h:39
SDL_blit blit
Definition: SDL_blit.h:90
int SDL_SetSurfaceRLE(SDL_Surface *surface, int flag)
Sets the RLE acceleration hint for a surface.
Definition: SDL_surface.c:230
static int SDL_CalculatePitch(Uint32 format, int width)
Definition: SDL_surface.c:41
Uint8 g
Definition: SDL_pixels.h:298
GLenum GLenum dst
GLint GLint GLint GLint GLint x
Definition: SDL_opengl.h:1574
#define SDL_SoftStretch
#define SDL_ISPIXELFORMAT_INDEXED(format)
Definition: SDL_pixels.h:134
int SDL_LockSurface(SDL_Surface *surface)
Sets up a surface for directly accessing the pixels.
Definition: SDL_surface.c:891
SDL_Surface * SDL_ConvertSurfaceFormat(SDL_Surface *surface, Uint32 pixel_format, Uint32 flags)
Definition: SDL_surface.c:1096
SDL_BlendMode
The blend mode used in SDL_RenderCopy() and drawing operations.
Definition: SDL_blendmode.h:40
Uint8 BytesPerPixel
Definition: SDL_pixels.h:320
SDL_Rect rect
Definition: testrelative.c:27
Uint8 g
Definition: SDL_blit.h:70
#define SDL_MasksToPixelFormatEnum
SDL_Surface * SDL_ConvertSurface(SDL_Surface *surface, const SDL_PixelFormat *format, Uint32 flags)
Definition: SDL_surface.c:939
GLfloat GLfloat GLfloat GLfloat h
static SDL_INLINE SDL_bool SDL_CreateSurfaceOnStack(int width, int height, Uint32 pixel_format, void *pixels, int pitch, SDL_Surface *surface, SDL_PixelFormat *format, SDL_BlitMap *blitmap)
Definition: SDL_surface.c:1114
#define SDL_COPY_MOD
Definition: SDL_blit.h:38
EGLSurface surface
Definition: eglext.h:248
int SDL_SetSurfaceColorMod(SDL_Surface *surface, Uint8 r, Uint8 g, Uint8 b)
Set an additional color value used in blit operations.
Definition: SDL_surface.c:398
A collection of pixels used in software blitting.
Definition: SDL_surface.h:69
int SDL_SetSurfaceAlphaMod(SDL_Surface *surface, Uint8 alpha)
Set an additional alpha value used in blit operations.
Definition: SDL_surface.c:443
#define SDL_DONTFREE
Definition: SDL_surface.h:55
uint8_t Uint8
Definition: SDL_stdinc.h:179
int SDL_UpperBlitScaled(SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:710
int SDL_SetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode blendMode)
Set the blend mode used for blit operations.
Definition: SDL_surface.c:479
void SDL_UnRLESurface(SDL_Surface *surface, int recode)
#define SDL_BlitSurface
Definition: SDL_surface.h:483
static void SDL_ConvertColorkeyToAlpha(SDL_Surface *surface)
Definition: SDL_surface.c:328
#define SDL_BYTESPERPIXEL(X)
Definition: SDL_pixels.h:128
Uint32 dst_palette_version
Definition: SDL_blit.h:96
Uint8 b
Definition: SDL_pixels.h:299
SDL_Surface * SDL_DuplicateSurface(SDL_Surface *surface)
Definition: SDL_surface.c:930
#define SDL_AllocFormat
#define SDL_COPY_RLE_COLORKEY
Definition: SDL_blit.h:42
#define SDL_MAX_SINT32
A signed 32-bit integer type.
Definition: SDL_stdinc.h:195
#define SDL_InvalidParamError(param)
Definition: SDL_error.h:54
GLenum src
#define SDL_IntersectRect
uint32_t Uint32
Definition: SDL_stdinc.h:203
#define SDL_floor
int SDL_LowerBlit(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:588
#define SDL_zerop(x)
Definition: SDL_stdinc.h:417
int SDL_SetColorKey(SDL_Surface *surface, int flag, Uint32 key)
Sets the color key (transparent pixel) in a blittable surface.
Definition: SDL_surface.c:251
int SDL_UpperBlit(SDL_Surface *src, const SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:611
int SDL_ConvertPixels_YUV_to_RGB(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Definition: SDL_yuv.c:479
GLfloat GLfloat GLfloat alpha
GLint GLint GLsizei width
Definition: SDL_opengl.h:1572
#define SDL_COPY_ADD
Definition: SDL_blit.h:37
Uint32 colorkey
Definition: SDL_blit.h:69
Uint32 flags
Definition: SDL_surface.h:71
void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect)
Definition: SDL_surface.c:569
Uint32 src_palette_version
Definition: SDL_blit.h:97
#define SDL_COPY_RLE_DESIRED
Definition: SDL_blit.h:41
static SDL_BlendMode blendMode
Definition: testdraw2.c:34
void SDL_InvalidateMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:972
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: SDL_opengl.h:1572
#define SDL_COPY_NEAREST
Definition: SDL_blit.h:40
#define SDL_ALPHA_TRANSPARENT
Definition: SDL_pixels.h:47
SDL_Surface * SDL_CreateRGBSurfaceWithFormat(Uint32 flags, int width, int height, int depth, Uint32 format)
Definition: SDL_surface.c:66
struct SDL_BlitMap * map
Definition: SDL_surface.h:88
#define SDL_memcpy
GLuint64 key
Definition: gl2ext.h:2192
Uint8 r
Definition: SDL_pixels.h:297
SDL_COMPILE_TIME_ASSERT(surface_size_assumptions, sizeof(int)==sizeof(Sint32) &&sizeof(size_t) >=sizeof(Sint32))
int SDL_MapSurface(SDL_Surface *src, SDL_Surface *dst)
Definition: SDL_pixels.c:991
void * pixels
Definition: SDL_surface.h:75
Uint8 a
Definition: SDL_pixels.h:300
#define SDL_free
Uint8 BitsPerPixel
Definition: SDL_pixels.h:319
int SDL_SetSurfacePalette(SDL_Surface *surface, SDL_Palette *palette)
Set the palette used by a surface.
Definition: SDL_surface.c:216
int SDL_GetSurfaceBlendMode(SDL_Surface *surface, SDL_BlendMode *blendMode)
Get the blend mode used for blit operations.
Definition: SDL_surface.c:516
int SDL_ConvertPixels(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Copy a block of pixels of one format to another format.
Definition: SDL_surface.c:1152
#define SDL_FreeFormat
#define SDL_memcmp
GLenum GLint GLuint mask
GLubyte GLubyte GLubyte GLubyte w
GLint GLint GLint GLint GLint GLint y
Definition: SDL_opengl.h:1574
SDL_Surface * SDL_CreateRGBSurfaceWithFormatFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 format)
Definition: SDL_surface.c:197
int SDL_GetSurfaceAlphaMod(SDL_Surface *surface, Uint8 *alpha)
Get the additional alpha value used in blit operations.
Definition: SDL_surface.c:466
int x
Definition: SDL_rect.h:66
GLint GLint GLsizei GLsizei GLsizei GLint GLenum GLenum const GLvoid * pixels
Definition: SDL_opengl.h:1572
int32_t Sint32
Definition: SDL_stdinc.h:197
int w
Definition: SDL_rect.h:67
GLsizeiptr size
#define SDL_AllocPalette
int SDL_InitFormat(SDL_PixelFormat *format, Uint32 pixel_format)
Definition: SDL_pixels.c:537
SDL_Rect clip_rect
Definition: SDL_surface.h:85
void SDL_FreeSurface(SDL_Surface *surface)
Definition: SDL_surface.c:1213
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
int SDL_RLESurface(SDL_Surface *surface)
SDL_Surface * dst
Definition: SDL_blit.h:88
#define NULL
Definition: begin_code.h:164
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_bool
Definition: SDL_stdinc.h:161
SDL_Color * colors
Definition: SDL_pixels.h:307
SDL_PixelFormat * format
Definition: SDL_surface.h:72
GLint GLint GLsizei GLsizei GLsizei depth
Definition: SDL_opengl.h:1572
#define SDL_FreePalette
#define SDL_SetError
SDL_Surface * SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
Definition: SDL_surface.c:153
GLbitfield flags
SDL_bool SDL_HasColorKey(SDL_Surface *surface)
Returns whether the surface has a color key.
Definition: SDL_surface.c:296
GLint GLint GLsizei GLsizei height
Definition: SDL_opengl.h:1572
#define SDL_calloc
#define SDL_COPY_MODULATE_ALPHA
Definition: SDL_blit.h:35
int h
Definition: SDL_rect.h:67
SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char int SDL_PRINTF_FORMAT_STRING const char const char SDL_SCANF_FORMAT_STRING const char return SDL_ThreadFunction const char void return Uint32 return Uint32 void
#define SDL_COPY_RLE_ALPHAKEY
Definition: SDL_blit.h:43
#define SDL_FillRect
uint16_t Uint16
Definition: SDL_stdinc.h:191
int SDL_LowerBlitScaled(SDL_Surface *src, SDL_Rect *srcrect, SDL_Surface *dst, SDL_Rect *dstrect)
Definition: SDL_surface.c:864
SDL_BlitMap * SDL_AllocBlitMap(void)
Definition: SDL_pixels.c:952
#define SDL_INLINE
Definition: begin_code.h:131
#define SDL_malloc
SDL_Palette * palette
Definition: SDL_pixels.h:318
#define SDL_ISPIXELFORMAT_FOURCC(format)
Definition: SDL_pixels.h:167
SDL_Surface * SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch, Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
Definition: SDL_surface.c:173
int64_t Sint64
Definition: SDL_stdinc.h:210
#define SDL_ALPHA_OPAQUE
Definition: SDL_pixels.h:46
int SDL_ConvertPixels_RGB_to_YUV(int width, int height, Uint32 src_format, const void *src, int src_pitch, Uint32 dst_format, void *dst, int dst_pitch)
Definition: SDL_yuv.c:876
GLboolean GLboolean g
GLboolean GLboolean GLboolean b
void SDL_FreeBlitMap(SDL_BlitMap *map)
Definition: SDL_pixels.c:1077
int SDL_GetSurfaceColorMod(SDL_Surface *surface, Uint8 *r, Uint8 *g, Uint8 *b)
Get the additional color value used in blit operations.
Definition: SDL_surface.c:424
GLenum GLenum void * row
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127
int y
Definition: SDL_rect.h:66
#define SDL_SetPixelFormatPalette
#define SDL_Unsupported()
Definition: SDL_error.h:53
#define SDL_COPY_BLEND
Definition: SDL_blit.h:36
SDL_BlitInfo info
Definition: SDL_blit.h:92
#define SDL_memset
#define SDL_PREALLOC
Definition: SDL_surface.h:53
A rectangle, with the origin at the upper left.
Definition: SDL_rect.h:64
#define SDL_RLEACCEL
Definition: SDL_surface.h:54
Uint8 a
Definition: SDL_blit.h:70