pixman/pixman-mmx.c

   1 /*
   2  * Copyright © 2004, 2005 Red Hat, Inc.
   3  * Copyright © 2004 Nicholas Miell
   4  * Copyright © 2005 Trolltech AS
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of Red Hat not be used in advertising or
  11  * publicity pertaining to distribution of the software without specific,
  12  * written prior permission.  Red Hat makes no representations about the
  13  * suitability of this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  *
  16  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  17  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  18  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  19  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  20  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  21  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  22  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23  * SOFTWARE.
  24  *
  25  * Author:  Søren Sandmann (sandmann@redhat.com)
  26  * Minor Improvements: Nicholas Miell (nmiell@gmail.com)
  27  * MMX code paths for fbcompose.c by Lars Knoll (lars@trolltech.com)
  28  *
  29  * Based on work by Owen Taylor
  30  */
  31
  32 #ifdef HAVE_CONFIG_H
  33 #include <config.h>
  34 #endif
  35
  36 #ifdef USE_MMX
  37
  38 #include <mmintrin.h>
  39 #include "pixman-private.h"
  40
  41 #define noVERBOSE
  42
  43 #ifdef VERBOSE
  44 #define CHECKPOINT() ErrorF ("at %s %d\n", __FUNCTION__, __LINE__)
  45 #else
  46 #define CHECKPOINT()
  47 #endif
  48
  49 /* Notes about writing mmx code
  50  *
  51  * give memory operands as the second operand. If you give it as the
  52  * first, gcc will first load it into a register, then use that
  53  * register
  54  *
  55  *   ie. use
  56  *
  57  *         _mm_mullo_pi16 (x, mmx_constant);
  58  *
  59  *   not
  60  *
  61  *         _mm_mullo_pi16 (mmx_constant, x);
  62  *
  63  * Also try to minimize dependencies. i.e. when you need a value, try
  64  * to calculate it from a value that was calculated as early as
  65  * possible.
  66  */
  67
  68 /* --------------- MMX primitives ------------------------------------- */
  69
  70 #ifdef __GNUC__
  71 typedef uint64_t mmxdatafield;
  72 #else
  73 typedef __m64 mmxdatafield;
  74 /* If __m64 is defined as a struct or union, define M64_MEMBER to be the
  75    name of the member used to access the data */
  76 # ifdef _MSC_VER
  77 #  define M64_MEMBER m64_u64
  78 # elif defined(__SUNPRO_C)
  79 #  define M64_MEMBER l_
  80 # endif
  81 #endif
  82
  83 typedef struct
  84 {
  85     mmxdatafield mmx_4x00ff;
  86     mmxdatafield mmx_4x0080;
  87     mmxdatafield mmx_565_rgb;
  88     mmxdatafield mmx_565_unpack_multiplier;
  89     mmxdatafield mmx_565_r;
  90     mmxdatafield mmx_565_g;
  91     mmxdatafield mmx_565_b;
  92     mmxdatafield mmx_mask_0;
  93     mmxdatafield mmx_mask_1;
  94     mmxdatafield mmx_mask_2;
  95     mmxdatafield mmx_mask_3;
  96     mmxdatafield mmx_full_alpha;
  97     mmxdatafield mmx_ffff0000ffff0000;
  98     mmxdatafield mmx_0000ffff00000000;
  99     mmxdatafield mmx_000000000000ffff;
 100 } MMXData;
 101
 102 #if defined(_MSC_VER)
 103 # define MMXDATA_INIT(field, val) { val##UI64 }
 104 #elif defined(M64_MEMBER)       /* __m64 is a struct, not an integral type */
 105 # define MMXDATA_INIT(field, val) field =   { val##ULL }
 106 #else                           /* __m64 is an integral type */
 107 # define MMXDATA_INIT(field, val) field =   val##ULL
 108 #endif
 109
 110 static const MMXData c =
 111 {
 112     MMXDATA_INIT(.mmx_4x00ff,                   0x00ff00ff00ff00ff),
 113     MMXDATA_INIT(.mmx_4x0080,                   0x0080008000800080),
 114     MMXDATA_INIT(.mmx_565_rgb,                  0x000001f0003f001f),
 115     MMXDATA_INIT(.mmx_565_unpack_multiplier,    0x0000008404100840),
 116     MMXDATA_INIT(.mmx_565_r,                    0x000000f800000000),
 117     MMXDATA_INIT(.mmx_565_g,                    0x0000000000fc0000),
 118     MMXDATA_INIT(.mmx_565_b,                    0x00000000000000f8),
 119     MMXDATA_INIT(.mmx_mask_0,                   0xffffffffffff0000),
 120     MMXDATA_INIT(.mmx_mask_1,                   0xffffffff0000ffff),
 121     MMXDATA_INIT(.mmx_mask_2,                   0xffff0000ffffffff),
 122     MMXDATA_INIT(.mmx_mask_3,                   0x0000ffffffffffff),
 123     MMXDATA_INIT(.mmx_full_alpha,               0x00ff000000000000),
 124     MMXDATA_INIT(.mmx_ffff0000ffff0000,         0xffff0000ffff0000),
 125     MMXDATA_INIT(.mmx_0000ffff00000000,         0x0000ffff00000000),
 126     MMXDATA_INIT(.mmx_000000000000ffff,         0x000000000000ffff),
 127 };
 128
 129 #ifdef __GNUC__
 130 #    ifdef __ICC
 131 #        define MC(x)  M64(c.mmx_##x)
 132 #    else
 133 #        define MC(x) ((__m64)c.mmx_##x)
 134 #    endif
 135 #else
 136 #    define MC(x) c.mmx_##x
 137 #endif
 138
 139 static force_inline __m64
 140 M64 (uint64_t x)
 141 {
 142 #ifdef __ICC
 143     return _mm_cvtsi64_m64 (x);
 144 #elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */
 145     __m64 res;
 146
 147     res.M64_MEMBER = x;
 148     return res;
 149 #else                           /* __m64 is an integral type */
 150     return (__m64)x;
 151 #endif
 152 }
 153
 154 static force_inline uint64_t
 155 UINT64 (__m64 x)
 156 {
 157 #ifdef __ICC
 158     return _mm_cvtm64_si64 (x);
 159 #elif defined M64_MEMBER        /* __m64 is a struct, not an integral type */
 160     uint64_t res = x.M64_MEMBER;
 161     return res;
 162 #else                           /* __m64 is an integral type */
 163     return (uint64_t)x;
 164 #endif
 165 }
 166
 167 static force_inline __m64
 168 shift (__m64 v, int s)
 169 {
 170     if (s > 0)
 171         return _mm_slli_si64 (v, s);
 172     else if (s < 0)
 173         return _mm_srli_si64 (v, -s);
 174     else
 175         return v;
 176 }
 177
 178 static force_inline __m64
 179 negate (__m64 mask)
 180 {
 181     return _mm_xor_si64 (mask, MC(4x00ff));
 182 }
 183
 184 static force_inline __m64
 185 pix_multiply (__m64 a, __m64 b)
 186 {
 187     __m64 res;
 188
 189     res = _mm_mullo_pi16 (a, b);
 190     res = _mm_adds_pu16 (res, MC(4x0080));
 191     res = _mm_adds_pu16 (res, _mm_srli_pi16 (res, 8));
 192     res = _mm_srli_pi16 (res, 8);
 193
 194     return res;
 195 }
 196
 197 static force_inline __m64
 198 pix_add (__m64 a, __m64 b)
 199 {
 200     return  _mm_adds_pu8 (a, b);
 201 }
 202
 203 static force_inline __m64
 204 expand_alpha (__m64 pixel)
 205 {
 206     __m64 t1, t2;
 207
 208     t1 = shift (pixel, -48);
 209     t2 = shift (t1, 16);
 210     t1 = _mm_or_si64 (t1, t2);
 211     t2 = shift (t1, 32);
 212     t1 = _mm_or_si64 (t1, t2);
 213
 214     return t1;
 215 }
 216
 217 static force_inline __m64
 218 expand_alpha_rev (__m64 pixel)
 219 {
 220     __m64 t1, t2;
 221
 222     /* move alpha to low 16 bits and zero the rest */
 223     t1 = shift (pixel,  48);
 224     t1 = shift (t1, -48);
 225
 226     t2 = shift (t1, 16);
 227     t1 = _mm_or_si64 (t1, t2);
 228     t2 = shift (t1, 32);
 229     t1 = _mm_or_si64 (t1, t2);
 230
 231     return t1;
 232 }
 233
 234 static force_inline __m64
 235 invert_colors (__m64 pixel)
 236 {
 237     __m64 x, y, z;
 238
 239     x = y = z = pixel;
 240
 241     x = _mm_and_si64 (x, MC(ffff0000ffff0000));
 242     y = _mm_and_si64 (y, MC(000000000000ffff));
 243     z = _mm_and_si64 (z, MC(0000ffff00000000));
 244
 245     y = shift (y, 32);
 246     z = shift (z, -32);
 247
 248     x = _mm_or_si64 (x, y);
 249     x = _mm_or_si64 (x, z);
 250
 251     return x;
 252 }
 253
 254 static force_inline __m64
 255 over (__m64 src, __m64 srca, __m64 dest)
 256 {
 257     return  _mm_adds_pu8 (src, pix_multiply(dest, negate(srca)));
 258 }
 259
 260 static force_inline __m64
 261 over_rev_non_pre (__m64 src, __m64 dest)
 262 {
 263     __m64 srca = expand_alpha (src);
 264     __m64 srcfaaa = _mm_or_si64 (srca, MC(full_alpha));
 265
 266     return over(pix_multiply(invert_colors(src), srcfaaa), srca, dest);
 267 }
 268
 269 static force_inline __m64
 270 in (__m64 src,
 271     __m64 mask)
 272 {
 273     return pix_multiply (src, mask);
 274 }
 275
 276 static force_inline __m64
 277 in_over_full_src_alpha (__m64 src, __m64 mask, __m64 dest)
 278 {
 279     src = _mm_or_si64 (src, MC(full_alpha));
 280
 281     return over(in (src, mask), mask, dest);
 282 }
 283
 284 #ifndef _MSC_VER
 285 static force_inline __m64
 286 in_over (__m64 src,
 287          __m64 srca,
 288          __m64 mask,
 289          __m64 dest)
 290 {
 291     return over(in(src, mask), pix_multiply(srca, mask), dest);
 292 }
 293 #else
 294 #define in_over(src, srca, mask, dest) over(in(src, mask), pix_multiply(srca, mask), dest)
 295 #endif
 296
 297 static force_inline __m64
 298 load8888 (uint32_t v)
 299 {
 300     return _mm_unpacklo_pi8 (_mm_cvtsi32_si64 (v), _mm_setzero_si64());
 301 }
 302
 303 static force_inline __m64
 304 pack8888 (__m64 lo, __m64 hi)
 305 {
 306     return _mm_packs_pu16 (lo, hi);
 307 }
 308
 309 static force_inline uint32_t
 310 store8888 (__m64 v)
 311 {
 312     return _mm_cvtsi64_si32(pack8888(v, _mm_setzero_si64()));
 313 }
 314
 315 /* Expand 16 bits positioned at @pos (0-3) of a mmx register into
 316  *
 317  *    00RR00GG00BB
 318  *
 319  * --- Expanding 565 in the low word ---
 320  *
 321  * m = (m << (32 - 3)) | (m << (16 - 5)) | m;
 322  * m = m & (01f0003f001f);
 323  * m = m * (008404100840);
 324  * m = m >> 8;
 325  *
 326  * Note the trick here - the top word is shifted by another nibble to
 327  * avoid it bumping into the middle word
 328  */
 329 static force_inline __m64
 330 expand565 (__m64 pixel, int pos)
 331 {
 332     __m64 p = pixel;
 333     __m64 t1, t2;
 334
 335     /* move pixel to low 16 bit and zero the rest */
 336     p = shift (shift (p, (3 - pos) * 16), -48);
 337
 338     t1 = shift (p, 36 - 11);
 339     t2 = shift (p, 16 - 5);
 340
 341     p = _mm_or_si64 (t1, p);
 342     p = _mm_or_si64 (t2, p);
 343     p = _mm_and_si64 (p, MC(565_rgb));
 344
 345     pixel = _mm_mullo_pi16 (p, MC(565_unpack_multiplier));
 346     return _mm_srli_pi16 (pixel, 8);
 347 }
 348
 349 static force_inline __m64
 350 expand8888 (__m64 in, int pos)
 351 {
 352     if (pos == 0)
 353         return _mm_unpacklo_pi8 (in, _mm_setzero_si64());
 354     else
 355         return _mm_unpackhi_pi8 (in, _mm_setzero_si64());
 356 }
 357
 358 static force_inline __m64
 359 expandx888 (__m64 in, int pos)
 360 {
 361     return _mm_or_si64 (expand8888 (in, pos), MC(full_alpha));
 362 }
 363
 364 static force_inline __m64
 365 pack565 (__m64 pixel, __m64 target, int pos)
 366 {
 367     __m64 p = pixel;
 368     __m64 t = target;
 369     __m64 r, g, b;
 370
 371     r = _mm_and_si64 (p, MC(565_r));
 372     g = _mm_and_si64 (p, MC(565_g));
 373     b = _mm_and_si64 (p, MC(565_b));
 374
 375     r = shift (r, - (32 - 8) + pos * 16);
 376     g = shift (g, - (16 - 3) + pos * 16);
 377     b = shift (b, - (0  + 3) + pos * 16);
 378
 379     if (pos == 0)
 380         t = _mm_and_si64 (t, MC(mask_0));
 381     else if (pos == 1)
 382         t = _mm_and_si64 (t, MC(mask_1));
 383     else if (pos == 2)
 384         t = _mm_and_si64 (t, MC(mask_2));
 385     else if (pos == 3)
 386         t = _mm_and_si64 (t, MC(mask_3));
 387
 388     p = _mm_or_si64 (r, t);
 389     p = _mm_or_si64 (g, p);
 390
 391     return _mm_or_si64 (b, p);
 392 }
 393
 394 #ifndef _MSC_VER
 395 static force_inline __m64
 396 pix_add_mul (__m64 x, __m64 a, __m64 y, __m64 b)
 397 {
 398     x = _mm_mullo_pi16 (x, a);
 399     y = _mm_mullo_pi16 (y, b);
 400     x = _mm_adds_pu16 (x, MC(4x0080));
 401     x = _mm_adds_pu16 (x, y);
 402     x = _mm_adds_pu16 (x, _mm_srli_pi16 (x, 8));
 403     x = _mm_srli_pi16 (x, 8);
 404
 405     return x;
 406 }
 407 #else
 408 #define pix_add_mul(x, a, y, b) \
 409 ( x = _mm_mullo_pi16 (x, a), \
 410   y = _mm_mullo_pi16 (y, b), \
 411   x = _mm_adds_pu16 (x, MC(4x0080)), \
 412   x = _mm_adds_pu16 (x, y), \
 413   x = _mm_adds_pu16 (x, _mm_srli_pi16 (x, 8)), \
 414   _mm_srli_pi16 (x, 8) )
 415 #endif
 416
 417 /* --------------- MMX code patch for fbcompose.c --------------------- */
 418
 419 static force_inline uint32_t
 420 combine (const uint32_t *src, const uint32_t *mask)
 421 {
 422     uint32_t ssrc = *src;
 423
 424     if (mask)
 425     {
 426         __m64 m = load8888 (*mask);
 427         __m64 s = load8888 (ssrc);
 428
 429         m = expand_alpha (m);
 430         s = pix_multiply (s, m);
 431
 432         ssrc = store8888 (s);
 433     }
 434
 435     return ssrc;
 436 }
 437
 438 static FASTCALL void
 439 mmxCombineOverU (pixman_implementation_t *imp, pixman_op_t op,
 440                  uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 441 {
 442     const uint32_t *end = dest + width;
 443
 444     while (dest < end) {
 445         uint32_t ssrc = combine (src, mask);
 446         uint32_t a = ssrc >> 24;
 447         if (a == 0xff) {
 448             *dest = ssrc;
 449         } else if (a) {
 450             __m64 s, sa;
 451             s = load8888(ssrc);
 452             sa = expand_alpha(s);
 453             *dest = store8888(over(s, sa, load8888(*dest)));
 454         }
 455         ++dest;
 456         ++src;
 457         if (mask)
 458             ++mask;
 459     }
 460     _mm_empty();
 461 }
 462
 463 static FASTCALL void
 464 mmxCombineOverReverseU (pixman_implementation_t *imp, pixman_op_t op,
 465                         uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 466 {
 467     const uint32_t *end = dest + width;
 468
 469     while (dest < end) {
 470         __m64 d, da;
 471         uint32_t s = combine (src, mask);
 472         d = load8888(*dest);
 473         da = expand_alpha(d);
 474         *dest = store8888(over (d, da, load8888(s)));
 475         ++dest;
 476         ++src;
 477         if (mask)
 478             mask++;
 479     }
 480     _mm_empty();
 481 }
 482
 483 static FASTCALL void
 484 mmxCombineInU (pixman_implementation_t *imp, pixman_op_t op,
 485                uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 486 {
 487     const uint32_t *end = dest + width;
 488
 489     while (dest < end) {
 490         __m64 x, a;
 491         x = load8888 (combine (src, mask));
 492         a = load8888(*dest);
 493         a = expand_alpha(a);
 494         x = pix_multiply(x, a);
 495         *dest = store8888(x);
 496         ++dest;
 497         ++src;
 498         if (mask)
 499             mask++;
 500     }
 501     _mm_empty();
 502 }
 503
 504 static FASTCALL void
 505 mmxCombineInReverseU (pixman_implementation_t *imp, pixman_op_t op,
 506                       uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 507 {
 508     const uint32_t *end = dest + width;
 509
 510     while (dest < end) {
 511         __m64 x, a;
 512         x = load8888(*dest);
 513         a = load8888(combine (src, mask));
 514         a = expand_alpha(a);
 515         x = pix_multiply(x, a);
 516         *dest = store8888(x);
 517         ++dest;
 518         ++src;
 519         if (mask)
 520             mask++;
 521     }
 522     _mm_empty();
 523 }
 524
 525 static FASTCALL void
 526 mmxCombineOutU (pixman_implementation_t *imp, pixman_op_t op,
 527                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 528 {
 529     const uint32_t *end = dest + width;
 530
 531     while (dest < end) {
 532         __m64 x, a;
 533         x = load8888(combine (src, mask));
 534         a = load8888(*dest);
 535         a = expand_alpha(a);
 536         a = negate(a);
 537         x = pix_multiply(x, a);
 538         *dest = store8888(x);
 539         ++dest;
 540         ++src;
 541         if (mask)
 542             mask++;
 543     }
 544     _mm_empty();
 545 }
 546
 547 static FASTCALL void
 548 mmxCombineOutReverseU (pixman_implementation_t *imp, pixman_op_t op,
 549                        uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 550 {
 551     const uint32_t *end = dest + width;
 552
 553     while (dest < end) {
 554         __m64 x, a;
 555         x = load8888(*dest);
 556         a = load8888(combine (src, mask));
 557         a = expand_alpha(a);
 558         a = negate(a);
 559         x = pix_multiply(x, a);
 560         *dest = store8888(x);
 561         ++dest;
 562         ++src;
 563         if (mask)
 564             mask++;
 565     }
 566     _mm_empty();
 567 }
 568
 569 static FASTCALL void
 570 mmxCombineAtopU (pixman_implementation_t *imp, pixman_op_t op,
 571                  uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 572 {
 573     const uint32_t *end = dest + width;
 574
 575     while (dest < end) {
 576         __m64 s, da, d, sia;
 577         s = load8888(combine (src, mask));
 578         d = load8888(*dest);
 579         sia = expand_alpha(s);
 580         sia = negate(sia);
 581         da = expand_alpha(d);
 582         s = pix_add_mul (s, da, d, sia);
 583         *dest = store8888(s);
 584         ++dest;
 585         ++src;
 586         if (mask)
 587             mask++;
 588     }
 589     _mm_empty();
 590 }
 591
 592 static FASTCALL void
 593 mmxCombineAtopReverseU (pixman_implementation_t *imp, pixman_op_t op,
 594                         uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 595 {
 596     const uint32_t *end;
 597
 598     end = dest + width;
 599
 600     while (dest < end) {
 601         __m64 s, dia, d, sa;
 602         s = load8888(combine(src, mask));
 603         d = load8888(*dest);
 604         sa = expand_alpha(s);
 605         dia = expand_alpha(d);
 606         dia = negate(dia);
 607         s = pix_add_mul (s, dia, d, sa);
 608         *dest = store8888(s);
 609         ++dest;
 610         ++src;
 611         if (mask)
 612             mask++;
 613     }
 614     _mm_empty();
 615 }
 616
 617 static FASTCALL void
 618 mmxCombineXorU (pixman_implementation_t *imp, pixman_op_t op,
 619                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 620 {
 621     const uint32_t *end = dest + width;
 622
 623     while (dest < end) {
 624         __m64 s, dia, d, sia;
 625         s = load8888(combine(src, mask));
 626         d = load8888(*dest);
 627         sia = expand_alpha(s);
 628         dia = expand_alpha(d);
 629         sia = negate(sia);
 630         dia = negate(dia);
 631         s = pix_add_mul (s, dia, d, sia);
 632         *dest = store8888(s);
 633         ++dest;
 634         ++src;
 635         if (mask)
 636             mask++;
 637     }
 638     _mm_empty();
 639 }
 640
 641 static FASTCALL void
 642 mmxCombineAddU (pixman_implementation_t *imp, pixman_op_t op,
 643                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 644 {
 645     const uint32_t *end = dest + width;
 646     while (dest < end) {
 647         __m64 s, d;
 648         s = load8888(combine(src,mask));
 649         d = load8888(*dest);
 650         s = pix_add(s, d);
 651         *dest = store8888(s);
 652         ++dest;
 653         ++src;
 654         if (mask)
 655             mask++;
 656     }
 657     _mm_empty();
 658 }
 659
 660 static FASTCALL void
 661 mmxCombineSaturateU (pixman_implementation_t *imp, pixman_op_t op,
 662                      uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 663 {
 664     const uint32_t *end = dest + width;
 665     while (dest < end) {
 666         uint32_t s = combine(src,mask);
 667         uint32_t d = *dest;
 668         __m64 ms = load8888(s);
 669         __m64 md = load8888(d);
 670         uint32_t sa = s >> 24;
 671         uint32_t da = ~d >> 24;
 672
 673         if (sa > da) {
 674             __m64 msa = load8888(FbIntDiv(da, sa) << 24);
 675             msa = expand_alpha(msa);
 676             ms = pix_multiply(ms, msa);
 677         }
 678         md = pix_add(md, ms);
 679         *dest = store8888(md);
 680         ++src;
 681         ++dest;
 682         if (mask)
 683             mask++;
 684     }
 685     _mm_empty();
 686 }
 687
 688
 689 static FASTCALL void
 690 mmxCombineSrcC (pixman_implementation_t *imp, pixman_op_t op,
 691                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 692 {
 693     const uint32_t *end = src + width;
 694     while (src < end) {
 695         __m64 a = load8888(*mask);
 696         __m64 s = load8888(*src);
 697         s = pix_multiply(s, a);
 698         *dest = store8888(s);
 699         ++src;
 700         ++mask;
 701         ++dest;
 702     }
 703     _mm_empty();
 704 }
 705
 706 static FASTCALL void
 707 mmxCombineOverC (pixman_implementation_t *imp, pixman_op_t op,
 708                  uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 709 {
 710     const uint32_t *end = src + width;
 711     while (src < end) {
 712         __m64 a = load8888(*mask);
 713         __m64 s = load8888(*src);
 714         __m64 d = load8888(*dest);
 715         __m64 sa = expand_alpha(s);
 716
 717         *dest = store8888(in_over (s, sa, a, d));
 718
 719         ++src;
 720         ++dest;
 721         ++mask;
 722     }
 723     _mm_empty();
 724 }
 725
 726 static FASTCALL void
 727 mmxCombineOverReverseC (pixman_implementation_t *imp, pixman_op_t op,
 728                         uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 729 {
 730     const uint32_t *end = src + width;
 731     while (src < end) {
 732         __m64 a = load8888(*mask);
 733         __m64 s = load8888(*src);
 734         __m64 d = load8888(*dest);
 735         __m64 da = expand_alpha(d);
 736
 737         *dest = store8888(over (d, da, in (s, a)));
 738
 739         ++src;
 740         ++dest;
 741         ++mask;
 742     }
 743     _mm_empty();
 744 }
 745
 746
 747 static FASTCALL void
 748 mmxCombineInC (pixman_implementation_t *imp, pixman_op_t op,
 749                uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 750 {
 751     const uint32_t *end = src + width;
 752     while (src < end) {
 753         __m64 a = load8888(*mask);
 754         __m64 s = load8888(*src);
 755         __m64 d = load8888(*dest);
 756         __m64 da = expand_alpha(d);
 757         s = pix_multiply(s, a);
 758         s = pix_multiply(s, da);
 759         *dest = store8888(s);
 760         ++src;
 761         ++dest;
 762         ++mask;
 763     }
 764     _mm_empty();
 765 }
 766
 767 static FASTCALL void
 768 mmxCombineInReverseC (pixman_implementation_t *imp, pixman_op_t op,
 769                       uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 770 {
 771     const uint32_t *end = src + width;
 772     while (src < end) {
 773         __m64 a = load8888(*mask);
 774         __m64 s = load8888(*src);
 775         __m64 d = load8888(*dest);
 776         __m64 sa = expand_alpha(s);
 777         a = pix_multiply(a, sa);
 778         d = pix_multiply(d, a);
 779         *dest = store8888(d);
 780         ++src;
 781         ++dest;
 782         ++mask;
 783     }
 784     _mm_empty();
 785 }
 786
 787 static FASTCALL void
 788 mmxCombineOutC (pixman_implementation_t *imp, pixman_op_t op,
 789                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 790 {
 791     const uint32_t *end = src + width;
 792     while (src < end) {
 793         __m64 a = load8888(*mask);
 794         __m64 s = load8888(*src);
 795         __m64 d = load8888(*dest);
 796         __m64 da = expand_alpha(d);
 797         da = negate(da);
 798         s = pix_multiply(s, a);
 799         s = pix_multiply(s, da);
 800         *dest = store8888(s);
 801         ++src;
 802         ++dest;
 803         ++mask;
 804     }
 805     _mm_empty();
 806 }
 807
 808 static FASTCALL void
 809 mmxCombineOutReverseC (pixman_implementation_t *imp, pixman_op_t op,
 810                        uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 811 {
 812     const uint32_t *end = src + width;
 813     while (src < end) {
 814         __m64 a = load8888(*mask);
 815         __m64 s = load8888(*src);
 816         __m64 d = load8888(*dest);
 817         __m64 sa = expand_alpha(s);
 818         a = pix_multiply(a, sa);
 819         a = negate(a);
 820         d = pix_multiply(d, a);
 821         *dest = store8888(d);
 822         ++src;
 823         ++dest;
 824         ++mask;
 825     }
 826     _mm_empty();
 827 }
 828
 829 static FASTCALL void
 830 mmxCombineAtopC (pixman_implementation_t *imp, pixman_op_t op,
 831                  uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 832 {
 833     const uint32_t *end = src + width;
 834     while (src < end) {
 835         __m64 a = load8888(*mask);
 836         __m64 s = load8888(*src);
 837         __m64 d = load8888(*dest);
 838         __m64 da = expand_alpha(d);
 839         __m64 sa = expand_alpha(s);
 840         s = pix_multiply(s, a);
 841         a = pix_multiply(a, sa);
 842         a = negate(a);
 843         d = pix_add_mul (d, a, s, da);
 844         *dest = store8888(d);
 845         ++src;
 846         ++dest;
 847         ++mask;
 848     }
 849     _mm_empty();
 850 }
 851
 852 static FASTCALL void
 853 mmxCombineAtopReverseC (pixman_implementation_t *imp, pixman_op_t op,
 854                         uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 855 {
 856     const uint32_t *end = src + width;
 857     while (src < end) {
 858         __m64 a = load8888(*mask);
 859         __m64 s = load8888(*src);
 860         __m64 d = load8888(*dest);
 861         __m64 da = expand_alpha(d);
 862         __m64 sa = expand_alpha(s);
 863         s = pix_multiply(s, a);
 864         a = pix_multiply(a, sa);
 865         da = negate(da);
 866         d = pix_add_mul (d, a, s, da);
 867         *dest = store8888(d);
 868         ++src;
 869         ++dest;
 870         ++mask;
 871     }
 872     _mm_empty();
 873 }
 874
 875 static FASTCALL void
 876 mmxCombineXorC (pixman_implementation_t *imp, pixman_op_t op,
 877                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 878 {
 879     const uint32_t *end = src + width;
 880     while (src < end) {
 881         __m64 a = load8888(*mask);
 882         __m64 s = load8888(*src);
 883         __m64 d = load8888(*dest);
 884         __m64 da = expand_alpha(d);
 885         __m64 sa = expand_alpha(s);
 886         s = pix_multiply(s, a);
 887         a = pix_multiply(a, sa);
 888         da = negate(da);
 889         a = negate(a);
 890         d = pix_add_mul (d, a, s, da);
 891         *dest = store8888(d);
 892         ++src;
 893         ++dest;
 894         ++mask;
 895     }
 896     _mm_empty();
 897 }
 898
 899 static FASTCALL void
 900 mmxCombineAddC (pixman_implementation_t *imp, pixman_op_t op,
 901                 uint32_t *dest, const uint32_t *src, const uint32_t *mask, int width)
 902 {
 903     const uint32_t *end = src + width;
 904     while (src < end) {
 905         __m64 a = load8888(*mask);
 906         __m64 s = load8888(*src);
 907         __m64 d = load8888(*dest);
 908         s = pix_multiply(s, a);
 909         d = pix_add(s, d);
 910         *dest = store8888(d);
 911         ++src;
 912         ++dest;
 913         ++mask;
 914     }
 915     _mm_empty();
 916 }
 917
 918 /* ------------------ MMX code paths called from fbpict.c ----------------------- */
 919
 920 static void
 921 fbCompositeSolid_nx8888mmx (pixman_implementation_t *imp,
 922                             pixman_op_t op,
 923                             pixman_image_t * pSrc,
 924                             pixman_image_t * pMask,
 925                             pixman_image_t * pDst,
 926                             int32_t     xSrc,
 927                             int32_t     ySrc,
 928                             int32_t     xMask,
 929                             int32_t     yMask,
 930                             int32_t     xDst,
 931                             int32_t     yDst,
 932                             int32_t     width,
 933                             int32_t     height)
 934 {
 935     uint32_t    src;
 936     uint32_t    *dstLine, *dst;
 937     uint16_t    w;
 938     int dstStride;
 939     __m64       vsrc, vsrca;
 940
 941     CHECKPOINT();
 942
 943     fbComposeGetSolid(pSrc, src, pDst->bits.format);
 944
 945     if (src >> 24 == 0)
 946         return;
 947
 948     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
 949
 950     vsrc = load8888 (src);
 951     vsrca = expand_alpha (vsrc);
 952
 953     while (height--)
 954     {
 955         dst = dstLine;
 956         dstLine += dstStride;
 957         w = width;
 958
 959         CHECKPOINT();
 960
 961         while (w && (unsigned long)dst & 7)
 962         {
 963             *dst = store8888(over(vsrc, vsrca, load8888(*dst)));
 964
 965             w--;
 966             dst++;
 967         }
 968
 969         while (w >= 2)
 970         {
 971             __m64 vdest;
 972             __m64 dest0, dest1;
 973
 974             vdest = *(__m64 *)dst;
 975
 976             dest0 = over(vsrc, vsrca, expand8888(vdest, 0));
 977             dest1 = over(vsrc, vsrca, expand8888(vdest, 1));
 978
 979             *(__m64 *)dst = pack8888(dest0, dest1);
 980
 981             dst += 2;
 982             w -= 2;
 983         }
 984
 985         CHECKPOINT();
 986
 987         while (w)
 988         {
 989             *dst = store8888(over(vsrc, vsrca, load8888(*dst)));
 990
 991             w--;
 992             dst++;
 993         }
 994     }
 995
 996     _mm_empty();
 997 }
 998
 999 static void
1000 fbCompositeSolid_nx0565mmx (pixman_implementation_t *imp,
1001                             pixman_op_t op,
1002                             pixman_image_t * pSrc,
1003                             pixman_image_t * pMask,
1004                             pixman_image_t * pDst,
1005                             int32_t     xSrc,
1006                             int32_t     ySrc,
1007                             int32_t     xMask,
1008                             int32_t     yMask,
1009                             int32_t     xDst,
1010                             int32_t     yDst,
1011                             int32_t     width,
1012                             int32_t     height)
1013 {
1014     uint32_t    src;
1015     uint16_t    *dstLine, *dst;
1016     uint16_t    w;
1017     int dstStride;
1018     __m64       vsrc, vsrca;
1019
1020     CHECKPOINT();
1021
1022     fbComposeGetSolid(pSrc, src, pDst->bits.format);
1023
1024     if (src >> 24 == 0)
1025         return;
1026
1027     fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
1028
1029     vsrc = load8888 (src);
1030     vsrca = expand_alpha (vsrc);
1031
1032     while (height--)
1033     {
1034         dst = dstLine;
1035         dstLine += dstStride;
1036         w = width;
1037
1038         CHECKPOINT();
1039
1040         while (w && (unsigned long)dst & 7)
1041         {
1042             uint64_t d = *dst;
1043             __m64 vdest = expand565 (M64(d), 0);
1044             vdest = pack565(over(vsrc, vsrca, vdest), vdest, 0);
1045             *dst = UINT64(vdest);
1046
1047             w--;
1048             dst++;
1049         }
1050
1051         while (w >= 4)
1052         {
1053             __m64 vdest;
1054
1055             vdest = *(__m64 *)dst;
1056
1057             vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 0)), vdest, 0);
1058             vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 1)), vdest, 1);
1059             vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 2)), vdest, 2);
1060             vdest = pack565 (over(vsrc, vsrca, expand565(vdest, 3)), vdest, 3);
1061
1062             *(__m64 *)dst = vdest;
1063
1064             dst += 4;
1065             w -= 4;
1066         }
1067
1068         CHECKPOINT();
1069
1070         while (w)
1071         {
1072             uint64_t d = *dst;
1073             __m64 vdest = expand565 (M64(d), 0);
1074             vdest = pack565(over(vsrc, vsrca, vdest), vdest, 0);
1075             *dst = UINT64(vdest);
1076
1077             w--;
1078             dst++;
1079         }
1080     }
1081
1082     _mm_empty();
1083 }
1084
1085 static void
1086 fbCompositeSolidMask_nx8888x8888Cmmx (pixman_implementation_t *imp,
1087                                       pixman_op_t op,
1088                                       pixman_image_t * pSrc,
1089                                       pixman_image_t * pMask,
1090                                       pixman_image_t * pDst,
1091                                       int32_t   xSrc,
1092                                       int32_t   ySrc,
1093                                       int32_t   xMask,
1094                                       int32_t   yMask,
1095                                       int32_t   xDst,
1096                                       int32_t   yDst,
1097                                       int32_t   width,
1098                                       int32_t   height)
1099 {
1100     uint32_t    src, srca;
1101     uint32_t    *dstLine;
1102     uint32_t    *maskLine;
1103     int dstStride, maskStride;
1104     __m64       vsrc, vsrca;
1105
1106     CHECKPOINT();
1107
1108     fbComposeGetSolid(pSrc, src, pDst->bits.format);
1109
1110     srca = src >> 24;
1111     if (srca == 0)
1112         return;
1113
1114     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
1115     fbComposeGetStart (pMask, xMask, yMask, uint32_t, maskStride, maskLine, 1);
1116
1117     vsrc = load8888(src);
1118     vsrca = expand_alpha(vsrc);
1119
1120     while (height--)
1121     {
1122         int twidth = width;
1123         uint32_t *p = (uint32_t *)maskLine;
1124         uint32_t *q = (uint32_t *)dstLine;
1125
1126         while (twidth && (unsigned long)q & 7)
1127         {
1128             uint32_t m = *(uint32_t *)p;
1129
1130             if (m)
1131             {
1132                 __m64 vdest = load8888(*q);
1133                 vdest = in_over(vsrc, vsrca, load8888(m), vdest);
1134                 *q = store8888(vdest);
1135             }
1136
1137             twidth--;
1138             p++;
1139             q++;
1140         }
1141
1142         while (twidth >= 2)
1143         {
1144             uint32_t m0, m1;
1145             m0 = *p;
1146             m1 = *(p + 1);
1147
1148             if (m0 | m1)
1149             {
1150                 __m64 dest0, dest1;
1151                 __m64 vdest = *(__m64 *)q;
1152
1153                 dest0 = in_over(vsrc, vsrca, load8888(m0),
1154                                 expand8888 (vdest, 0));
1155                 dest1 = in_over(vsrc, vsrca, load8888(m1),
1156                                 expand8888 (vdest, 1));
1157
1158                 *(__m64 *)q = pack8888(dest0, dest1);
1159             }
1160
1161             p += 2;
1162             q += 2;
1163             twidth -= 2;
1164         }
1165
1166         while (twidth)
1167         {
1168             uint32_t m = *(uint32_t *)p;
1169
1170             if (m)
1171             {
1172                 __m64 vdest = load8888(*q);
1173                 vdest = in_over(vsrc, vsrca, load8888(m), vdest);
1174                 *q = store8888(vdest);
1175             }
1176
1177             twidth--;
1178             p++;
1179             q++;
1180         }
1181
1182         dstLine += dstStride;
1183         maskLine += maskStride;
1184     }
1185
1186     _mm_empty();
1187 }
1188
1189 static void
1190 fbCompositeSrc_8888x8x8888mmx (pixman_implementation_t *imp,
1191                                pixman_op_t op,
1192                                pixman_image_t * pSrc,
1193                                pixman_image_t * pMask,
1194                                pixman_image_t * pDst,
1195                                int32_t  xSrc,
1196                                int32_t  ySrc,
1197                                int32_t      xMask,
1198                                int32_t      yMask,
1199                                int32_t      xDst,
1200                                int32_t      yDst,
1201                                int32_t     width,
1202                                int32_t     height)
1203 {
1204     uint32_t    *dstLine, *dst;
1205     uint32_t    *srcLine, *src;
1206     uint32_t    mask;
1207     __m64       vmask;
1208     int dstStride, srcStride;
1209     uint16_t    w;
1210     __m64  srca;
1211
1212     CHECKPOINT();
1213
1214     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
1215     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
1216
1217     fbComposeGetSolid (pMask, mask, pDst->bits.format);
1218     mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
1219     vmask = load8888 (mask);
1220     srca = MC(4x00ff);
1221
1222     while (height--)
1223     {
1224         dst = dstLine;
1225         dstLine += dstStride;
1226         src = srcLine;
1227         srcLine += srcStride;
1228         w = width;
1229
1230         while (w && (unsigned long)dst & 7)
1231         {
1232             __m64 s = load8888 (*src);
1233             __m64 d = load8888 (*dst);
1234
1235             *dst = store8888 (in_over (s, expand_alpha (s), vmask, d));
1236
1237             w--;
1238             dst++;
1239             src++;
1240         }
1241
1242         while (w >= 2)
1243         {
1244             __m64 vs = *(__m64 *)src;
1245             __m64 vd = *(__m64 *)dst;
1246             __m64 vsrc0 = expand8888 (vs, 0);
1247             __m64 vsrc1 = expand8888 (vs, 1);
1248
1249             *(__m64 *)dst = pack8888 (
1250                 in_over (vsrc0, expand_alpha (vsrc0), vmask, expand8888 (vd, 0)),
1251                 in_over (vsrc1, expand_alpha (vsrc1), vmask, expand8888 (vd, 1)));
1252
1253             w -= 2;
1254             dst += 2;
1255             src += 2;
1256         }
1257
1258         while (w)
1259         {
1260             __m64 s = load8888 (*src);
1261             __m64 d = load8888 (*dst);
1262
1263             *dst = store8888 (in_over (s, expand_alpha (s), vmask, d));
1264
1265             w--;
1266             dst++;
1267             src++;
1268         }
1269     }
1270
1271     _mm_empty();
1272 }
1273
1274 static void
1275 fbCompositeSrc_x888xnx8888mmx (pixman_implementation_t *imp,
1276                                pixman_op_t op,
1277                                pixman_image_t * pSrc,
1278                                pixman_image_t * pMask,
1279                                pixman_image_t * pDst,
1280                                int32_t  xSrc,
1281                                int32_t  ySrc,
1282                                int32_t      xMask,
1283                                int32_t      yMask,
1284                                int32_t      xDst,
1285                                int32_t      yDst,
1286                                int32_t     width,
1287                                int32_t     height)
1288 {
1289     uint32_t    *dstLine, *dst;
1290     uint32_t    *srcLine, *src;
1291     uint32_t    mask;
1292     __m64       vmask;
1293     int dstStride, srcStride;
1294     uint16_t    w;
1295     __m64  srca;
1296
1297     CHECKPOINT();
1298
1299     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
1300     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
1301     fbComposeGetSolid (pMask, mask, pDst->bits.format);
1302
1303     mask = mask | mask >> 8 | mask >> 16 | mask >> 24;
1304     vmask = load8888 (mask);
1305     srca = MC(4x00ff);
1306
1307     while (height--)
1308     {
1309         dst = dstLine;
1310         dstLine += dstStride;
1311         src = srcLine;
1312         srcLine += srcStride;
1313         w = width;
1314
1315         while (w && (unsigned long)dst & 7)
1316         {
1317             __m64 s = load8888 (*src | 0xff000000);
1318             __m64 d = load8888 (*dst);
1319
1320             *dst = store8888 (in_over (s, srca, vmask, d));
1321
1322             w--;
1323             dst++;
1324             src++;
1325         }
1326
1327         while (w >= 16)
1328         {
1329             __m64 vd0 = *(__m64 *)(dst + 0);
1330             __m64 vd1 = *(__m64 *)(dst + 2);
1331             __m64 vd2 = *(__m64 *)(dst + 4);
1332             __m64 vd3 = *(__m64 *)(dst + 6);
1333             __m64 vd4 = *(__m64 *)(dst + 8);
1334             __m64 vd5 = *(__m64 *)(dst + 10);
1335             __m64 vd6 = *(__m64 *)(dst + 12);
1336             __m64 vd7 = *(__m64 *)(dst + 14);
1337
1338             __m64 vs0 = *(__m64 *)(src + 0);
1339             __m64 vs1 = *(__m64 *)(src + 2);
1340             __m64 vs2 = *(__m64 *)(src + 4);
1341             __m64 vs3 = *(__m64 *)(src + 6);
1342             __m64 vs4 = *(__m64 *)(src + 8);
1343             __m64 vs5 = *(__m64 *)(src + 10);
1344             __m64 vs6 = *(__m64 *)(src + 12);
1345             __m64 vs7 = *(__m64 *)(src + 14);
1346
1347             vd0 = pack8888 (
1348                 in_over (expandx888 (vs0, 0), srca, vmask, expand8888 (vd0, 0)),
1349                 in_over (expandx888 (vs0, 1), srca, vmask, expand8888 (vd0, 1)));
1350
1351             vd1 = pack8888 (
1352                 in_over (expandx888 (vs1, 0), srca, vmask, expand8888 (vd1, 0)),
1353                 in_over (expandx888 (vs1, 1), srca, vmask, expand8888 (vd1, 1)));
1354
1355             vd2 = pack8888 (
1356                 in_over (expandx888 (vs2, 0), srca, vmask, expand8888 (vd2, 0)),
1357                 in_over (expandx888 (vs2, 1), srca, vmask, expand8888 (vd2, 1)));
1358
1359             vd3 = pack8888 (
1360                 in_over (expandx888 (vs3, 0), srca, vmask, expand8888 (vd3, 0)),
1361                 in_over (expandx888 (vs3, 1), srca, vmask, expand8888 (vd3, 1)));
1362
1363             vd4 = pack8888 (
1364                 in_over (expandx888 (vs4, 0), srca, vmask, expand8888 (vd4, 0)),
1365                 in_over (expandx888 (vs4, 1), srca, vmask, expand8888 (vd4, 1)));
1366
1367             vd5 = pack8888 (
1368                 in_over (expandx888 (vs5, 0), srca, vmask, expand8888 (vd5, 0)),
1369                 in_over (expandx888 (vs5, 1), srca, vmask, expand8888 (vd5, 1)));
1370
1371             vd6 = pack8888 (
1372                 in_over (expandx888 (vs6, 0), srca, vmask, expand8888 (vd6, 0)),
1373                 in_over (expandx888 (vs6, 1), srca, vmask, expand8888 (vd6, 1)));
1374
1375             vd7 = pack8888 (
1376                 in_over (expandx888 (vs7, 0), srca, vmask, expand8888 (vd7, 0)),
1377                 in_over (expandx888 (vs7, 1), srca, vmask, expand8888 (vd7, 1)));
1378
1379             *(__m64 *)(dst + 0) = vd0;
1380             *(__m64 *)(dst + 2) = vd1;
1381             *(__m64 *)(dst + 4) = vd2;
1382             *(__m64 *)(dst + 6) = vd3;
1383             *(__m64 *)(dst + 8) = vd4;
1384             *(__m64 *)(dst + 10) = vd5;
1385             *(__m64 *)(dst + 12) = vd6;
1386             *(__m64 *)(dst + 14) = vd7;
1387
1388             w -= 16;
1389             dst += 16;
1390             src += 16;
1391         }
1392
1393         while (w)
1394         {
1395             __m64 s = load8888 (*src | 0xff000000);
1396             __m64 d = load8888 (*dst);
1397
1398             *dst = store8888 (in_over (s, srca, vmask, d));
1399
1400             w--;
1401             dst++;
1402             src++;
1403         }
1404     }
1405
1406     _mm_empty();
1407 }
1408
1409 static void
1410 fbCompositeSrc_8888x8888mmx (pixman_implementation_t *imp,
1411                              pixman_op_t op,
1412                              pixman_image_t * pSrc,
1413                              pixman_image_t * pMask,
1414                              pixman_image_t * pDst,
1415                              int32_t    xSrc,
1416                              int32_t    ySrc,
1417                              int32_t      xMask,
1418                              int32_t      yMask,
1419                              int32_t      xDst,
1420                              int32_t      yDst,
1421                              int32_t     width,
1422                              int32_t     height)
1423 {
1424     uint32_t    *dstLine, *dst;
1425     uint32_t    *srcLine, *src;
1426     uint32_t    s;
1427     int dstStride, srcStride;
1428     uint8_t     a;
1429     uint16_t    w;
1430
1431     CHECKPOINT();
1432
1433     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
1434     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
1435
1436     while (height--)
1437     {
1438         dst = dstLine;
1439         dstLine += dstStride;
1440         src = srcLine;
1441         srcLine += srcStride;
1442         w = width;
1443
1444         while (w--)
1445         {
1446             s = *src++;
1447             a = s >> 24;
1448             if (a == 0xff)
1449                 *dst = s;
1450             else if (a) {
1451                 __m64 ms, sa;
1452                 ms = load8888(s);
1453                 sa = expand_alpha(ms);
1454                 *dst = store8888(over(ms, sa, load8888(*dst)));
1455             }
1456             dst++;
1457         }
1458     }
1459     _mm_empty();
1460 }
1461
1462 static void
1463 fbCompositeSrc_8888x0565mmx (pixman_implementation_t *imp,
1464                              pixman_op_t op,
1465                              pixman_image_t * pSrc,
1466                              pixman_image_t * pMask,
1467                              pixman_image_t * pDst,
1468                              int32_t      xSrc,
1469                              int32_t      ySrc,
1470                              int32_t      xMask,
1471                              int32_t      yMask,
1472                              int32_t      xDst,
1473                              int32_t      yDst,
1474                              int32_t     width,
1475                              int32_t     height)
1476 {
1477     uint16_t    *dstLine, *dst;
1478     uint32_t    *srcLine, *src;
1479     int dstStride, srcStride;
1480     uint16_t    w;
1481
1482     CHECKPOINT();
1483
1484     fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
1485     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
1486
1487 #if 0
1488     /* FIXME */
1489     assert (pSrc->pDrawable == pMask->pDrawable);
1490 #endif
1491
1492     while (height--)
1493     {
1494         dst = dstLine;
1495         dstLine += dstStride;
1496         src = srcLine;
1497         srcLine += srcStride;
1498         w = width;
1499
1500         CHECKPOINT();
1501
1502         while (w && (unsigned long)dst & 7)
1503         {
1504             __m64 vsrc = load8888 (*src);
1505             uint64_t d = *dst;
1506             __m64 vdest = expand565 (M64(d), 0);
1507
1508             vdest = pack565(over(vsrc, expand_alpha(vsrc), vdest), vdest, 0);
1509
1510             *dst = UINT64(vdest);
1511
1512             w--;
1513             dst++;
1514             src++;
1515         }
1516
1517         CHECKPOINT();
1518
1519         while (w >= 4)
1520         {
1521             __m64 vsrc0, vsrc1, vsrc2, vsrc3;
1522             __m64 vdest;
1523
1524             vsrc0 = load8888(*(src + 0));
1525             vsrc1 = load8888(*(src + 1));
1526             vsrc2 = load8888(*(src + 2));
1527             vsrc3 = load8888(*(src + 3));
1528
1529             vdest = *(__m64 *)dst;
1530
1531             vdest = pack565(over(vsrc0, expand_alpha(vsrc0), expand565(vdest, 0)), vdest, 0);
1532             vdest = pack565(over(vsrc1, expand_alpha(vsrc1), expand565(vdest, 1)), vdest, 1);
1533             vdest = pack565(over(vsrc2, expand_alpha(vsrc2), expand565(vdest, 2)), vdest, 2);
1534             vdest = pack565(over(vsrc3, expand_alpha(vsrc3), expand565(vdest, 3)), vdest, 3);
1535
1536             *(__m64 *)dst = vdest;
1537
1538             w -= 4;
1539             dst += 4;
1540             src += 4;
1541         }
1542
1543         CHECKPOINT();
1544
1545         while (w)
1546         {
1547             __m64 vsrc = load8888 (*src);
1548             uint64_t d = *dst;
1549             __m64 vdest = expand565 (M64(d), 0);
1550
1551             vdest = pack565(over(vsrc, expand_alpha(vsrc), vdest), vdest, 0);
1552
1553             *dst = UINT64(vdest);
1554
1555             w--;
1556             dst++;
1557             src++;
1558         }
1559     }
1560
1561     _mm_empty();
1562 }
1563
1564 static void
1565 fbCompositeSolidMask_nx8x8888mmx (pixman_implementation_t *imp,
1566                                   pixman_op_t op,
1567                                   pixman_image_t * pSrc,
1568                                   pixman_image_t * pMask,
1569                                   pixman_image_t * pDst,
1570                                   int32_t      xSrc,
1571                                   int32_t      ySrc,
1572                                   int32_t      xMask,
1573                                   int32_t      yMask,
1574                                   int32_t      xDst,
1575                                   int32_t      yDst,
1576                                   int32_t     width,
1577                                   int32_t     height)
1578 {
1579     uint32_t    src, srca;
1580     uint32_t    *dstLine, *dst;
1581     uint8_t     *maskLine, *mask;
1582     int dstStride, maskStride;
1583     uint16_t    w;
1584     __m64       vsrc, vsrca;
1585     uint64_t    srcsrc;
1586
1587     CHECKPOINT();
1588
1589     fbComposeGetSolid(pSrc, src, pDst->bits.format);
1590
1591     srca = src >> 24;
1592     if (srca == 0)
1593         return;
1594
1595     srcsrc = (uint64_t)src << 32 | src;
1596
1597     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
1598     fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
1599
1600     vsrc = load8888 (src);
1601     vsrca = expand_alpha (vsrc);
1602
1603     while (height--)
1604     {
1605         dst = dstLine;
1606         dstLine += dstStride;
1607         mask = maskLine;
1608         maskLine += maskStride;
1609         w = width;
1610
1611         CHECKPOINT();
1612
1613         while (w && (unsigned long)dst & 7)
1614         {
1615             uint64_t m = *mask;
1616
1617             if (m)
1618             {
1619                 __m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64(m)), load8888(*dst));
1620                 *dst = store8888(vdest);
1621             }
1622
1623             w--;
1624             mask++;
1625             dst++;
1626         }
1627
1628         CHECKPOINT();
1629
1630         while (w >= 2)
1631         {
1632             uint64_t m0, m1;
1633             m0 = *mask;
1634             m1 = *(mask + 1);
1635
1636             if (srca == 0xff && (m0 & m1) == 0xff)
1637             {
1638                 *(uint64_t *)dst = srcsrc;
1639             }
1640             else if (m0 | m1)
1641             {
1642                 __m64 vdest;
1643                 __m64 dest0, dest1;
1644
1645                 vdest = *(__m64 *)dst;
1646
1647                 dest0 = in_over(vsrc, vsrca, expand_alpha_rev (M64(m0)), expand8888(vdest, 0));
1648                 dest1 = in_over(vsrc, vsrca, expand_alpha_rev (M64(m1)), expand8888(vdest, 1));
1649
1650                 *(__m64 *)dst = pack8888(dest0, dest1);
1651             }
1652
1653             mask += 2;
1654             dst += 2;
1655             w -= 2;
1656         }
1657
1658         CHECKPOINT();
1659
1660         while (w)
1661         {
1662             uint64_t m = *mask;
1663
1664             if (m)
1665             {
1666                 __m64 vdest = load8888(*dst);
1667                 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64(m)), vdest);
1668                 *dst = store8888(vdest);
1669             }
1670
1671             w--;
1672             mask++;
1673             dst++;
1674         }
1675     }
1676
1677     _mm_empty();
1678 }
1679
1680 pixman_bool_t
1681 pixman_fill_mmx (uint32_t *bits,
1682                  int stride,
1683                  int bpp,
1684                  int x,
1685                  int y,
1686                  int width,
1687                  int height,
1688                  uint32_t xor)
1689 {
1690     uint64_t    fill;
1691     __m64       vfill;
1692     uint32_t    byte_width;
1693     uint8_t     *byte_line;
1694 #ifdef __GNUC__
1695     __m64       v1, v2, v3, v4, v5, v6, v7;
1696 #endif
1697
1698     if (bpp != 16 && bpp != 32 && bpp != 8)
1699         return FALSE;
1700
1701     if (bpp == 16 && (xor >> 16 != (xor & 0xffff)))
1702         return FALSE;
1703
1704     if (bpp == 8 &&
1705         ((xor >> 16 != (xor & 0xffff)) ||
1706          (xor >> 24 != (xor & 0x00ff) >> 16)))
1707     {
1708         return FALSE;
1709     }
1710
1711     if (bpp == 8)
1712     {
1713         stride = stride * (int) sizeof (uint32_t) / 1;
1714         byte_line = (uint8_t *)(((uint8_t *)bits) + stride * y + x);
1715         byte_width = width;
1716         stride *= 1;
1717     }
1718     else if (bpp == 16)
1719     {
1720         stride = stride * (int) sizeof (uint32_t) / 2;
1721         byte_line = (uint8_t *)(((uint16_t *)bits) + stride * y + x);
1722         byte_width = 2 * width;
1723         stride *= 2;
1724     }
1725     else
1726     {
1727         stride = stride * (int) sizeof (uint32_t) / 4;
1728         byte_line = (uint8_t *)(((uint32_t *)bits) + stride * y + x);
1729         byte_width = 4 * width;
1730         stride *= 4;
1731     }
1732
1733     fill = ((uint64_t)xor << 32) | xor;
1734     vfill = M64(fill);
1735
1736 #ifdef __GNUC__
1737     __asm__ (
1738         "movq           %7,     %0\n"
1739         "movq           %7,     %1\n"
1740         "movq           %7,     %2\n"
1741         "movq           %7,     %3\n"
1742         "movq           %7,     %4\n"
1743         "movq           %7,     %5\n"
1744         "movq           %7,     %6\n"
1745         : "=y" (v1), "=y" (v2), "=y" (v3),
1746           "=y" (v4), "=y" (v5), "=y" (v6), "=y" (v7)
1747         : "y" (vfill));
1748 #endif
1749
1750     while (height--)
1751     {
1752         int w;
1753         uint8_t *d = byte_line;
1754         byte_line += stride;
1755         w = byte_width;
1756
1757         while (w >= 1 && ((unsigned long)d & 1))
1758         {
1759             *(uint8_t *)d = (xor & 0xff);
1760             w--;
1761             d++;
1762         }
1763
1764         while (w >= 2 && ((unsigned long)d & 3))
1765         {
1766             *(uint16_t *)d = xor;
1767             w -= 2;
1768             d += 2;
1769         }
1770
1771         while (w >= 4 && ((unsigned long)d & 7))
1772         {
1773             *(uint32_t *)d = xor;
1774
1775             w -= 4;
1776             d += 4;
1777         }
1778
1779         while (w >= 64)
1780         {
1781 #ifdef __GNUC__
1782             __asm__ (
1783                 "movq   %1,       (%0)\n"
1784                 "movq   %2,      8(%0)\n"
1785                 "movq   %3,     16(%0)\n"
1786                 "movq   %4,     24(%0)\n"
1787                 "movq   %5,     32(%0)\n"
1788                 "movq   %6,     40(%0)\n"
1789                 "movq   %7,     48(%0)\n"
1790                 "movq   %8,     56(%0)\n"
1791                 :
1792                 : "r" (d),
1793                   "y" (vfill), "y" (v1), "y" (v2), "y" (v3),
1794                   "y" (v4), "y" (v5), "y" (v6), "y" (v7)
1795                 : "memory");
1796 #else
1797             *(__m64*) (d +  0) = vfill;
1798             *(__m64*) (d +  8) = vfill;
1799             *(__m64*) (d + 16) = vfill;
1800             *(__m64*) (d + 24) = vfill;
1801             *(__m64*) (d + 32) = vfill;
1802             *(__m64*) (d + 40) = vfill;
1803             *(__m64*) (d + 48) = vfill;
1804             *(__m64*) (d + 56) = vfill;
1805 #endif
1806             w -= 64;
1807             d += 64;
1808         }
1809
1810         while (w >= 4)
1811         {
1812             *(uint32_t *)d = xor;
1813
1814             w -= 4;
1815             d += 4;
1816         }
1817         while (w >= 2)
1818         {
1819             *(uint16_t *)d = xor;
1820             w -= 2;
1821             d += 2;
1822         }
1823         while (w >= 1)
1824         {
1825             *(uint8_t *)d = (xor & 0xff);
1826             w--;
1827             d++;
1828         }
1829
1830     }
1831
1832     _mm_empty();
1833     return TRUE;
1834 }
1835
1836 static void
1837 fbCompositeSolidMaskSrc_nx8x8888mmx (pixman_implementation_t *imp,
1838                                      pixman_op_t op,
1839                                      pixman_image_t * pSrc,
1840                                      pixman_image_t * pMask,
1841                                      pixman_image_t * pDst,
1842                                      int32_t      xSrc,
1843                                      int32_t      ySrc,
1844                                      int32_t      xMask,
1845                                      int32_t      yMask,
1846                                      int32_t      xDst,
1847                                      int32_t      yDst,
1848                                      int32_t     width,
1849                                      int32_t     height)
1850 {
1851     uint32_t    src, srca;
1852     uint32_t    *dstLine, *dst;
1853     uint8_t     *maskLine, *mask;
1854     int dstStride, maskStride;
1855     uint16_t    w;
1856     __m64       vsrc, vsrca;
1857     uint64_t    srcsrc;
1858
1859     CHECKPOINT();
1860
1861     fbComposeGetSolid(pSrc, src, pDst->bits.format);
1862
1863     srca = src >> 24;
1864     if (srca == 0)
1865     {
1866         pixman_fill_mmx (pDst->bits.bits, pDst->bits.rowstride, PIXMAN_FORMAT_BPP (pDst->bits.format),
1867                          xDst, yDst, width, height, 0);
1868         return;
1869     }
1870
1871     srcsrc = (uint64_t)src << 32 | src;
1872
1873     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
1874     fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
1875
1876     vsrc = load8888 (src);
1877     vsrca = expand_alpha (vsrc);
1878
1879     while (height--)
1880     {
1881         dst = dstLine;
1882         dstLine += dstStride;
1883         mask = maskLine;
1884         maskLine += maskStride;
1885         w = width;
1886
1887         CHECKPOINT();
1888
1889         while (w && (unsigned long)dst & 7)
1890         {
1891             uint64_t m = *mask;
1892
1893             if (m)
1894             {
1895                 __m64 vdest = in(vsrc, expand_alpha_rev (M64(m)));
1896                 *dst = store8888(vdest);
1897             }
1898             else
1899             {
1900                 *dst = 0;
1901             }
1902
1903             w--;
1904             mask++;
1905             dst++;
1906         }
1907
1908         CHECKPOINT();
1909
1910         while (w >= 2)
1911         {
1912             uint64_t m0, m1;
1913             m0 = *mask;
1914             m1 = *(mask + 1);
1915
1916             if (srca == 0xff && (m0 & m1) == 0xff)
1917             {
1918                 *(uint64_t *)dst = srcsrc;
1919             }
1920             else if (m0 | m1)
1921             {
1922                 __m64 vdest;
1923                 __m64 dest0, dest1;
1924
1925                 vdest = *(__m64 *)dst;
1926
1927                 dest0 = in(vsrc, expand_alpha_rev (M64(m0)));
1928                 dest1 = in(vsrc, expand_alpha_rev (M64(m1)));
1929
1930                 *(__m64 *)dst = pack8888(dest0, dest1);
1931             }
1932             else
1933             {
1934                 *(uint64_t *)dst = 0;
1935             }
1936
1937             mask += 2;
1938             dst += 2;
1939             w -= 2;
1940         }
1941
1942         CHECKPOINT();
1943
1944         while (w)
1945         {
1946             uint64_t m = *mask;
1947
1948             if (m)
1949             {
1950                 __m64 vdest = load8888(*dst);
1951                 vdest = in(vsrc, expand_alpha_rev (M64(m)));
1952                 *dst = store8888(vdest);
1953             }
1954             else
1955             {
1956                 *dst = 0;
1957             }
1958
1959             w--;
1960             mask++;
1961             dst++;
1962         }
1963     }
1964
1965     _mm_empty();
1966 }
1967
1968 static void
1969 fbCompositeSolidMask_nx8x0565mmx (pixman_implementation_t *imp,
1970                                   pixman_op_t op,
1971                                   pixman_image_t * pSrc,
1972                                   pixman_image_t * pMask,
1973                                   pixman_image_t * pDst,
1974                                   int32_t      xSrc,
1975                                   int32_t      ySrc,
1976                                   int32_t      xMask,
1977                                   int32_t      yMask,
1978                                   int32_t      xDst,
1979                                   int32_t      yDst,
1980                                   int32_t     width,
1981                                   int32_t     height)
1982 {
1983     uint32_t    src, srca;
1984     uint16_t    *dstLine, *dst;
1985     uint8_t     *maskLine, *mask;
1986     int dstStride, maskStride;
1987     uint16_t    w;
1988     __m64       vsrc, vsrca, tmp;
1989     uint64_t srcsrcsrcsrc, src16;
1990
1991     CHECKPOINT();
1992
1993     fbComposeGetSolid(pSrc, src, pDst->bits.format);
1994
1995     srca = src >> 24;
1996     if (srca == 0)
1997         return;
1998
1999     fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
2000     fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
2001
2002     vsrc = load8888 (src);
2003     vsrca = expand_alpha (vsrc);
2004
2005     tmp = pack565(vsrc, _mm_setzero_si64(), 0);
2006     src16 = UINT64(tmp);
2007
2008     srcsrcsrcsrc = (uint64_t)src16 << 48 | (uint64_t)src16 << 32 |
2009         (uint64_t)src16 << 16 | (uint64_t)src16;
2010
2011     while (height--)
2012     {
2013         dst = dstLine;
2014         dstLine += dstStride;
2015         mask = maskLine;
2016         maskLine += maskStride;
2017         w = width;
2018
2019         CHECKPOINT();
2020
2021         while (w && (unsigned long)dst & 7)
2022         {
2023             uint64_t m = *mask;
2024
2025             if (m)
2026             {
2027                 uint64_t d = *dst;
2028                 __m64 vd = M64(d);
2029                 __m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64 (m)), expand565(vd, 0));
2030                 vd = pack565(vdest, _mm_setzero_si64(), 0);
2031                 *dst = UINT64(vd);
2032             }
2033
2034             w--;
2035             mask++;
2036             dst++;
2037         }
2038
2039         CHECKPOINT();
2040
2041         while (w >= 4)
2042         {
2043             uint64_t m0, m1, m2, m3;
2044             m0 = *mask;
2045             m1 = *(mask + 1);
2046             m2 = *(mask + 2);
2047             m3 = *(mask + 3);
2048
2049             if (srca == 0xff && (m0 & m1 & m2 & m3) == 0xff)
2050             {
2051                 *(uint64_t *)dst = srcsrcsrcsrc;
2052             }
2053             else if (m0 | m1 | m2 | m3)
2054             {
2055                 __m64 vdest;
2056                 __m64 vm0, vm1, vm2, vm3;
2057
2058                 vdest = *(__m64 *)dst;
2059
2060                 vm0 = M64(m0);
2061                 vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm0), expand565(vdest, 0)), vdest, 0);
2062                 vm1 = M64(m1);
2063                 vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm1), expand565(vdest, 1)), vdest, 1);
2064                 vm2 = M64(m2);
2065                 vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm2), expand565(vdest, 2)), vdest, 2);
2066                 vm3 = M64(m3);
2067                 vdest = pack565(in_over(vsrc, vsrca, expand_alpha_rev(vm3), expand565(vdest, 3)), vdest, 3);
2068
2069                 *(__m64 *)dst = vdest;
2070             }
2071
2072             w -= 4;
2073             mask += 4;
2074             dst += 4;
2075         }
2076
2077         CHECKPOINT();
2078
2079         while (w)
2080         {
2081             uint64_t m = *mask;
2082
2083             if (m)
2084             {
2085                 uint64_t d = *dst;
2086                 __m64 vd = M64(d);
2087                 __m64 vdest = in_over(vsrc, vsrca, expand_alpha_rev (M64(m)), expand565(vd, 0));
2088                 vd = pack565(vdest, _mm_setzero_si64(), 0);
2089                 *dst = UINT64(vd);
2090             }
2091
2092             w--;
2093             mask++;
2094             dst++;
2095         }
2096     }
2097
2098     _mm_empty();
2099 }
2100
2101 static void
2102 fbCompositeSrc_8888RevNPx0565mmx (pixman_implementation_t *imp,
2103                                   pixman_op_t op,
2104                                   pixman_image_t * pSrc,
2105                                   pixman_image_t * pMask,
2106                                   pixman_image_t * pDst,
2107                                   int32_t      xSrc,
2108                                   int32_t      ySrc,
2109                                   int32_t      xMask,
2110                                   int32_t      yMask,
2111                                   int32_t      xDst,
2112                                   int32_t      yDst,
2113                                   int32_t     width,
2114                                   int32_t     height)
2115 {
2116     uint16_t    *dstLine, *dst;
2117     uint32_t    *srcLine, *src;
2118     int dstStride, srcStride;
2119     uint16_t    w;
2120
2121     CHECKPOINT();
2122
2123     fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
2124     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
2125
2126 #if 0
2127     /* FIXME */
2128     assert (pSrc->pDrawable == pMask->pDrawable);
2129 #endif
2130
2131     while (height--)
2132     {
2133         dst = dstLine;
2134         dstLine += dstStride;
2135         src = srcLine;
2136         srcLine += srcStride;
2137         w = width;
2138
2139         CHECKPOINT();
2140
2141         while (w && (unsigned long)dst & 7)
2142         {
2143             __m64 vsrc = load8888 (*src);
2144             uint64_t d = *dst;
2145             __m64 vdest = expand565 (M64(d), 0);
2146
2147             vdest = pack565(over_rev_non_pre(vsrc, vdest), vdest, 0);
2148
2149             *dst = UINT64(vdest);
2150
2151             w--;
2152             dst++;
2153             src++;
2154         }
2155
2156         CHECKPOINT();
2157
2158         while (w >= 4)
2159         {
2160             uint32_t s0, s1, s2, s3;
2161             unsigned char a0, a1, a2, a3;
2162
2163             s0 = *src;
2164             s1 = *(src + 1);
2165             s2 = *(src + 2);
2166             s3 = *(src + 3);
2167
2168             a0 = (s0 >> 24);
2169             a1 = (s1 >> 24);
2170             a2 = (s2 >> 24);
2171             a3 = (s3 >> 24);
2172
2173             if ((a0 & a1 & a2 & a3) == 0xFF)
2174             {
2175                 __m64 vdest;
2176                 vdest = pack565(invert_colors(load8888(s0)), _mm_setzero_si64(), 0);
2177                 vdest = pack565(invert_colors(load8888(s1)), vdest, 1);
2178                 vdest = pack565(invert_colors(load8888(s2)), vdest, 2);
2179                 vdest = pack565(invert_colors(load8888(s3)), vdest, 3);
2180
2181                 *(__m64 *)dst = vdest;
2182             }
2183             else if (a0 | a1 | a2 | a3)
2184             {
2185                 __m64 vdest = *(__m64 *)dst;
2186
2187                 vdest = pack565(over_rev_non_pre(load8888(s0), expand565(vdest, 0)), vdest, 0);
2188                 vdest = pack565(over_rev_non_pre(load8888(s1), expand565(vdest, 1)), vdest, 1);
2189                 vdest = pack565(over_rev_non_pre(load8888(s2), expand565(vdest, 2)), vdest, 2);
2190                 vdest = pack565(over_rev_non_pre(load8888(s3), expand565(vdest, 3)), vdest, 3);
2191
2192                 *(__m64 *)dst = vdest;
2193             }
2194
2195             w -= 4;
2196             dst += 4;
2197             src += 4;
2198         }
2199
2200         CHECKPOINT();
2201
2202         while (w)
2203         {
2204             __m64 vsrc = load8888 (*src);
2205             uint64_t d = *dst;
2206             __m64 vdest = expand565 (M64(d), 0);
2207
2208             vdest = pack565(over_rev_non_pre(vsrc, vdest), vdest, 0);
2209
2210             *dst = UINT64(vdest);
2211
2212             w--;
2213             dst++;
2214             src++;
2215         }
2216     }
2217
2218     _mm_empty();
2219 }
2220
2221 /* "8888RevNP" is GdkPixbuf's format: ABGR, non premultiplied */
2222
2223 static void
2224 fbCompositeSrc_8888RevNPx8888mmx (pixman_implementation_t *imp,
2225                                   pixman_op_t op,
2226                                   pixman_image_t * pSrc,
2227                                   pixman_image_t * pMask,
2228                                   pixman_image_t * pDst,
2229                                   int32_t      xSrc,
2230                                   int32_t      ySrc,
2231                                   int32_t      xMask,
2232                                   int32_t      yMask,
2233                                   int32_t      xDst,
2234                                   int32_t      yDst,
2235                                   int32_t     width,
2236                                   int32_t     height)
2237 {
2238     uint32_t    *dstLine, *dst;
2239     uint32_t    *srcLine, *src;
2240     int dstStride, srcStride;
2241     uint16_t    w;
2242
2243     CHECKPOINT();
2244
2245     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
2246     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
2247
2248 #if 0
2249     /* FIXME */
2250     assert (pSrc->pDrawable == pMask->pDrawable);
2251 #endif
2252
2253     while (height--)
2254     {
2255         dst = dstLine;
2256         dstLine += dstStride;
2257         src = srcLine;
2258         srcLine += srcStride;
2259         w = width;
2260
2261         while (w && (unsigned long)dst & 7)
2262         {
2263             __m64 s = load8888 (*src);
2264             __m64 d = load8888 (*dst);
2265
2266             *dst = store8888 (over_rev_non_pre (s, d));
2267
2268             w--;
2269             dst++;
2270             src++;
2271         }
2272
2273         while (w >= 2)
2274         {
2275             uint64_t s0, s1;
2276             unsigned char a0, a1;
2277             __m64 d0, d1;
2278
2279             s0 = *src;
2280             s1 = *(src + 1);
2281
2282             a0 = (s0 >> 24);
2283             a1 = (s1 >> 24);
2284
2285             if ((a0 & a1) == 0xFF)
2286             {
2287                 d0 = invert_colors(load8888(s0));
2288                 d1 = invert_colors(load8888(s1));
2289
2290                 *(__m64 *)dst = pack8888 (d0, d1);
2291             }
2292             else if (a0 | a1)
2293             {
2294                 __m64 vdest = *(__m64 *)dst;
2295
2296                 d0 = over_rev_non_pre (load8888(s0), expand8888 (vdest, 0));
2297                 d1 = over_rev_non_pre (load8888(s1), expand8888 (vdest, 1));
2298
2299                 *(__m64 *)dst = pack8888 (d0, d1);
2300             }
2301
2302             w -= 2;
2303             dst += 2;
2304             src += 2;
2305         }
2306
2307         while (w)
2308         {
2309             __m64 s = load8888 (*src);
2310             __m64 d = load8888 (*dst);
2311
2312             *dst = store8888 (over_rev_non_pre (s, d));
2313
2314             w--;
2315             dst++;
2316             src++;
2317         }
2318     }
2319
2320     _mm_empty();
2321 }
2322
2323 static void
2324 fbCompositeSolidMask_nx8888x0565Cmmx (pixman_implementation_t *imp,
2325                                       pixman_op_t op,
2326                                       pixman_image_t * pSrc,
2327                                       pixman_image_t * pMask,
2328                                       pixman_image_t * pDst,
2329                                       int32_t      xSrc,
2330                                       int32_t      ySrc,
2331                                       int32_t      xMask,
2332                                       int32_t      yMask,
2333                                       int32_t      xDst,
2334                                       int32_t      yDst,
2335                                       int32_t     width,
2336                                       int32_t     height)
2337 {
2338     uint32_t    src, srca;
2339     uint16_t    *dstLine;
2340     uint32_t    *maskLine;
2341     int dstStride, maskStride;
2342     __m64  vsrc, vsrca;
2343
2344     CHECKPOINT();
2345
2346     fbComposeGetSolid(pSrc, src, pDst->bits.format);
2347
2348     srca = src >> 24;
2349     if (srca == 0)
2350         return;
2351
2352     fbComposeGetStart (pDst, xDst, yDst, uint16_t, dstStride, dstLine, 1);
2353     fbComposeGetStart (pMask, xMask, yMask, uint32_t, maskStride, maskLine, 1);
2354
2355     vsrc = load8888 (src);
2356     vsrca = expand_alpha (vsrc);
2357
2358     while (height--)
2359     {
2360         int twidth = width;
2361         uint32_t *p = (uint32_t *)maskLine;
2362         uint16_t *q = (uint16_t *)dstLine;
2363
2364         while (twidth && ((unsigned long)q & 7))
2365         {
2366             uint32_t m = *(uint32_t *)p;
2367
2368             if (m)
2369             {
2370                 uint64_t d = *q;
2371                 __m64 vdest = expand565 (M64(d), 0);
2372                 vdest = pack565 (in_over (vsrc, vsrca, load8888 (m), vdest), vdest, 0);
2373                 *q = UINT64(vdest);
2374             }
2375
2376             twidth--;
2377             p++;
2378             q++;
2379         }
2380
2381         while (twidth >= 4)
2382         {
2383             uint32_t m0, m1, m2, m3;
2384
2385             m0 = *p;
2386             m1 = *(p + 1);
2387             m2 = *(p + 2);
2388             m3 = *(p + 3);
2389
2390             if ((m0 | m1 | m2 | m3))
2391             {
2392                 __m64 vdest = *(__m64 *)q;
2393
2394                 vdest = pack565(in_over(vsrc, vsrca, load8888(m0), expand565(vdest, 0)), vdest, 0);
2395                 vdest = pack565(in_over(vsrc, vsrca, load8888(m1), expand565(vdest, 1)), vdest, 1);
2396                 vdest = pack565(in_over(vsrc, vsrca, load8888(m2), expand565(vdest, 2)), vdest, 2);
2397                 vdest = pack565(in_over(vsrc, vsrca, load8888(m3), expand565(vdest, 3)), vdest, 3);
2398
2399                 *(__m64 *)q = vdest;
2400             }
2401             twidth -= 4;
2402             p += 4;
2403             q += 4;
2404         }
2405
2406         while (twidth)
2407         {
2408             uint32_t m;
2409
2410             m = *(uint32_t *)p;
2411             if (m)
2412             {
2413                 uint64_t d = *q;
2414                 __m64 vdest = expand565(M64(d), 0);
2415                 vdest = pack565 (in_over(vsrc, vsrca, load8888(m), vdest), vdest, 0);
2416                 *q = UINT64(vdest);
2417             }
2418
2419             twidth--;
2420             p++;
2421             q++;
2422         }
2423
2424         maskLine += maskStride;
2425         dstLine += dstStride;
2426     }
2427
2428     _mm_empty ();
2429 }
2430
2431 static void
2432 fbCompositeIn_nx8x8mmx (pixman_implementation_t *imp,
2433                         pixman_op_t op,
2434                         pixman_image_t * pSrc,
2435                         pixman_image_t * pMask,
2436                         pixman_image_t * pDst,
2437                         int32_t      xSrc,
2438                         int32_t      ySrc,
2439                         int32_t      xMask,
2440                         int32_t      yMask,
2441                         int32_t      xDst,
2442                         int32_t      yDst,
2443                         int32_t     width,
2444                         int32_t     height)
2445 {
2446     uint8_t     *dstLine, *dst;
2447     uint8_t     *maskLine, *mask;
2448     int dstStride, maskStride;
2449     uint16_t    w;
2450     uint32_t    src;
2451     uint8_t     sa;
2452     __m64       vsrc, vsrca;
2453
2454     fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
2455     fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
2456
2457     fbComposeGetSolid(pSrc, src, pDst->bits.format);
2458
2459     sa = src >> 24;
2460     if (sa == 0)
2461         return;
2462
2463     vsrc = load8888(src);
2464     vsrca = expand_alpha(vsrc);
2465
2466     while (height--)
2467     {
2468         dst = dstLine;
2469         dstLine += dstStride;
2470         mask = maskLine;
2471         maskLine += maskStride;
2472         w = width;
2473
2474         if ((((unsigned long)pDst & 3) == 0) &&
2475             (((unsigned long)pSrc & 3) == 0))
2476         {
2477             while (w >= 4)
2478             {
2479                 uint32_t m;
2480                 __m64 vmask;
2481                 __m64 vdest;
2482
2483                 m = 0;
2484
2485                 vmask = load8888 (*(uint32_t *)mask);
2486                 vdest = load8888 (*(uint32_t *)dst);
2487
2488                 *(uint32_t *)dst = store8888 (in (in (vsrca, vmask), vdest));
2489
2490                 dst += 4;
2491                 mask += 4;
2492                 w -= 4;
2493             }
2494         }
2495
2496         while (w--)
2497         {
2498             uint16_t    tmp;
2499             uint8_t     a;
2500             uint32_t    m, d;
2501             uint32_t    r;
2502
2503             a = *mask++;
2504             d = *dst;
2505
2506             m = FbInU (sa, 0, a, tmp);
2507             r = FbInU (m, 0, d, tmp);
2508
2509             *dst++ = r;
2510         }
2511     }
2512
2513     _mm_empty();
2514 }
2515
2516 static void
2517 fbCompositeIn_8x8mmx (pixman_implementation_t *imp,
2518                       pixman_op_t op,
2519                       pixman_image_t * pSrc,
2520                       pixman_image_t * pMask,
2521                       pixman_image_t * pDst,
2522                       int32_t      xSrc,
2523                       int32_t      ySrc,
2524                       int32_t      xMask,
2525                       int32_t      yMask,
2526                       int32_t      xDst,
2527                       int32_t      yDst,
2528                       int32_t     width,
2529                       int32_t     height)
2530 {
2531     uint8_t     *dstLine, *dst;
2532     uint8_t     *srcLine, *src;
2533     int srcStride, dstStride;
2534     uint16_t    w;
2535
2536     fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
2537     fbComposeGetStart (pSrc, xSrc, ySrc, uint8_t, srcStride, srcLine, 1);
2538
2539     while (height--)
2540     {
2541         dst = dstLine;
2542         dstLine += dstStride;
2543         src = srcLine;
2544         srcLine += srcStride;
2545         w = width;
2546
2547         if ((((unsigned long)pDst & 3) == 0) &&
2548             (((unsigned long)pSrc & 3) == 0))
2549         {
2550             while (w >= 4)
2551             {
2552                 uint32_t *s = (uint32_t *)src;
2553                 uint32_t *d = (uint32_t *)dst;
2554
2555                 *d = store8888 (in (load8888 (*s), load8888 (*d)));
2556
2557                 w -= 4;
2558                 dst += 4;
2559                 src += 4;
2560             }
2561         }
2562
2563         while (w--)
2564         {
2565             uint8_t s, d;
2566             uint16_t tmp;
2567
2568             s = *src;
2569             d = *dst;
2570
2571             *dst = FbInU (s, 0, d, tmp);
2572
2573             src++;
2574             dst++;
2575         }
2576     }
2577
2578     _mm_empty ();
2579 }
2580
2581 static void
2582 fbCompositeSrcAdd_8888x8x8mmx (pixman_implementation_t *imp,
2583                                pixman_op_t op,
2584                                pixman_image_t * pSrc,
2585                                pixman_image_t * pMask,
2586                                pixman_image_t * pDst,
2587                                int32_t      xSrc,
2588                                int32_t      ySrc,
2589                                int32_t      xMask,
2590                                int32_t      yMask,
2591                                int32_t      xDst,
2592                                int32_t      yDst,
2593                                int32_t     width,
2594                                int32_t     height)
2595 {
2596     uint8_t     *dstLine, *dst;
2597     uint8_t     *maskLine, *mask;
2598     int dstStride, maskStride;
2599     uint16_t    w;
2600     uint32_t    src;
2601     uint8_t     sa;
2602     __m64       vsrc, vsrca;
2603
2604     fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
2605     fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
2606
2607     fbComposeGetSolid(pSrc, src, pDst->bits.format);
2608
2609     sa = src >> 24;
2610     if (sa == 0)
2611         return;
2612
2613     vsrc = load8888(src);
2614     vsrca = expand_alpha(vsrc);
2615
2616     while (height--)
2617     {
2618         dst = dstLine;
2619         dstLine += dstStride;
2620         mask = maskLine;
2621         maskLine += maskStride;
2622         w = width;
2623
2624         if ((((unsigned long)pMask & 3) == 0) &&
2625             (((unsigned long)pDst  & 3) == 0))
2626         {
2627             while (w >= 4)
2628             {
2629                 __m64 vmask = load8888 (*(uint32_t *)mask);
2630                 __m64 vdest = load8888 (*(uint32_t *)dst);
2631
2632                 *(uint32_t *)dst = store8888 (_mm_adds_pu8 (in (vsrca, vmask), vdest));
2633
2634                 w -= 4;
2635                 dst += 4;
2636                 mask += 4;
2637             }
2638         }
2639
2640         while (w--)
2641         {
2642             uint16_t    tmp;
2643             uint16_t    a;
2644             uint32_t    m, d;
2645             uint32_t    r;
2646
2647             a = *mask++;
2648             d = *dst;
2649
2650             m = FbInU (sa, 0, a, tmp);
2651             r = FbAdd (m, d, 0, tmp);
2652
2653             *dst++ = r;
2654         }
2655     }
2656
2657     _mm_empty();
2658 }
2659
2660 static void
2661 fbCompositeSrcAdd_8000x8000mmx (pixman_implementation_t *imp,
2662                                 pixman_op_t op,
2663                                 pixman_image_t * pSrc,
2664                                 pixman_image_t * pMask,
2665                                 pixman_image_t * pDst,
2666                                 int32_t      xSrc,
2667                                 int32_t      ySrc,
2668                                 int32_t      xMask,
2669                                 int32_t      yMask,
2670                                 int32_t      xDst,
2671                                 int32_t      yDst,
2672                                 int32_t     width,
2673                                 int32_t     height)
2674 {
2675     uint8_t     *dstLine, *dst;
2676     uint8_t     *srcLine, *src;
2677     int dstStride, srcStride;
2678     uint16_t    w;
2679     uint8_t     s, d;
2680     uint16_t    t;
2681
2682     CHECKPOINT();
2683
2684     fbComposeGetStart (pSrc, xSrc, ySrc, uint8_t, srcStride, srcLine, 1);
2685     fbComposeGetStart (pDst, xDst, yDst, uint8_t, dstStride, dstLine, 1);
2686
2687     while (height--)
2688     {
2689         dst = dstLine;
2690         dstLine += dstStride;
2691         src = srcLine;
2692         srcLine += srcStride;
2693         w = width;
2694
2695         while (w && (unsigned long)dst & 7)
2696         {
2697             s = *src;
2698             d = *dst;
2699             t = d + s;
2700             s = t | (0 - (t >> 8));
2701             *dst = s;
2702
2703             dst++;
2704             src++;
2705             w--;
2706         }
2707
2708         while (w >= 8)
2709         {
2710             *(__m64*)dst = _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
2711             dst += 8;
2712             src += 8;
2713             w -= 8;
2714         }
2715
2716         while (w)
2717         {
2718             s = *src;
2719             d = *dst;
2720             t = d + s;
2721             s = t | (0 - (t >> 8));
2722             *dst = s;
2723
2724             dst++;
2725             src++;
2726             w--;
2727         }
2728     }
2729
2730     _mm_empty();
2731 }
2732
2733 static void
2734 fbCompositeSrcAdd_8888x8888mmx (pixman_implementation_t *imp,
2735                                 pixman_op_t     op,
2736                                 pixman_image_t *        pSrc,
2737                                 pixman_image_t *        pMask,
2738                                 pixman_image_t *         pDst,
2739                                 int32_t          xSrc,
2740                                 int32_t      ySrc,
2741                                 int32_t      xMask,
2742                                 int32_t      yMask,
2743                                 int32_t      xDst,
2744                                 int32_t      yDst,
2745                                 int32_t     width,
2746                                 int32_t     height)
2747 {
2748     __m64 dst64;
2749     uint32_t    *dstLine, *dst;
2750     uint32_t    *srcLine, *src;
2751     int dstStride, srcStride;
2752     uint16_t    w;
2753
2754     CHECKPOINT();
2755
2756     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
2757     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
2758
2759     while (height--)
2760     {
2761         dst = dstLine;
2762         dstLine += dstStride;
2763         src = srcLine;
2764         srcLine += srcStride;
2765         w = width;
2766
2767         while (w && (unsigned long)dst & 7)
2768         {
2769             *dst = _mm_cvtsi64_si32(_mm_adds_pu8(_mm_cvtsi32_si64(*src),
2770                                                  _mm_cvtsi32_si64(*dst)));
2771             dst++;
2772             src++;
2773             w--;
2774         }
2775
2776         while (w >= 2)
2777         {
2778             dst64 = _mm_adds_pu8(*(__m64*)src, *(__m64*)dst);
2779             *(uint64_t*)dst = UINT64(dst64);
2780             dst += 2;
2781             src += 2;
2782             w -= 2;
2783         }
2784
2785         if (w)
2786         {
2787             *dst = _mm_cvtsi64_si32(_mm_adds_pu8(_mm_cvtsi32_si64(*src),
2788                                                  _mm_cvtsi32_si64(*dst)));
2789
2790         }
2791     }
2792
2793     _mm_empty();
2794 }
2795
2796 static pixman_bool_t
2797 pixman_blt_mmx (uint32_t *src_bits,
2798                 uint32_t *dst_bits,
2799                 int src_stride,
2800                 int dst_stride,
2801                 int src_bpp,
2802                 int dst_bpp,
2803                 int src_x, int src_y,
2804                 int dst_x, int dst_y,
2805                 int width, int height)
2806 {
2807     uint8_t *   src_bytes;
2808     uint8_t *   dst_bytes;
2809     int         byte_width;
2810
2811     if (src_bpp != dst_bpp)
2812         return FALSE;
2813
2814     if (src_bpp == 16)
2815     {
2816         src_stride = src_stride * (int) sizeof (uint32_t) / 2;
2817         dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
2818         src_bytes = (uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
2819         dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
2820         byte_width = 2 * width;
2821         src_stride *= 2;
2822         dst_stride *= 2;
2823     } else if (src_bpp == 32) {
2824         src_stride = src_stride * (int) sizeof (uint32_t) / 4;
2825         dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
2826         src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
2827         dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dst_y) + (dst_x));
2828         byte_width = 4 * width;
2829         src_stride *= 4;
2830         dst_stride *= 4;
2831     } else {
2832         return FALSE;
2833     }
2834
2835     while (height--)
2836     {
2837         int w;
2838         uint8_t *s = src_bytes;
2839         uint8_t *d = dst_bytes;
2840         src_bytes += src_stride;
2841         dst_bytes += dst_stride;
2842         w = byte_width;
2843
2844         while (w >= 2 && ((unsigned long)d & 3))
2845         {
2846             *(uint16_t *)d = *(uint16_t *)s;
2847             w -= 2;
2848             s += 2;
2849             d += 2;
2850         }
2851
2852         while (w >= 4 && ((unsigned long)d & 7))
2853         {
2854             *(uint32_t *)d = *(uint32_t *)s;
2855
2856             w -= 4;
2857             s += 4;
2858             d += 4;
2859         }
2860
2861         while (w >= 64)
2862         {
2863 #if defined (__GNUC__) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))
2864             __asm__ (
2865                 "movq     (%1),   %%mm0\n"
2866                 "movq    8(%1),   %%mm1\n"
2867                 "movq   16(%1),   %%mm2\n"
2868                 "movq   24(%1),   %%mm3\n"
2869                 "movq   32(%1),   %%mm4\n"
2870                 "movq   40(%1),   %%mm5\n"
2871                 "movq   48(%1),   %%mm6\n"
2872                 "movq   56(%1),   %%mm7\n"
2873
2874                 "movq   %%mm0,    (%0)\n"
2875                 "movq   %%mm1,   8(%0)\n"
2876                 "movq   %%mm2,  16(%0)\n"
2877                 "movq   %%mm3,  24(%0)\n"
2878                 "movq   %%mm4,  32(%0)\n"
2879                 "movq   %%mm5,  40(%0)\n"
2880                 "movq   %%mm6,  48(%0)\n"
2881                 "movq   %%mm7,  56(%0)\n"
2882                 :
2883                 : "r" (d), "r" (s)
2884                 : "memory",
2885                   "%mm0", "%mm1", "%mm2", "%mm3",
2886                   "%mm4", "%mm5", "%mm6", "%mm7");
2887 #else
2888             __m64 v0 = *(__m64 *)(s + 0);
2889             __m64 v1 = *(__m64 *)(s + 8);
2890             __m64 v2 = *(__m64 *)(s + 16);
2891             __m64 v3 = *(__m64 *)(s + 24);
2892             __m64 v4 = *(__m64 *)(s + 32);
2893             __m64 v5 = *(__m64 *)(s + 40);
2894             __m64 v6 = *(__m64 *)(s + 48);
2895             __m64 v7 = *(__m64 *)(s + 56);
2896             *(__m64 *)(d + 0)  = v0;
2897             *(__m64 *)(d + 8)  = v1;
2898             *(__m64 *)(d + 16) = v2;
2899             *(__m64 *)(d + 24) = v3;
2900             *(__m64 *)(d + 32) = v4;
2901             *(__m64 *)(d + 40) = v5;
2902             *(__m64 *)(d + 48) = v6;
2903             *(__m64 *)(d + 56) = v7;
2904 #endif
2905
2906             w -= 64;
2907             s += 64;
2908             d += 64;
2909         }
2910         while (w >= 4)
2911         {
2912             *(uint32_t *)d = *(uint32_t *)s;
2913
2914             w -= 4;
2915             s += 4;
2916             d += 4;
2917         }
2918         if (w >= 2)
2919         {
2920             *(uint16_t *)d = *(uint16_t *)s;
2921             w -= 2;
2922             s += 2;
2923             d += 2;
2924         }
2925     }
2926
2927     _mm_empty();
2928
2929     return TRUE;
2930 }
2931
2932 static void
2933 fbCompositeCopyAreammx (pixman_implementation_t *imp,
2934                         pixman_op_t       op,
2935                         pixman_image_t *        pSrc,
2936                         pixman_image_t *        pMask,
2937                         pixman_image_t *        pDst,
2938                         int32_t         xSrc,
2939                         int32_t         ySrc,
2940                         int32_t         xMask,
2941                         int32_t         yMask,
2942                         int32_t         xDst,
2943                         int32_t         yDst,
2944                         int32_t         width,
2945                         int32_t         height)
2946 {
2947     pixman_blt_mmx (pSrc->bits.bits,
2948                     pDst->bits.bits,
2949                     pSrc->bits.rowstride,
2950                     pDst->bits.rowstride,
2951                     PIXMAN_FORMAT_BPP (pSrc->bits.format),
2952                     PIXMAN_FORMAT_BPP (pDst->bits.format),
2953                     xSrc, ySrc, xDst, yDst, width, height);
2954 }
2955
2956 static void
2957 fbCompositeOver_x888x8x8888mmx (pixman_implementation_t *imp,
2958                                 pixman_op_t      op,
2959                                 pixman_image_t * pSrc,
2960                                 pixman_image_t * pMask,
2961                                 pixman_image_t * pDst,
2962                                 int32_t      xSrc,
2963                                 int32_t      ySrc,
2964                                 int32_t      xMask,
2965                                 int32_t      yMask,
2966                                 int32_t      xDst,
2967                                 int32_t      yDst,
2968                                 int32_t     width,
2969                                 int32_t     height)
2970 {
2971     uint32_t    *src, *srcLine;
2972     uint32_t    *dst, *dstLine;
2973     uint8_t     *mask, *maskLine;
2974     int          srcStride, maskStride, dstStride;
2975     uint16_t w;
2976
2977     fbComposeGetStart (pDst, xDst, yDst, uint32_t, dstStride, dstLine, 1);
2978     fbComposeGetStart (pMask, xMask, yMask, uint8_t, maskStride, maskLine, 1);
2979     fbComposeGetStart (pSrc, xSrc, ySrc, uint32_t, srcStride, srcLine, 1);
2980
2981     while (height--)
2982     {
2983         src = srcLine;
2984         srcLine += srcStride;
2985         dst = dstLine;
2986         dstLine += dstStride;
2987         mask = maskLine;
2988         maskLine += maskStride;
2989
2990         w = width;
2991
2992         while (w--)
2993         {
2994             uint64_t m = *mask;
2995
2996             if (m)
2997             {
2998                 __m64 s = load8888 (*src | 0xff000000);
2999
3000                 if (m == 0xff)
3001                     *dst = store8888 (s);
3002                 else
3003                 {
3004                     __m64 sa = expand_alpha (s);
3005                     __m64 vm = expand_alpha_rev (M64(m));
3006                     __m64 vdest = in_over(s, sa, vm, load8888 (*dst));
3007
3008                     *dst = store8888 (vdest);
3009                 }
3010             }
3011
3012             mask++;
3013             dst++;
3014             src++;
3015         }
3016     }
3017
3018     _mm_empty();
3019 }
3020
3021 static const FastPathInfo mmx_fast_paths[] =
3022 {
3023     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8,       PIXMAN_r5g6b5,   fbCompositeSolidMask_nx8x0565mmx,     0 },
3024     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8,       PIXMAN_b5g6r5,   fbCompositeSolidMask_nx8x0565mmx,     0 },
3025     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8,       PIXMAN_a8r8g8b8, fbCompositeSolidMask_nx8x8888mmx,     0 },
3026     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8,       PIXMAN_x8r8g8b8, fbCompositeSolidMask_nx8x8888mmx,     0 },
3027     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8,       PIXMAN_a8b8g8r8, fbCompositeSolidMask_nx8x8888mmx,     0 },
3028     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8,       PIXMAN_x8b8g8r8, fbCompositeSolidMask_nx8x8888mmx,     0 },
3029     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8r8g8b8, PIXMAN_a8r8g8b8, fbCompositeSolidMask_nx8888x8888Cmmx, NEED_COMPONENT_ALPHA },
3030     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8r8g8b8, PIXMAN_x8r8g8b8, fbCompositeSolidMask_nx8888x8888Cmmx, NEED_COMPONENT_ALPHA },
3031     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8r8g8b8, PIXMAN_r5g6b5,   fbCompositeSolidMask_nx8888x0565Cmmx, NEED_COMPONENT_ALPHA },
3032     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8b8g8r8, PIXMAN_a8b8g8r8, fbCompositeSolidMask_nx8888x8888Cmmx, NEED_COMPONENT_ALPHA },
3033     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8b8g8r8, PIXMAN_x8b8g8r8, fbCompositeSolidMask_nx8888x8888Cmmx, NEED_COMPONENT_ALPHA },
3034     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_a8b8g8r8, PIXMAN_b5g6r5,   fbCompositeSolidMask_nx8888x0565Cmmx, NEED_COMPONENT_ALPHA },
3035     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8r8g8b8, PIXMAN_a8r8g8b8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3036     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8b8g8r8, PIXMAN_a8r8g8b8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3037     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8r8g8b8, PIXMAN_x8r8g8b8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3038     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8b8g8r8, PIXMAN_x8r8g8b8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3039     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8r8g8b8, PIXMAN_r5g6b5,   fbCompositeSrc_8888RevNPx0565mmx, NEED_PIXBUF },
3040     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8b8g8r8, PIXMAN_r5g6b5,   fbCompositeSrc_8888RevNPx0565mmx, NEED_PIXBUF },
3041     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8r8g8b8, PIXMAN_a8b8g8r8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3042     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8b8g8r8, PIXMAN_a8b8g8r8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3043     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8r8g8b8, PIXMAN_x8b8g8r8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3044     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8b8g8r8, PIXMAN_x8b8g8r8, fbCompositeSrc_8888RevNPx8888mmx, NEED_PIXBUF },
3045     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8r8g8b8, PIXMAN_b5g6r5,   fbCompositeSrc_8888RevNPx0565mmx, NEED_PIXBUF },
3046     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8b8g8r8, PIXMAN_b5g6r5,   fbCompositeSrc_8888RevNPx0565mmx, NEED_PIXBUF },
3047     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8,       PIXMAN_a8r8g8b8, fbCompositeSrc_x888xnx8888mmx,    NEED_SOLID_MASK },
3048     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8,       PIXMAN_x8r8g8b8, fbCompositeSrc_x888xnx8888mmx,    NEED_SOLID_MASK },
3049     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8,       PIXMAN_a8b8g8r8, fbCompositeSrc_x888xnx8888mmx,    NEED_SOLID_MASK },
3050     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_a8,       PIXMAN_x8b8g8r8, fbCompositeSrc_x888xnx8888mmx,    NEED_SOLID_MASK },
3051     { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, PIXMAN_a8,       PIXMAN_a8r8g8b8, fbCompositeSrc_8888x8x8888mmx,    NEED_SOLID_MASK },
3052     { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, PIXMAN_a8,       PIXMAN_x8r8g8b8, fbCompositeSrc_8888x8x8888mmx,    NEED_SOLID_MASK },
3053     { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, PIXMAN_a8,       PIXMAN_a8b8g8r8, fbCompositeSrc_8888x8x8888mmx,    NEED_SOLID_MASK },
3054     { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, PIXMAN_a8,       PIXMAN_x8b8g8r8, fbCompositeSrc_8888x8x8888mmx,    NEED_SOLID_MASK },
3055 #if 0
3056     /* FIXME: This code is commented out since it's apparently not actually faster than the generic code. */
3057     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8,       PIXMAN_x8r8g8b8, fbCompositeOver_x888x8x8888mmx,   0 },
3058     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_a8,       PIXMAN_a8r8g8b8, fbCompositeOver_x888x8x8888mmx,   0 },
3059     { PIXMAN_OP_OVER, PIXMAN_x8b8r8g8, PIXMAN_a8,       PIXMAN_x8b8g8r8, fbCompositeOver_x888x8x8888mmx,   0 },
3060     { PIXMAN_OP_OVER, PIXMAN_x8b8r8g8, PIXMAN_a8,       PIXMAN_a8r8g8b8, fbCompositeOver_x888x8x8888mmx,   0 },
3061 #endif
3062     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_null,     PIXMAN_a8r8g8b8, fbCompositeSolid_nx8888mmx,       0 },
3063     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_null,     PIXMAN_x8r8g8b8, fbCompositeSolid_nx8888mmx,       0 },
3064     { PIXMAN_OP_OVER, PIXMAN_solid,    PIXMAN_null,     PIXMAN_r5g6b5,   fbCompositeSolid_nx0565mmx,       0 },
3065     { PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, PIXMAN_null,     PIXMAN_x8r8g8b8, fbCompositeCopyAreammx,           0 },
3066     { PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, PIXMAN_null,     PIXMAN_x8b8g8r8, fbCompositeCopyAreammx,           0 },
3067     { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, PIXMAN_null,     PIXMAN_a8r8g8b8, fbCompositeSrc_8888x8888mmx,      0 },
3068     { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, PIXMAN_null,     PIXMAN_x8r8g8b8, fbCompositeSrc_8888x8888mmx,      0 },
3069     { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, PIXMAN_null,     PIXMAN_r5g6b5,   fbCompositeSrc_8888x0565mmx,      0 },
3070     { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, PIXMAN_null,     PIXMAN_a8b8g8r8, fbCompositeSrc_8888x8888mmx,      0 },
3071     { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, PIXMAN_null,     PIXMAN_x8b8g8r8, fbCompositeSrc_8888x8888mmx,      0 },
3072     { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, PIXMAN_null,     PIXMAN_b5g6r5,   fbCompositeSrc_8888x0565mmx,      0 },
3073
3074     { PIXMAN_OP_ADD, PIXMAN_a8r8g8b8,  PIXMAN_null,     PIXMAN_a8r8g8b8, fbCompositeSrcAdd_8888x8888mmx,   0 },
3075     { PIXMAN_OP_ADD, PIXMAN_a8b8g8r8,  PIXMAN_null,     PIXMAN_a8b8g8r8, fbCompositeSrcAdd_8888x8888mmx,   0 },
3076     { PIXMAN_OP_ADD, PIXMAN_a8,        PIXMAN_null,     PIXMAN_a8,       fbCompositeSrcAdd_8000x8000mmx,   0 },
3077     { PIXMAN_OP_ADD, PIXMAN_solid,     PIXMAN_a8,       PIXMAN_a8,       fbCompositeSrcAdd_8888x8x8mmx,    0 },
3078
3079     { PIXMAN_OP_SRC, PIXMAN_solid,     PIXMAN_a8,       PIXMAN_a8r8g8b8, fbCompositeSolidMaskSrc_nx8x8888mmx, 0 },
3080     { PIXMAN_OP_SRC, PIXMAN_solid,     PIXMAN_a8,       PIXMAN_x8r8g8b8, fbCompositeSolidMaskSrc_nx8x8888mmx, 0 },
3081     { PIXMAN_OP_SRC, PIXMAN_solid,     PIXMAN_a8,       PIXMAN_a8b8g8r8, fbCompositeSolidMaskSrc_nx8x8888mmx, 0 },
3082     { PIXMAN_OP_SRC, PIXMAN_solid,     PIXMAN_a8,       PIXMAN_x8b8g8r8, fbCompositeSolidMaskSrc_nx8x8888mmx, 0 },
3083     { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8,  PIXMAN_null,     PIXMAN_a8r8g8b8, fbCompositeCopyAreammx, 0 },
3084     { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8,  PIXMAN_null,     PIXMAN_a8b8g8r8, fbCompositeCopyAreammx, 0 },
3085     { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8,  PIXMAN_null,     PIXMAN_x8r8g8b8, fbCompositeCopyAreammx, 0 },
3086     { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8,  PIXMAN_null,     PIXMAN_x8b8g8r8, fbCompositeCopyAreammx, 0 },
3087     { PIXMAN_OP_SRC, PIXMAN_x8r8g8b8,  PIXMAN_null,     PIXMAN_x8r8g8b8, fbCompositeCopyAreammx, 0 },
3088     { PIXMAN_OP_SRC, PIXMAN_x8b8g8r8,  PIXMAN_null,     PIXMAN_x8b8g8r8, fbCompositeCopyAreammx, 0 },
3089     { PIXMAN_OP_SRC, PIXMAN_r5g6b5,    PIXMAN_null,     PIXMAN_r5g6b5,   fbCompositeCopyAreammx, 0 },
3090     { PIXMAN_OP_SRC, PIXMAN_b5g6r5,    PIXMAN_null,     PIXMAN_b5g6r5,   fbCompositeCopyAreammx, 0 },
3091
3092     { PIXMAN_OP_IN,  PIXMAN_a8,        PIXMAN_null,     PIXMAN_a8,       fbCompositeIn_8x8mmx,   0 },
3093     { PIXMAN_OP_IN,  PIXMAN_solid,     PIXMAN_a8,       PIXMAN_a8,       fbCompositeIn_nx8x8mmx, 0 },
3094
3095     { PIXMAN_OP_NONE },
3096 };
3097
3098 static void
3099 mmx_composite (pixman_implementation_t *imp,
3100                pixman_op_t     op,
3101                pixman_image_t *src,
3102                pixman_image_t *mask,
3103                pixman_image_t *dest,
3104                int32_t         src_x,
3105                int32_t         src_y,
3106                int32_t         mask_x,
3107                int32_t         mask_y,
3108                int32_t         dest_x,
3109                int32_t         dest_y,
3110                int32_t         width,
3111                int32_t         height)
3112 {
3113     if (_pixman_run_fast_path (mmx_fast_paths, imp,
3114                                op, src, mask, dest,
3115                                src_x, src_y,
3116                                mask_x, mask_y,
3117                                dest_x, dest_y,
3118                                width, height))
3119         return;
3120
3121     _pixman_implementation_composite (imp->delegate,
3122                                       op, src, mask, dest, src_x, src_y,
3123                                       mask_x, mask_y, dest_x, dest_y,
3124                                       width, height);
3125 }
3126
3127 static pixman_bool_t
3128 mmx_blt (pixman_implementation_t *imp,
3129          uint32_t *src_bits,
3130          uint32_t *dst_bits,
3131          int src_stride,
3132          int dst_stride,
3133          int src_bpp,
3134          int dst_bpp,
3135          int src_x, int src_y,
3136          int dst_x, int dst_y,
3137          int width, int height)
3138 {
3139     if (!pixman_blt_mmx (
3140             src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
3141             src_x, src_y, dst_x, dst_y, width, height))
3142
3143     {
3144         return _pixman_implementation_blt (
3145             imp->delegate,
3146             src_bits, dst_bits, src_stride, dst_stride, src_bpp, dst_bpp,
3147             src_x, src_y, dst_x, dst_y, width, height);
3148     }
3149
3150     return TRUE;
3151 }
3152
3153 static pixman_bool_t
3154 mmx_fill (pixman_implementation_t *imp,
3155           uint32_t *bits,
3156           int stride,
3157           int bpp,
3158           int x,
3159           int y,
3160           int width,
3161           int height,
3162           uint32_t xor)
3163 {
3164     if (!pixman_fill_mmx (bits, stride, bpp, x, y, width, height, xor))
3165     {
3166         return _pixman_implementation_fill (
3167             imp->delegate, bits, stride, bpp, x, y, width, height, xor);
3168     }
3169
3170     return TRUE;
3171 }
3172
3173 pixman_implementation_t *
3174 _pixman_implementation_create_mmx (pixman_implementation_t *toplevel)
3175 {
3176     pixman_implementation_t *general = _pixman_implementation_create_fast_path (NULL);
3177     pixman_implementation_t *imp = _pixman_implementation_create (toplevel, general);
3178
3179     imp->combine_32[PIXMAN_OP_OVER] = mmxCombineOverU;
3180     imp->combine_32[PIXMAN_OP_OVER_REVERSE] = mmxCombineOverReverseU;
3181     imp->combine_32[PIXMAN_OP_IN] = mmxCombineInU;
3182     imp->combine_32[PIXMAN_OP_IN_REVERSE] = mmxCombineInReverseU;
3183     imp->combine_32[PIXMAN_OP_OUT] = mmxCombineOutU;
3184     imp->combine_32[PIXMAN_OP_OUT_REVERSE] = mmxCombineOutReverseU;
3185     imp->combine_32[PIXMAN_OP_ATOP] = mmxCombineAtopU;
3186     imp->combine_32[PIXMAN_OP_ATOP_REVERSE] = mmxCombineAtopReverseU;
3187     imp->combine_32[PIXMAN_OP_XOR] = mmxCombineXorU;
3188     imp->combine_32[PIXMAN_OP_ADD] = mmxCombineAddU;
3189     imp->combine_32[PIXMAN_OP_SATURATE] = mmxCombineSaturateU;
3190
3191     imp->combine_32_ca[PIXMAN_OP_SRC] = mmxCombineSrcC;
3192     imp->combine_32_ca[PIXMAN_OP_OVER] = mmxCombineOverC;
3193     imp->combine_32_ca[PIXMAN_OP_OVER_REVERSE] = mmxCombineOverReverseC;
3194     imp->combine_32_ca[PIXMAN_OP_IN] = mmxCombineInC;
3195     imp->combine_32_ca[PIXMAN_OP_IN_REVERSE] = mmxCombineInReverseC;
3196     imp->combine_32_ca[PIXMAN_OP_OUT] = mmxCombineOutC;
3197     imp->combine_32_ca[PIXMAN_OP_OUT_REVERSE] = mmxCombineOutReverseC;
3198     imp->combine_32_ca[PIXMAN_OP_ATOP] = mmxCombineAtopC;
3199     imp->combine_32_ca[PIXMAN_OP_ATOP_REVERSE] = mmxCombineAtopReverseC;
3200     imp->combine_32_ca[PIXMAN_OP_XOR] = mmxCombineXorC;
3201     imp->combine_32_ca[PIXMAN_OP_ADD] = mmxCombineAddC;
3202
3203     imp->composite = mmx_composite;
3204     imp->blt = mmx_blt;
3205     imp->fill = mmx_fill;
3206
3207     return imp;
3208 }
3209
3210 #endif /* USE_MMX */