w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

pixman-private.h
Go to the documentation of this file.
1 #ifndef PIXMAN_PRIVATE_H
2 #define PIXMAN_PRIVATE_H
3 
4 /*
5  * The defines which are shared between C and assembly code
6  */
7 
8 /* bilinear interpolation precision (must be < 8) */
9 #define BILINEAR_INTERPOLATION_BITS 7
10 #define BILINEAR_INTERPOLATION_RANGE (1 << BILINEAR_INTERPOLATION_BITS)
11 
12 /*
13  * C specific part
14  */
15 
16 #ifndef __ASSEMBLER__
17 
18 #ifndef PACKAGE
19 # error config.h must be included before pixman-private.h
20 #endif
21 
22 #define PIXMAN_DISABLE_DEPRECATED
23 #define PIXMAN_USE_INTERNAL_API
24 
25 #include "pixman.h"
26 #include <time.h>
27 #include <assert.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <stddef.h>
31 #include <float.h>
32 
33 #include "pixman-compiler.h"
34 
35 /*
36  * Images
37  */
38 typedef struct image_common image_common_t;
39 typedef struct solid_fill solid_fill_t;
40 typedef struct gradient gradient_t;
41 typedef struct linear_gradient linear_gradient_t;
42 typedef struct horizontal_gradient horizontal_gradient_t;
43 typedef struct vertical_gradient vertical_gradient_t;
45 typedef struct radial_gradient radial_gradient_t;
46 typedef struct bits_image bits_image_t;
47 typedef struct circle circle_t;
48 
49 typedef struct argb_t argb_t;
50 
51 struct argb_t
52 {
53  float a;
54  float r;
55  float g;
56  float b;
57 };
58 
60  int x,
61  int y,
62  int width,
64  const uint32_t *mask);
65 
67  int x,
68  int y);
69 
71  int x,
72  int y);
73 
75  int x,
76  int y,
77  int width,
78  const uint32_t *values);
79 
80 typedef enum
81 {
86  SOLID
88 
90 
92 {
96  int32_t alpha_count; /* How many times this image is being used as an alpha map */
97  pixman_bool_t have_clip_region; /* FALSE if there is no clip */
98  pixman_bool_t client_clip; /* Whether the source clip was
99  set by a client */
100  pixman_bool_t clip_sources; /* Whether the clip applies when
101  * the image is used as a source
102  */
114 
116  void * destroy_data;
117 
120 };
121 
123 {
126 
129 };
130 
131 struct gradient
132 {
134  int n_stops;
136 };
137 
139 {
143 };
144 
145 struct circle
146 {
150 };
151 
153 {
155 
158 
160  double a;
161  double inva;
162  double mindr;
163 };
164 
166 {
169  double angle;
170 };
171 
173 {
177  int width;
178  int height;
181  int rowstride; /* in number of uint32_t's */
182 
186 
190 
194 
195  /* Used for indirect access to the bits */
198 };
199 
201 {
210 };
211 
212 typedef struct pixman_iter_t pixman_iter_t;
213 typedef uint32_t *(* pixman_iter_get_scanline_t) (pixman_iter_t *iter, const uint32_t *mask);
216 
217 typedef enum
218 {
219  ITER_NARROW = (1 << 0),
220  ITER_WIDE = (1 << 1),
221 
222  /* "Localized alpha" is when the alpha channel is used only to compute
223  * the alpha value of the destination. This means that the computation
224  * of the RGB values of the result is independent of the alpha value.
225  *
226  * For example, the OVER operator has localized alpha for the
227  * destination, because the RGB values of the result can be computed
228  * without knowing the destination alpha. Similarly, ADD has localized
229  * alpha for both source and destination because the RGB values of the
230  * result can be computed without knowing the alpha value of source or
231  * destination.
232  *
233  * When he destination is xRGB, this is useful knowledge, because then
234  * we can treat it as if it were ARGB, which means in some cases we can
235  * avoid copying it to a temporary buffer.
236  */
238  ITER_IGNORE_ALPHA = (1 << 3),
239  ITER_IGNORE_RGB = (1 << 4),
240 
241  /* These indicate whether the iterator is for a source
242  * or a destination image
243  */
244  ITER_SRC = (1 << 5),
245  ITER_DEST = (1 << 6)
247 
249 {
250  /* These are initialized by _pixman_implementation_{src,dest}_init */
253  int x, y;
254  int width;
255  int height;
258 
259  /* These function pointers are initialized by the implementation */
263 
264  /* These fields are scratch data that implementations can use */
265  void * data;
267  int stride;
268 };
269 
272  const pixman_iter_info_t *info);
274 {
281 };
282 
283 void
285 
286 void
288 
289 void
291 
292 void
294 
295 void
297 
298 void
300 
301 void
303 
307  int width,
308  int height,
309  uint32_t * bits,
310  int rowstride,
314 
317 
320  const pixman_gradient_stop_t *stops,
321  int n_stops);
322 void
324 
325 void
327 
328 #define PIXMAN_IMAGE_GET_LINE(image, x, y, type, out_stride, line, mul) \
329  do \
330  { \
331  uint32_t *__bits__; \
332  int __stride__; \
333  \
334  __bits__ = image->bits.bits; \
335  __stride__ = image->bits.rowstride; \
336  (out_stride) = \
337  __stride__ * (int) sizeof (uint32_t) / (int) sizeof (type); \
338  (line) = \
339  ((type *) __bits__) + (out_stride) * (y) + (mul) * (x); \
340  } while (0)
341 
342 /*
343  * Gradient walker
344  */
345 typedef struct
346 {
347  float a_s, a_b;
348  float r_s, r_b;
349  float g_s, g_b;
350  float b_s, b_b;
353 
357 
360 
361 void
365 
366 void
369 
371  pixman_gradient_walker_t *walker,
373  uint32_t *buffer);
374 
375 void
378  uint32_t *buffer);
379 
380 void
383  uint32_t *buffer);
384 
386  pixman_gradient_walker_t *walker,
388  uint32_t *buffer,
389  uint32_t *end);
390 
391 void
394  uint32_t *buffer,
395  uint32_t *end);
396 
397 void
400  uint32_t *buffer,
401  uint32_t *end);
402 
403 /*
404  * Edges
405  */
406 
407 #define MAX_ALPHA(n) ((1 << (n)) - 1)
408 #define N_Y_FRAC(n) ((n) == 1 ? 1 : (1 << ((n) / 2)) - 1)
409 #define N_X_FRAC(n) ((n) == 1 ? 1 : (1 << ((n) / 2)) + 1)
410 
411 #define STEP_Y_SMALL(n) (pixman_fixed_1 / N_Y_FRAC (n))
412 #define STEP_Y_BIG(n) (pixman_fixed_1 - (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
413 
414 #define Y_FRAC_FIRST(n) (STEP_Y_BIG (n) / 2)
415 #define Y_FRAC_LAST(n) (Y_FRAC_FIRST (n) + (N_Y_FRAC (n) - 1) * STEP_Y_SMALL (n))
416 
417 #define STEP_X_SMALL(n) (pixman_fixed_1 / N_X_FRAC (n))
418 #define STEP_X_BIG(n) (pixman_fixed_1 - (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
419 
420 #define X_FRAC_FIRST(n) (STEP_X_BIG (n) / 2)
421 #define X_FRAC_LAST(n) (X_FRAC_FIRST (n) + (N_X_FRAC (n) - 1) * STEP_X_SMALL (n))
422 
423 #define RENDER_SAMPLES_X(x, n) \
424  ((n) == 1? 0 : (pixman_fixed_frac (x) + \
425  X_FRAC_FIRST (n)) / STEP_X_SMALL (n))
426 
427 void
429  pixman_edge_t * l,
430  pixman_edge_t * r,
432  pixman_fixed_t b);
433 
434 /*
435  * Implementations
436  */
438 
439 typedef struct
440 {
453 
458 
459 #define PIXMAN_COMPOSITE_ARGS(info) \
460  MAYBE_UNUSED pixman_op_t op = info->op; \
461  MAYBE_UNUSED pixman_image_t * src_image = info->src_image; \
462  MAYBE_UNUSED pixman_image_t * mask_image = info->mask_image; \
463  MAYBE_UNUSED pixman_image_t * dest_image = info->dest_image; \
464  MAYBE_UNUSED int32_t src_x = info->src_x; \
465  MAYBE_UNUSED int32_t src_y = info->src_y; \
466  MAYBE_UNUSED int32_t mask_x = info->mask_x; \
467  MAYBE_UNUSED int32_t mask_y = info->mask_y; \
468  MAYBE_UNUSED int32_t dest_x = info->dest_x; \
469  MAYBE_UNUSED int32_t dest_y = info->dest_y; \
470  MAYBE_UNUSED int32_t width = info->width; \
471  MAYBE_UNUSED int32_t height = info->height
472 
474  pixman_op_t op,
475  uint32_t * dest,
476  const uint32_t * src,
477  const uint32_t * mask,
478  int width);
479 
481  pixman_op_t op,
482  float * dest,
483  const float * src,
484  const float * mask,
485  int n_pixels);
486 
490  uint32_t * src_bits,
491  uint32_t * dst_bits,
492  int src_stride,
493  int dst_stride,
494  int src_bpp,
495  int dst_bpp,
496  int src_x,
497  int src_y,
498  int dest_x,
499  int dest_y,
500  int width,
501  int height);
503  uint32_t * bits,
504  int stride,
505  int bpp,
506  int x,
507  int y,
508  int width,
509  int height,
510  uint32_t filler);
511 
514 
515 typedef struct
516 {
526 
528 {
533 
536 
541 };
542 
543 uint32_t
547 
550  const pixman_fast_path_t *fast_paths);
551 
552 void
554  pixman_op_t op,
555  pixman_format_code_t src_format,
556  uint32_t src_flags,
557  pixman_format_code_t mask_format,
558  uint32_t mask_flags,
559  pixman_format_code_t dest_format,
560  uint32_t dest_flags,
561  pixman_implementation_t **out_imp,
563 
566  pixman_op_t op,
567  pixman_bool_t component_alpha,
568  pixman_bool_t wide);
569 
572  uint32_t * src_bits,
573  uint32_t * dst_bits,
574  int src_stride,
575  int dst_stride,
576  int src_bpp,
577  int dst_bpp,
578  int src_x,
579  int src_y,
580  int dest_x,
581  int dest_y,
582  int width,
583  int height);
584 
587  uint32_t * bits,
588  int stride,
589  int bpp,
590  int x,
591  int y,
592  int width,
593  int height,
594  uint32_t filler);
595 
596 void
598  pixman_iter_t *iter,
600  int x,
601  int y,
602  int width,
603  int height,
604  uint8_t *buffer,
606  uint32_t image_flags);
607 
608 /* Specific implementations */
611 
614 
617 
618 #if defined USE_X86_MMX || defined USE_ARM_IWMMXT || defined USE_LOONGSON_MMI
620 _pixman_implementation_create_mmx (pixman_implementation_t *fallback);
621 #endif
622 
623 #ifdef USE_SSE2
626 #endif
627 
628 #ifdef USE_SSSE3
631 #endif
632 
633 #ifdef USE_ARM_SIMD
636 #endif
637 
638 #ifdef USE_ARM_NEON
641 #endif
642 
643 #ifdef USE_MIPS_DSPR2
646 #endif
647 
648 #ifdef USE_VMX
651 #endif
652 
655 
658 
661 
664 
667 
670 
672 _pixman_disabled (const char *name);
673 
674 
675 /*
676  * Utilities
677  */
680  pixman_image_t * src_image,
681  pixman_image_t * mask_image,
682  pixman_image_t * dest_image,
683  int32_t src_x,
684  int32_t src_y,
685  int32_t mask_x,
686  int32_t mask_y,
687  int32_t dest_x,
688  int32_t dest_y,
689  int32_t width,
690  int32_t height);
691 uint32_t *
693 
694 void
696 
697 /* These "formats" all have depth 0, so they
698  * will never clash with any real ones
699  */
700 #define PIXMAN_null PIXMAN_FORMAT (0, 0, 0, 0, 0, 0)
701 #define PIXMAN_solid PIXMAN_FORMAT (0, 1, 0, 0, 0, 0)
702 #define PIXMAN_pixbuf PIXMAN_FORMAT (0, 2, 0, 0, 0, 0)
703 #define PIXMAN_rpixbuf PIXMAN_FORMAT (0, 3, 0, 0, 0, 0)
704 #define PIXMAN_unknown PIXMAN_FORMAT (0, 4, 0, 0, 0, 0)
705 #define PIXMAN_any PIXMAN_FORMAT (0, 5, 0, 0, 0, 0)
706 
707 #define PIXMAN_OP_any (PIXMAN_N_OPERATORS + 1)
708 
709 #define FAST_PATH_ID_TRANSFORM (1 << 0)
710 #define FAST_PATH_NO_ALPHA_MAP (1 << 1)
711 #define FAST_PATH_NO_CONVOLUTION_FILTER (1 << 2)
712 #define FAST_PATH_NO_PAD_REPEAT (1 << 3)
713 #define FAST_PATH_NO_REFLECT_REPEAT (1 << 4)
714 #define FAST_PATH_NO_ACCESSORS (1 << 5)
715 #define FAST_PATH_NARROW_FORMAT (1 << 6)
716 #define FAST_PATH_COMPONENT_ALPHA (1 << 8)
717 #define FAST_PATH_SAMPLES_OPAQUE (1 << 7)
718 #define FAST_PATH_UNIFIED_ALPHA (1 << 9)
719 #define FAST_PATH_SCALE_TRANSFORM (1 << 10)
720 #define FAST_PATH_NEAREST_FILTER (1 << 11)
721 #define FAST_PATH_HAS_TRANSFORM (1 << 12)
722 #define FAST_PATH_IS_OPAQUE (1 << 13)
723 #define FAST_PATH_NO_NORMAL_REPEAT (1 << 14)
724 #define FAST_PATH_NO_NONE_REPEAT (1 << 15)
725 #define FAST_PATH_X_UNIT_POSITIVE (1 << 16)
726 #define FAST_PATH_AFFINE_TRANSFORM (1 << 17)
727 #define FAST_PATH_Y_UNIT_ZERO (1 << 18)
728 #define FAST_PATH_BILINEAR_FILTER (1 << 19)
729 #define FAST_PATH_ROTATE_90_TRANSFORM (1 << 20)
730 #define FAST_PATH_ROTATE_180_TRANSFORM (1 << 21)
731 #define FAST_PATH_ROTATE_270_TRANSFORM (1 << 22)
732 #define FAST_PATH_SAMPLES_COVER_CLIP_NEAREST (1 << 23)
733 #define FAST_PATH_SAMPLES_COVER_CLIP_BILINEAR (1 << 24)
734 #define FAST_PATH_BITS_IMAGE (1 << 25)
735 #define FAST_PATH_SEPARABLE_CONVOLUTION_FILTER (1 << 26)
736 
737 #define FAST_PATH_PAD_REPEAT \
738  (FAST_PATH_NO_NONE_REPEAT | \
739  FAST_PATH_NO_NORMAL_REPEAT | \
740  FAST_PATH_NO_REFLECT_REPEAT)
741 
742 #define FAST_PATH_NORMAL_REPEAT \
743  (FAST_PATH_NO_NONE_REPEAT | \
744  FAST_PATH_NO_PAD_REPEAT | \
745  FAST_PATH_NO_REFLECT_REPEAT)
746 
747 #define FAST_PATH_NONE_REPEAT \
748  (FAST_PATH_NO_NORMAL_REPEAT | \
749  FAST_PATH_NO_PAD_REPEAT | \
750  FAST_PATH_NO_REFLECT_REPEAT)
751 
752 #define FAST_PATH_REFLECT_REPEAT \
753  (FAST_PATH_NO_NONE_REPEAT | \
754  FAST_PATH_NO_NORMAL_REPEAT | \
755  FAST_PATH_NO_PAD_REPEAT)
756 
757 #define FAST_PATH_STANDARD_FLAGS \
758  (FAST_PATH_NO_CONVOLUTION_FILTER | \
759  FAST_PATH_NO_ACCESSORS | \
760  FAST_PATH_NO_ALPHA_MAP | \
761  FAST_PATH_NARROW_FORMAT)
762 
763 #define FAST_PATH_STD_DEST_FLAGS \
764  (FAST_PATH_NO_ACCESSORS | \
765  FAST_PATH_NO_ALPHA_MAP | \
766  FAST_PATH_NARROW_FORMAT)
767 
768 #define SOURCE_FLAGS(format) \
769  (FAST_PATH_STANDARD_FLAGS | \
770  ((PIXMAN_ ## format == PIXMAN_solid) ? \
771  0 : (FAST_PATH_SAMPLES_COVER_CLIP_NEAREST | FAST_PATH_NEAREST_FILTER | FAST_PATH_ID_TRANSFORM)))
772 
773 #define MASK_FLAGS(format, extra) \
774  ((PIXMAN_ ## format == PIXMAN_null) ? 0 : (SOURCE_FLAGS (format) | extra))
775 
776 #define FAST_PATH(op, src, src_flags, mask, mask_flags, dest, dest_flags, func) \
777  PIXMAN_OP_ ## op, \
778  PIXMAN_ ## src, \
779  src_flags, \
780  PIXMAN_ ## mask, \
781  mask_flags, \
782  PIXMAN_ ## dest, \
783  dest_flags, \
784  func
785 
786 #define PIXMAN_STD_FAST_PATH(op, src, mask, dest, func) \
787  { FAST_PATH ( \
788  op, \
789  src, SOURCE_FLAGS (src), \
790  mask, MASK_FLAGS (mask, FAST_PATH_UNIFIED_ALPHA), \
791  dest, FAST_PATH_STD_DEST_FLAGS, \
792  func) }
793 
794 #define PIXMAN_STD_FAST_PATH_CA(op, src, mask, dest, func) \
795  { FAST_PATH ( \
796  op, \
797  src, SOURCE_FLAGS (src), \
798  mask, MASK_FLAGS (mask, FAST_PATH_COMPONENT_ALPHA), \
799  dest, FAST_PATH_STD_DEST_FLAGS, \
800  func) }
801 
803 
806 {
807 #ifndef TOOLCHAIN_SUPPORTS_ATTRIBUTE_CONSTRUCTOR
810 #endif
811  return global_implementation;
812 }
813 
814 /* This function is exported for the sake of the test suite and not part
815  * of the ABI.
816  */
819 
820 /* Memory allocation helpers */
821 void *
822 pixman_malloc_ab (unsigned int n, unsigned int b);
823 
824 void *
825 pixman_malloc_abc (unsigned int a, unsigned int b, unsigned int c);
826 
827 void *
828 pixman_malloc_ab_plus_c (unsigned int a, unsigned int b, unsigned int c);
829 
831 _pixman_multiply_overflows_size (size_t a, size_t b);
832 
834 _pixman_multiply_overflows_int (unsigned int a, unsigned int b);
835 
837 _pixman_addition_overflows_int (unsigned int a, unsigned int b);
838 
839 /* Compositing utilities */
840 void
842  const uint32_t *src,
844  int width);
845 
846 void
848  const argb_t *src,
849  int width);
850 
851 /* Region Helpers */
855 
859 
860 /* Doubly linked lists */
861 typedef struct pixman_link_t pixman_link_t;
863 {
866 };
867 
868 typedef struct pixman_list_t pixman_list_t;
870 {
873 };
874 
875 static force_inline void
877 {
878  list->head = (pixman_link_t *)list;
879  list->tail = (pixman_link_t *)list;
880 }
881 
882 static force_inline void
884 {
885  link->next = list->head;
886  link->prev = (pixman_link_t *)list;
887  list->head->prev = link;
888  list->head = link;
889 }
890 
891 static force_inline void
893 {
894  link->prev->next = link->next;
895  link->next->prev = link->prev;
896 }
897 
898 static force_inline void
900 {
903 }
904 
905 /* Misc macros */
906 
907 #ifndef FALSE
908 # define FALSE 0
909 #endif
910 
911 #ifndef TRUE
912 # define TRUE 1
913 #endif
914 
915 #ifndef MIN
916 # define MIN(a, b) ((a < b) ? a : b)
917 #endif
918 
919 #ifndef MAX
920 # define MAX(a, b) ((a > b) ? a : b)
921 #endif
922 
923 /* Integer division that rounds towards -infinity */
924 #define DIV(a, b) \
925  ((((a) < 0) == ((b) < 0)) ? (a) / (b) : \
926  ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))
927 
928 /* Modulus that produces the remainder wrt. DIV */
929 #define MOD(a, b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b))
930 
931 #define CLIP(v, low, high) ((v) < (low) ? (low) : ((v) > (high) ? (high) : (v)))
932 
933 #define FLOAT_IS_ZERO(f) (-FLT_MIN < (f) && (f) < FLT_MIN)
934 
935 /* Conversion between 8888 and 0565 */
936 
937 static force_inline uint16_t
939 {
940  /* The following code can be compiled into just 4 instructions on ARM */
941  uint32_t a, b;
942  a = (s >> 3) & 0x1F001F;
943  b = s & 0xFC00;
944  a |= a >> 5;
945  a |= b >> 5;
946  return (uint16_t)a;
947 }
948 
949 static force_inline uint32_t
951 {
952  return (((((s) << 3) & 0xf8) | (((s) >> 2) & 0x7)) |
953  ((((s) << 5) & 0xfc00) | (((s) >> 1) & 0x300)) |
954  ((((s) << 8) & 0xf80000) | (((s) << 3) & 0x70000)));
955 }
956 
957 static force_inline uint32_t
959 {
960  return convert_0565_to_0888 (s) | 0xff000000;
961 }
962 
963 /* Trivial versions that are useful in macros */
964 
965 static force_inline uint32_t
967 {
968  return s;
969 }
970 
971 static force_inline uint32_t
973 {
974  return s | 0xff000000;
975 }
976 
977 static force_inline uint16_t
979 {
980  return s;
981 }
982 
983 #define PIXMAN_FORMAT_IS_WIDE(f) \
984  (PIXMAN_FORMAT_A (f) > 8 || \
985  PIXMAN_FORMAT_R (f) > 8 || \
986  PIXMAN_FORMAT_G (f) > 8 || \
987  PIXMAN_FORMAT_B (f) > 8 || \
988  PIXMAN_FORMAT_TYPE (f) == PIXMAN_TYPE_ARGB_SRGB)
989 
990 #ifdef WORDS_BIGENDIAN
991 # define SCREEN_SHIFT_LEFT(x,n) ((x) << (n))
992 # define SCREEN_SHIFT_RIGHT(x,n) ((x) >> (n))
993 #else
994 # define SCREEN_SHIFT_LEFT(x,n) ((x) >> (n))
995 # define SCREEN_SHIFT_RIGHT(x,n) ((x) << (n))
996 #endif
997 
998 static force_inline uint32_t
999 unorm_to_unorm (uint32_t val, int from_bits, int to_bits)
1000 {
1001  uint32_t result;
1002 
1003  if (from_bits == 0)
1004  return 0;
1005 
1006  /* Delete any extra bits */
1007  val &= ((1 << from_bits) - 1);
1008 
1009  if (from_bits >= to_bits)
1010  return val >> (from_bits - to_bits);
1011 
1012  /* Start out with the high bit of val in the high bit of result. */
1013  result = val << (to_bits - from_bits);
1014 
1015  /* Copy the bits in result, doubling the number of bits each time, until
1016  * we fill all to_bits. Unrolled manually because from_bits and to_bits
1017  * are usually known statically, so the compiler can turn all of this
1018  * into a few shifts.
1019  */
1020 #define REPLICATE() \
1021  do \
1022  { \
1023  if (from_bits < to_bits) \
1024  { \
1025  result |= result >> from_bits; \
1026  \
1027  from_bits *= 2; \
1028  } \
1029  } \
1030  while (0)
1031 
1032  REPLICATE();
1033  REPLICATE();
1034  REPLICATE();
1035  REPLICATE();
1036  REPLICATE();
1037 
1038  return result;
1039 }
1040 
1041 uint16_t pixman_float_to_unorm (float f, int n_bits);
1042 float pixman_unorm_to_float (uint16_t u, int n_bits);
1043 
1044 /*
1045  * Various debugging code
1046  */
1047 
1048 #undef DEBUG
1049 
1050 #define COMPILE_TIME_ASSERT(x) \
1051  do { typedef int compile_time_assertion [(x)?1:-1]; } while (0)
1052 
1053 /* Turn on debugging depending on what type of release this is
1054  */
1055 #if (((PIXMAN_VERSION_MICRO % 2) == 0) && ((PIXMAN_VERSION_MINOR % 2) == 1))
1056 
1057 /* Debugging gets turned on for development releases because these
1058  * are the things that end up in bleeding edge distributions such
1059  * as Rawhide etc.
1060  *
1061  * For performance reasons we don't turn it on for stable releases or
1062  * random git checkouts. (Random git checkouts are often used for
1063  * performance work).
1064  */
1065 
1066 # define DEBUG
1067 
1068 #endif
1069 
1070 void
1071 _pixman_log_error (const char *function, const char *message);
1072 
1073 #define return_if_fail(expr) \
1074  do \
1075  { \
1076  if (unlikely (!(expr))) \
1077  { \
1078  _pixman_log_error (FUNC, "The expression " # expr " was false"); \
1079  return; \
1080  } \
1081  } \
1082  while (0)
1083 
1084 #define return_val_if_fail(expr, retval) \
1085  do \
1086  { \
1087  if (unlikely (!(expr))) \
1088  { \
1089  _pixman_log_error (FUNC, "The expression " # expr " was false"); \
1090  return (retval); \
1091  } \
1092  } \
1093  while (0)
1094 
1095 #define critical_if_fail(expr) \
1096  do \
1097  { \
1098  if (unlikely (!(expr))) \
1099  _pixman_log_error (FUNC, "The expression " # expr " was false"); \
1100  } \
1101  while (0)
1102 
1103 /*
1104  * Matrix
1105  */
1106 
1108 
1112  const pixman_vector_48_16_t *v,
1114 
1116 void
1118  const pixman_vector_48_16_t *v,
1120 
1122 void
1124  const pixman_vector_48_16_t *v,
1126 
1127 /*
1128  * Timers
1129  */
1130 
1131 #ifdef PIXMAN_TIMERS
1132 
1133 static inline uint64_t
1134 oil_profile_stamp_rdtsc (void)
1135 {
1136  uint32_t hi, lo;
1137 
1138  __asm__ __volatile__ ("rdtsc\n" : "=a" (lo), "=d" (hi));
1139 
1140  return lo | (((uint64_t)hi) << 32);
1141 }
1142 
1143 #define OIL_STAMP oil_profile_stamp_rdtsc
1144 
1145 typedef struct pixman_timer_t pixman_timer_t;
1146 
1147 struct pixman_timer_t
1148 {
1149  int initialized;
1150  const char * name;
1151  uint64_t n_times;
1152  uint64_t total;
1153  pixman_timer_t *next;
1154 };
1155 
1156 extern int timer_defined;
1157 
1158 void pixman_timer_register (pixman_timer_t *timer);
1159 
1160 #define TIMER_BEGIN(tname) \
1161  { \
1162  static pixman_timer_t timer ## tname; \
1163  uint64_t begin ## tname; \
1164  \
1165  if (!timer ## tname.initialized) \
1166  { \
1167  timer ## tname.initialized = 1; \
1168  timer ## tname.name = # tname; \
1169  pixman_timer_register (&timer ## tname); \
1170  } \
1171  \
1172  timer ## tname.n_times++; \
1173  begin ## tname = OIL_STAMP ();
1174 
1175 #define TIMER_END(tname) \
1176  timer ## tname.total += OIL_STAMP () - begin ## tname; \
1177  }
1178 
1179 #else
1180 
1181 #define TIMER_BEGIN(tname)
1182 #define TIMER_END(tname)
1183 
1184 #endif /* PIXMAN_TIMERS */
1185 
1186 #endif /* __ASSEMBLER__ */
1187 
1188 #endif /* PIXMAN_PRIVATE_H */
#define message
Definition: aptex-macros.h:418
#define width(a)
Definition: aptex-macros.h:198
#define name
#define height(a)
Definition: aptex-macros.h:200
#define next(a)
Definition: aptex-macros.h:924
static struct brw_reg stride(struct brw_reg reg, uint32_t vstride, uint32_t width, uint32_t hstride)
#define n
Definition: t4ht.c:1290
#define b
Definition: jpegint.h:372
int v
Definition: dviconv.c:10
#define info
Definition: dviinfo.c:42
static void
Definition: fpif.c:118
mpz_t * f
Definition: gen-fib.c:34
#define s
Definition: afcover.h:80
#define c(n)
Definition: gpos-common.c:150
#define a(n)
Definition: gpos-common.c:148
static void clear()
unsigned char * image
Definition: in_pcx.cpp:323
small capitals from c petite p scientific f u
Definition: afcover.h:88
#define bits
Definition: infblock.c:15
kerning y
Definition: ttdriver.c:212
unsigned short uint16_t
Definition: stdint.h:79
unsigned int uint32_t
Definition: stdint.h:80
signed int int32_t
Definition: stdint.h:77
unsigned char uint8_t
Definition: stdint.h:78
unsigned __int64 uint64_t
Definition: stdint.h:90
int(* out_func)()
Definition: zlib.h:1094
#define link
Definition: win32lib.h:82
#define dest
const int * pos
Definition: combiners.h:905
float x
Definition: cordic.py:15
static int format
Definition: pbmclean.c:15
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp *numpix else pixst endif endm macro pixld1_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl mov asr adds SRC_WIDTH_FIXED bpl add asl else error unsupported endif endm macro pixld2_s mem_operand if mov asr add asl add asl mov asr sub UNIT_X add asl mov asr add asl add asl mov asr add UNIT_X add asl else pixld1_s mem_operand pixld1_s mem_operand endif endm macro pixld0_s mem_operand if asr adds SRC_WIDTH_FIXED bpl add asl elseif asr adds SRC_WIDTH_FIXED bpl add asl endif endm macro pixld_s_internal mem_operand if mem_operand pixld2_s mem_operand pixdeinterleave basereg elseif mem_operand elseif mem_operand elseif mem_operand elseif mem_operand pixld0_s mem_operand else pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else pixld0_s mem_operand pixld0_s mem_operand endif elseif mem_operand else error unsupported mem_operand if bpp mem_operand endif endm macro vuzp8 reg2 vuzp d d &reg2 endm macro vzip8 reg2 vzip d d &reg2 endm macro pixdeinterleave basereg basereg basereg basereg basereg endif endm macro pixinterleave basereg basereg basereg basereg basereg endif endm macro PF boost_increment endif if endif PF tst PF addne PF subne PF cmp ORIG_W if endif if endif if endif PF subge ORIG_W PF subges if endif if endif if endif endif endm macro cache_preload_simple endif if dst_r_bpp pld[DST_R, #(PREFETCH_DISTANCE_SIMPLE *dst_r_bpp/8)] endif if mask_bpp pld src_bpp[MASK, #(PREFETCH_DISTANCE_SIMPLE *mask_bpp/8)] endif endif endm macro fetch_mask_pixblock pixld mask_basereg pixblock_size MASK endm macro ensure_destination_ptr_alignment process_pixblock_tail_head if beq irp skip1 beq endif
set set set set set set set macro pixldst1 abits if abits op else op endif endm macro pixldst2 abits if abits op else op endif endm macro pixldst4 abits if abits op else op endif endm macro pixldst0 abits op endm macro pixldst3 mem_operand op endm macro pixldst30 mem_operand op endm macro pixldst abits if abits elseif abits elseif abits elseif abits elseif abits pixldst0 abits else pixldst0 abits pixldst0 abits pixldst0 abits pixldst0 abits endif elseif abits else pixldst0 abits pixldst0 abits endif elseif abits else error unsupported bpp
pixman_implementation_t * _pixman_implementation_create_arm_neon(pixman_implementation_t *fallback)
pixman_implementation_t * _pixman_implementation_create_arm_simd(pixman_implementation_t *fallback)
#define PIXMAN_EXPORT
#define force_inline
pixman_implementation_t * _pixman_implementation_create_mips_dspr2(pixman_implementation_t *fallback)
float pixman_unorm_to_float(uint16_t u, int n_bits)
Definition: pixman-utils.c:195
void _pixman_setup_combiner_functions_float(pixman_implementation_t *imp)
pixman_implementation_t * _pixman_implementation_create_noop(pixman_implementation_t *fallback)
Definition: pixman-noop.c:153
void pixman_transform_point_31_16_3d(const pixman_transform_t *t, const pixman_vector_48_16_t *v, pixman_vector_48_16_t *result)
struct horizontal_gradient horizontal_gradient_t
pixman_implementation_t * _pixman_implementation_create_general(void)
pixman_bool_t pixman_region32_copy_from_region16(pixman_region32_t *dst, pixman_region16_t *src)
Definition: pixman-utils.c:270
static uint32_t convert_x888_to_8888(uint32_t s)
pixman_bool_t _pixman_addition_overflows_int(unsigned int a, unsigned int b)
Definition: pixman-utils.c:46
void _pixman_linear_gradient_iter_init(pixman_image_t *image, pixman_iter_t *iter)
pixman_bool_t _pixman_init_gradient(gradient_t *gradient, const pixman_gradient_stop_t *stops, int n_stops)
Definition: pixman-image.c:79
image_type_t
@ SOLID
@ RADIAL
@ CONICAL
@ BITS
@ LINEAR
pixman_bool_t _pixman_implementation_disabled(const char *name)
uint32_t(* fetch_pixel_32_t)(bits_image_t *image, int x, int y)
void(* pixman_gradient_walker_fill_t)(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x, uint32_t *buffer, uint32_t *end)
static uint32_t convert_0565_to_0888(uint16_t s)
void(* pixman_combine_float_func_t)(pixman_implementation_t *imp, pixman_op_t op, float *dest, const float *src, const float *mask, int n_pixels)
void(* pixman_iter_fini_t)(pixman_iter_t *iter)
void _pixman_image_validate(pixman_image_t *image)
Definition: pixman-image.c:547
pixman_bool_t _pixman_compute_composite_region32(pixman_region32_t *region, pixman_image_t *src_image, pixman_image_t *mask_image, pixman_image_t *dest_image, int32_t src_x, int32_t src_y, int32_t mask_x, int32_t mask_y, int32_t dest_x, int32_t dest_y, int32_t width, int32_t height)
Definition: pixman.c:228
void _pixman_implementation_lookup_composite(pixman_implementation_t *toplevel, pixman_op_t op, pixman_format_code_t src_format, uint32_t src_flags, pixman_format_code_t mask_format, uint32_t mask_flags, pixman_format_code_t dest_format, uint32_t dest_flags, pixman_implementation_t **out_imp, pixman_composite_func_t *out_func)
pixman_bool_t _pixman_multiply_overflows_int(unsigned int a, unsigned int b)
Definition: pixman-utils.c:40
void(* pixman_composite_func_t)(pixman_implementation_t *imp, pixman_composite_info_t *info)
void(* property_changed_func_t)(pixman_image_t *image)
void _pixman_image_reset_clip_region(pixman_image_t *image)
Definition: pixman-image.c:236
pixman_implementation_t * _pixman_choose_implementation(void)
void _pixman_bits_image_src_iter_init(pixman_image_t *image, pixman_iter_t *iter)
void _pixman_iter_init_bits_stride(pixman_iter_t *iter, const pixman_iter_info_t *info)
Definition: pixman-utils.c:227
pixman_bool_t _pixman_implementation_fill(pixman_implementation_t *imp, uint32_t *bits, int stride, int bpp, int x, int y, int width, int height, uint32_t filler)
void _pixman_setup_combiner_functions_32(pixman_implementation_t *imp)
struct vertical_gradient vertical_gradient_t
static uint32_t convert_0565_to_8888(uint16_t s)
void(* store_scanline_t)(bits_image_t *image, int x, int y, int width, const uint32_t *values)
pixman_implementation_t * _pixman_mips_get_implementations(pixman_implementation_t *imp)
Definition: pixman-mips.c:69
iter_flags_t
@ ITER_DEST
@ ITER_IGNORE_ALPHA
@ ITER_WIDE
@ ITER_IGNORE_RGB
@ ITER_SRC
@ ITER_LOCALIZED_ALPHA
@ ITER_NARROW
static uint16_t convert_8888_to_0565(uint32_t s)
void _pixman_log_error(const char *function, const char *message)
Definition: pixman-utils.c:316
void _pixman_gradient_walker_init(pixman_gradient_walker_t *walker, gradient_t *gradient, pixman_repeat_t repeat)
struct argb_t argb_t
pixman_implementation_t * _pixman_arm_get_implementations(pixman_implementation_t *imp)
Definition: pixman-arm.c:232
void * pixman_malloc_ab_plus_c(unsigned int a, unsigned int b, unsigned int c)
Definition: pixman-utils.c:52
void pixman_contract_from_float(uint32_t *dst, const argb_t *src, int width)
Definition: pixman-utils.c:201
void * pixman_malloc_ab(unsigned int n, unsigned int b)
Definition: pixman-utils.c:61
argb_t(* fetch_pixel_float_t)(bits_image_t *image, int x, int y)
void _pixman_image_init(pixman_image_t *image)
Definition: pixman-image.c:110
static void pixman_list_unlink(pixman_link_t *link)
void(* pixman_iter_write_back_t)(pixman_iter_t *iter)
void _pixman_conical_gradient_iter_init(pixman_image_t *image, pixman_iter_t *iter)
void _pixman_radial_gradient_iter_init(pixman_image_t *image, pixman_iter_t *iter)
void _pixman_gradient_walker_fill_narrow(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x, uint32_t *buffer, uint32_t *end)
pixman_implementation_t * _pixman_implementation_create_fast_path(pixman_implementation_t *fallback)
static uint32_t convert_8888_to_8888(uint32_t s)
pixman_bool_t _pixman_disabled(const char *name)
static pixman_implementation_t * get_implementation(void)
pixman_bool_t pixman_region16_copy_from_region32(pixman_region16_t *dst, pixman_region32_t *src)
Definition: pixman-utils.c:240
void _pixman_gradient_walker_write_narrow(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x, uint32_t *buffer)
pixman_implementation_t * _pixman_internal_only_get_implementation(void)
Definition: pixman-utils.c:310
void _pixman_gradient_walker_write_wide(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x, uint32_t *buffer)
pixman_implementation_t * _pixman_implementation_create(pixman_implementation_t *fallback, const pixman_fast_path_t *fast_paths)
static uint16_t convert_0565_to_0565(uint16_t s)
pixman_bool_t(* pixman_fill_func_t)(pixman_implementation_t *imp, uint32_t *bits, int stride, int bpp, int x, int y, int width, int height, uint32_t filler)
uint32_t _pixman_image_get_solid(pixman_implementation_t *imp, pixman_image_t *image, pixman_format_code_t format)
Definition: pixman-image.c:946
void _pixman_implementation_iter_init(pixman_implementation_t *imp, pixman_iter_t *iter, pixman_image_t *image, int x, int y, int width, int height, uint8_t *buffer, iter_flags_t flags, uint32_t image_flags)
pixman_bool_t _pixman_bits_image_init(pixman_image_t *image, pixman_format_code_t format, int width, int height, uint32_t *bits, int rowstride, pixman_bool_t clear)
void _pixman_gradient_walker_fill_wide(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x, uint32_t *buffer, uint32_t *end)
static void pixman_list_prepend(pixman_list_t *list, pixman_link_t *link)
void * pixman_malloc_abc(unsigned int a, unsigned int b, unsigned int c)
Definition: pixman-utils.c:71
pixman_implementation_t * global_implementation
Definition: pixman.c:33
pixman_implementation_t * _pixman_x86_get_implementations(pixman_implementation_t *imp)
Definition: pixman-x86.c:227
pixman_bool_t(* pixman_blt_func_t)(pixman_implementation_t *imp, uint32_t *src_bits, uint32_t *dst_bits, int src_stride, int dst_stride, int src_bpp, int dst_bpp, int src_x, int src_y, int dest_x, int dest_y, int width, int height)
void pixman_rasterize_edges_accessors(pixman_image_t *image, pixman_edge_t *l, pixman_edge_t *r, pixman_fixed_t t, pixman_fixed_t b)
Definition: pixman-edge.c:342
pixman_implementation_t * _pixman_ppc_get_implementations(pixman_implementation_t *imp)
Definition: pixman-ppc.c:147
void(* pixman_iter_initializer_t)(pixman_iter_t *iter, const pixman_iter_info_t *info)
uint32_t * _pixman_iter_get_scanline_noop(pixman_iter_t *iter, const uint32_t *mask)
Definition: pixman-utils.c:221
#define REPLICATE()
pixman_image_t * _pixman_image_allocate(void)
Definition: pixman-image.c:182
void pixman_expand_to_float(argb_t *dst, const uint32_t *src, pixman_format_code_t format, int width)
Definition: pixman-utils.c:118
void(* fetch_scanline_t)(bits_image_t *image, int x, int y, int width, uint32_t *buffer, const uint32_t *mask)
void(* pixman_gradient_walker_write_t)(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t x, uint32_t *buffer)
pixman_combine_32_func_t _pixman_implementation_lookup_combiner(pixman_implementation_t *imp, pixman_op_t op, pixman_bool_t component_alpha, pixman_bool_t wide)
void _pixman_bits_image_setup_accessors(bits_image_t *image)
void _pixman_gradient_walker_reset(pixman_gradient_walker_t *walker, pixman_fixed_48_16_t pos)
static void pixman_list_init(pixman_list_t *list)
void(* pixman_combine_32_func_t)(pixman_implementation_t *imp, pixman_op_t op, uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
pixman_bool_t _pixman_implementation_blt(pixman_implementation_t *imp, uint32_t *src_bits, uint32_t *dst_bits, int src_stride, int dst_stride, int src_bpp, int dst_bpp, int src_x, int src_y, int dest_x, int dest_y, int width, int height)
uint16_t pixman_float_to_unorm(float f, int n_bits)
Definition: pixman-utils.c:189
void pixman_transform_point_31_16_affine(const pixman_transform_t *t, const pixman_vector_48_16_t *v, pixman_vector_48_16_t *result)
pixman_bool_t _pixman_multiply_overflows_size(size_t a, size_t b)
Definition: pixman-utils.c:34
pixman_bool_t _pixman_image_fini(pixman_image_t *image)
Definition: pixman-image.c:135
void _pixman_bits_image_dest_iter_init(pixman_image_t *image, pixman_iter_t *iter)
static void pixman_list_move_to_front(pixman_list_t *list, pixman_link_t *link)
pixman_bool_t pixman_transform_point_31_16(const pixman_transform_t *t, const pixman_vector_48_16_t *v, pixman_vector_48_16_t *result)
uint32_t *(* pixman_iter_get_scanline_t)(pixman_iter_t *iter, const uint32_t *mask)
static uint32_t unorm_to_unorm(uint32_t val, int from_bits, int to_bits)
pixman_implementation_t * _pixman_implementation_create_sse2(pixman_implementation_t *fallback)
Definition: pixman-sse2.c:6472
pixman_implementation_t * _pixman_implementation_create_ssse3(pixman_implementation_t *fallback)
Definition: pixman-ssse3.c:343
pixman_implementation_t * _pixman_implementation_create_vmx(pixman_implementation_t *fallback)
Definition: pixman-vmx.c:3116
void(* pixman_image_destroy_func_t)(pixman_image_t *image, void *data)
Definition: pixman.h:794
uint32_t(* pixman_read_memory_func_t)(const void *src, int size)
Definition: pixman.h:791
pixman_fixed_16_16_t pixman_fixed_t
Definition: pixman.h:123
pixman_repeat_t
Definition: pixman.h:340
int pixman_bool_t
Definition: pixman.h:113
pixman_dither_t
Definition: pixman.h:348
void(* pixman_write_memory_func_t)(void *dst, uint32_t value, int size)
Definition: pixman.h:792
pixman_op_t
Definition: pixman.h:389
pixman_fixed_32_32_t pixman_fixed_48_16_t
Definition: pixman.h:119
pixman_format_code_t
Definition: pixman.h:871
pixman_filter_t
Definition: pixman.h:358
static int repeat
Definition: pnmtops.c:230
int r
Definition: ppmqvga.c:68
static int n_bits
Definition: ppmtogif.c:604
#define flags
#define mask(n)
Definition: lbitlib.c:93
#define uint32_t
Definition: stdint.in.h:168
#define uint64_t
Definition: stdint.in.h:215
float b
float g
float r
float a
pixman_dither_t dither
fetch_pixel_float_t fetch_pixel_float
pixman_read_memory_func_t read_func
uint32_t dither_offset_x
pixman_format_code_t format
uint32_t * free_me
image_common_t common
store_scanline_t store_scanline_float
fetch_scanline_t fetch_scanline_float
const pixman_indexed_t * indexed
pixman_write_memory_func_t write_func
store_scanline_t store_scanline_32
fetch_scanline_t fetch_scanline_32
uint32_t dither_offset_y
uint32_t * bits
fetch_pixel_32_t fetch_pixel_32
Definition: namelist.c:170
Definition: utils.c:300
struct cell * prev
pixman_fixed_t radius
pixman_fixed_t x
pixman_fixed_t y
pixman_point_fixed_t center
image_common_t common
pixman_gradient_stop_t * stops
pixman_filter_t filter
pixman_image_destroy_func_t destroy_func
pixman_bool_t dirty
image_type_t type
pixman_bool_t clip_sources
pixman_bool_t client_clip
property_changed_func_t property_changed
pixman_region32_t clip_region
pixman_fixed_t * filter_params
uint32_t flags
pixman_repeat_t repeat
pixman_transform_t * transform
int32_t alpha_count
pixman_format_code_t extended_format_code
void * destroy_data
pixman_bool_t have_clip_region
pixman_bool_t component_alpha
int32_t ref_count
bits_image_t * alpha_map
Definition: sd.h:76
pixman_point_fixed_t p1
gradient_t common
pixman_point_fixed_t p2
Definition: sh.h:1226
pixman_image_t * src_image
pixman_image_t * dest_image
pixman_image_t * mask_image
pixman_format_code_t dest_format
pixman_composite_func_t func
pixman_format_code_t src_format
pixman_format_code_t mask_format
pixman_gradient_stop_t * stops
pixman_fixed_48_16_t right_x
pixman_fixed_48_16_t left_x
const pixman_iter_info_t * iter_info
pixman_implementation_t * toplevel
pixman_combine_32_func_t combine_32_ca[PIXMAN_N_OPERATORS]
pixman_combine_float_func_t combine_float[PIXMAN_N_OPERATORS]
const pixman_fast_path_t * fast_paths
pixman_combine_32_func_t combine_32[PIXMAN_N_OPERATORS]
pixman_blt_func_t blt
pixman_combine_float_func_t combine_float_ca[PIXMAN_N_OPERATORS]
pixman_fill_func_t fill
pixman_implementation_t * fallback
pixman_format_code_t format
pixman_iter_write_back_t write_back
pixman_iter_get_scanline_t get_scanline
pixman_iter_initializer_t initializer
iter_flags_t iter_flags
uint8_t * bits
pixman_iter_get_scanline_t get_scanline
pixman_iter_write_back_t write_back
pixman_iter_fini_t fini
pixman_image_t * image
uint32_t image_flags
iter_flags_t iter_flags
uint32_t * buffer
pixman_link_t * tail
pixman_link_t * head
gradient_t common
Definition: regions.h:31
pixman_color_t color
image_common_t common
uint32_t color_32
argb_t color_float
Definition: dvips.h:235
Definition: strexpr.c:21
op
Definition: tex4ht.c:3129
static UBool fallback(char *loc)
Definition: ucurr.cpp:604
radial_gradient_t radial
image_common_t common
bits_image_t bits
linear_gradient_t linear
conical_gradient_t conical
image_type_t type
solid_fill_t solid
gradient_t gradient
#define buffer
Definition: xmlparse.c:611
#define end(cp)
Definition: zic.c:71