pixman/pixman-image.c

   1 /*
   2  * Copyright © 2000 SuSE, Inc.
   3  * Copyright © 2007 Red Hat, Inc.
   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, and that the name of SuSE not be used in advertising or
  10  * publicity pertaining to distribution of the software without specific,
  11  * written prior permission.  SuSE makes no representations about the
  12  * suitability of this software for any purpose.  It is provided "as is"
  13  * without express or implied warranty.
  14  *
  15  * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
  17  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  19  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <assert.h>
  31
  32 #include "pixman-private.h"
  33
  34 static const pixman_color_t transparent_black = { 0, 0, 0, 0 };
  35
  36 static void
  37 gradient_property_changed (pixman_image_t *image)
  38 {
  39     gradient_t *gradient = &image->gradient;
  40     int n = gradient->n_stops;
  41     pixman_gradient_stop_t *stops = gradient->stops;
  42     pixman_gradient_stop_t *begin = &(gradient->stops[-1]);
  43     pixman_gradient_stop_t *end = &(gradient->stops[n]);
  44
  45     switch (gradient->common.repeat)
  46     {
  47     default:
  48     case PIXMAN_REPEAT_NONE:
  49         begin->x = INT32_MIN;
  50         begin->color = transparent_black;
  51         end->x = INT32_MAX;
  52         end->color = transparent_black;
  53         break;
  54
  55     case PIXMAN_REPEAT_NORMAL:
  56         begin->x = stops[n - 1].x - pixman_fixed_1;
  57         begin->color = stops[n - 1].color;
  58         end->x = stops[0].x + pixman_fixed_1;
  59         end->color = stops[0].color;
  60         break;
  61
  62     case PIXMAN_REPEAT_REFLECT:
  63         begin->x = - stops[0].x;
  64         begin->color = stops[0].color;
  65         end->x = pixman_int_to_fixed (2) - stops[n - 1].x;
  66         end->color = stops[n - 1].color;
  67         break;
  68
  69     case PIXMAN_REPEAT_PAD:
  70         begin->x = INT32_MIN;
  71         begin->color = stops[0].color;
  72         end->x = INT32_MAX;
  73         end->color = stops[n - 1].color;
  74         break;
  75     }
  76 }
  77
  78 pixman_bool_t
  79 _pixman_init_gradient (gradient_t *                  gradient,
  80                        const pixman_gradient_stop_t *stops,
  81                        int                           n_stops)
  82 {
  83     return_val_if_fail (n_stops > 0, FALSE);
  84
  85     /* We allocate two extra stops, one before the beginning of the stop list,
  86      * and one after the end. These stops are initialized to whatever color
  87      * would be used for positions outside the range of the stop list.
  88      *
  89      * This saves a bit of computation in the gradient walker.
  90      *
  91      * The pointer we store in the gradient_t struct still points to the
  92      * first user-supplied struct, so when freeing, we will have to
  93      * subtract one.
  94      */
  95     gradient->stops =
  96         pixman_malloc_ab (n_stops + 2, sizeof (pixman_gradient_stop_t));
  97     if (!gradient->stops)
  98         return FALSE;
  99
 100     gradient->stops += 1;
 101     memcpy (gradient->stops, stops, n_stops * sizeof (pixman_gradient_stop_t));
 102     gradient->n_stops = n_stops;
 103
 104     gradient->common.property_changed = gradient_property_changed;
 105
 106     return TRUE;
 107 }
 108
 109 void
 110 _pixman_image_init (pixman_image_t *image)
 111 {
 112     image_common_t *common = &image->common;
 113
 114     pixman_region32_init (&common->clip_region);
 115
 116     common->alpha_count = 0;
 117     common->have_clip_region = FALSE;
 118     common->clip_sources = FALSE;
 119     common->transform = NULL;
 120     common->repeat = PIXMAN_REPEAT_NONE;
 121     common->filter = PIXMAN_FILTER_NEAREST;
 122     common->filter_params = NULL;
 123     common->n_filter_params = 0;
 124     common->alpha_map = NULL;
 125     common->component_alpha = FALSE;
 126     common->ref_count = 1;
 127     common->property_changed = NULL;
 128     common->client_clip = FALSE;
 129     common->destroy_func = NULL;
 130     common->destroy_data = NULL;
 131     common->dirty = TRUE;
 132 }
 133
 134 pixman_bool_t
 135 _pixman_image_fini (pixman_image_t *image)
 136 {
 137     image_common_t *common = (image_common_t *)image;
 138
 139     common->ref_count--;
 140
 141     if (common->ref_count == 0)
 142     {
 143         if (image->common.destroy_func)
 144             image->common.destroy_func (image, image->common.destroy_data);
 145
 146         pixman_region32_fini (&common->clip_region);
 147
 148         free (common->transform);
 149         free (common->filter_params);
 150
 151         if (common->alpha_map)
 152             pixman_image_unref ((pixman_image_t *)common->alpha_map);
 153
 154         if (image->type == LINEAR ||
 155             image->type == RADIAL ||
 156             image->type == CONICAL)
 157         {
 158             if (image->gradient.stops)
 159             {
 160                 /* See _pixman_init_gradient() for an explanation of the - 1 */
 161                 free (image->gradient.stops - 1);
 162             }
 163
 164             /* This will trigger if someone adds a property_changed
 165              * method to the linear/radial/conical gradient overwriting
 166              * the general one.
 167              */
 168             assert (
 169                 image->common.property_changed == gradient_property_changed);
 170         }
 171
 172         if (image->type == BITS && image->bits.free_me)
 173             free (image->bits.free_me);
 174
 175         return TRUE;
 176     }
 177
 178     return FALSE;
 179 }
 180
 181 pixman_image_t *
 182 _pixman_image_allocate (void)
 183 {
 184     pixman_image_t *image = malloc (sizeof (pixman_image_t));
 185
 186     if (image)
 187         _pixman_image_init (image);
 188
 189     return image;
 190 }
 191
 192 static void
 193 image_property_changed (pixman_image_t *image)
 194 {
 195     image->common.dirty = TRUE;
 196 }
 197
 198 /* Ref Counting */
 199 PIXMAN_EXPORT pixman_image_t *
 200 pixman_image_ref (pixman_image_t *image)
 201 {
 202     image->common.ref_count++;
 203
 204     return image;
 205 }
 206
 207 /* returns TRUE when the image is freed */
 208 PIXMAN_EXPORT pixman_bool_t
 209 pixman_image_unref (pixman_image_t *image)
 210 {
 211     if (_pixman_image_fini (image))
 212     {
 213         free (image);
 214         return TRUE;
 215     }
 216
 217     return FALSE;
 218 }
 219
 220 PIXMAN_EXPORT void
 221 pixman_image_set_destroy_function (pixman_image_t *            image,
 222                                    pixman_image_destroy_func_t func,
 223                                    void *                      data)
 224 {
 225     image->common.destroy_func = func;
 226     image->common.destroy_data = data;
 227 }
 228
 229 PIXMAN_EXPORT void *
 230 pixman_image_get_destroy_data (pixman_image_t *image)
 231 {
 232   return image->common.destroy_data;
 233 }
 234
 235 void
 236 _pixman_image_reset_clip_region (pixman_image_t *image)
 237 {
 238     image->common.have_clip_region = FALSE;
 239 }
 240
 241 /* Executive Summary: This function is a no-op that only exists
 242  * for historical reasons.
 243  *
 244  * There used to be a bug in the X server where it would rely on
 245  * out-of-bounds accesses when it was asked to composite with a
 246  * window as the source. It would create a pixman image pointing
 247  * to some bogus position in memory, but then set a clip region
 248  * to the position where the actual bits were.
 249  *
 250  * Due to a bug in old versions of pixman, where it would not clip
 251  * against the image bounds when a clip region was set, this would
 252  * actually work. So when the pixman bug was fixed, a workaround was
 253  * added to allow certain out-of-bound accesses. This function disabled
 254  * those workarounds.
 255  *
 256  * Since 0.21.2, pixman doesn't do these workarounds anymore, so now
 257  * this function is a no-op.
 258  */
 259 PIXMAN_EXPORT void
 260 pixman_disable_out_of_bounds_workaround (void)
 261 {
 262 }
 263
 264 static void
 265 compute_image_info (pixman_image_t *image)
 266 {
 267     pixman_format_code_t code;
 268     uint32_t flags = 0;
 269
 270     /* Transform */
 271     if (!image->common.transform)
 272     {
 273         flags |= (FAST_PATH_ID_TRANSFORM        |
 274                   FAST_PATH_X_UNIT_POSITIVE     |
 275                   FAST_PATH_Y_UNIT_ZERO         |
 276                   FAST_PATH_AFFINE_TRANSFORM);
 277     }
 278     else
 279     {
 280         flags |= FAST_PATH_HAS_TRANSFORM;
 281
 282         if (image->common.transform->matrix[2][0] == 0                  &&
 283             image->common.transform->matrix[2][1] == 0                  &&
 284             image->common.transform->matrix[2][2] == pixman_fixed_1)
 285         {
 286             flags |= FAST_PATH_AFFINE_TRANSFORM;
 287
 288             if (image->common.transform->matrix[0][1] == 0 &&
 289                 image->common.transform->matrix[1][0] == 0)
 290             {
 291                 if (image->common.transform->matrix[0][0] == -pixman_fixed_1 &&
 292                     image->common.transform->matrix[1][1] == -pixman_fixed_1)
 293                 {
 294                     flags |= FAST_PATH_ROTATE_180_TRANSFORM;
 295                 }
 296                 flags |= FAST_PATH_SCALE_TRANSFORM;
 297             }
 298             else if (image->common.transform->matrix[0][0] == 0 &&
 299                      image->common.transform->matrix[1][1] == 0)
 300             {
 301                 pixman_fixed_t m01 = image->common.transform->matrix[0][1];
 302                 pixman_fixed_t m10 = image->common.transform->matrix[1][0];
 303
 304                 if (m01 == -1 && m10 == 1)
 305                     flags |= FAST_PATH_ROTATE_90_TRANSFORM;
 306                 else if (m01 == 1 && m10 == -1)
 307                     flags |= FAST_PATH_ROTATE_270_TRANSFORM;
 308             }
 309         }
 310
 311         if (image->common.transform->matrix[0][0] > 0)
 312             flags |= FAST_PATH_X_UNIT_POSITIVE;
 313
 314         if (image->common.transform->matrix[1][0] == 0)
 315             flags |= FAST_PATH_Y_UNIT_ZERO;
 316     }
 317
 318     /* Filter */
 319     switch (image->common.filter)
 320     {
 321     case PIXMAN_FILTER_NEAREST:
 322     case PIXMAN_FILTER_FAST:
 323         flags |= (FAST_PATH_NEAREST_FILTER | FAST_PATH_NO_CONVOLUTION_FILTER);
 324         break;
 325
 326     case PIXMAN_FILTER_BILINEAR:
 327     case PIXMAN_FILTER_GOOD:
 328     case PIXMAN_FILTER_BEST:
 329         flags |= (FAST_PATH_BILINEAR_FILTER | FAST_PATH_NO_CONVOLUTION_FILTER);
 330
 331         /* Here we have a chance to optimize BILINEAR filter to NEAREST if
 332          * they are equivalent for the currently used transformation matrix.
 333          */
 334         if (flags & FAST_PATH_ID_TRANSFORM)
 335         {
 336             flags |= FAST_PATH_NEAREST_FILTER;
 337         }
 338         else if (
 339             /* affine and integer translation components in matrix ... */
 340             ((flags & FAST_PATH_AFFINE_TRANSFORM) &&
 341              !pixman_fixed_frac (image->common.transform->matrix[0][2] |
 342                                  image->common.transform->matrix[1][2])) &&
 343             (
 344                 /* ... combined with a simple rotation */
 345                 (flags & (FAST_PATH_ROTATE_90_TRANSFORM |
 346                           FAST_PATH_ROTATE_180_TRANSFORM |
 347                           FAST_PATH_ROTATE_270_TRANSFORM)) ||
 348                 /* ... or combined with a simple non-rotated translation */
 349                 (image->common.transform->matrix[0][0] == pixman_fixed_1 &&
 350                  image->common.transform->matrix[1][1] == pixman_fixed_1 &&
 351                  image->common.transform->matrix[0][1] == 0 &&
 352                  image->common.transform->matrix[1][0] == 0)
 353                 )
 354             )
 355         {
 356             /* FIXME: there are some affine-test failures, showing that
 357              * handling of BILINEAR and NEAREST filter is not quite
 358              * equivalent when getting close to 32K for the translation
 359              * components of the matrix. That's likely some bug, but for
 360              * now just skip BILINEAR->NEAREST optimization in this case.
 361              */
 362             pixman_fixed_t magic_limit = pixman_int_to_fixed (30000);
 363             if (image->common.transform->matrix[0][2] <= magic_limit  &&
 364                 image->common.transform->matrix[1][2] <= magic_limit  &&
 365                 image->common.transform->matrix[0][2] >= -magic_limit &&
 366                 image->common.transform->matrix[1][2] >= -magic_limit)
 367             {
 368                 flags |= FAST_PATH_NEAREST_FILTER;
 369             }
 370         }
 371         break;
 372
 373     case PIXMAN_FILTER_CONVOLUTION:
 374         break;
 375
 376     default:
 377         flags |= FAST_PATH_NO_CONVOLUTION_FILTER;
 378         break;
 379     }
 380
 381     /* Repeat mode */
 382     switch (image->common.repeat)
 383     {
 384     case PIXMAN_REPEAT_NONE:
 385         flags |=
 386             FAST_PATH_NO_REFLECT_REPEAT         |
 387             FAST_PATH_NO_PAD_REPEAT             |
 388             FAST_PATH_NO_NORMAL_REPEAT;
 389         break;
 390
 391     case PIXMAN_REPEAT_REFLECT:
 392         flags |=
 393             FAST_PATH_NO_PAD_REPEAT             |
 394             FAST_PATH_NO_NONE_REPEAT            |
 395             FAST_PATH_NO_NORMAL_REPEAT;
 396         break;
 397
 398     case PIXMAN_REPEAT_PAD:
 399         flags |=
 400             FAST_PATH_NO_REFLECT_REPEAT         |
 401             FAST_PATH_NO_NONE_REPEAT            |
 402             FAST_PATH_NO_NORMAL_REPEAT;
 403         break;
 404
 405     default:
 406         flags |=
 407             FAST_PATH_NO_REFLECT_REPEAT         |
 408             FAST_PATH_NO_PAD_REPEAT             |
 409             FAST_PATH_NO_NONE_REPEAT;
 410         break;
 411     }
 412
 413     /* Component alpha */
 414     if (image->common.component_alpha)
 415         flags |= FAST_PATH_COMPONENT_ALPHA;
 416     else
 417         flags |= FAST_PATH_UNIFIED_ALPHA;
 418
 419     flags |= (FAST_PATH_NO_ACCESSORS | FAST_PATH_NARROW_FORMAT);
 420
 421     /* Type specific checks */
 422     switch (image->type)
 423     {
 424     case SOLID:
 425         code = PIXMAN_solid;
 426
 427         if (image->solid.color.alpha == 0xffff)
 428             flags |= FAST_PATH_IS_OPAQUE;
 429         break;
 430
 431     case BITS:
 432         if (image->bits.width == 1      &&
 433             image->bits.height == 1     &&
 434             image->common.repeat != PIXMAN_REPEAT_NONE)
 435         {
 436             code = PIXMAN_solid;
 437         }
 438         else
 439         {
 440             code = image->bits.format;
 441             flags |= FAST_PATH_BITS_IMAGE;
 442         }
 443
 444         if (!PIXMAN_FORMAT_A (image->bits.format)                               &&
 445             PIXMAN_FORMAT_TYPE (image->bits.format) != PIXMAN_TYPE_GRAY         &&
 446             PIXMAN_FORMAT_TYPE (image->bits.format) != PIXMAN_TYPE_COLOR)
 447         {
 448             flags |= FAST_PATH_SAMPLES_OPAQUE;
 449
 450             if (image->common.repeat != PIXMAN_REPEAT_NONE)
 451                 flags |= FAST_PATH_IS_OPAQUE;
 452         }
 453
 454         if (image->bits.read_func || image->bits.write_func)
 455             flags &= ~FAST_PATH_NO_ACCESSORS;
 456
 457         if (PIXMAN_FORMAT_IS_WIDE (image->bits.format))
 458             flags &= ~FAST_PATH_NARROW_FORMAT;
 459         break;
 460
 461     case RADIAL:
 462         code = PIXMAN_unknown;
 463
 464         /*
 465          * As explained in pixman-radial-gradient.c, every point of
 466          * the plane has a valid associated radius (and thus will be
 467          * colored) if and only if a is negative (i.e. one of the two
 468          * circles contains the other one).
 469          */
 470
 471         if (image->radial.a >= 0)
 472             break;
 473
 474         /* Fall through */
 475
 476     case CONICAL:
 477     case LINEAR:
 478         code = PIXMAN_unknown;
 479
 480         if (image->common.repeat != PIXMAN_REPEAT_NONE)
 481         {
 482             int i;
 483
 484             flags |= FAST_PATH_IS_OPAQUE;
 485             for (i = 0; i < image->gradient.n_stops; ++i)
 486             {
 487                 if (image->gradient.stops[i].color.alpha != 0xffff)
 488                 {
 489                     flags &= ~FAST_PATH_IS_OPAQUE;
 490                     break;
 491                 }
 492             }
 493         }
 494         break;
 495
 496     default:
 497         code = PIXMAN_unknown;
 498         break;
 499     }
 500
 501     /* Alpha map */
 502     if (!image->common.alpha_map)
 503     {
 504         flags |= FAST_PATH_NO_ALPHA_MAP;
 505     }
 506     else
 507     {
 508         if (PIXMAN_FORMAT_IS_WIDE (image->common.alpha_map->format))
 509             flags &= ~FAST_PATH_NARROW_FORMAT;
 510     }
 511
 512     /* Both alpha maps and convolution filters can introduce
 513      * non-opaqueness in otherwise opaque images. Also
 514      * an image with component alpha turned on is only opaque
 515      * if all channels are opaque, so we simply turn it off
 516      * unconditionally for those images.
 517      */
 518     if (image->common.alpha_map                                 ||
 519         image->common.filter == PIXMAN_FILTER_CONVOLUTION       ||
 520         image->common.component_alpha)
 521     {
 522         flags &= ~(FAST_PATH_IS_OPAQUE | FAST_PATH_SAMPLES_OPAQUE);
 523     }
 524
 525     image->common.flags = flags;
 526     image->common.extended_format_code = code;
 527 }
 528
 529 void
 530 _pixman_image_validate (pixman_image_t *image)
 531 {
 532     if (image->common.dirty)
 533     {
 534         compute_image_info (image);
 535
 536         /* It is important that property_changed is
 537          * called *after* compute_image_info() because
 538          * property_changed() can make use of the flags
 539          * to set up accessors etc.
 540          */
 541         if (image->common.property_changed)
 542             image->common.property_changed (image);
 543
 544         image->common.dirty = FALSE;
 545     }
 546
 547     if (image->common.alpha_map)
 548         _pixman_image_validate ((pixman_image_t *)image->common.alpha_map);
 549 }
 550
 551 PIXMAN_EXPORT pixman_bool_t
 552 pixman_image_set_clip_region32 (pixman_image_t *   image,
 553                                 pixman_region32_t *region)
 554 {
 555     image_common_t *common = (image_common_t *)image;
 556     pixman_bool_t result;
 557
 558     if (region)
 559     {
 560         if ((result = pixman_region32_copy (&common->clip_region, region)))
 561             image->common.have_clip_region = TRUE;
 562     }
 563     else
 564     {
 565         _pixman_image_reset_clip_region (image);
 566
 567         result = TRUE;
 568     }
 569
 570     image_property_changed (image);
 571
 572     return result;
 573 }
 574
 575 PIXMAN_EXPORT pixman_bool_t
 576 pixman_image_set_clip_region (pixman_image_t *   image,
 577                               pixman_region16_t *region)
 578 {
 579     image_common_t *common = (image_common_t *)image;
 580     pixman_bool_t result;
 581
 582     if (region)
 583     {
 584         if ((result = pixman_region32_copy_from_region16 (&common->clip_region, region)))
 585             image->common.have_clip_region = TRUE;
 586     }
 587     else
 588     {
 589         _pixman_image_reset_clip_region (image);
 590
 591         result = TRUE;
 592     }
 593
 594     image_property_changed (image);
 595
 596     return result;
 597 }
 598
 599 PIXMAN_EXPORT void
 600 pixman_image_set_has_client_clip (pixman_image_t *image,
 601                                   pixman_bool_t   client_clip)
 602 {
 603     image->common.client_clip = client_clip;
 604 }
 605
 606 PIXMAN_EXPORT pixman_bool_t
 607 pixman_image_set_transform (pixman_image_t *          image,
 608                             const pixman_transform_t *transform)
 609 {
 610     static const pixman_transform_t id =
 611     {
 612         { { pixman_fixed_1, 0, 0 },
 613           { 0, pixman_fixed_1, 0 },
 614           { 0, 0, pixman_fixed_1 } }
 615     };
 616
 617     image_common_t *common = (image_common_t *)image;
 618     pixman_bool_t result;
 619
 620     if (common->transform == transform)
 621         return TRUE;
 622
 623     if (!transform || memcmp (&id, transform, sizeof (pixman_transform_t)) == 0)
 624     {
 625         free (common->transform);
 626         common->transform = NULL;
 627         result = TRUE;
 628
 629         goto out;
 630     }
 631
 632     if (common->transform &&
 633         memcmp (common->transform, transform, sizeof (pixman_transform_t)) == 0)
 634     {
 635         return TRUE;
 636     }
 637
 638     if (common->transform == NULL)
 639         common->transform = malloc (sizeof (pixman_transform_t));
 640
 641     if (common->transform == NULL)
 642     {
 643         result = FALSE;
 644
 645         goto out;
 646     }
 647
 648     memcpy (common->transform, transform, sizeof(pixman_transform_t));
 649
 650     result = TRUE;
 651
 652 out:
 653     image_property_changed (image);
 654
 655     return result;
 656 }
 657
 658 PIXMAN_EXPORT void
 659 pixman_image_set_repeat (pixman_image_t *image,
 660                          pixman_repeat_t repeat)
 661 {
 662     if (image->common.repeat == repeat)
 663         return;
 664
 665     image->common.repeat = repeat;
 666
 667     image_property_changed (image);
 668 }
 669
 670 PIXMAN_EXPORT pixman_bool_t
 671 pixman_image_set_filter (pixman_image_t *      image,
 672                          pixman_filter_t       filter,
 673                          const pixman_fixed_t *params,
 674                          int                   n_params)
 675 {
 676     image_common_t *common = (image_common_t *)image;
 677     pixman_fixed_t *new_params;
 678
 679     if (params == common->filter_params && filter == common->filter)
 680         return TRUE;
 681
 682     new_params = NULL;
 683     if (params)
 684     {
 685         new_params = pixman_malloc_ab (n_params, sizeof (pixman_fixed_t));
 686         if (!new_params)
 687             return FALSE;
 688
 689         memcpy (new_params,
 690                 params, n_params * sizeof (pixman_fixed_t));
 691     }
 692
 693     common->filter = filter;
 694
 695     if (common->filter_params)
 696         free (common->filter_params);
 697
 698     common->filter_params = new_params;
 699     common->n_filter_params = n_params;
 700
 701     image_property_changed (image);
 702     return TRUE;
 703 }
 704
 705 PIXMAN_EXPORT void
 706 pixman_image_set_source_clipping (pixman_image_t *image,
 707                                   pixman_bool_t   clip_sources)
 708 {
 709     if (image->common.clip_sources == clip_sources)
 710         return;
 711
 712     image->common.clip_sources = clip_sources;
 713
 714     image_property_changed (image);
 715 }
 716
 717 /* Unlike all the other property setters, this function does not
 718  * copy the content of indexed. Doing this copying is simply
 719  * way, way too expensive.
 720  */
 721 PIXMAN_EXPORT void
 722 pixman_image_set_indexed (pixman_image_t *        image,
 723                           const pixman_indexed_t *indexed)
 724 {
 725     bits_image_t *bits = (bits_image_t *)image;
 726
 727     if (bits->indexed == indexed)
 728         return;
 729
 730     bits->indexed = indexed;
 731
 732     image_property_changed (image);
 733 }
 734
 735 PIXMAN_EXPORT void
 736 pixman_image_set_alpha_map (pixman_image_t *image,
 737                             pixman_image_t *alpha_map,
 738                             int16_t         x,
 739                             int16_t         y)
 740 {
 741     image_common_t *common = (image_common_t *)image;
 742
 743     return_if_fail (!alpha_map || alpha_map->type == BITS);
 744
 745     if (alpha_map && common->alpha_count > 0)
 746     {
 747         /* If this image is being used as an alpha map itself,
 748          * then you can't give it an alpha map of its own.
 749          */
 750         return;
 751     }
 752
 753     if (alpha_map && alpha_map->common.alpha_map)
 754     {
 755         /* If the image has an alpha map of its own,
 756          * then it can't be used as an alpha map itself
 757          */
 758         return;
 759     }
 760
 761     if (common->alpha_map != (bits_image_t *)alpha_map)
 762     {
 763         if (common->alpha_map)
 764         {
 765             common->alpha_map->common.alpha_count--;
 766
 767             pixman_image_unref ((pixman_image_t *)common->alpha_map);
 768         }
 769
 770         if (alpha_map)
 771         {
 772             common->alpha_map = (bits_image_t *)pixman_image_ref (alpha_map);
 773
 774             common->alpha_map->common.alpha_count++;
 775         }
 776         else
 777         {
 778             common->alpha_map = NULL;
 779         }
 780     }
 781
 782     common->alpha_origin_x = x;
 783     common->alpha_origin_y = y;
 784
 785     image_property_changed (image);
 786 }
 787
 788 PIXMAN_EXPORT void
 789 pixman_image_set_component_alpha   (pixman_image_t *image,
 790                                     pixman_bool_t   component_alpha)
 791 {
 792     if (image->common.component_alpha == component_alpha)
 793         return;
 794
 795     image->common.component_alpha = component_alpha;
 796
 797     image_property_changed (image);
 798 }
 799
 800 PIXMAN_EXPORT pixman_bool_t
 801 pixman_image_get_component_alpha   (pixman_image_t       *image)
 802 {
 803     return image->common.component_alpha;
 804 }
 805
 806 PIXMAN_EXPORT void
 807 pixman_image_set_accessors (pixman_image_t *           image,
 808                             pixman_read_memory_func_t  read_func,
 809                             pixman_write_memory_func_t write_func)
 810 {
 811     return_if_fail (image != NULL);
 812
 813     if (image->type == BITS)
 814     {
 815         image->bits.read_func = read_func;
 816         image->bits.write_func = write_func;
 817
 818         image_property_changed (image);
 819     }
 820 }
 821
 822 PIXMAN_EXPORT uint32_t *
 823 pixman_image_get_data (pixman_image_t *image)
 824 {
 825     if (image->type == BITS)
 826         return image->bits.bits;
 827
 828     return NULL;
 829 }
 830
 831 PIXMAN_EXPORT int
 832 pixman_image_get_width (pixman_image_t *image)
 833 {
 834     if (image->type == BITS)
 835         return image->bits.width;
 836
 837     return 0;
 838 }
 839
 840 PIXMAN_EXPORT int
 841 pixman_image_get_height (pixman_image_t *image)
 842 {
 843     if (image->type == BITS)
 844         return image->bits.height;
 845
 846     return 0;
 847 }
 848
 849 PIXMAN_EXPORT int
 850 pixman_image_get_stride (pixman_image_t *image)
 851 {
 852     if (image->type == BITS)
 853         return image->bits.rowstride * (int) sizeof (uint32_t);
 854
 855     return 0;
 856 }
 857
 858 PIXMAN_EXPORT int
 859 pixman_image_get_depth (pixman_image_t *image)
 860 {
 861     if (image->type == BITS)
 862         return PIXMAN_FORMAT_DEPTH (image->bits.format);
 863
 864     return 0;
 865 }
 866
 867 PIXMAN_EXPORT pixman_format_code_t
 868 pixman_image_get_format (pixman_image_t *image)
 869 {
 870     if (image->type == BITS)
 871         return image->bits.format;
 872
 873     return 0;
 874 }
 875
 876 uint32_t
 877 _pixman_image_get_solid (pixman_implementation_t *imp,
 878                          pixman_image_t *         image,
 879                          pixman_format_code_t     format)
 880 {
 881     uint32_t result;
 882     pixman_iter_t iter;
 883
 884     _pixman_implementation_src_iter_init (
 885         imp, &iter, image, 0, 0, 1, 1,
 886         (uint8_t *)&result, ITER_NARROW, image->common.flags);
 887
 888     result = *iter.get_scanline (&iter, NULL);
 889
 890     /* If necessary, convert RGB <--> BGR. */
 891     if (PIXMAN_FORMAT_TYPE (format) != PIXMAN_TYPE_ARGB)
 892     {
 893         result = (((result & 0xff000000) >>  0) |
 894                   ((result & 0x00ff0000) >> 16) |
 895                   ((result & 0x0000ff00) >>  0) |
 896                   ((result & 0x000000ff) << 16));
 897     }
 898
 899     return result;
 900 }