LCOV - code coverage report
Current view: directory - objdir/dist/include - pixman.h (source / functions) Found Hit Coverage
Test: app.info Lines: 2 0 0.0 %
Date: 2012-06-02 Functions: 2 0 0.0 %

       1                 : /***********************************************************
       2                 : 
       3                 : Copyright 1987, 1998  The Open Group
       4                 : 
       5                 : Permission to use, copy, modify, distribute, and sell this software and its
       6                 : documentation for any purpose is hereby granted without fee, provided that
       7                 : the above copyright notice appear in all copies and that both that
       8                 : copyright notice and this permission notice appear in supporting
       9                 : documentation.
      10                 : 
      11                 : The above copyright notice and this permission notice shall be included in
      12                 : all copies or substantial portions of the Software.
      13                 : 
      14                 : THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      15                 : IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      16                 : FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
      17                 : OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
      18                 : AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
      19                 : CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
      20                 : 
      21                 : Except as contained in this notice, the name of The Open Group shall not be
      22                 : used in advertising or otherwise to promote the sale, use or other dealings
      23                 : in this Software without prior written authorization from The Open Group.
      24                 : 
      25                 : Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
      26                 : 
      27                 :                         All Rights Reserved
      28                 : 
      29                 : Permission to use, copy, modify, and distribute this software and its
      30                 : documentation for any purpose and without fee is hereby granted,
      31                 : provided that the above copyright notice appear in all copies and that
      32                 : both that copyright notice and this permission notice appear in
      33                 : supporting documentation, and that the name of Digital not be
      34                 : used in advertising or publicity pertaining to distribution of the
      35                 : software without specific, written prior permission.
      36                 : 
      37                 : DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
      38                 : ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
      39                 : DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
      40                 : ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
      41                 : WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
      42                 : ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
      43                 : SOFTWARE.
      44                 : 
      45                 : ******************************************************************/
      46                 : /*
      47                 :  * Copyright © 1998, 2004 Keith Packard
      48                 :  * Copyright   2007 Red Hat, Inc.
      49                 :  *
      50                 :  * Permission to use, copy, modify, distribute, and sell this software and its
      51                 :  * documentation for any purpose is hereby granted without fee, provided that
      52                 :  * the above copyright notice appear in all copies and that both that
      53                 :  * copyright notice and this permission notice appear in supporting
      54                 :  * documentation, and that the name of Keith Packard not be used in
      55                 :  * advertising or publicity pertaining to distribution of the software without
      56                 :  * specific, written prior permission.  Keith Packard makes no
      57                 :  * representations about the suitability of this software for any purpose.  It
      58                 :  * is provided "as is" without express or implied warranty.
      59                 :  *
      60                 :  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
      61                 :  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
      62                 :  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
      63                 :  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
      64                 :  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
      65                 :  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
      66                 :  * PERFORMANCE OF THIS SOFTWARE.
      67                 :  */
      68                 : 
      69                 : #ifndef PIXMAN_H__
      70                 : #define PIXMAN_H__
      71                 : 
      72                 : #include "cairo-platform.h"
      73                 : 
      74                 : #include <pixman-version.h>
      75                 : 
      76                 : #ifdef  __cplusplus
      77                 : #define PIXMAN_BEGIN_DECLS extern "C" {
      78                 : #define PIXMAN_END_DECLS }
      79                 : #else
      80                 : #define PIXMAN_BEGIN_DECLS
      81                 : #define PIXMAN_END_DECLS
      82                 : #endif
      83                 : 
      84                 : PIXMAN_BEGIN_DECLS
      85                 : 
      86                 : /*
      87                 :  * Standard integers
      88                 :  */
      89                 : 
      90                 : #if !defined (PIXMAN_DONT_DEFINE_STDINT)
      91                 : 
      92                 : #if defined (_SVR4) || defined (SVR4) || defined (__OpenBSD__) || defined (_sgi) || defined (__sun) || defined (sun) || defined (__digital__) || defined (__HP_cc)
      93                 : #  include <inttypes.h>
      94                 : /* VS 2010 (_MSC_VER 1600) has stdint.h */
      95                 : #elif defined (_MSC_VER) && _MSC_VER < 1600
      96                 : typedef __int8 int8_t;
      97                 : typedef unsigned __int8 uint8_t;
      98                 : typedef __int16 int16_t;
      99                 : typedef unsigned __int16 uint16_t;
     100                 : typedef __int32 int32_t;
     101                 : typedef unsigned __int32 uint32_t;
     102                 : typedef __int64 int64_t;
     103                 : typedef unsigned __int64 uint64_t;
     104                 : #elif defined (_AIX)
     105                 : #  include <sys/inttypes.h>
     106                 : #else
     107                 : #  include <stdint.h>
     108                 : #endif
     109                 : 
     110                 : #endif
     111                 : 
     112                 : /*
     113                 :  * Boolean
     114                 :  */
     115                 : typedef int pixman_bool_t;
     116                 : 
     117                 : /*
     118                 :  * Fixpoint numbers
     119                 :  */
     120                 : typedef int64_t                 pixman_fixed_32_32_t;
     121                 : typedef pixman_fixed_32_32_t    pixman_fixed_48_16_t;
     122                 : typedef uint32_t                pixman_fixed_1_31_t;
     123                 : typedef uint32_t                pixman_fixed_1_16_t;
     124                 : typedef int32_t                 pixman_fixed_16_16_t;
     125                 : typedef pixman_fixed_16_16_t    pixman_fixed_t;
     126                 : 
     127                 : #define pixman_fixed_e                  ((pixman_fixed_t) 1)
     128                 : #define pixman_fixed_1                  (pixman_int_to_fixed(1))
     129                 : #define pixman_fixed_1_minus_e          (pixman_fixed_1 - pixman_fixed_e)
     130                 : #define pixman_fixed_minus_1            (pixman_int_to_fixed(-1))
     131                 : #define pixman_fixed_to_int(f)          ((int) ((f) >> 16))
     132                 : #define pixman_int_to_fixed(i)          ((pixman_fixed_t) ((i) << 16))
     133                 : #define pixman_fixed_to_double(f)       (double) ((f) / (double) pixman_fixed_1)
     134                 : #define pixman_double_to_fixed(d)       ((pixman_fixed_t) ((d) * 65536.0))
     135                 : #define pixman_fixed_frac(f)            ((f) & pixman_fixed_1_minus_e)
     136                 : #define pixman_fixed_floor(f)           ((f) & ~pixman_fixed_1_minus_e)
     137                 : #define pixman_fixed_ceil(f)            pixman_fixed_floor ((f) + pixman_fixed_1_minus_e)
     138                 : #define pixman_fixed_fraction(f)        ((f) & pixman_fixed_1_minus_e)
     139                 : #define pixman_fixed_mod_2(f)           ((f) & (pixman_fixed1 | pixman_fixed_1_minus_e))
     140                 : #define pixman_max_fixed_48_16          ((pixman_fixed_48_16_t) 0x7fffffff)
     141                 : #define pixman_min_fixed_48_16          (-((pixman_fixed_48_16_t) 1 << 31))
     142                 : 
     143                 : /*
     144                 :  * Misc structs
     145                 :  */
     146                 : typedef struct pixman_color pixman_color_t;
     147                 : typedef struct pixman_point_fixed pixman_point_fixed_t;
     148                 : typedef struct pixman_line_fixed pixman_line_fixed_t;
     149                 : typedef struct pixman_vector pixman_vector_t;
     150                 : typedef struct pixman_transform pixman_transform_t;
     151                 : 
     152                 : struct pixman_color
     153                 : {
     154                 :     uint16_t    red;
     155                 :     uint16_t    green;
     156                 :     uint16_t    blue;
     157                 :     uint16_t    alpha;
     158                 : };
     159                 : 
     160                 : struct pixman_point_fixed
     161                 : {
     162                 :     pixman_fixed_t      x;
     163                 :     pixman_fixed_t      y;
     164                 : };
     165                 : 
     166                 : struct pixman_line_fixed
     167                 : {
     168                 :     pixman_point_fixed_t        p1, p2;
     169                 : };
     170                 : 
     171                 : /*
     172                 :  * Fixed point matrices
     173                 :  */
     174                 : 
     175                 : struct pixman_vector
     176                 : {
     177                 :     pixman_fixed_t      vector[3];
     178                 : };
     179                 : 
     180                 : struct pixman_transform
     181                 : {
     182                 :     pixman_fixed_t      matrix[3][3];
     183                 : };
     184                 : 
     185                 : /* forward declaration (sorry) */
     186                 : struct pixman_box16;
     187                 : typedef  union pixman_image             pixman_image_t;
     188                 : 
     189                 : void          pixman_transform_init_identity    (struct pixman_transform       *matrix);
     190                 : pixman_bool_t pixman_transform_point_3d         (const struct pixman_transform *transform,
     191                 :                                                  struct pixman_vector          *vector);
     192                 : pixman_bool_t pixman_transform_point            (const struct pixman_transform *transform,
     193                 :                                                  struct pixman_vector          *vector);
     194                 : pixman_bool_t pixman_transform_multiply         (struct pixman_transform       *dst,
     195                 :                                                  const struct pixman_transform *l,
     196                 :                                                  const struct pixman_transform *r);
     197                 : void          pixman_transform_init_scale       (struct pixman_transform       *t,
     198                 :                                                  pixman_fixed_t                 sx,
     199                 :                                                  pixman_fixed_t                 sy);
     200                 : pixman_bool_t pixman_transform_scale            (struct pixman_transform       *forward,
     201                 :                                                  struct pixman_transform       *reverse,
     202                 :                                                  pixman_fixed_t                 sx,
     203                 :                                                  pixman_fixed_t                 sy);
     204                 : void          pixman_transform_init_rotate      (struct pixman_transform       *t,
     205                 :                                                  pixman_fixed_t                 cos,
     206                 :                                                  pixman_fixed_t                 sin);
     207                 : pixman_bool_t pixman_transform_rotate           (struct pixman_transform       *forward,
     208                 :                                                  struct pixman_transform       *reverse,
     209                 :                                                  pixman_fixed_t                 c,
     210                 :                                                  pixman_fixed_t                 s);
     211                 : void          pixman_transform_init_translate   (struct pixman_transform       *t,
     212                 :                                                  pixman_fixed_t                 tx,
     213                 :                                                  pixman_fixed_t                 ty);
     214                 : pixman_bool_t pixman_transform_translate        (struct pixman_transform       *forward,
     215                 :                                                  struct pixman_transform       *reverse,
     216                 :                                                  pixman_fixed_t                 tx,
     217                 :                                                  pixman_fixed_t                 ty);
     218                 : pixman_bool_t pixman_transform_bounds           (const struct pixman_transform *matrix,
     219                 :                                                  struct pixman_box16           *b);
     220                 : pixman_bool_t pixman_transform_invert           (struct pixman_transform       *dst,
     221                 :                                                  const struct pixman_transform *src);
     222                 : pixman_bool_t pixman_transform_is_identity      (const struct pixman_transform *t);
     223                 : pixman_bool_t pixman_transform_is_scale         (const struct pixman_transform *t);
     224                 : pixman_bool_t pixman_transform_is_int_translate (const struct pixman_transform *t);
     225                 : pixman_bool_t pixman_transform_is_inverse       (const struct pixman_transform *a,
     226                 :                                                  const struct pixman_transform *b);
     227                 : 
     228                 : /*
     229                 :  * Floating point matrices
     230                 :  */
     231                 : struct pixman_f_vector
     232                 : {
     233                 :     double  v[3];
     234                 : };
     235                 : 
     236                 : struct pixman_f_transform
     237                 : {
     238                 :     double  m[3][3];
     239                 : };
     240                 : 
     241                 : pixman_bool_t pixman_transform_from_pixman_f_transform (struct pixman_transform         *t,
     242                 :                                                         const struct pixman_f_transform *ft);
     243                 : void          pixman_f_transform_from_pixman_transform (struct pixman_f_transform       *ft,
     244                 :                                                         const struct pixman_transform   *t);
     245                 : pixman_bool_t pixman_f_transform_invert                (struct pixman_f_transform       *dst,
     246                 :                                                         const struct pixman_f_transform *src);
     247                 : pixman_bool_t pixman_f_transform_point                 (const struct pixman_f_transform *t,
     248                 :                                                         struct pixman_f_vector          *v);
     249                 : void          pixman_f_transform_point_3d              (const struct pixman_f_transform *t,
     250                 :                                                         struct pixman_f_vector          *v);
     251                 : void          pixman_f_transform_multiply              (struct pixman_f_transform       *dst,
     252                 :                                                         const struct pixman_f_transform *l,
     253                 :                                                         const struct pixman_f_transform *r);
     254                 : void          pixman_f_transform_init_scale            (struct pixman_f_transform       *t,
     255                 :                                                         double                           sx,
     256                 :                                                         double                           sy);
     257                 : pixman_bool_t pixman_f_transform_scale                 (struct pixman_f_transform       *forward,
     258                 :                                                         struct pixman_f_transform       *reverse,
     259                 :                                                         double                           sx,
     260                 :                                                         double                           sy);
     261                 : void          pixman_f_transform_init_rotate           (struct pixman_f_transform       *t,
     262                 :                                                         double                           cos,
     263                 :                                                         double                           sin);
     264                 : pixman_bool_t pixman_f_transform_rotate                (struct pixman_f_transform       *forward,
     265                 :                                                         struct pixman_f_transform       *reverse,
     266                 :                                                         double                           c,
     267                 :                                                         double                           s);
     268                 : void          pixman_f_transform_init_translate        (struct pixman_f_transform       *t,
     269                 :                                                         double                           tx,
     270                 :                                                         double                           ty);
     271                 : pixman_bool_t pixman_f_transform_translate             (struct pixman_f_transform       *forward,
     272                 :                                                         struct pixman_f_transform       *reverse,
     273                 :                                                         double                           tx,
     274                 :                                                         double                           ty);
     275                 : pixman_bool_t pixman_f_transform_bounds                (const struct pixman_f_transform *t,
     276                 :                                                         struct pixman_box16             *b);
     277                 : void          pixman_f_transform_init_identity         (struct pixman_f_transform       *t);
     278                 : 
     279                 : typedef enum
     280                 : {
     281                 :     PIXMAN_REPEAT_NONE,
     282                 :     PIXMAN_REPEAT_NORMAL,
     283                 :     PIXMAN_REPEAT_PAD,
     284                 :     PIXMAN_REPEAT_REFLECT
     285                 : } pixman_repeat_t;
     286                 : 
     287                 : typedef enum
     288                 : {
     289                 :     PIXMAN_FILTER_FAST,
     290                 :     PIXMAN_FILTER_GOOD,
     291                 :     PIXMAN_FILTER_BEST,
     292                 :     PIXMAN_FILTER_NEAREST,
     293                 :     PIXMAN_FILTER_BILINEAR,
     294                 :     PIXMAN_FILTER_CONVOLUTION
     295                 : } pixman_filter_t;
     296                 : 
     297                 : typedef enum
     298                 : {
     299                 :     PIXMAN_OP_CLEAR                     = 0x00,
     300                 :     PIXMAN_OP_SRC                       = 0x01,
     301                 :     PIXMAN_OP_DST                       = 0x02,
     302                 :     PIXMAN_OP_OVER                      = 0x03,
     303                 :     PIXMAN_OP_OVER_REVERSE              = 0x04,
     304                 :     PIXMAN_OP_IN                        = 0x05,
     305                 :     PIXMAN_OP_IN_REVERSE                = 0x06,
     306                 :     PIXMAN_OP_OUT                       = 0x07,
     307                 :     PIXMAN_OP_OUT_REVERSE               = 0x08,
     308                 :     PIXMAN_OP_ATOP                      = 0x09,
     309                 :     PIXMAN_OP_ATOP_REVERSE              = 0x0a,
     310                 :     PIXMAN_OP_XOR                       = 0x0b,
     311                 :     PIXMAN_OP_ADD                       = 0x0c,
     312                 :     PIXMAN_OP_SATURATE                  = 0x0d,
     313                 : 
     314                 :     PIXMAN_OP_DISJOINT_CLEAR            = 0x10,
     315                 :     PIXMAN_OP_DISJOINT_SRC              = 0x11,
     316                 :     PIXMAN_OP_DISJOINT_DST              = 0x12,
     317                 :     PIXMAN_OP_DISJOINT_OVER             = 0x13,
     318                 :     PIXMAN_OP_DISJOINT_OVER_REVERSE     = 0x14,
     319                 :     PIXMAN_OP_DISJOINT_IN               = 0x15,
     320                 :     PIXMAN_OP_DISJOINT_IN_REVERSE       = 0x16,
     321                 :     PIXMAN_OP_DISJOINT_OUT              = 0x17,
     322                 :     PIXMAN_OP_DISJOINT_OUT_REVERSE      = 0x18,
     323                 :     PIXMAN_OP_DISJOINT_ATOP             = 0x19,
     324                 :     PIXMAN_OP_DISJOINT_ATOP_REVERSE     = 0x1a,
     325                 :     PIXMAN_OP_DISJOINT_XOR              = 0x1b,
     326                 : 
     327                 :     PIXMAN_OP_CONJOINT_CLEAR            = 0x20,
     328                 :     PIXMAN_OP_CONJOINT_SRC              = 0x21,
     329                 :     PIXMAN_OP_CONJOINT_DST              = 0x22,
     330                 :     PIXMAN_OP_CONJOINT_OVER             = 0x23,
     331                 :     PIXMAN_OP_CONJOINT_OVER_REVERSE     = 0x24,
     332                 :     PIXMAN_OP_CONJOINT_IN               = 0x25,
     333                 :     PIXMAN_OP_CONJOINT_IN_REVERSE       = 0x26,
     334                 :     PIXMAN_OP_CONJOINT_OUT              = 0x27,
     335                 :     PIXMAN_OP_CONJOINT_OUT_REVERSE      = 0x28,
     336                 :     PIXMAN_OP_CONJOINT_ATOP             = 0x29,
     337                 :     PIXMAN_OP_CONJOINT_ATOP_REVERSE     = 0x2a,
     338                 :     PIXMAN_OP_CONJOINT_XOR              = 0x2b,
     339                 : 
     340                 :     PIXMAN_OP_MULTIPLY                  = 0x30,
     341                 :     PIXMAN_OP_SCREEN                    = 0x31,
     342                 :     PIXMAN_OP_OVERLAY                   = 0x32,
     343                 :     PIXMAN_OP_DARKEN                    = 0x33,
     344                 :     PIXMAN_OP_LIGHTEN                   = 0x34,
     345                 :     PIXMAN_OP_COLOR_DODGE               = 0x35,
     346                 :     PIXMAN_OP_COLOR_BURN                = 0x36,
     347                 :     PIXMAN_OP_HARD_LIGHT                = 0x37,
     348                 :     PIXMAN_OP_SOFT_LIGHT                = 0x38,
     349                 :     PIXMAN_OP_DIFFERENCE                = 0x39,
     350                 :     PIXMAN_OP_EXCLUSION                 = 0x3a,
     351                 :     PIXMAN_OP_HSL_HUE                   = 0x3b,
     352                 :     PIXMAN_OP_HSL_SATURATION            = 0x3c,
     353                 :     PIXMAN_OP_HSL_COLOR                 = 0x3d,
     354                 :     PIXMAN_OP_HSL_LUMINOSITY            = 0x3e
     355                 : 
     356                 : #ifdef PIXMAN_USE_INTERNAL_API
     357                 :     ,
     358                 :     PIXMAN_N_OPERATORS,
     359                 :     PIXMAN_OP_NONE = PIXMAN_N_OPERATORS
     360                 : #endif
     361                 : } pixman_op_t;
     362                 : 
     363                 : /*
     364                 :  * Regions
     365                 :  */
     366                 : typedef struct pixman_region16_data     pixman_region16_data_t;
     367                 : typedef struct pixman_box16             pixman_box16_t;
     368                 : typedef struct pixman_rectangle16       pixman_rectangle16_t;
     369                 : typedef struct pixman_region16          pixman_region16_t;
     370                 : 
     371                 : struct pixman_region16_data {
     372                 :     long                size;
     373                 :     long                numRects;
     374                 : /*  pixman_box16_t      rects[size];   in memory but not explicitly declared */
     375                 : };
     376                 : 
     377                 : struct pixman_rectangle16
     378                 : {
     379                 :     int16_t     x, y;
     380                 :     uint16_t    width, height;
     381                 : };
     382                 : 
     383                 : struct pixman_box16
     384                 : {
     385                 :     int16_t x1, y1, x2, y2;
     386                 : };
     387                 : 
     388                 : struct pixman_region16
     389                 : {
     390                 :     pixman_box16_t          extents;
     391                 :     pixman_region16_data_t *data;
     392                 : };
     393                 : 
     394                 : typedef enum
     395                 : {
     396                 :     PIXMAN_REGION_OUT,
     397                 :     PIXMAN_REGION_IN,
     398                 :     PIXMAN_REGION_PART
     399                 : } pixman_region_overlap_t;
     400                 : 
     401                 : /* This function exists only to make it possible to preserve
     402                 :  * the X ABI - it should go away at first opportunity.
     403                 :  */
     404                 : void pixman_region_set_static_pointers (pixman_box16_t         *empty_box,
     405                 :                                         pixman_region16_data_t *empty_data,
     406                 :                                         pixman_region16_data_t *broken_data);
     407                 : 
     408                 : /* creation/destruction */
     409                 : void                    pixman_region_init               (pixman_region16_t *region);
     410                 : void                    pixman_region_init_rect          (pixman_region16_t *region,
     411                 :                                                           int                x,
     412                 :                                                           int                y,
     413                 :                                                           unsigned int       width,
     414                 :                                                           unsigned int       height);
     415                 : pixman_bool_t           pixman_region_init_rects         (pixman_region16_t *region,
     416                 :                                                           const pixman_box16_t *boxes,
     417                 :                                                           int                count);
     418                 : void                    pixman_region_init_with_extents  (pixman_region16_t *region,
     419                 :                                                           pixman_box16_t    *extents);
     420                 : void                    pixman_region_init_from_image    (pixman_region16_t *region,
     421                 :                                                           pixman_image_t    *image);
     422                 : void                    pixman_region_fini               (pixman_region16_t *region);
     423                 : 
     424                 : 
     425                 : /* manipulation */
     426                 : void                    pixman_region_translate          (pixman_region16_t *region,
     427                 :                                                           int                x,
     428                 :                                                           int                y);
     429                 : pixman_bool_t           pixman_region_copy               (pixman_region16_t *dest,
     430                 :                                                           pixman_region16_t *source);
     431                 : pixman_bool_t           pixman_region_intersect          (pixman_region16_t *new_reg,
     432                 :                                                           pixman_region16_t *reg1,
     433                 :                                                           pixman_region16_t *reg2);
     434                 : pixman_bool_t           pixman_region_union              (pixman_region16_t *new_reg,
     435                 :                                                           pixman_region16_t *reg1,
     436                 :                                                           pixman_region16_t *reg2);
     437                 : pixman_bool_t           pixman_region_union_rect         (pixman_region16_t *dest,
     438                 :                                                           pixman_region16_t *source,
     439                 :                                                           int                x,
     440                 :                                                           int                y,
     441                 :                                                           unsigned int       width,
     442                 :                                                           unsigned int       height);
     443                 : pixman_bool_t           pixman_region_intersect_rect     (pixman_region16_t *dest,
     444                 :                                                           pixman_region16_t *source,
     445                 :                                                           int                x,
     446                 :                                                           int                y,
     447                 :                                                           unsigned int       width,
     448                 :                                                           unsigned int       height);
     449                 : pixman_bool_t           pixman_region_subtract           (pixman_region16_t *reg_d,
     450                 :                                                           pixman_region16_t *reg_m,
     451                 :                                                           pixman_region16_t *reg_s);
     452                 : pixman_bool_t           pixman_region_inverse            (pixman_region16_t *new_reg,
     453                 :                                                           pixman_region16_t *reg1,
     454                 :                                                           pixman_box16_t    *inv_rect);
     455                 : pixman_bool_t           pixman_region_contains_point     (pixman_region16_t *region,
     456                 :                                                           int                x,
     457                 :                                                           int                y,
     458                 :                                                           pixman_box16_t    *box);
     459                 : pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *region,
     460                 :                                                           pixman_box16_t    *prect);
     461                 : pixman_bool_t           pixman_region_not_empty          (pixman_region16_t *region);
     462                 : pixman_box16_t *        pixman_region_extents            (pixman_region16_t *region);
     463                 : int                     pixman_region_n_rects            (pixman_region16_t *region);
     464                 : pixman_box16_t *        pixman_region_rectangles         (pixman_region16_t *region,
     465                 :                                                           int               *n_rects);
     466                 : pixman_bool_t           pixman_region_equal              (pixman_region16_t *region1,
     467                 :                                                           pixman_region16_t *region2);
     468                 : pixman_bool_t           pixman_region_selfcheck          (pixman_region16_t *region);
     469                 : void                    pixman_region_reset              (pixman_region16_t *region,
     470                 :                                                           pixman_box16_t    *box);
     471                 : /*
     472                 :  * 32 bit regions
     473                 :  */
     474                 : typedef struct pixman_region32_data     pixman_region32_data_t;
     475                 : typedef struct pixman_box32             pixman_box32_t;
     476                 : typedef struct pixman_rectangle32       pixman_rectangle32_t;
     477                 : typedef struct pixman_region32          pixman_region32_t;
     478                 : 
     479                 : struct pixman_region32_data {
     480                 :     long                size;
     481                 :     long                numRects;
     482                 : /*  pixman_box32_t      rects[size];   in memory but not explicitly declared */
     483                 : };
     484                 : 
     485                 : struct pixman_rectangle32
     486                 : {
     487                 :     int32_t x, y;
     488                 :     uint32_t width, height;
     489                 : };
     490                 : 
     491                 : struct pixman_box32
     492               0 : {
     493                 :     int32_t x1, y1, x2, y2;
     494                 : };
     495                 : 
     496                 : struct pixman_region32
     497               0 : {
     498                 :     pixman_box32_t          extents;
     499                 :     pixman_region32_data_t  *data;
     500                 : };
     501                 : 
     502                 : /* creation/destruction */
     503                 : void                    pixman_region32_init               (pixman_region32_t *region);
     504                 : void                    pixman_region32_init_rect          (pixman_region32_t *region,
     505                 :                                                             int                x,
     506                 :                                                             int                y,
     507                 :                                                             unsigned int       width,
     508                 :                                                             unsigned int       height);
     509                 : pixman_bool_t           pixman_region32_init_rects         (pixman_region32_t *region,
     510                 :                                                             const pixman_box32_t *boxes,
     511                 :                                                             int                count);
     512                 : void                    pixman_region32_init_with_extents  (pixman_region32_t *region,
     513                 :                                                             pixman_box32_t    *extents);
     514                 : void                    pixman_region32_init_from_image    (pixman_region32_t *region,
     515                 :                                                             pixman_image_t    *image);
     516                 : void                    pixman_region32_fini               (pixman_region32_t *region);
     517                 : 
     518                 : 
     519                 : /* manipulation */
     520                 : void                    pixman_region32_translate          (pixman_region32_t *region,
     521                 :                                                             int                x,
     522                 :                                                             int                y);
     523                 : pixman_bool_t           pixman_region32_copy               (pixman_region32_t *dest,
     524                 :                                                             pixman_region32_t *source);
     525                 : pixman_bool_t           pixman_region32_intersect          (pixman_region32_t *new_reg,
     526                 :                                                             pixman_region32_t *reg1,
     527                 :                                                             pixman_region32_t *reg2);
     528                 : pixman_bool_t           pixman_region32_union              (pixman_region32_t *new_reg,
     529                 :                                                             pixman_region32_t *reg1,
     530                 :                                                             pixman_region32_t *reg2);
     531                 : pixman_bool_t           pixman_region32_intersect_rect     (pixman_region32_t *dest,
     532                 :                                                             pixman_region32_t *source,
     533                 :                                                             int                x,
     534                 :                                                             int                y,
     535                 :                                                             unsigned int       width,
     536                 :                                                             unsigned int       height);
     537                 : pixman_bool_t           pixman_region32_union_rect         (pixman_region32_t *dest,
     538                 :                                                             pixman_region32_t *source,
     539                 :                                                             int                x,
     540                 :                                                             int                y,
     541                 :                                                             unsigned int       width,
     542                 :                                                             unsigned int       height);
     543                 : pixman_bool_t           pixman_region32_subtract           (pixman_region32_t *reg_d,
     544                 :                                                             pixman_region32_t *reg_m,
     545                 :                                                             pixman_region32_t *reg_s);
     546                 : pixman_bool_t           pixman_region32_inverse            (pixman_region32_t *new_reg,
     547                 :                                                             pixman_region32_t *reg1,
     548                 :                                                             pixman_box32_t    *inv_rect);
     549                 : pixman_bool_t           pixman_region32_contains_point     (pixman_region32_t *region,
     550                 :                                                             int                x,
     551                 :                                                             int                y,
     552                 :                                                             pixman_box32_t    *box);
     553                 : pixman_region_overlap_t pixman_region32_contains_rectangle (pixman_region32_t *region,
     554                 :                                                             pixman_box32_t    *prect);
     555                 : pixman_bool_t           pixman_region32_not_empty          (pixman_region32_t *region);
     556                 : pixman_box32_t *        pixman_region32_extents            (pixman_region32_t *region);
     557                 : int                     pixman_region32_n_rects            (pixman_region32_t *region);
     558                 : pixman_box32_t *        pixman_region32_rectangles         (pixman_region32_t *region,
     559                 :                                                             int               *n_rects);
     560                 : pixman_bool_t           pixman_region32_equal              (pixman_region32_t *region1,
     561                 :                                                             pixman_region32_t *region2);
     562                 : pixman_bool_t           pixman_region32_selfcheck          (pixman_region32_t *region);
     563                 : void                    pixman_region32_reset              (pixman_region32_t *region,
     564                 :                                                             pixman_box32_t    *box);
     565                 : 
     566                 : 
     567                 : /* Copy / Fill / Misc */
     568                 : pixman_bool_t pixman_blt                (uint32_t           *src_bits,
     569                 :                                          uint32_t           *dst_bits,
     570                 :                                          int                 src_stride,
     571                 :                                          int                 dst_stride,
     572                 :                                          int                 src_bpp,
     573                 :                                          int                 dst_bpp,
     574                 :                                          int                 src_x,
     575                 :                                          int                 src_y,
     576                 :                                          int                 dst_x,
     577                 :                                          int                 dst_y,
     578                 :                                          int                 width,
     579                 :                                          int                 height);
     580                 : pixman_bool_t pixman_fill               (uint32_t           *bits,
     581                 :                                          int                 stride,
     582                 :                                          int                 bpp,
     583                 :                                          int                 x,
     584                 :                                          int                 y,
     585                 :                                          int                 width,
     586                 :                                          int                 height,
     587                 :                                          uint32_t            _xor);
     588                 : 
     589                 : int           pixman_version            (void);
     590                 : const char*   pixman_version_string     (void);
     591                 : 
     592                 : /*
     593                 :  * Images
     594                 :  */
     595                 : typedef struct pixman_indexed           pixman_indexed_t;
     596                 : typedef struct pixman_gradient_stop     pixman_gradient_stop_t;
     597                 : 
     598                 : typedef uint32_t (* pixman_read_memory_func_t) (const void *src, int size);
     599                 : typedef void     (* pixman_write_memory_func_t) (void *dst, uint32_t value, int size);
     600                 : 
     601                 : typedef void     (* pixman_image_destroy_func_t) (pixman_image_t *image, void *data);
     602                 : 
     603                 : struct pixman_gradient_stop {
     604                 :     pixman_fixed_t x;
     605                 :     pixman_color_t color;
     606                 : };
     607                 : 
     608                 : #define PIXMAN_MAX_INDEXED  256 /* XXX depth must be <= 8 */
     609                 : 
     610                 : #if PIXMAN_MAX_INDEXED <= 256
     611                 : typedef uint8_t pixman_index_type;
     612                 : #endif
     613                 : 
     614                 : struct pixman_indexed
     615                 : {
     616                 :     pixman_bool_t       color;
     617                 :     uint32_t            rgba[PIXMAN_MAX_INDEXED];
     618                 :     pixman_index_type   ent[32768];
     619                 : };
     620                 : 
     621                 : /*
     622                 :  * While the protocol is generous in format support, the
     623                 :  * sample implementation allows only packed RGB and GBR
     624                 :  * representations for data to simplify software rendering,
     625                 :  */
     626                 : #define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) |  \
     627                 :                                          ((type) << 16) | \
     628                 :                                          ((a) << 12) |      \
     629                 :                                          ((r) << 8) |       \
     630                 :                                          ((g) << 4) |       \
     631                 :                                          ((b)))
     632                 : 
     633                 : #define PIXMAN_FORMAT_BPP(f)    (((f) >> 24)       )
     634                 : #define PIXMAN_FORMAT_TYPE(f)   (((f) >> 16) & 0xff)
     635                 : #define PIXMAN_FORMAT_A(f)      (((f) >> 12) & 0x0f)
     636                 : #define PIXMAN_FORMAT_R(f)      (((f) >>  8) & 0x0f)
     637                 : #define PIXMAN_FORMAT_G(f)      (((f) >>  4) & 0x0f)
     638                 : #define PIXMAN_FORMAT_B(f)      (((f)      ) & 0x0f)
     639                 : #define PIXMAN_FORMAT_RGB(f)    (((f)      ) & 0xfff)
     640                 : #define PIXMAN_FORMAT_VIS(f)    (((f)      ) & 0xffff)
     641                 : #define PIXMAN_FORMAT_DEPTH(f)  (PIXMAN_FORMAT_A(f) +   \
     642                 :                                  PIXMAN_FORMAT_R(f) +   \
     643                 :                                  PIXMAN_FORMAT_G(f) +   \
     644                 :                                  PIXMAN_FORMAT_B(f))
     645                 : 
     646                 : #define PIXMAN_TYPE_OTHER       0
     647                 : #define PIXMAN_TYPE_A           1
     648                 : #define PIXMAN_TYPE_ARGB        2
     649                 : #define PIXMAN_TYPE_ABGR        3
     650                 : #define PIXMAN_TYPE_COLOR       4
     651                 : #define PIXMAN_TYPE_GRAY        5
     652                 : #define PIXMAN_TYPE_YUY2        6
     653                 : #define PIXMAN_TYPE_YV12        7
     654                 : #define PIXMAN_TYPE_BGRA        8
     655                 : #define PIXMAN_TYPE_RGBA        9
     656                 : 
     657                 : #define PIXMAN_FORMAT_COLOR(f)                          \
     658                 :         (PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ARGB ||   \
     659                 :          PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ABGR ||   \
     660                 :          PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_BGRA ||   \
     661                 :          PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_RGBA)
     662                 : 
     663                 : /* 32bpp formats */
     664                 : typedef enum {
     665                 :     PIXMAN_a8r8g8b8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8),
     666                 :     PIXMAN_x8r8g8b8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8),
     667                 :     PIXMAN_a8b8g8r8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8),
     668                 :     PIXMAN_x8b8g8r8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,8,8,8),
     669                 :     PIXMAN_b8g8r8a8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_BGRA,8,8,8,8),
     670                 :     PIXMAN_b8g8r8x8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_BGRA,0,8,8,8),
     671                 :     PIXMAN_r8g8b8a8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_RGBA,8,8,8,8),
     672                 :     PIXMAN_r8g8b8x8 =    PIXMAN_FORMAT(32,PIXMAN_TYPE_RGBA,0,8,8,8),
     673                 :     PIXMAN_x14r6g6b6 =   PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,6,6,6),
     674                 :     PIXMAN_x2r10g10b10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,10,10,10),
     675                 :     PIXMAN_a2r10g10b10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,2,10,10,10),
     676                 :     PIXMAN_x2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,0,10,10,10),
     677                 :     PIXMAN_a2b10g10r10 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,2,10,10,10),
     678                 : 
     679                 : /* 24bpp formats */
     680                 :     PIXMAN_r8g8b8 =      PIXMAN_FORMAT(24,PIXMAN_TYPE_ARGB,0,8,8,8),
     681                 :     PIXMAN_b8g8r8 =      PIXMAN_FORMAT(24,PIXMAN_TYPE_ABGR,0,8,8,8),
     682                 : 
     683                 : /* 16bpp formats */
     684                 :     PIXMAN_r5g6b5 =      PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,6,5),
     685                 :     PIXMAN_b5g6r5 =      PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,6,5),
     686                 : 
     687                 :     PIXMAN_a1r5g5b5 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,1,5,5,5),
     688                 :     PIXMAN_x1r5g5b5 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,5,5,5),
     689                 :     PIXMAN_a1b5g5r5 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,1,5,5,5),
     690                 :     PIXMAN_x1b5g5r5 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,5,5,5),
     691                 :     PIXMAN_a4r4g4b4 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,4,4,4,4),
     692                 :     PIXMAN_x4r4g4b4 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ARGB,0,4,4,4),
     693                 :     PIXMAN_a4b4g4r4 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,4,4,4,4),
     694                 :     PIXMAN_x4b4g4r4 =    PIXMAN_FORMAT(16,PIXMAN_TYPE_ABGR,0,4,4,4),
     695                 : 
     696                 : /* 8bpp formats */
     697                 :     PIXMAN_a8 =          PIXMAN_FORMAT(8,PIXMAN_TYPE_A,8,0,0,0),
     698                 :     PIXMAN_r3g3b2 =      PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,0,3,3,2),
     699                 :     PIXMAN_b2g3r3 =      PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,0,3,3,2),
     700                 :     PIXMAN_a2r2g2b2 =    PIXMAN_FORMAT(8,PIXMAN_TYPE_ARGB,2,2,2,2),
     701                 :     PIXMAN_a2b2g2r2 =    PIXMAN_FORMAT(8,PIXMAN_TYPE_ABGR,2,2,2,2),
     702                 : 
     703                 :     PIXMAN_c8 =          PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
     704                 :     PIXMAN_g8 =          PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
     705                 : 
     706                 :     PIXMAN_x4a4 =        PIXMAN_FORMAT(8,PIXMAN_TYPE_A,4,0,0,0),
     707                 : 
     708                 :     PIXMAN_x4c4 =        PIXMAN_FORMAT(8,PIXMAN_TYPE_COLOR,0,0,0,0),
     709                 :     PIXMAN_x4g4 =        PIXMAN_FORMAT(8,PIXMAN_TYPE_GRAY,0,0,0,0),
     710                 : 
     711                 : /* 4bpp formats */
     712                 :     PIXMAN_a4 =          PIXMAN_FORMAT(4,PIXMAN_TYPE_A,4,0,0,0),
     713                 :     PIXMAN_r1g2b1 =      PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,0,1,2,1),
     714                 :     PIXMAN_b1g2r1 =      PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,0,1,2,1),
     715                 :     PIXMAN_a1r1g1b1 =    PIXMAN_FORMAT(4,PIXMAN_TYPE_ARGB,1,1,1,1),
     716                 :     PIXMAN_a1b1g1r1 =    PIXMAN_FORMAT(4,PIXMAN_TYPE_ABGR,1,1,1,1),
     717                 : 
     718                 :     PIXMAN_c4 =          PIXMAN_FORMAT(4,PIXMAN_TYPE_COLOR,0,0,0,0),
     719                 :     PIXMAN_g4 =          PIXMAN_FORMAT(4,PIXMAN_TYPE_GRAY,0,0,0,0),
     720                 : 
     721                 : /* 1bpp formats */
     722                 :     PIXMAN_a1 =          PIXMAN_FORMAT(1,PIXMAN_TYPE_A,1,0,0,0),
     723                 : 
     724                 :     PIXMAN_g1 =          PIXMAN_FORMAT(1,PIXMAN_TYPE_GRAY,0,0,0,0),
     725                 : 
     726                 : /* YUV formats */
     727                 :     PIXMAN_yuy2 =        PIXMAN_FORMAT(16,PIXMAN_TYPE_YUY2,0,0,0,0),
     728                 :     PIXMAN_yv12 =        PIXMAN_FORMAT(12,PIXMAN_TYPE_YV12,0,0,0,0)
     729                 : } pixman_format_code_t;
     730                 : 
     731                 : /* Querying supported format values. */
     732                 : pixman_bool_t pixman_format_supported_destination (pixman_format_code_t format);
     733                 : pixman_bool_t pixman_format_supported_source      (pixman_format_code_t format);
     734                 : 
     735                 : /* Constructors */
     736                 : pixman_image_t *pixman_image_create_solid_fill       (pixman_color_t               *color);
     737                 : pixman_image_t *pixman_image_create_linear_gradient  (pixman_point_fixed_t         *p1,
     738                 :                                                       pixman_point_fixed_t         *p2,
     739                 :                                                       const pixman_gradient_stop_t *stops,
     740                 :                                                       int                           n_stops);
     741                 : pixman_image_t *pixman_image_create_radial_gradient  (pixman_point_fixed_t         *inner,
     742                 :                                                       pixman_point_fixed_t         *outer,
     743                 :                                                       pixman_fixed_t                inner_radius,
     744                 :                                                       pixman_fixed_t                outer_radius,
     745                 :                                                       const pixman_gradient_stop_t *stops,
     746                 :                                                       int                           n_stops);
     747                 : pixman_image_t *pixman_image_create_conical_gradient (pixman_point_fixed_t         *center,
     748                 :                                                       pixman_fixed_t                angle,
     749                 :                                                       const pixman_gradient_stop_t *stops,
     750                 :                                                       int                           n_stops);
     751                 : pixman_image_t *pixman_image_create_bits             (pixman_format_code_t          format,
     752                 :                                                       int                           width,
     753                 :                                                       int                           height,
     754                 :                                                       uint32_t                     *bits,
     755                 :                                                       int                           rowstride_bytes);
     756                 : 
     757                 : /* Destructor */
     758                 : pixman_image_t *pixman_image_ref                     (pixman_image_t               *image);
     759                 : pixman_bool_t   pixman_image_unref                   (pixman_image_t               *image);
     760                 : 
     761                 : void            pixman_image_set_destroy_function    (pixman_image_t               *image,
     762                 :                                                       pixman_image_destroy_func_t   function,
     763                 :                                                       void                         *data);
     764                 : void *          pixman_image_get_destroy_data        (pixman_image_t               *image);
     765                 : 
     766                 : /* Set properties */
     767                 : pixman_bool_t   pixman_image_set_clip_region         (pixman_image_t               *image,
     768                 :                                                       pixman_region16_t            *region);
     769                 : pixman_bool_t   pixman_image_set_clip_region32       (pixman_image_t               *image,
     770                 :                                                       pixman_region32_t            *region);
     771                 : void            pixman_image_set_has_client_clip     (pixman_image_t               *image,
     772                 :                                                       pixman_bool_t                 clien_clip);
     773                 : pixman_bool_t   pixman_image_set_transform           (pixman_image_t               *image,
     774                 :                                                       const pixman_transform_t     *transform);
     775                 : void            pixman_image_set_repeat              (pixman_image_t               *image,
     776                 :                                                       pixman_repeat_t               repeat);
     777                 : pixman_bool_t   pixman_image_set_filter              (pixman_image_t               *image,
     778                 :                                                       pixman_filter_t               filter,
     779                 :                                                       const pixman_fixed_t         *filter_params,
     780                 :                                                       int                           n_filter_params);
     781                 : void            pixman_image_set_source_clipping     (pixman_image_t               *image,
     782                 :                                                       pixman_bool_t                 source_clipping);
     783                 : void            pixman_image_set_alpha_map           (pixman_image_t               *image,
     784                 :                                                       pixman_image_t               *alpha_map,
     785                 :                                                       int16_t                       x,
     786                 :                                                       int16_t                       y);
     787                 : void            pixman_image_set_component_alpha     (pixman_image_t               *image,
     788                 :                                                       pixman_bool_t                 component_alpha);
     789                 : pixman_bool_t   pixman_image_get_component_alpha     (pixman_image_t               *image);
     790                 : void            pixman_image_set_accessors           (pixman_image_t               *image,
     791                 :                                                       pixman_read_memory_func_t     read_func,
     792                 :                                                       pixman_write_memory_func_t    write_func);
     793                 : void            pixman_image_set_indexed             (pixman_image_t               *image,
     794                 :                                                       const pixman_indexed_t       *indexed);
     795                 : uint32_t       *pixman_image_get_data                (pixman_image_t               *image);
     796                 : int             pixman_image_get_width               (pixman_image_t               *image);
     797                 : int             pixman_image_get_height              (pixman_image_t               *image);
     798                 : int             pixman_image_get_stride              (pixman_image_t               *image); /* in bytes */
     799                 : int             pixman_image_get_depth               (pixman_image_t               *image);
     800                 : pixman_format_code_t pixman_image_get_format         (pixman_image_t               *image);
     801                 : pixman_bool_t   pixman_image_fill_rectangles         (pixman_op_t                   op,
     802                 :                                                       pixman_image_t               *image,
     803                 :                                                       pixman_color_t               *color,
     804                 :                                                       int                           n_rects,
     805                 :                                                       const pixman_rectangle16_t   *rects);
     806                 : pixman_bool_t   pixman_image_fill_boxes              (pixman_op_t                   op,
     807                 :                                                       pixman_image_t               *dest,
     808                 :                                                       pixman_color_t               *color,
     809                 :                                                       int                           n_boxes,
     810                 :                                                       const pixman_box32_t         *boxes);
     811                 : 
     812                 : /* Composite */
     813                 : pixman_bool_t pixman_compute_composite_region (pixman_region16_t *region,
     814                 :                                                pixman_image_t    *src_image,
     815                 :                                                pixman_image_t    *mask_image,
     816                 :                                                pixman_image_t    *dst_image,
     817                 :                                                int16_t            src_x,
     818                 :                                                int16_t            src_y,
     819                 :                                                int16_t            mask_x,
     820                 :                                                int16_t            mask_y,
     821                 :                                                int16_t            dest_x,
     822                 :                                                int16_t            dest_y,
     823                 :                                                uint16_t           width,
     824                 :                                                uint16_t           height);
     825                 : void          pixman_image_composite          (pixman_op_t        op,
     826                 :                                                pixman_image_t    *src,
     827                 :                                                pixman_image_t    *mask,
     828                 :                                                pixman_image_t    *dest,
     829                 :                                                int16_t            src_x,
     830                 :                                                int16_t            src_y,
     831                 :                                                int16_t            mask_x,
     832                 :                                                int16_t            mask_y,
     833                 :                                                int16_t            dest_x,
     834                 :                                                int16_t            dest_y,
     835                 :                                                uint16_t           width,
     836                 :                                                uint16_t           height);
     837                 : void          pixman_image_composite32        (pixman_op_t        op,
     838                 :                                                pixman_image_t    *src,
     839                 :                                                pixman_image_t    *mask,
     840                 :                                                pixman_image_t    *dest,
     841                 :                                                int32_t            src_x,
     842                 :                                                int32_t            src_y,
     843                 :                                                int32_t            mask_x,
     844                 :                                                int32_t            mask_y,
     845                 :                                                int32_t            dest_x,
     846                 :                                                int32_t            dest_y,
     847                 :                                                int32_t            width,
     848                 :                                                int32_t            height);
     849                 : 
     850                 : /* Executive Summary: This function is a no-op that only exists
     851                 :  * for historical reasons.
     852                 :  *
     853                 :  * There used to be a bug in the X server where it would rely on
     854                 :  * out-of-bounds accesses when it was asked to composite with a
     855                 :  * window as the source. It would create a pixman image pointing
     856                 :  * to some bogus position in memory, but then set a clip region
     857                 :  * to the position where the actual bits were.
     858                 :  *
     859                 :  * Due to a bug in old versions of pixman, where it would not clip
     860                 :  * against the image bounds when a clip region was set, this would
     861                 :  * actually work. So when the pixman bug was fixed, a workaround was
     862                 :  * added to allow certain out-of-bound accesses. This function disabled
     863                 :  * those workarounds.
     864                 :  *
     865                 :  * Since 0.21.2, pixman doesn't do these workarounds anymore, so now this
     866                 :  * function is a no-op.
     867                 :  */
     868                 : void pixman_disable_out_of_bounds_workaround (void);
     869                 : 
     870                 : /*
     871                 :  * Trapezoids
     872                 :  */
     873                 : typedef struct pixman_edge pixman_edge_t;
     874                 : typedef struct pixman_trapezoid pixman_trapezoid_t;
     875                 : typedef struct pixman_trap pixman_trap_t;
     876                 : typedef struct pixman_span_fix pixman_span_fix_t;
     877                 : typedef struct pixman_triangle pixman_triangle_t;
     878                 : 
     879                 : /*
     880                 :  * An edge structure.  This represents a single polygon edge
     881                 :  * and can be quickly stepped across small or large gaps in the
     882                 :  * sample grid
     883                 :  */
     884                 : struct pixman_edge
     885                 : {
     886                 :     pixman_fixed_t      x;
     887                 :     pixman_fixed_t      e;
     888                 :     pixman_fixed_t      stepx;
     889                 :     pixman_fixed_t      signdx;
     890                 :     pixman_fixed_t      dy;
     891                 :     pixman_fixed_t      dx;
     892                 : 
     893                 :     pixman_fixed_t      stepx_small;
     894                 :     pixman_fixed_t      stepx_big;
     895                 :     pixman_fixed_t      dx_small;
     896                 :     pixman_fixed_t      dx_big;
     897                 : };
     898                 : 
     899                 : struct pixman_trapezoid
     900                 : {
     901                 :     pixman_fixed_t      top, bottom;
     902                 :     pixman_line_fixed_t left, right;
     903                 : };
     904                 : 
     905                 : struct pixman_triangle
     906                 : {
     907                 :     pixman_point_fixed_t p1, p2, p3;
     908                 : };
     909                 : 
     910                 : /* whether 't' is a well defined not obviously empty trapezoid */
     911                 : #define pixman_trapezoid_valid(t)                                  \
     912                 :     ((t)->left.p1.y != (t)->left.p2.y &&                     \
     913                 :      (t)->right.p1.y != (t)->right.p2.y &&                           \
     914                 :      (int) ((t)->bottom - (t)->top) > 0)
     915                 : 
     916                 : struct pixman_span_fix
     917                 : {
     918                 :     pixman_fixed_t      l, r, y;
     919                 : };
     920                 : 
     921                 : struct pixman_trap
     922                 : {
     923                 :     pixman_span_fix_t   top, bot;
     924                 : };
     925                 : 
     926                 : pixman_fixed_t pixman_sample_ceil_y        (pixman_fixed_t             y,
     927                 :                                             int                        bpp);
     928                 : pixman_fixed_t pixman_sample_floor_y       (pixman_fixed_t             y,
     929                 :                                             int                        bpp);
     930                 : void           pixman_edge_step            (pixman_edge_t             *e,
     931                 :                                             int                        n);
     932                 : void           pixman_edge_init            (pixman_edge_t             *e,
     933                 :                                             int                        bpp,
     934                 :                                             pixman_fixed_t             y_start,
     935                 :                                             pixman_fixed_t             x_top,
     936                 :                                             pixman_fixed_t             y_top,
     937                 :                                             pixman_fixed_t             x_bot,
     938                 :                                             pixman_fixed_t             y_bot);
     939                 : void           pixman_line_fixed_edge_init (pixman_edge_t             *e,
     940                 :                                             int                        bpp,
     941                 :                                             pixman_fixed_t             y,
     942                 :                                             const pixman_line_fixed_t *line,
     943                 :                                             int                        x_off,
     944                 :                                             int                        y_off);
     945                 : void           pixman_rasterize_edges      (pixman_image_t            *image,
     946                 :                                             pixman_edge_t             *l,
     947                 :                                             pixman_edge_t             *r,
     948                 :                                             pixman_fixed_t             t,
     949                 :                                             pixman_fixed_t             b);
     950                 : void           pixman_add_traps            (pixman_image_t            *image,
     951                 :                                             int16_t                    x_off,
     952                 :                                             int16_t                    y_off,
     953                 :                                             int                        ntrap,
     954                 :                                             pixman_trap_t             *traps);
     955                 : void           pixman_add_trapezoids       (pixman_image_t            *image,
     956                 :                                             int16_t                    x_off,
     957                 :                                             int                        y_off,
     958                 :                                             int                        ntraps,
     959                 :                                             const pixman_trapezoid_t  *traps);
     960                 : void           pixman_rasterize_trapezoid  (pixman_image_t            *image,
     961                 :                                             const pixman_trapezoid_t  *trap,
     962                 :                                             int                        x_off,
     963                 :                                             int                        y_off);
     964                 : void          pixman_composite_trapezoids (pixman_op_t                 op,
     965                 :                                            pixman_image_t *            src,
     966                 :                                            pixman_image_t *            dst,
     967                 :                                            pixman_format_code_t        mask_format,
     968                 :                                            int                         x_src,
     969                 :                                            int                         y_src,
     970                 :                                            int                         x_dst,
     971                 :                                            int                         y_dst,
     972                 :                                            int                         n_traps,
     973                 :                                            const pixman_trapezoid_t *  traps);
     974                 : void          pixman_composite_triangles (pixman_op_t                  op,
     975                 :                                           pixman_image_t *             src,
     976                 :                                           pixman_image_t *             dst,
     977                 :                                           pixman_format_code_t         mask_format,
     978                 :                                           int                          x_src,
     979                 :                                           int                          y_src,
     980                 :                                           int                          x_dst,
     981                 :                                           int                          y_dst,
     982                 :                                           int                          n_tris,
     983                 :                                           const pixman_triangle_t *    tris);
     984                 : void          pixman_add_triangles       (pixman_image_t              *image,
     985                 :                                           int32_t                      x_off,
     986                 :                                           int32_t                      y_off,
     987                 :                                           int                          n_tris,
     988                 :                                           const pixman_triangle_t     *tris);
     989                 : 
     990                 : PIXMAN_END_DECLS
     991                 : 
     992                 : #endif /* PIXMAN_H__ */

Generated by: LCOV version 1.7