pixman/pixman-vmx.c

   1 /*
   2  * Copyright © 2007 Luca Barbato
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of Luca Barbato not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  Luca Barbato makes no representations about the
  11  * suitability of this software for any purpose.  It is provided "as is"
  12  * without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  19  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  20  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21  * SOFTWARE.
  22  *
  23  * Author:  Luca Barbato (lu_zero@gentoo.org)
  24  *
  25  * Based on fbmmx.c by Owen Taylor, Søren Sandmann and Nicholas Miell
  26  */
  27
  28 #include <config.h>
  29 #include "pixman-private.h"
  30 #include "pixman-combine32.h"
  31 #include <altivec.h>
  32
  33 #define AVV(x...) {x}
  34
  35 static force_inline vector unsigned int
  36 splat_alpha (vector unsigned int pix)
  37 {
  38     return vec_perm (pix, pix,
  39                      (vector unsigned char)AVV (
  40                          0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04,
  41                          0x08, 0x08, 0x08, 0x08, 0x0C, 0x0C, 0x0C, 0x0C));
  42 }
  43
  44 static force_inline vector unsigned int
  45 pix_multiply (vector unsigned int p, vector unsigned int a)
  46 {
  47     vector unsigned short hi, lo, mod;
  48
  49     /* unpack to short */
  50     hi = (vector unsigned short)
  51         vec_mergeh ((vector unsigned char)AVV (0),
  52                     (vector unsigned char)p);
  53
  54     mod = (vector unsigned short)
  55         vec_mergeh ((vector unsigned char)AVV (0),
  56                     (vector unsigned char)a);
  57
  58     hi = vec_mladd (hi, mod, (vector unsigned short)
  59                     AVV (0x0080, 0x0080, 0x0080, 0x0080,
  60                          0x0080, 0x0080, 0x0080, 0x0080));
  61
  62     hi = vec_adds (hi, vec_sr (hi, vec_splat_u16 (8)));
  63
  64     hi = vec_sr (hi, vec_splat_u16 (8));
  65
  66     /* unpack to short */
  67     lo = (vector unsigned short)
  68         vec_mergel ((vector unsigned char)AVV (0),
  69                     (vector unsigned char)p);
  70     mod = (vector unsigned short)
  71         vec_mergel ((vector unsigned char)AVV (0),
  72                     (vector unsigned char)a);
  73
  74     lo = vec_mladd (lo, mod, (vector unsigned short)
  75                     AVV (0x0080, 0x0080, 0x0080, 0x0080,
  76                          0x0080, 0x0080, 0x0080, 0x0080));
  77
  78     lo = vec_adds (lo, vec_sr (lo, vec_splat_u16 (8)));
  79
  80     lo = vec_sr (lo, vec_splat_u16 (8));
  81
  82     return (vector unsigned int)vec_packsu (hi, lo);
  83 }
  84
  85 static force_inline vector unsigned int
  86 pix_add (vector unsigned int a, vector unsigned int b)
  87 {
  88     return (vector unsigned int)vec_adds ((vector unsigned char)a,
  89                                           (vector unsigned char)b);
  90 }
  91
  92 static force_inline vector unsigned int
  93 pix_add_mul (vector unsigned int x,
  94              vector unsigned int a,
  95              vector unsigned int y,
  96              vector unsigned int b)
  97 {
  98     vector unsigned int t1, t2;
  99
 100     t1 = pix_multiply (x, a);
 101     t2 = pix_multiply (y, b);
 102
 103     return pix_add (t1, t2);
 104 }
 105
 106 static force_inline vector unsigned int
 107 negate (vector unsigned int src)
 108 {
 109     return vec_nor (src, src);
 110 }
 111
 112 /* dest*~srca + src */
 113 static force_inline vector unsigned int
 114 over (vector unsigned int src,
 115       vector unsigned int srca,
 116       vector unsigned int dest)
 117 {
 118     vector unsigned char tmp = (vector unsigned char)
 119         pix_multiply (dest, negate (srca));
 120
 121     tmp = vec_adds ((vector unsigned char)src, tmp);
 122     return (vector unsigned int)tmp;
 123 }
 124
 125 /* in == pix_multiply */
 126 #define in_over(src, srca, mask, dest)                                  \
 127     over (pix_multiply (src, mask),                                     \
 128           pix_multiply (srca, mask), dest)
 129
 130
 131 #define COMPUTE_SHIFT_MASK(source)                                      \
 132     source ## _mask = vec_lvsl (0, source);
 133
 134 #define COMPUTE_SHIFT_MASKS(dest, source)                               \
 135     dest ## _mask = vec_lvsl (0, dest);                                 \
 136     source ## _mask = vec_lvsl (0, source);                             \
 137     store_mask = vec_lvsr (0, dest);
 138
 139 #define COMPUTE_SHIFT_MASKC(dest, source, mask)                         \
 140     mask ## _mask = vec_lvsl (0, mask);                                 \
 141     dest ## _mask = vec_lvsl (0, dest);                                 \
 142     source ## _mask = vec_lvsl (0, source);                             \
 143     store_mask = vec_lvsr (0, dest);
 144
 145 /* notice you have to declare temp vars...
 146  * Note: tmp3 and tmp4 must remain untouched!
 147  */
 148
 149 #define LOAD_VECTORS(dest, source)                        \
 150     tmp1 = (typeof(tmp1))vec_ld (0, source);              \
 151     tmp2 = (typeof(tmp2))vec_ld (15, source);             \
 152     tmp3 = (typeof(tmp3))vec_ld (0, dest);                \
 153     v ## source = (typeof(v ## source))                   \
 154         vec_perm (tmp1, tmp2, source ## _mask);           \
 155     tmp4 = (typeof(tmp4))vec_ld (15, dest);               \
 156     v ## dest = (typeof(v ## dest))                       \
 157         vec_perm (tmp3, tmp4, dest ## _mask);
 158
 159 #define LOAD_VECTORSC(dest, source, mask)                 \
 160     tmp1 = (typeof(tmp1))vec_ld (0, source);              \
 161     tmp2 = (typeof(tmp2))vec_ld (15, source);             \
 162     tmp3 = (typeof(tmp3))vec_ld (0, dest);                \
 163     v ## source = (typeof(v ## source))                   \
 164         vec_perm (tmp1, tmp2, source ## _mask);           \
 165     tmp4 = (typeof(tmp4))vec_ld (15, dest);               \
 166     tmp1 = (typeof(tmp1))vec_ld (0, mask);                \
 167     v ## dest = (typeof(v ## dest))                       \
 168         vec_perm (tmp3, tmp4, dest ## _mask);             \
 169     tmp2 = (typeof(tmp2))vec_ld (15, mask);               \
 170     v ## mask = (typeof(v ## mask))                       \
 171         vec_perm (tmp1, tmp2, mask ## _mask);
 172
 173 #define LOAD_VECTORSM(dest, source, mask)                               \
 174     LOAD_VECTORSC (dest, source, mask)                                  \
 175     v ## source = pix_multiply (v ## source,                            \
 176                                 splat_alpha (v ## mask));
 177
 178 #define STORE_VECTOR(dest)                                              \
 179     edges = vec_perm (tmp4, tmp3, dest ## _mask);                       \
 180     tmp3 = vec_perm ((vector unsigned char)v ## dest, edges, store_mask); \
 181     tmp1 = vec_perm (edges, (vector unsigned char)v ## dest, store_mask); \
 182     vec_st ((vector unsigned int) tmp3, 15, dest);                      \
 183     vec_st ((vector unsigned int) tmp1, 0, dest);
 184
 185 static void
 186 vmx_combine_over_u_no_mask (uint32_t *      dest,
 187                             const uint32_t *src,
 188                             int             width)
 189 {
 190     int i;
 191     vector unsigned int vdest, vsrc;
 192     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 193         dest_mask, src_mask, store_mask;
 194
 195     COMPUTE_SHIFT_MASKS (dest, src);
 196
 197     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 198     for (i = width / 4; i > 0; i--)
 199     {
 200
 201         LOAD_VECTORS (dest, src);
 202
 203         vdest = over (vsrc, splat_alpha (vsrc), vdest);
 204
 205         STORE_VECTOR (dest);
 206
 207         src += 4;
 208         dest += 4;
 209     }
 210
 211     for (i = width % 4; --i >= 0;)
 212     {
 213         uint32_t s = src[i];
 214         uint32_t d = dest[i];
 215         uint32_t ia = ALPHA_8 (~s);
 216
 217         UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);
 218
 219         dest[i] = d;
 220     }
 221 }
 222
 223 static void
 224 vmx_combine_over_u_mask (uint32_t *      dest,
 225                          const uint32_t *src,
 226                          const uint32_t *mask,
 227                          int             width)
 228 {
 229     int i;
 230     vector unsigned int vdest, vsrc, vmask;
 231     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 232         dest_mask, src_mask, mask_mask, store_mask;
 233
 234     COMPUTE_SHIFT_MASKC (dest, src, mask);
 235
 236     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 237     for (i = width / 4; i > 0; i--)
 238     {
 239         LOAD_VECTORSM (dest, src, mask);
 240
 241         vdest = over (vsrc, splat_alpha (vsrc), vdest);
 242
 243         STORE_VECTOR (dest);
 244
 245         src += 4;
 246         dest += 4;
 247         mask += 4;
 248     }
 249
 250     for (i = width % 4; --i >= 0;)
 251     {
 252         uint32_t m = ALPHA_8 (mask[i]);
 253         uint32_t s = src[i];
 254         uint32_t d = dest[i];
 255         uint32_t ia;
 256
 257         UN8x4_MUL_UN8 (s, m);
 258
 259         ia = ALPHA_8 (~s);
 260
 261         UN8x4_MUL_UN8_ADD_UN8x4 (d, ia, s);
 262         dest[i] = d;
 263     }
 264 }
 265
 266 static void
 267 vmx_combine_over_u (pixman_implementation_t *imp,
 268                     pixman_op_t              op,
 269                     uint32_t *               dest,
 270                     const uint32_t *         src,
 271                     const uint32_t *         mask,
 272                     int                      width)
 273 {
 274     if (mask)
 275         vmx_combine_over_u_mask (dest, src, mask, width);
 276     else
 277         vmx_combine_over_u_no_mask (dest, src, width);
 278 }
 279
 280 static void
 281 vmx_combine_over_reverse_u_no_mask (uint32_t *      dest,
 282                                     const uint32_t *src,
 283                                     int             width)
 284 {
 285     int i;
 286     vector unsigned int vdest, vsrc;
 287     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 288         dest_mask, src_mask, store_mask;
 289
 290     COMPUTE_SHIFT_MASKS (dest, src);
 291
 292     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 293     for (i = width / 4; i > 0; i--)
 294     {
 295
 296         LOAD_VECTORS (dest, src);
 297
 298         vdest = over (vdest, splat_alpha (vdest), vsrc);
 299
 300         STORE_VECTOR (dest);
 301
 302         src += 4;
 303         dest += 4;
 304     }
 305
 306     for (i = width % 4; --i >= 0;)
 307     {
 308         uint32_t s = src[i];
 309         uint32_t d = dest[i];
 310         uint32_t ia = ALPHA_8 (~dest[i]);
 311
 312         UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);
 313         dest[i] = s;
 314     }
 315 }
 316
 317 static void
 318 vmx_combine_over_reverse_u_mask (uint32_t *      dest,
 319                                  const uint32_t *src,
 320                                  const uint32_t *mask,
 321                                  int             width)
 322 {
 323     int i;
 324     vector unsigned int vdest, vsrc, vmask;
 325     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 326         dest_mask, src_mask, mask_mask, store_mask;
 327
 328     COMPUTE_SHIFT_MASKC (dest, src, mask);
 329
 330     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 331     for (i = width / 4; i > 0; i--)
 332     {
 333
 334         LOAD_VECTORSM (dest, src, mask);
 335
 336         vdest = over (vdest, splat_alpha (vdest), vsrc);
 337
 338         STORE_VECTOR (dest);
 339
 340         src += 4;
 341         dest += 4;
 342         mask += 4;
 343     }
 344
 345     for (i = width % 4; --i >= 0;)
 346     {
 347         uint32_t m = ALPHA_8 (mask[i]);
 348         uint32_t s = src[i];
 349         uint32_t d = dest[i];
 350         uint32_t ia = ALPHA_8 (~dest[i]);
 351
 352         UN8x4_MUL_UN8 (s, m);
 353
 354         UN8x4_MUL_UN8_ADD_UN8x4 (s, ia, d);
 355         dest[i] = s;
 356     }
 357 }
 358
 359 static void
 360 vmx_combine_over_reverse_u (pixman_implementation_t *imp,
 361                             pixman_op_t              op,
 362                             uint32_t *               dest,
 363                             const uint32_t *         src,
 364                             const uint32_t *         mask,
 365                             int                      width)
 366 {
 367     if (mask)
 368         vmx_combine_over_reverse_u_mask (dest, src, mask, width);
 369     else
 370         vmx_combine_over_reverse_u_no_mask (dest, src, width);
 371 }
 372
 373 static void
 374 vmx_combine_in_u_no_mask (uint32_t *      dest,
 375                           const uint32_t *src,
 376                           int             width)
 377 {
 378     int i;
 379     vector unsigned int vdest, vsrc;
 380     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 381         dest_mask, src_mask, store_mask;
 382
 383     COMPUTE_SHIFT_MASKS (dest, src);
 384
 385     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 386     for (i = width / 4; i > 0; i--)
 387     {
 388         LOAD_VECTORS (dest, src);
 389
 390         vdest = pix_multiply (vsrc, splat_alpha (vdest));
 391
 392         STORE_VECTOR (dest);
 393
 394         src += 4;
 395         dest += 4;
 396     }
 397
 398     for (i = width % 4; --i >= 0;)
 399     {
 400         uint32_t s = src[i];
 401         uint32_t a = ALPHA_8 (dest[i]);
 402
 403         UN8x4_MUL_UN8 (s, a);
 404         dest[i] = s;
 405     }
 406 }
 407
 408 static void
 409 vmx_combine_in_u_mask (uint32_t *      dest,
 410                        const uint32_t *src,
 411                        const uint32_t *mask,
 412                        int             width)
 413 {
 414     int i;
 415     vector unsigned int vdest, vsrc, vmask;
 416     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 417         dest_mask, src_mask, mask_mask, store_mask;
 418
 419     COMPUTE_SHIFT_MASKC (dest, src, mask);
 420
 421     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 422     for (i = width / 4; i > 0; i--)
 423     {
 424         LOAD_VECTORSM (dest, src, mask);
 425
 426         vdest = pix_multiply (vsrc, splat_alpha (vdest));
 427
 428         STORE_VECTOR (dest);
 429
 430         src += 4;
 431         dest += 4;
 432         mask += 4;
 433     }
 434
 435     for (i = width % 4; --i >= 0;)
 436     {
 437         uint32_t m = ALPHA_8 (mask[i]);
 438         uint32_t s = src[i];
 439         uint32_t a = ALPHA_8 (dest[i]);
 440
 441         UN8x4_MUL_UN8 (s, m);
 442         UN8x4_MUL_UN8 (s, a);
 443
 444         dest[i] = s;
 445     }
 446 }
 447
 448 static void
 449 vmx_combine_in_u (pixman_implementation_t *imp,
 450                   pixman_op_t              op,
 451                   uint32_t *               dest,
 452                   const uint32_t *         src,
 453                   const uint32_t *         mask,
 454                   int                      width)
 455 {
 456     if (mask)
 457         vmx_combine_in_u_mask (dest, src, mask, width);
 458     else
 459         vmx_combine_in_u_no_mask (dest, src, width);
 460 }
 461
 462 static void
 463 vmx_combine_in_reverse_u_no_mask (uint32_t *      dest,
 464                                   const uint32_t *src,
 465                                   int             width)
 466 {
 467     int i;
 468     vector unsigned int vdest, vsrc;
 469     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 470         dest_mask, src_mask, store_mask;
 471
 472     COMPUTE_SHIFT_MASKS (dest, src);
 473
 474     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 475     for (i = width / 4; i > 0; i--)
 476     {
 477         LOAD_VECTORS (dest, src);
 478
 479         vdest = pix_multiply (vdest, splat_alpha (vsrc));
 480
 481         STORE_VECTOR (dest);
 482
 483         src += 4;
 484         dest += 4;
 485     }
 486
 487     for (i = width % 4; --i >= 0;)
 488     {
 489         uint32_t d = dest[i];
 490         uint32_t a = ALPHA_8 (src[i]);
 491
 492         UN8x4_MUL_UN8 (d, a);
 493
 494         dest[i] = d;
 495     }
 496 }
 497
 498 static void
 499 vmx_combine_in_reverse_u_mask (uint32_t *      dest,
 500                                const uint32_t *src,
 501                                const uint32_t *mask,
 502                                int             width)
 503 {
 504     int i;
 505     vector unsigned int vdest, vsrc, vmask;
 506     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 507         dest_mask, src_mask, mask_mask, store_mask;
 508
 509     COMPUTE_SHIFT_MASKC (dest, src, mask);
 510
 511     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 512     for (i = width / 4; i > 0; i--)
 513     {
 514         LOAD_VECTORSM (dest, src, mask);
 515
 516         vdest = pix_multiply (vdest, splat_alpha (vsrc));
 517
 518         STORE_VECTOR (dest);
 519
 520         src += 4;
 521         dest += 4;
 522         mask += 4;
 523     }
 524
 525     for (i = width % 4; --i >= 0;)
 526     {
 527         uint32_t m = ALPHA_8 (mask[i]);
 528         uint32_t d = dest[i];
 529         uint32_t a = src[i];
 530
 531         UN8x4_MUL_UN8 (a, m);
 532         a = ALPHA_8 (a);
 533         UN8x4_MUL_UN8 (d, a);
 534
 535         dest[i] = d;
 536     }
 537 }
 538
 539 static void
 540 vmx_combine_in_reverse_u (pixman_implementation_t *imp,
 541                           pixman_op_t              op,
 542                           uint32_t *               dest,
 543                           const uint32_t *         src,
 544                           const uint32_t *         mask,
 545                           int                      width)
 546 {
 547     if (mask)
 548         vmx_combine_in_reverse_u_mask (dest, src, mask, width);
 549     else
 550         vmx_combine_in_reverse_u_no_mask (dest, src, width);
 551 }
 552
 553 static void
 554 vmx_combine_out_u_no_mask (uint32_t *      dest,
 555                            const uint32_t *src,
 556                            int             width)
 557 {
 558     int i;
 559     vector unsigned int vdest, vsrc;
 560     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 561         dest_mask, src_mask, store_mask;
 562
 563     COMPUTE_SHIFT_MASKS (dest, src);
 564
 565     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 566     for (i = width / 4; i > 0; i--)
 567     {
 568         LOAD_VECTORS (dest, src);
 569
 570         vdest = pix_multiply (vsrc, splat_alpha (negate (vdest)));
 571
 572         STORE_VECTOR (dest);
 573
 574         src += 4;
 575         dest += 4;
 576     }
 577
 578     for (i = width % 4; --i >= 0;)
 579     {
 580         uint32_t s = src[i];
 581         uint32_t a = ALPHA_8 (~dest[i]);
 582
 583         UN8x4_MUL_UN8 (s, a);
 584
 585         dest[i] = s;
 586     }
 587 }
 588
 589 static void
 590 vmx_combine_out_u_mask (uint32_t *      dest,
 591                         const uint32_t *src,
 592                         const uint32_t *mask,
 593                         int             width)
 594 {
 595     int i;
 596     vector unsigned int vdest, vsrc, vmask;
 597     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 598         dest_mask, src_mask, mask_mask, store_mask;
 599
 600     COMPUTE_SHIFT_MASKC (dest, src, mask);
 601
 602     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 603     for (i = width / 4; i > 0; i--)
 604     {
 605         LOAD_VECTORSM (dest, src, mask);
 606
 607         vdest = pix_multiply (vsrc, splat_alpha (negate (vdest)));
 608
 609         STORE_VECTOR (dest);
 610
 611         src += 4;
 612         dest += 4;
 613         mask += 4;
 614     }
 615
 616     for (i = width % 4; --i >= 0;)
 617     {
 618         uint32_t m = ALPHA_8 (mask[i]);
 619         uint32_t s = src[i];
 620         uint32_t a = ALPHA_8 (~dest[i]);
 621
 622         UN8x4_MUL_UN8 (s, m);
 623         UN8x4_MUL_UN8 (s, a);
 624
 625         dest[i] = s;
 626     }
 627 }
 628
 629 static void
 630 vmx_combine_out_u (pixman_implementation_t *imp,
 631                    pixman_op_t              op,
 632                    uint32_t *               dest,
 633                    const uint32_t *         src,
 634                    const uint32_t *         mask,
 635                    int                      width)
 636 {
 637     if (mask)
 638         vmx_combine_out_u_mask (dest, src, mask, width);
 639     else
 640         vmx_combine_out_u_no_mask (dest, src, width);
 641 }
 642
 643 static void
 644 vmx_combine_out_reverse_u_no_mask (uint32_t *      dest,
 645                                    const uint32_t *src,
 646                                    int             width)
 647 {
 648     int i;
 649     vector unsigned int vdest, vsrc;
 650     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 651         dest_mask, src_mask, store_mask;
 652
 653     COMPUTE_SHIFT_MASKS (dest, src);
 654
 655     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 656     for (i = width / 4; i > 0; i--)
 657     {
 658
 659         LOAD_VECTORS (dest, src);
 660
 661         vdest = pix_multiply (vdest, splat_alpha (negate (vsrc)));
 662
 663         STORE_VECTOR (dest);
 664
 665         src += 4;
 666         dest += 4;
 667     }
 668
 669     for (i = width % 4; --i >= 0;)
 670     {
 671         uint32_t d = dest[i];
 672         uint32_t a = ALPHA_8 (~src[i]);
 673
 674         UN8x4_MUL_UN8 (d, a);
 675
 676         dest[i] = d;
 677     }
 678 }
 679
 680 static void
 681 vmx_combine_out_reverse_u_mask (uint32_t *      dest,
 682                                 const uint32_t *src,
 683                                 const uint32_t *mask,
 684                                 int             width)
 685 {
 686     int i;
 687     vector unsigned int vdest, vsrc, vmask;
 688     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 689         dest_mask, src_mask, mask_mask, store_mask;
 690
 691     COMPUTE_SHIFT_MASKC (dest, src, mask);
 692
 693     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 694     for (i = width / 4; i > 0; i--)
 695     {
 696         LOAD_VECTORSM (dest, src, mask);
 697
 698         vdest = pix_multiply (vdest, splat_alpha (negate (vsrc)));
 699
 700         STORE_VECTOR (dest);
 701
 702         src += 4;
 703         dest += 4;
 704         mask += 4;
 705     }
 706
 707     for (i = width % 4; --i >= 0;)
 708     {
 709         uint32_t m = ALPHA_8 (mask[i]);
 710         uint32_t d = dest[i];
 711         uint32_t a = src[i];
 712
 713         UN8x4_MUL_UN8 (a, m);
 714         a = ALPHA_8 (~a);
 715         UN8x4_MUL_UN8 (d, a);
 716
 717         dest[i] = d;
 718     }
 719 }
 720
 721 static void
 722 vmx_combine_out_reverse_u (pixman_implementation_t *imp,
 723                            pixman_op_t              op,
 724                            uint32_t *               dest,
 725                            const uint32_t *         src,
 726                            const uint32_t *         mask,
 727                            int                      width)
 728 {
 729     if (mask)
 730         vmx_combine_out_reverse_u_mask (dest, src, mask, width);
 731     else
 732         vmx_combine_out_reverse_u_no_mask (dest, src, width);
 733 }
 734
 735 static void
 736 vmx_combine_atop_u_no_mask (uint32_t *      dest,
 737                             const uint32_t *src,
 738                             int             width)
 739 {
 740     int i;
 741     vector unsigned int vdest, vsrc;
 742     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 743         dest_mask, src_mask, store_mask;
 744
 745     COMPUTE_SHIFT_MASKS (dest, src);
 746
 747     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 748     for (i = width / 4; i > 0; i--)
 749     {
 750         LOAD_VECTORS (dest, src);
 751
 752         vdest = pix_add_mul (vsrc, splat_alpha (vdest),
 753                              vdest, splat_alpha (negate (vsrc)));
 754
 755         STORE_VECTOR (dest);
 756
 757         src += 4;
 758         dest += 4;
 759     }
 760
 761     for (i = width % 4; --i >= 0;)
 762     {
 763         uint32_t s = src[i];
 764         uint32_t d = dest[i];
 765         uint32_t dest_a = ALPHA_8 (d);
 766         uint32_t src_ia = ALPHA_8 (~s);
 767
 768         UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_a, d, src_ia);
 769
 770         dest[i] = s;
 771     }
 772 }
 773
 774 static void
 775 vmx_combine_atop_u_mask (uint32_t *      dest,
 776                          const uint32_t *src,
 777                          const uint32_t *mask,
 778                          int             width)
 779 {
 780     int i;
 781     vector unsigned int vdest, vsrc, vmask;
 782     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 783         dest_mask, src_mask, mask_mask, store_mask;
 784
 785     COMPUTE_SHIFT_MASKC (dest, src, mask);
 786
 787     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 788     for (i = width / 4; i > 0; i--)
 789     {
 790         LOAD_VECTORSM (dest, src, mask);
 791
 792         vdest = pix_add_mul (vsrc, splat_alpha (vdest),
 793                              vdest, splat_alpha (negate (vsrc)));
 794
 795         STORE_VECTOR (dest);
 796
 797         src += 4;
 798         dest += 4;
 799         mask += 4;
 800     }
 801
 802     for (i = width % 4; --i >= 0;)
 803     {
 804         uint32_t m = ALPHA_8 (mask[i]);
 805         uint32_t s = src[i];
 806         uint32_t d = dest[i];
 807         uint32_t dest_a = ALPHA_8 (d);
 808         uint32_t src_ia;
 809
 810         UN8x4_MUL_UN8 (s, m);
 811
 812         src_ia = ALPHA_8 (~s);
 813
 814         UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_a, d, src_ia);
 815
 816         dest[i] = s;
 817     }
 818 }
 819
 820 static void
 821 vmx_combine_atop_u (pixman_implementation_t *imp,
 822                     pixman_op_t              op,
 823                     uint32_t *               dest,
 824                     const uint32_t *         src,
 825                     const uint32_t *         mask,
 826                     int                      width)
 827 {
 828     if (mask)
 829         vmx_combine_atop_u_mask (dest, src, mask, width);
 830     else
 831         vmx_combine_atop_u_no_mask (dest, src, width);
 832 }
 833
 834 static void
 835 vmx_combine_atop_reverse_u_no_mask (uint32_t *      dest,
 836                                     const uint32_t *src,
 837                                     int             width)
 838 {
 839     int i;
 840     vector unsigned int vdest, vsrc;
 841     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 842         dest_mask, src_mask, store_mask;
 843
 844     COMPUTE_SHIFT_MASKS (dest, src);
 845
 846     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 847     for (i = width / 4; i > 0; i--)
 848     {
 849         LOAD_VECTORS (dest, src);
 850
 851         vdest = pix_add_mul (vdest, splat_alpha (vsrc),
 852                              vsrc, splat_alpha (negate (vdest)));
 853
 854         STORE_VECTOR (dest);
 855
 856         src += 4;
 857         dest += 4;
 858     }
 859
 860     for (i = width % 4; --i >= 0;)
 861     {
 862         uint32_t s = src[i];
 863         uint32_t d = dest[i];
 864         uint32_t src_a = ALPHA_8 (s);
 865         uint32_t dest_ia = ALPHA_8 (~d);
 866
 867         UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_ia, d, src_a);
 868
 869         dest[i] = s;
 870     }
 871 }
 872
 873 static void
 874 vmx_combine_atop_reverse_u_mask (uint32_t *      dest,
 875                                  const uint32_t *src,
 876                                  const uint32_t *mask,
 877                                  int             width)
 878 {
 879     int i;
 880     vector unsigned int vdest, vsrc, vmask;
 881     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 882         dest_mask, src_mask, mask_mask, store_mask;
 883
 884     COMPUTE_SHIFT_MASKC (dest, src, mask);
 885
 886     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 887     for (i = width / 4; i > 0; i--)
 888     {
 889         LOAD_VECTORSM (dest, src, mask);
 890
 891         vdest = pix_add_mul (vdest, splat_alpha (vsrc),
 892                              vsrc, splat_alpha (negate (vdest)));
 893
 894         STORE_VECTOR (dest);
 895
 896         src += 4;
 897         dest += 4;
 898         mask += 4;
 899     }
 900
 901     for (i = width % 4; --i >= 0;)
 902     {
 903         uint32_t m = ALPHA_8 (mask[i]);
 904         uint32_t s = src[i];
 905         uint32_t d = dest[i];
 906         uint32_t src_a;
 907         uint32_t dest_ia = ALPHA_8 (~d);
 908
 909         UN8x4_MUL_UN8 (s, m);
 910
 911         src_a = ALPHA_8 (s);
 912
 913         UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_ia, d, src_a);
 914
 915         dest[i] = s;
 916     }
 917 }
 918
 919 static void
 920 vmx_combine_atop_reverse_u (pixman_implementation_t *imp,
 921                             pixman_op_t              op,
 922                             uint32_t *               dest,
 923                             const uint32_t *         src,
 924                             const uint32_t *         mask,
 925                             int                      width)
 926 {
 927     if (mask)
 928         vmx_combine_atop_reverse_u_mask (dest, src, mask, width);
 929     else
 930         vmx_combine_atop_reverse_u_no_mask (dest, src, width);
 931 }
 932
 933 static void
 934 vmx_combine_xor_u_no_mask (uint32_t *      dest,
 935                            const uint32_t *src,
 936                            int             width)
 937 {
 938     int i;
 939     vector unsigned int vdest, vsrc;
 940     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 941         dest_mask, src_mask, store_mask;
 942
 943     COMPUTE_SHIFT_MASKS (dest, src);
 944
 945     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 946     for (i = width / 4; i > 0; i--)
 947     {
 948         LOAD_VECTORS (dest, src);
 949
 950         vdest = pix_add_mul (vsrc, splat_alpha (negate (vdest)),
 951                              vdest, splat_alpha (negate (vsrc)));
 952
 953         STORE_VECTOR (dest);
 954
 955         src += 4;
 956         dest += 4;
 957     }
 958
 959     for (i = width % 4; --i >= 0;)
 960     {
 961         uint32_t s = src[i];
 962         uint32_t d = dest[i];
 963         uint32_t src_ia = ALPHA_8 (~s);
 964         uint32_t dest_ia = ALPHA_8 (~d);
 965
 966         UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_ia, d, src_ia);
 967
 968         dest[i] = s;
 969     }
 970 }
 971
 972 static void
 973 vmx_combine_xor_u_mask (uint32_t *      dest,
 974                         const uint32_t *src,
 975                         const uint32_t *mask,
 976                         int             width)
 977 {
 978     int i;
 979     vector unsigned int vdest, vsrc, vmask;
 980     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
 981         dest_mask, src_mask, mask_mask, store_mask;
 982
 983     COMPUTE_SHIFT_MASKC (dest, src, mask);
 984
 985     /* printf ("%s\n",__PRETTY_FUNCTION__); */
 986     for (i = width / 4; i > 0; i--)
 987     {
 988         LOAD_VECTORSM (dest, src, mask);
 989
 990         vdest = pix_add_mul (vsrc, splat_alpha (negate (vdest)),
 991                              vdest, splat_alpha (negate (vsrc)));
 992
 993         STORE_VECTOR (dest);
 994
 995         src += 4;
 996         dest += 4;
 997         mask += 4;
 998     }
 999
1000     for (i = width % 4; --i >= 0;)
1001     {
1002         uint32_t m = ALPHA_8 (mask[i]);
1003         uint32_t s = src[i];
1004         uint32_t d = dest[i];
1005         uint32_t src_ia;
1006         uint32_t dest_ia = ALPHA_8 (~d);
1007
1008         UN8x4_MUL_UN8 (s, m);
1009
1010         src_ia = ALPHA_8 (~s);
1011
1012         UN8x4_MUL_UN8_ADD_UN8x4_MUL_UN8 (s, dest_ia, d, src_ia);
1013
1014         dest[i] = s;
1015     }
1016 }
1017
1018 static void
1019 vmx_combine_xor_u (pixman_implementation_t *imp,
1020                    pixman_op_t              op,
1021                    uint32_t *               dest,
1022                    const uint32_t *         src,
1023                    const uint32_t *         mask,
1024                    int                      width)
1025 {
1026     if (mask)
1027         vmx_combine_xor_u_mask (dest, src, mask, width);
1028     else
1029         vmx_combine_xor_u_no_mask (dest, src, width);
1030 }
1031
1032 static void
1033 vmx_combine_add_u_no_mask (uint32_t *      dest,
1034                            const uint32_t *src,
1035                            int             width)
1036 {
1037     int i;
1038     vector unsigned int vdest, vsrc;
1039     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1040         dest_mask, src_mask, store_mask;
1041
1042     COMPUTE_SHIFT_MASKS (dest, src);
1043     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1044     for (i = width / 4; i > 0; i--)
1045     {
1046         LOAD_VECTORS (dest, src);
1047
1048         vdest = pix_add (vsrc, vdest);
1049
1050         STORE_VECTOR (dest);
1051
1052         src += 4;
1053         dest += 4;
1054     }
1055
1056     for (i = width % 4; --i >= 0;)
1057     {
1058         uint32_t s = src[i];
1059         uint32_t d = dest[i];
1060
1061         UN8x4_ADD_UN8x4 (d, s);
1062
1063         dest[i] = d;
1064     }
1065 }
1066
1067 static void
1068 vmx_combine_add_u_mask (uint32_t *      dest,
1069                         const uint32_t *src,
1070                         const uint32_t *mask,
1071                         int             width)
1072 {
1073     int i;
1074     vector unsigned int vdest, vsrc, vmask;
1075     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1076         dest_mask, src_mask, mask_mask, store_mask;
1077
1078     COMPUTE_SHIFT_MASKC (dest, src, mask);
1079
1080     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1081     for (i = width / 4; i > 0; i--)
1082     {
1083         LOAD_VECTORSM (dest, src, mask);
1084
1085         vdest = pix_add (vsrc, vdest);
1086
1087         STORE_VECTOR (dest);
1088
1089         src += 4;
1090         dest += 4;
1091         mask += 4;
1092     }
1093
1094     for (i = width % 4; --i >= 0;)
1095     {
1096         uint32_t m = ALPHA_8 (mask[i]);
1097         uint32_t s = src[i];
1098         uint32_t d = dest[i];
1099
1100         UN8x4_MUL_UN8 (s, m);
1101         UN8x4_ADD_UN8x4 (d, s);
1102
1103         dest[i] = d;
1104     }
1105 }
1106
1107 static void
1108 vmx_combine_add_u (pixman_implementation_t *imp,
1109                    pixman_op_t              op,
1110                    uint32_t *               dest,
1111                    const uint32_t *         src,
1112                    const uint32_t *         mask,
1113                    int                      width)
1114 {
1115     if (mask)
1116         vmx_combine_add_u_mask (dest, src, mask, width);
1117     else
1118         vmx_combine_add_u_no_mask (dest, src, width);
1119 }
1120
1121 static void
1122 vmx_combine_src_ca (pixman_implementation_t *imp,
1123                     pixman_op_t              op,
1124                     uint32_t *               dest,
1125                     const uint32_t *         src,
1126                     const uint32_t *         mask,
1127                     int                      width)
1128 {
1129     int i;
1130     vector unsigned int vdest, vsrc, vmask;
1131     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1132         dest_mask, mask_mask, src_mask, store_mask;
1133
1134     COMPUTE_SHIFT_MASKC (dest, src, mask);
1135
1136     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1137     for (i = width / 4; i > 0; i--)
1138     {
1139         LOAD_VECTORSC (dest, src, mask);
1140
1141         vdest = pix_multiply (vsrc, vmask);
1142
1143         STORE_VECTOR (dest);
1144
1145         mask += 4;
1146         src += 4;
1147         dest += 4;
1148     }
1149
1150     for (i = width % 4; --i >= 0;)
1151     {
1152         uint32_t a = mask[i];
1153         uint32_t s = src[i];
1154
1155         UN8x4_MUL_UN8x4 (s, a);
1156
1157         dest[i] = s;
1158     }
1159 }
1160
1161 static void
1162 vmx_combine_over_ca (pixman_implementation_t *imp,
1163                      pixman_op_t              op,
1164                      uint32_t *               dest,
1165                      const uint32_t *         src,
1166                      const uint32_t *         mask,
1167                      int                      width)
1168 {
1169     int i;
1170     vector unsigned int vdest, vsrc, vmask;
1171     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1172         dest_mask, mask_mask, src_mask, store_mask;
1173
1174     COMPUTE_SHIFT_MASKC (dest, src, mask);
1175
1176     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1177     for (i = width / 4; i > 0; i--)
1178     {
1179         LOAD_VECTORSC (dest, src, mask);
1180
1181         vdest = in_over (vsrc, splat_alpha (vsrc), vmask, vdest);
1182
1183         STORE_VECTOR (dest);
1184
1185         mask += 4;
1186         src += 4;
1187         dest += 4;
1188     }
1189
1190     for (i = width % 4; --i >= 0;)
1191     {
1192         uint32_t a = mask[i];
1193         uint32_t s = src[i];
1194         uint32_t d = dest[i];
1195         uint32_t sa = ALPHA_8 (s);
1196
1197         UN8x4_MUL_UN8x4 (s, a);
1198         UN8x4_MUL_UN8 (a, sa);
1199         UN8x4_MUL_UN8x4_ADD_UN8x4 (d, ~a, s);
1200
1201         dest[i] = d;
1202     }
1203 }
1204
1205 static void
1206 vmx_combine_over_reverse_ca (pixman_implementation_t *imp,
1207                              pixman_op_t              op,
1208                              uint32_t *               dest,
1209                              const uint32_t *         src,
1210                              const uint32_t *         mask,
1211                              int                      width)
1212 {
1213     int i;
1214     vector unsigned int vdest, vsrc, vmask;
1215     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1216         dest_mask, mask_mask, src_mask, store_mask;
1217
1218     COMPUTE_SHIFT_MASKC (dest, src, mask);
1219
1220     /* printf("%s\n",__PRETTY_FUNCTION__); */
1221     for (i = width / 4; i > 0; i--)
1222     {
1223         LOAD_VECTORSC (dest, src, mask);
1224
1225         vdest = over (vdest, splat_alpha (vdest), pix_multiply (vsrc, vmask));
1226
1227         STORE_VECTOR (dest);
1228
1229         mask += 4;
1230         src += 4;
1231         dest += 4;
1232     }
1233
1234     for (i = width % 4; --i >= 0;)
1235     {
1236         uint32_t a = mask[i];
1237         uint32_t s = src[i];
1238         uint32_t d = dest[i];
1239         uint32_t ida = ALPHA_8 (~d);
1240
1241         UN8x4_MUL_UN8x4 (s, a);
1242         UN8x4_MUL_UN8_ADD_UN8x4 (s, ida, d);
1243
1244         dest[i] = s;
1245     }
1246 }
1247
1248 static void
1249 vmx_combine_in_ca (pixman_implementation_t *imp,
1250                    pixman_op_t              op,
1251                    uint32_t *               dest,
1252                    const uint32_t *         src,
1253                    const uint32_t *         mask,
1254                    int                      width)
1255 {
1256     int i;
1257     vector unsigned int vdest, vsrc, vmask;
1258     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1259         dest_mask, mask_mask, src_mask, store_mask;
1260
1261     COMPUTE_SHIFT_MASKC (dest, src, mask);
1262
1263     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1264     for (i = width / 4; i > 0; i--)
1265     {
1266         LOAD_VECTORSC (dest, src, mask);
1267
1268         vdest = pix_multiply (pix_multiply (vsrc, vmask), splat_alpha (vdest));
1269
1270         STORE_VECTOR (dest);
1271
1272         src += 4;
1273         dest += 4;
1274         mask += 4;
1275     }
1276
1277     for (i = width % 4; --i >= 0;)
1278     {
1279         uint32_t a = mask[i];
1280         uint32_t s = src[i];
1281         uint32_t da = ALPHA_8 (dest[i]);
1282
1283         UN8x4_MUL_UN8x4 (s, a);
1284         UN8x4_MUL_UN8 (s, da);
1285
1286         dest[i] = s;
1287     }
1288 }
1289
1290 static void
1291 vmx_combine_in_reverse_ca (pixman_implementation_t *imp,
1292                            pixman_op_t              op,
1293                            uint32_t *               dest,
1294                            const uint32_t *         src,
1295                            const uint32_t *         mask,
1296                            int                      width)
1297 {
1298     int i;
1299     vector unsigned int vdest, vsrc, vmask;
1300     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1301         dest_mask, mask_mask, src_mask, store_mask;
1302
1303     COMPUTE_SHIFT_MASKC (dest, src, mask);
1304
1305     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1306     for (i = width / 4; i > 0; i--)
1307     {
1308
1309         LOAD_VECTORSC (dest, src, mask);
1310
1311         vdest = pix_multiply (vdest, pix_multiply (vmask, splat_alpha (vsrc)));
1312
1313         STORE_VECTOR (dest);
1314
1315         src += 4;
1316         dest += 4;
1317         mask += 4;
1318     }
1319
1320     for (i = width % 4; --i >= 0;)
1321     {
1322         uint32_t a = mask[i];
1323         uint32_t d = dest[i];
1324         uint32_t sa = ALPHA_8 (src[i]);
1325
1326         UN8x4_MUL_UN8 (a, sa);
1327         UN8x4_MUL_UN8x4 (d, a);
1328
1329         dest[i] = d;
1330     }
1331 }
1332
1333 static void
1334 vmx_combine_out_ca (pixman_implementation_t *imp,
1335                     pixman_op_t              op,
1336                     uint32_t *               dest,
1337                     const uint32_t *         src,
1338                     const uint32_t *         mask,
1339                     int                      width)
1340 {
1341     int i;
1342     vector unsigned int vdest, vsrc, vmask;
1343     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1344         dest_mask, mask_mask, src_mask, store_mask;
1345
1346     COMPUTE_SHIFT_MASKC (dest, src, mask);
1347
1348     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1349     for (i = width / 4; i > 0; i--)
1350     {
1351         LOAD_VECTORSC (dest, src, mask);
1352
1353         vdest = pix_multiply (
1354             pix_multiply (vsrc, vmask), splat_alpha (negate (vdest)));
1355
1356         STORE_VECTOR (dest);
1357
1358         src += 4;
1359         dest += 4;
1360         mask += 4;
1361     }
1362
1363     for (i = width % 4; --i >= 0;)
1364     {
1365         uint32_t a = mask[i];
1366         uint32_t s = src[i];
1367         uint32_t d = dest[i];
1368         uint32_t da = ALPHA_8 (~d);
1369
1370         UN8x4_MUL_UN8x4 (s, a);
1371         UN8x4_MUL_UN8 (s, da);
1372
1373         dest[i] = s;
1374     }
1375 }
1376
1377 static void
1378 vmx_combine_out_reverse_ca (pixman_implementation_t *imp,
1379                             pixman_op_t              op,
1380                             uint32_t *               dest,
1381                             const uint32_t *         src,
1382                             const uint32_t *         mask,
1383                             int                      width)
1384 {
1385     int i;
1386     vector unsigned int vdest, vsrc, vmask;
1387     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1388         dest_mask, mask_mask, src_mask, store_mask;
1389
1390     COMPUTE_SHIFT_MASKC (dest, src, mask);
1391
1392     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1393     for (i = width / 4; i > 0; i--)
1394     {
1395         LOAD_VECTORSC (dest, src, mask);
1396
1397         vdest = pix_multiply (
1398             vdest, negate (pix_multiply (vmask, splat_alpha (vsrc))));
1399
1400         STORE_VECTOR (dest);
1401
1402         src += 4;
1403         dest += 4;
1404         mask += 4;
1405     }
1406
1407     for (i = width % 4; --i >= 0;)
1408     {
1409         uint32_t a = mask[i];
1410         uint32_t s = src[i];
1411         uint32_t d = dest[i];
1412         uint32_t sa = ALPHA_8 (s);
1413
1414         UN8x4_MUL_UN8 (a, sa);
1415         UN8x4_MUL_UN8x4 (d, ~a);
1416
1417         dest[i] = d;
1418     }
1419 }
1420
1421 static void
1422 vmx_combine_atop_ca (pixman_implementation_t *imp,
1423                      pixman_op_t              op,
1424                      uint32_t *               dest,
1425                      const uint32_t *         src,
1426                      const uint32_t *         mask,
1427                      int                      width)
1428 {
1429     int i;
1430     vector unsigned int vdest, vsrc, vmask, vsrca;
1431     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1432         dest_mask, mask_mask, src_mask, store_mask;
1433
1434     COMPUTE_SHIFT_MASKC (dest, src, mask);
1435
1436     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1437     for (i = width / 4; i > 0; i--)
1438     {
1439         LOAD_VECTORSC (dest, src, mask);
1440
1441         vsrca = splat_alpha (vsrc);
1442
1443         vsrc = pix_multiply (vsrc, vmask);
1444         vmask = pix_multiply (vmask, vsrca);
1445
1446         vdest = pix_add_mul (vsrc, splat_alpha (vdest),
1447                              negate (vmask), vdest);
1448
1449         STORE_VECTOR (dest);
1450
1451         src += 4;
1452         dest += 4;
1453         mask += 4;
1454     }
1455
1456     for (i = width % 4; --i >= 0;)
1457     {
1458         uint32_t a = mask[i];
1459         uint32_t s = src[i];
1460         uint32_t d = dest[i];
1461         uint32_t sa = ALPHA_8 (s);
1462         uint32_t da = ALPHA_8 (d);
1463
1464         UN8x4_MUL_UN8x4 (s, a);
1465         UN8x4_MUL_UN8 (a, sa);
1466         UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (d, ~a, s, da);
1467
1468         dest[i] = d;
1469     }
1470 }
1471
1472 static void
1473 vmx_combine_atop_reverse_ca (pixman_implementation_t *imp,
1474                              pixman_op_t              op,
1475                              uint32_t *               dest,
1476                              const uint32_t *         src,
1477                              const uint32_t *         mask,
1478                              int                      width)
1479 {
1480     int i;
1481     vector unsigned int vdest, vsrc, vmask;
1482     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1483         dest_mask, mask_mask, src_mask, store_mask;
1484
1485     COMPUTE_SHIFT_MASKC (dest, src, mask);
1486
1487     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1488     for (i = width / 4; i > 0; i--)
1489     {
1490         LOAD_VECTORSC (dest, src, mask);
1491
1492         vdest = pix_add_mul (vdest,
1493                              pix_multiply (vmask, splat_alpha (vsrc)),
1494                              pix_multiply (vsrc, vmask),
1495                              negate (splat_alpha (vdest)));
1496
1497         STORE_VECTOR (dest);
1498
1499         src += 4;
1500         dest += 4;
1501         mask += 4;
1502     }
1503
1504     for (i = width % 4; --i >= 0;)
1505     {
1506         uint32_t a = mask[i];
1507         uint32_t s = src[i];
1508         uint32_t d = dest[i];
1509         uint32_t sa = ALPHA_8 (s);
1510         uint32_t da = ALPHA_8 (~d);
1511
1512         UN8x4_MUL_UN8x4 (s, a);
1513         UN8x4_MUL_UN8 (a, sa);
1514         UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (d, a, s, da);
1515
1516         dest[i] = d;
1517     }
1518 }
1519
1520 static void
1521 vmx_combine_xor_ca (pixman_implementation_t *imp,
1522                     pixman_op_t              op,
1523                     uint32_t *               dest,
1524                     const uint32_t *         src,
1525                     const uint32_t *         mask,
1526                     int                      width)
1527 {
1528     int i;
1529     vector unsigned int vdest, vsrc, vmask;
1530     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1531         dest_mask, mask_mask, src_mask, store_mask;
1532
1533     COMPUTE_SHIFT_MASKC (dest, src, mask);
1534
1535     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1536     for (i = width / 4; i > 0; i--)
1537     {
1538         LOAD_VECTORSC (dest, src, mask);
1539
1540         vdest = pix_add_mul (vdest,
1541                              negate (pix_multiply (vmask, splat_alpha (vsrc))),
1542                              pix_multiply (vsrc, vmask),
1543                              negate (splat_alpha (vdest)));
1544
1545         STORE_VECTOR (dest);
1546
1547         src += 4;
1548         dest += 4;
1549         mask += 4;
1550     }
1551
1552     for (i = width % 4; --i >= 0;)
1553     {
1554         uint32_t a = mask[i];
1555         uint32_t s = src[i];
1556         uint32_t d = dest[i];
1557         uint32_t sa = ALPHA_8 (s);
1558         uint32_t da = ALPHA_8 (~d);
1559
1560         UN8x4_MUL_UN8x4 (s, a);
1561         UN8x4_MUL_UN8 (a, sa);
1562         UN8x4_MUL_UN8x4_ADD_UN8x4_MUL_UN8 (d, ~a, s, da);
1563
1564         dest[i] = d;
1565     }
1566 }
1567
1568 static void
1569 vmx_combine_add_ca (pixman_implementation_t *imp,
1570                     pixman_op_t              op,
1571                     uint32_t *               dest,
1572                     const uint32_t *         src,
1573                     const uint32_t *         mask,
1574                     int                      width)
1575 {
1576     int i;
1577     vector unsigned int vdest, vsrc, vmask;
1578     vector unsigned char tmp1, tmp2, tmp3, tmp4, edges,
1579         dest_mask, mask_mask, src_mask, store_mask;
1580
1581     COMPUTE_SHIFT_MASKC (dest, src, mask);
1582
1583     /* printf ("%s\n",__PRETTY_FUNCTION__); */
1584     for (i = width / 4; i > 0; i--)
1585     {
1586         LOAD_VECTORSC (dest, src, mask);
1587
1588         vdest = pix_add (pix_multiply (vsrc, vmask), vdest);
1589
1590         STORE_VECTOR (dest);
1591
1592         src += 4;
1593         dest += 4;
1594         mask += 4;
1595     }
1596
1597     for (i = width % 4; --i >= 0;)
1598     {
1599         uint32_t a = mask[i];
1600         uint32_t s = src[i];
1601         uint32_t d = dest[i];
1602
1603         UN8x4_MUL_UN8x4 (s, a);
1604         UN8x4_ADD_UN8x4 (s, d);
1605
1606         dest[i] = s;
1607     }
1608 }
1609
1610 static const pixman_fast_path_t vmx_fast_paths[] =
1611 {
1612     {   PIXMAN_OP_NONE  },
1613 };
1614
1615 pixman_implementation_t *
1616 _pixman_implementation_create_vmx (pixman_implementation_t *fallback)
1617 {
1618     pixman_implementation_t *imp = _pixman_implementation_create (fallback, vmx_fast_paths);
1619
1620     /* Set up function pointers */
1621
1622     imp->combine_32[PIXMAN_OP_OVER] = vmx_combine_over_u;
1623     imp->combine_32[PIXMAN_OP_OVER_REVERSE] = vmx_combine_over_reverse_u;
1624     imp->combine_32[PIXMAN_OP_IN] = vmx_combine_in_u;
1625     imp->combine_32[PIXMAN_OP_IN_REVERSE] = vmx_combine_in_reverse_u;
1626     imp->combine_32[PIXMAN_OP_OUT] = vmx_combine_out_u;
1627     imp->combine_32[PIXMAN_OP_OUT_REVERSE] = vmx_combine_out_reverse_u;
1628     imp->combine_32[PIXMAN_OP_ATOP] = vmx_combine_atop_u;
1629     imp->combine_32[PIXMAN_OP_ATOP_REVERSE] = vmx_combine_atop_reverse_u;
1630     imp->combine_32[PIXMAN_OP_XOR] = vmx_combine_xor_u;
1631
1632     imp->combine_32[PIXMAN_OP_ADD] = vmx_combine_add_u;
1633
1634     imp->combine_32_ca[PIXMAN_OP_SRC] = vmx_combine_src_ca;
1635     imp->combine_32_ca[PIXMAN_OP_OVER] = vmx_combine_over_ca;
1636     imp->combine_32_ca[PIXMAN_OP_OVER_REVERSE] = vmx_combine_over_reverse_ca;
1637     imp->combine_32_ca[PIXMAN_OP_IN] = vmx_combine_in_ca;
1638     imp->combine_32_ca[PIXMAN_OP_IN_REVERSE] = vmx_combine_in_reverse_ca;
1639     imp->combine_32_ca[PIXMAN_OP_OUT] = vmx_combine_out_ca;
1640     imp->combine_32_ca[PIXMAN_OP_OUT_REVERSE] = vmx_combine_out_reverse_ca;
1641     imp->combine_32_ca[PIXMAN_OP_ATOP] = vmx_combine_atop_ca;
1642     imp->combine_32_ca[PIXMAN_OP_ATOP_REVERSE] = vmx_combine_atop_reverse_ca;
1643     imp->combine_32_ca[PIXMAN_OP_XOR] = vmx_combine_xor_ca;
1644     imp->combine_32_ca[PIXMAN_OP_ADD] = vmx_combine_add_ca;
1645
1646     return imp;
1647 }