Bug Summary

File:pixman/pixman-mmx.c
Location:line 3779, column 1
Description:Assigned value is garbage or undefined

Annotated Source Code

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_H1
33#include <config.h>
34#endif
35
36#if defined USE_X86_MMX1 || defined USE_ARM_IWMMXT || defined USE_LOONGSON_MMI
37
38#ifdef USE_LOONGSON_MMI
39#include <loongson-mmintrin.h>
40#else
41#include <mmintrin.h>
42#endif
43#include "pixman-private.h"
44#include "pixman-combine32.h"
45#include "pixman-inlines.h"
46
47#ifdef VERBOSE
48#define CHECKPOINT() error_f ("at %s %d\n", __FUNCTION__, __LINE__48)
49#else
50#define CHECKPOINT()
51#endif
52
53#if defined USE_ARM_IWMMXT && __GNUC__4 == 4 && __GNUC_MINOR__2 < 8
54/* Empty the multimedia state. For some reason, ARM's mmintrin.h doesn't provide this. */
55extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
56_mm_empty (void)
57{
58
59}
60#endif
61
62#ifdef USE_X86_MMX1
63# if (defined(__SUNPRO_C) || defined(_MSC_VER) || defined(_WIN64))
64# include <xmmintrin.h>
65# else
66/* We have to compile with -msse to use xmmintrin.h, but that causes SSE
67 * instructions to be generated that we don't want. Just duplicate the
68 * functions we want to use. */
69extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
70_mm_movemask_pi8 (__m64 __A)
71{
72 int ret;
73
74 asm ("pmovmskb %1, %0\n\t"
75 : "=r" (ret)
76 : "y" (__A)
77 );
78
79 return ret;
80}
81
82extern __inline __m64 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
83_mm_mulhi_pu16 (__m64 __A, __m64 __B)
84{
85 asm ("pmulhuw %1, %0\n\t"
86 : "+y" (__A)
87 : "y" (__B)
88 );
89 return __A;
90}
91
92# define _mm_shuffle_pi16(A, N)({ __m64 ret; asm ("pshufw %2, %1, %0\n\t" : "=y" (ret) : "y"
(A), "K" ((const int8_t)N) ); ret; })
\
93 ({ \
94 __m64 ret; \
95 \
96 asm ("pshufw %2, %1, %0\n\t" \
97 : "=y" (ret) \
98 : "y" (A), "K" ((const int8_t)N) \
99 ); \
100 \
101 ret; \
102 })
103# endif
104#endif
105
106#ifndef _MSC_VER
107#define _MM_SHUFFLE(fp3,fp2,fp1,fp0)(((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2)
| (fp0))
\
108 (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0))
109#endif
110
111/* Notes about writing mmx code
112 *
113 * give memory operands as the second operand. If you give it as the
114 * first, gcc will first load it into a register, then use that
115 * register
116 *
117 * ie. use
118 *
119 * _mm_mullo_pi16 (x, mmx_constant);
120 *
121 * not
122 *
123 * _mm_mullo_pi16 (mmx_constant, x);
124 *
125 * Also try to minimize dependencies. i.e. when you need a value, try
126 * to calculate it from a value that was calculated as early as
127 * possible.
128 */
129
130/* --------------- MMX primitives ------------------------------------- */
131
132/* If __m64 is defined as a struct or union, then define M64_MEMBER to be
133 * the name of the member used to access the data.
134 * If __m64 requires using mm_cvt* intrinsics functions to convert between
135 * uint64_t and __m64 values, then define USE_CVT_INTRINSICS.
136 * If __m64 and uint64_t values can just be cast to each other directly,
137 * then define USE_M64_CASTS.
138 * If __m64 is a double datatype, then define USE_M64_DOUBLE.
139 */
140#ifdef _MSC_VER
141# define M64_MEMBER m64_u64
142#elif defined(__ICC)
143# define USE_CVT_INTRINSICS
144#elif defined(USE_LOONGSON_MMI)
145# define USE_M64_DOUBLE
146#elif defined(__GNUC__4)
147# define USE_M64_CASTS
148#elif defined(__SUNPRO_C)
149# if (__SUNPRO_C >= 0x5120) && !defined(__NOVECTORSIZE__)
150/* Solaris Studio 12.3 (Sun C 5.12) introduces __attribute__(__vector_size__)
151 * support, and defaults to using it to define __m64, unless __NOVECTORSIZE__
152 * is defined. If it is used, then the mm_cvt* intrinsics must be used.
153 */
154# define USE_CVT_INTRINSICS
155# else
156/* For Studio 12.2 or older, or when __attribute__(__vector_size__) is
157 * disabled, __m64 is defined as a struct containing "unsigned long long l_".
158 */
159# define M64_MEMBER l_
160# endif
161#endif
162
163#if defined(USE_M64_CASTS) || defined(USE_CVT_INTRINSICS) || defined(USE_M64_DOUBLE)
164typedef uint64_t mmxdatafield;
165#else
166typedef __m64 mmxdatafield;
167#endif
168
169typedef struct
170{
171 mmxdatafield mmx_4x00ff;
172 mmxdatafield mmx_4x0080;
173 mmxdatafield mmx_565_rgb;
174 mmxdatafield mmx_565_unpack_multiplier;
175 mmxdatafield mmx_565_pack_multiplier;
176 mmxdatafield mmx_565_r;
177 mmxdatafield mmx_565_g;
178 mmxdatafield mmx_565_b;
179 mmxdatafield mmx_packed_565_rb;
180 mmxdatafield mmx_packed_565_g;
181 mmxdatafield mmx_expand_565_g;
182 mmxdatafield mmx_expand_565_b;
183 mmxdatafield mmx_expand_565_r;
184#ifndef USE_LOONGSON_MMI
185 mmxdatafield mmx_mask_0;
186 mmxdatafield mmx_mask_1;
187 mmxdatafield mmx_mask_2;
188 mmxdatafield mmx_mask_3;
189#endif
190 mmxdatafield mmx_full_alpha;
191 mmxdatafield mmx_4x0101;
192 mmxdatafield mmx_ff000000;
193} mmx_data_t;
194
195#if defined(_MSC_VER)
196# define MMXDATA_INIT(field, val)field = valULL { val ## UI64 }
197#elif defined(M64_MEMBER) /* __m64 is a struct, not an integral type */
198# define MMXDATA_INIT(field, val)field = valULL field = { val ## ULL }
199#else /* mmxdatafield is an integral type */
200# define MMXDATA_INIT(field, val)field = valULL field = val ## ULL
201#endif
202
203static const mmx_data_t c =
204{
205 MMXDATA_INIT (.mmx_4x00ff, 0x00ff00ff00ff00ff).mmx_4x00ff = 0x00ff00ff00ff00ffULL,
206 MMXDATA_INIT (.mmx_4x0080, 0x0080008000800080).mmx_4x0080 = 0x0080008000800080ULL,
207 MMXDATA_INIT (.mmx_565_rgb, 0x000001f0003f001f).mmx_565_rgb = 0x000001f0003f001fULL,
208 MMXDATA_INIT (.mmx_565_unpack_multiplier, 0x0000008404100840).mmx_565_unpack_multiplier = 0x0000008404100840ULL,
209 MMXDATA_INIT (.mmx_565_pack_multiplier, 0x2000000420000004).mmx_565_pack_multiplier = 0x2000000420000004ULL,
210 MMXDATA_INIT (.mmx_565_r, 0x000000f800000000).mmx_565_r = 0x000000f800000000ULL,
211 MMXDATA_INIT (.mmx_565_g, 0x0000000000fc0000).mmx_565_g = 0x0000000000fc0000ULL,
212 MMXDATA_INIT (.mmx_565_b, 0x00000000000000f8).mmx_565_b = 0x00000000000000f8ULL,
213 MMXDATA_INIT (.mmx_packed_565_rb, 0x00f800f800f800f8).mmx_packed_565_rb = 0x00f800f800f800f8ULL,
214 MMXDATA_INIT (.mmx_packed_565_g, 0x0000fc000000fc00).mmx_packed_565_g = 0x0000fc000000fc00ULL,
215 MMXDATA_INIT (.mmx_expand_565_g, 0x07e007e007e007e0).mmx_expand_565_g = 0x07e007e007e007e0ULL,
216 MMXDATA_INIT (.mmx_expand_565_b, 0x001f001f001f001f).mmx_expand_565_b = 0x001f001f001f001fULL,
217 MMXDATA_INIT (.mmx_expand_565_r, 0xf800f800f800f800).mmx_expand_565_r = 0xf800f800f800f800ULL,
218#ifndef USE_LOONGSON_MMI
219 MMXDATA_INIT (.mmx_mask_0, 0xffffffffffff0000).mmx_mask_0 = 0xffffffffffff0000ULL,
220 MMXDATA_INIT (.mmx_mask_1, 0xffffffff0000ffff).mmx_mask_1 = 0xffffffff0000ffffULL,
221 MMXDATA_INIT (.mmx_mask_2, 0xffff0000ffffffff).mmx_mask_2 = 0xffff0000ffffffffULL,
222 MMXDATA_INIT (.mmx_mask_3, 0x0000ffffffffffff).mmx_mask_3 = 0x0000ffffffffffffULL,
223#endif
224 MMXDATA_INIT (.mmx_full_alpha, 0x00ff000000000000).mmx_full_alpha = 0x00ff000000000000ULL,
225 MMXDATA_INIT (.mmx_4x0101, 0x0101010101010101).mmx_4x0101 = 0x0101010101010101ULL,
226 MMXDATA_INIT (.mmx_ff000000, 0xff000000ff000000).mmx_ff000000 = 0xff000000ff000000ULL,
227};
228
229#ifdef USE_CVT_INTRINSICS
230# define MC(x)((__m64)c.mmx_x) to_m64 (c.mmx_ ## x)
231#elif defined(USE_M64_CASTS)
232# define MC(x)((__m64)c.mmx_x) ((__m64)c.mmx_ ## x)
233#elif defined(USE_M64_DOUBLE)
234# define MC(x)((__m64)c.mmx_x) (*(__m64 *)&c.mmx_ ## x)
235#else
236# define MC(x)((__m64)c.mmx_x) c.mmx_ ## x
237#endif
238
239static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
240to_m64 (uint64_t x)
241{
242#ifdef USE_CVT_INTRINSICS
243 return _mm_cvtsi64_m64 (x);
244#elif defined M64_MEMBER /* __m64 is a struct, not an integral type */
245 __m64 res;
246
247 res.M64_MEMBER = x;
248 return res;
249#elif defined USE_M64_DOUBLE
250 return *(__m64 *)&x;
251#else /* USE_M64_CASTS */
252 return (__m64)x;
253#endif
254}
255
256static force_inline__inline__ __attribute__ ((__always_inline__)) uint64_t
257to_uint64 (__m64 x)
258{
259#ifdef USE_CVT_INTRINSICS
260 return _mm_cvtm64_si64 (x);
261#elif defined M64_MEMBER /* __m64 is a struct, not an integral type */
262 uint64_t res = x.M64_MEMBER;
263 return res;
264#elif defined USE_M64_DOUBLE
265 return *(uint64_t *)&x;
266#else /* USE_M64_CASTS */
267 return (uint64_t)x;
268#endif
269}
270
271static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
272shift (__m64 v,
273 int s)
274{
275 if (s > 0)
276 return _mm_slli_si64 (v, s);
277 else if (s < 0)
278 return _mm_srli_si64 (v, -s);
279 else
280 return v;
281}
282
283static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
284negate (__m64 mask)
285{
286 return _mm_xor_si64 (mask, MC (4x00ff)((__m64)c.mmx_4x00ff));
287}
288
289/* Computes the product of two unsigned fixed-point 8-bit values from 0 to 1
290 * and maps its result to the same range.
291 *
292 * Jim Blinn gives multiple ways to compute this in "Jim Blinn's Corner:
293 * Notation, Notation, Notation", the first of which is
294 *
295 * prod(a, b) = (a * b + 128) / 255.
296 *
297 * By approximating the division by 255 as 257/65536 it can be replaced by a
298 * multiply and a right shift. This is the implementation that we use in
299 * pix_multiply(), but we _mm_mulhi_pu16() by 257 (part of SSE1 or Extended
300 * 3DNow!, and unavailable at the time of the book's publication) to perform
301 * the multiplication and right shift in a single operation.
302 *
303 * prod(a, b) = ((a * b + 128) * 257) >> 16.
304 *
305 * A third way (how pix_multiply() was implemented prior to 14208344) exists
306 * also that performs the multiplication by 257 with adds and shifts.
307 *
308 * Where temp = a * b + 128
309 *
310 * prod(a, b) = (temp + (temp >> 8)) >> 8.
311 */
312static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
313pix_multiply (__m64 a, __m64 b)
314{
315 __m64 res;
316
317 res = _mm_mullo_pi16 (a, b);
318 res = _mm_adds_pu16 (res, MC (4x0080)((__m64)c.mmx_4x0080));
319 res = _mm_mulhi_pu16 (res, MC (4x0101)((__m64)c.mmx_4x0101));
320
321 return res;
322}
323
324static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
325pix_add (__m64 a, __m64 b)
326{
327 return _mm_adds_pu8 (a, b);
328}
329
330static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
331expand_alpha (__m64 pixel)
332{
333 return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (3, 3, 3, 3))({ __m64 ret; asm ("pshufw %2, %1, %0\n\t" : "=y" (ret) : "y"
(pixel), "K" ((const int8_t)(((3) << 6) | ((3) <<
4) | ((3) << 2) | (3))) ); ret; })
;
334}
335
336static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
337expand_alpha_rev (__m64 pixel)
338{
339 return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (0, 0, 0, 0))({ __m64 ret; asm ("pshufw %2, %1, %0\n\t" : "=y" (ret) : "y"
(pixel), "K" ((const int8_t)(((0) << 6) | ((0) <<
4) | ((0) << 2) | (0))) ); ret; })
;
340}
341
342static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
343invert_colors (__m64 pixel)
344{
345 return _mm_shuffle_pi16 (pixel, _MM_SHUFFLE (3, 0, 1, 2))({ __m64 ret; asm ("pshufw %2, %1, %0\n\t" : "=y" (ret) : "y"
(pixel), "K" ((const int8_t)(((3) << 6) | ((0) <<
4) | ((1) << 2) | (2))) ); ret; })
;
346}
347
348static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
349over (__m64 src,
350 __m64 srca,
351 __m64 dest)
352{
353 return _mm_adds_pu8 (src, pix_multiply (dest, negate (srca)));
354}
355
356static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
357over_rev_non_pre (__m64 src, __m64 dest)
358{
359 __m64 srca = expand_alpha (src);
360 __m64 srcfaaa = _mm_or_si64 (srca, MC (full_alpha)((__m64)c.mmx_full_alpha));
361
362 return over (pix_multiply (invert_colors (src), srcfaaa), srca, dest);
363}
364
365static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
366in (__m64 src, __m64 mask)
367{
368 return pix_multiply (src, mask);
369}
370
371#ifndef _MSC_VER
372static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
373in_over (__m64 src, __m64 srca, __m64 mask, __m64 dest)
374{
375 return over (in (src, mask), pix_multiply (srca, mask), dest);
376}
377
378#else
379
380#define in_over(src, srca, mask, dest) \
381 over (in (src, mask), pix_multiply (srca, mask), dest)
382
383#endif
384
385/* Elemental unaligned loads */
386
387static force_inline__inline__ __attribute__ ((__always_inline__)) __m64 ldq_u(__m64 *p)
388{
389#ifdef USE_X86_MMX1
390 /* x86's alignment restrictions are very relaxed. */
391 return *(__m64 *)p;
392#elif defined USE_ARM_IWMMXT
393 int align = (uintptr_t)p & 7;
394 __m64 *aligned_p;
395 if (align == 0)
396 return *p;
397 aligned_p = (__m64 *)((uintptr_t)p & ~7);
398 return (__m64) _mm_align_si64 (aligned_p[0], aligned_p[1], align);
399#else
400 struct __una_u64 { __m64 x __attribute__((packed)); };
401 const struct __una_u64 *ptr = (const struct __una_u64 *) p;
402 return (__m64) ptr->x;
403#endif
404}
405
406static force_inline__inline__ __attribute__ ((__always_inline__)) uint32_t ldl_u(const uint32_t *p)
407{
408#ifdef USE_X86_MMX1
409 /* x86's alignment restrictions are very relaxed. */
410 return *p;
411#else
412 struct __una_u32 { uint32_t x __attribute__((packed)); };
413 const struct __una_u32 *ptr = (const struct __una_u32 *) p;
414 return ptr->x;
415#endif
416}
417
418static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
419load (const uint32_t *v)
420{
421#ifdef USE_LOONGSON_MMI
422 __m64 ret;
423 asm ("lwc1 %0, %1\n\t"
424 : "=f" (ret)
425 : "m" (*v)
426 );
427 return ret;
428#else
429 return _mm_cvtsi32_si64 (*v);
430#endif
431}
432
433static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
434load8888 (const uint32_t *v)
435{
436#ifdef USE_LOONGSON_MMI
437 return _mm_unpacklo_pi8_f (*(__m32 *)v, _mm_setzero_si64 ());
438#else
439 return _mm_unpacklo_pi8 (load (v), _mm_setzero_si64 ());
440#endif
441}
442
443static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
444load8888u (const uint32_t *v)
445{
446 uint32_t l = ldl_u (v);
447 return load8888 (&l);
448}
449
450static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
451pack8888 (__m64 lo, __m64 hi)
452{
453 return _mm_packs_pu16 (lo, hi);
454}
455
456static force_inline__inline__ __attribute__ ((__always_inline__)) void
457store (uint32_t *dest, __m64 v)
458{
459#ifdef USE_LOONGSON_MMI
460 asm ("swc1 %1, %0\n\t"
461 : "=m" (*dest)
462 : "f" (v)
463 : "memory"
464 );
465#else
466 *dest = _mm_cvtsi64_si32 (v);
467#endif
468}
469
470static force_inline__inline__ __attribute__ ((__always_inline__)) void
471store8888 (uint32_t *dest, __m64 v)
472{
473 v = pack8888 (v, _mm_setzero_si64 ());
474 store (dest, v);
475}
476
477static force_inline__inline__ __attribute__ ((__always_inline__)) pixman_bool_t
478is_equal (__m64 a, __m64 b)
479{
480#ifdef USE_LOONGSON_MMI
481 /* __m64 is double, we can compare directly. */
482 return a == b;
483#else
484 return _mm_movemask_pi8 (_mm_cmpeq_pi8 (a, b)) == 0xff;
485#endif
486}
487
488static force_inline__inline__ __attribute__ ((__always_inline__)) pixman_bool_t
489is_opaque (__m64 v)
490{
491#ifdef USE_LOONGSON_MMI
492 return is_equal (_mm_and_si64 (v, MC (full_alpha)((__m64)c.mmx_full_alpha)), MC (full_alpha)((__m64)c.mmx_full_alpha));
493#else
494 __m64 ffs = _mm_cmpeq_pi8 (v, v);
495 return (_mm_movemask_pi8 (_mm_cmpeq_pi8 (v, ffs)) & 0x40);
496#endif
497}
498
499static force_inline__inline__ __attribute__ ((__always_inline__)) pixman_bool_t
500is_zero (__m64 v)
501{
502 return is_equal (v, _mm_setzero_si64 ());
503}
504
505/* Expand 16 bits positioned at @pos (0-3) of a mmx register into
506 *
507 * 00RR00GG00BB
508 *
509 * --- Expanding 565 in the low word ---
510 *
511 * m = (m << (32 - 3)) | (m << (16 - 5)) | m;
512 * m = m & (01f0003f001f);
513 * m = m * (008404100840);
514 * m = m >> 8;
515 *
516 * Note the trick here - the top word is shifted by another nibble to
517 * avoid it bumping into the middle word
518 */
519static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
520expand565 (__m64 pixel, int pos)
521{
522 __m64 p = pixel;
523 __m64 t1, t2;
524
525 /* move pixel to low 16 bit and zero the rest */
526#ifdef USE_LOONGSON_MMI
527 p = loongson_extract_pi16 (p, pos);
528#else
529 p = shift (shift (p, (3 - pos) * 16), -48);
530#endif
531
532 t1 = shift (p, 36 - 11);
533 t2 = shift (p, 16 - 5);
534
535 p = _mm_or_si64 (t1, p);
536 p = _mm_or_si64 (t2, p);
537 p = _mm_and_si64 (p, MC (565_rgb)((__m64)c.mmx_565_rgb));
538
539 pixel = _mm_mullo_pi16 (p, MC (565_unpack_multiplier)((__m64)c.mmx_565_unpack_multiplier));
540 return _mm_srli_pi16 (pixel, 8);
541}
542
543/* Expand 4 16 bit pixels in an mmx register into two mmx registers of
544 *
545 * AARRGGBBRRGGBB
546 */
547static force_inline__inline__ __attribute__ ((__always_inline__)) void
548expand_4xpacked565 (__m64 vin, __m64 *vout0, __m64 *vout1, int full_alpha)
549{
550 __m64 t0, t1, alpha = _mm_setzero_si64 ();
551 __m64 r = _mm_and_si64 (vin, MC (expand_565_r)((__m64)c.mmx_expand_565_r));
552 __m64 g = _mm_and_si64 (vin, MC (expand_565_g)((__m64)c.mmx_expand_565_g));
553 __m64 b = _mm_and_si64 (vin, MC (expand_565_b)((__m64)c.mmx_expand_565_b));
554 if (full_alpha)
555 alpha = _mm_cmpeq_pi32 (alpha, alpha);
556
557 /* Replicate high bits into empty low bits. */
558 r = _mm_or_si64 (_mm_srli_pi16 (r, 8), _mm_srli_pi16 (r, 13));
559 g = _mm_or_si64 (_mm_srli_pi16 (g, 3), _mm_srli_pi16 (g, 9));
560 b = _mm_or_si64 (_mm_slli_pi16 (b, 3), _mm_srli_pi16 (b, 2));
561
562 r = _mm_packs_pu16 (r, _mm_setzero_si64 ()); /* 00 00 00 00 R3 R2 R1 R0 */
563 g = _mm_packs_pu16 (g, _mm_setzero_si64 ()); /* 00 00 00 00 G3 G2 G1 G0 */
564 b = _mm_packs_pu16 (b, _mm_setzero_si64 ()); /* 00 00 00 00 B3 B2 B1 B0 */
565
566 t1 = _mm_unpacklo_pi8 (r, alpha); /* A3 R3 A2 R2 A1 R1 A0 R0 */
567 t0 = _mm_unpacklo_pi8 (b, g); /* G3 B3 G2 B2 G1 B1 G0 B0 */
568
569 *vout0 = _mm_unpacklo_pi16 (t0, t1); /* A1 R1 G1 B1 A0 R0 G0 B0 */
570 *vout1 = _mm_unpackhi_pi16 (t0, t1); /* A3 R3 G3 B3 A2 R2 G2 B2 */
571}
572
573static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
574expand8888 (__m64 in, int pos)
575{
576 if (pos == 0)
577 return _mm_unpacklo_pi8 (in, _mm_setzero_si64 ());
578 else
579 return _mm_unpackhi_pi8 (in, _mm_setzero_si64 ());
580}
581
582static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
583expandx888 (__m64 in, int pos)
584{
585 return _mm_or_si64 (expand8888 (in, pos), MC (full_alpha)((__m64)c.mmx_full_alpha));
586}
587
588static force_inline__inline__ __attribute__ ((__always_inline__)) void
589expand_4x565 (__m64 vin, __m64 *vout0, __m64 *vout1, __m64 *vout2, __m64 *vout3, int full_alpha)
590{
591 __m64 v0, v1;
592 expand_4xpacked565 (vin, &v0, &v1, full_alpha);
593 *vout0 = expand8888 (v0, 0);
594 *vout1 = expand8888 (v0, 1);
595 *vout2 = expand8888 (v1, 0);
596 *vout3 = expand8888 (v1, 1);
597}
598
599static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
600pack_565 (__m64 pixel, __m64 target, int pos)
601{
602 __m64 p = pixel;
603 __m64 t = target;
604 __m64 r, g, b;
605
606 r = _mm_and_si64 (p, MC (565_r)((__m64)c.mmx_565_r));
607 g = _mm_and_si64 (p, MC (565_g)((__m64)c.mmx_565_g));
608 b = _mm_and_si64 (p, MC (565_b)((__m64)c.mmx_565_b));
609
610#ifdef USE_LOONGSON_MMI
611 r = shift (r, -(32 - 8));
612 g = shift (g, -(16 - 3));
613 b = shift (b, -(0 + 3));
614
615 p = _mm_or_si64 (r, g);
616 p = _mm_or_si64 (p, b);
617 return loongson_insert_pi16 (t, p, pos);
618#else
619 r = shift (r, -(32 - 8) + pos * 16);
620 g = shift (g, -(16 - 3) + pos * 16);
621 b = shift (b, -(0 + 3) + pos * 16);
622
623 if (pos == 0)
624 t = _mm_and_si64 (t, MC (mask_0)((__m64)c.mmx_mask_0));
625 else if (pos == 1)
626 t = _mm_and_si64 (t, MC (mask_1)((__m64)c.mmx_mask_1));
627 else if (pos == 2)
628 t = _mm_and_si64 (t, MC (mask_2)((__m64)c.mmx_mask_2));
629 else if (pos == 3)
630 t = _mm_and_si64 (t, MC (mask_3)((__m64)c.mmx_mask_3));
631
632 p = _mm_or_si64 (r, t);
633 p = _mm_or_si64 (g, p);
634
635 return _mm_or_si64 (b, p);
636#endif
637}
638
639static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
640pack_4xpacked565 (__m64 a, __m64 b)
641{
642 __m64 rb0 = _mm_and_si64 (a, MC (packed_565_rb)((__m64)c.mmx_packed_565_rb));
643 __m64 rb1 = _mm_and_si64 (b, MC (packed_565_rb)((__m64)c.mmx_packed_565_rb));
644
645 __m64 t0 = _mm_madd_pi16 (rb0, MC (565_pack_multiplier)((__m64)c.mmx_565_pack_multiplier));
646 __m64 t1 = _mm_madd_pi16 (rb1, MC (565_pack_multiplier)((__m64)c.mmx_565_pack_multiplier));
647
648 __m64 g0 = _mm_and_si64 (a, MC (packed_565_g)((__m64)c.mmx_packed_565_g));
649 __m64 g1 = _mm_and_si64 (b, MC (packed_565_g)((__m64)c.mmx_packed_565_g));
650
651 t0 = _mm_or_si64 (t0, g0);
652 t1 = _mm_or_si64 (t1, g1);
653
654 t0 = shift(t0, -5);
655#ifdef USE_ARM_IWMMXT
656 t1 = shift(t1, -5);
657 return _mm_packs_pu32 (t0, t1);
658#else
659 t1 = shift(t1, -5 + 16);
660 return _mm_shuffle_pi16 (_mm_or_si64 (t0, t1), _MM_SHUFFLE (3, 1, 2, 0))({ __m64 ret; asm ("pshufw %2, %1, %0\n\t" : "=y" (ret) : "y"
(_mm_or_si64 (t0, t1)), "K" ((const int8_t)(((3) << 6)
| ((1) << 4) | ((2) << 2) | (0))) ); ret; })
;
661#endif
662}
663
664#ifndef _MSC_VER
665
666static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
667pack_4x565 (__m64 v0, __m64 v1, __m64 v2, __m64 v3)
668{
669 return pack_4xpacked565 (pack8888 (v0, v1), pack8888 (v2, v3));
670}
671
672static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
673pix_add_mul (__m64 x, __m64 a, __m64 y, __m64 b)
674{
675 x = pix_multiply (x, a);
676 y = pix_multiply (y, b);
677
678 return pix_add (x, y);
679}
680
681#else
682
683/* MSVC only handles a "pass by register" of up to three SSE intrinsics */
684
685#define pack_4x565(v0, v1, v2, v3) \
686 pack_4xpacked565 (pack8888 (v0, v1), pack8888 (v2, v3))
687
688#define pix_add_mul(x, a, y, b) \
689 ( x = pix_multiply (x, a), \
690 y = pix_multiply (y, b), \
691 pix_add (x, y) )
692
693#endif
694
695/* --------------- MMX code patch for fbcompose.c --------------------- */
696
697static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
698combine (const uint32_t *src, const uint32_t *mask)
699{
700 __m64 vsrc = load8888 (src);
701
702 if (mask)
703 {
704 __m64 m = load8888 (mask);
705
706 m = expand_alpha (m);
707 vsrc = pix_multiply (vsrc, m);
708 }
709
710 return vsrc;
711}
712
713static force_inline__inline__ __attribute__ ((__always_inline__)) __m64
714core_combine_over_u_pixel_mmx (__m64 vsrc, __m64 vdst)
715{
716 vsrc = _mm_unpacklo_pi8 (vsrc, _mm_setzero_si64 ());
717
718 if (is_opaque (vsrc))
719 {
720 return vsrc;
721 }
722 else if (!is_zero (vsrc))
723 {
724 return over (vsrc, expand_alpha (vsrc),
725 _mm_unpacklo_pi8 (vdst, _mm_setzero_si64 ()));
726 }
727
728 return _mm_unpacklo_pi8 (vdst, _mm_setzero_si64 ());
729}
730
731static void
732mmx_combine_over_u (pixman_implementation_t *imp,
733 pixman_op_t op,
734 uint32_t * dest,
735 const uint32_t * src,
736 const uint32_t * mask,
737 int width)
738{
739 const uint32_t *end = dest + width;
740
741 while (dest < end)
742 {
743 __m64 vsrc = combine (src, mask);
744
745 if (is_opaque (vsrc))
746 {
747 store8888 (dest, vsrc);
748 }
749 else if (!is_zero (vsrc))
750 {
751 __m64 sa = expand_alpha (vsrc);
752 store8888 (dest, over (vsrc, sa, load8888 (dest)));
753 }
754
755 ++dest;
756 ++src;
757 if (mask)
758 ++mask;
759 }
760 _mm_empty ();
761}
762
763static void
764mmx_combine_over_reverse_u (pixman_implementation_t *imp,
765 pixman_op_t op,
766 uint32_t * dest,
767 const uint32_t * src,
768 const uint32_t * mask,
769 int width)
770{
771 const uint32_t *end = dest + width;
772
773 while (dest < end)
774 {
775 __m64 d, da;
776 __m64 s = combine (src, mask);
777
778 d = load8888 (dest);
779 da = expand_alpha (d);
780 store8888 (dest, over (d, da, s));
781
782 ++dest;
783 ++src;
784 if (mask)
785 mask++;
786 }
787 _mm_empty ();
788}
789
790static void
791mmx_combine_in_u (pixman_implementation_t *imp,
792 pixman_op_t op,
793 uint32_t * dest,
794 const uint32_t * src,
795 const uint32_t * mask,
796 int width)
797{
798 const uint32_t *end = dest + width;
799
800 while (dest < end)
801 {
802 __m64 a;
803 __m64 x = combine (src, mask);
804
805 a = load8888 (dest);
806 a = expand_alpha (a);
807 x = pix_multiply (x, a);
808
809 store8888 (dest, x);
810
811 ++dest;
812 ++src;
813 if (mask)
814 mask++;
815 }
816 _mm_empty ();
817}
818
819static void
820mmx_combine_in_reverse_u (pixman_implementation_t *imp,
821 pixman_op_t op,
822 uint32_t * dest,
823 const uint32_t * src,
824 const uint32_t * mask,
825 int width)
826{
827 const uint32_t *end = dest + width;
828
829 while (dest < end)
830 {
831 __m64 a = combine (src, mask);
832 __m64 x;
833
834 x = load8888 (dest);
835 a = expand_alpha (a);
836 x = pix_multiply (x, a);
837 store8888 (dest, x);
838
839 ++dest;
840 ++src;
841 if (mask)
842 mask++;
843 }
844 _mm_empty ();
845}
846
847static void
848mmx_combine_out_u (pixman_implementation_t *imp,
849 pixman_op_t op,
850 uint32_t * dest,
851 const uint32_t * src,
852 const uint32_t * mask,
853 int width)
854{
855 const uint32_t *end = dest + width;
856
857 while (dest < end)
858 {
859 __m64 a;
860 __m64 x = combine (src, mask);
861
862 a = load8888 (dest);
863 a = expand_alpha (a);
864 a = negate (a);
865 x = pix_multiply (x, a);
866 store8888 (dest, x);
867
868 ++dest;
869 ++src;
870 if (mask)
871 mask++;
872 }
873 _mm_empty ();
874}
875
876static void
877mmx_combine_out_reverse_u (pixman_implementation_t *imp,
878 pixman_op_t op,
879 uint32_t * dest,
880 const uint32_t * src,
881 const uint32_t * mask,
882 int width)
883{
884 const uint32_t *end = dest + width;
885
886 while (dest < end)
887 {
888 __m64 a = combine (src, mask);
889 __m64 x;
890
891 x = load8888 (dest);
892 a = expand_alpha (a);
893 a = negate (a);
894 x = pix_multiply (x, a);
895
896 store8888 (dest, x);
897
898 ++dest;
899 ++src;
900 if (mask)
901 mask++;
902 }
903 _mm_empty ();
904}
905
906static void
907mmx_combine_atop_u (pixman_implementation_t *imp,
908 pixman_op_t op,
909 uint32_t * dest,
910 const uint32_t * src,
911 const uint32_t * mask,
912 int width)
913{
914 const uint32_t *end = dest + width;
915
916 while (dest < end)
917 {
918 __m64 da, d, sia;
919 __m64 s = combine (src, mask);
920
921 d = load8888 (dest);
922 sia = expand_alpha (s);
923 sia = negate (sia);
924 da = expand_alpha (d);
925 s = pix_add_mul (s, da, d, sia);
926 store8888 (dest, s);
927
928 ++dest;
929 ++src;
930 if (mask)
931 mask++;
932 }
933 _mm_empty ();
934}
935
936static void
937mmx_combine_atop_reverse_u (pixman_implementation_t *imp,
938 pixman_op_t op,
939 uint32_t * dest,
940 const uint32_t * src,
941 const uint32_t * mask,
942 int width)
943{
944 const uint32_t *end;
945
946 end = dest + width;
947
948 while (dest < end)
949 {
950 __m64 dia, d, sa;
951 __m64 s = combine (src, mask);
952
953 d = load8888 (dest);
954 sa = expand_alpha (s);
955 dia = expand_alpha (d);
956 dia = negate (dia);
957 s = pix_add_mul (s, dia, d, sa);
958 store8888 (dest, s);
959
960 ++dest;
961 ++src;
962 if (mask)
963 mask++;
964 }
965 _mm_empty ();
966}
967
968static void
969mmx_combine_xor_u (pixman_implementation_t *imp,
970 pixman_op_t op,
971 uint32_t * dest,
972 const uint32_t * src,
973 const uint32_t * mask,
974 int width)
975{
976 const uint32_t *end = dest + width;
977
978 while (dest < end)
979 {
980 __m64 dia, d, sia;
981 __m64 s = combine (src, mask);
982
983 d = load8888 (dest);
984 sia = expand_alpha (s);
985 dia = expand_alpha (d);
986 sia = negate (sia);
987 dia = negate (dia);
988 s = pix_add_mul (s, dia, d, sia);
989 store8888 (dest, s);
990
991 ++dest;
992 ++src;
993 if (mask)
994 mask++;
995 }
996 _mm_empty ();
997}
998
999static void
1000mmx_combine_add_u (pixman_implementation_t *imp,
1001 pixman_op_t op,
1002 uint32_t * dest,
1003 const uint32_t * src,
1004 const uint32_t * mask,
1005 int width)
1006{
1007 const uint32_t *end = dest + width;
1008
1009 while (dest < end)
1010 {
1011 __m64 d;
1012 __m64 s = combine (src, mask);
1013
1014 d = load8888 (dest);
1015 s = pix_add (s, d);
1016 store8888 (dest, s);
1017
1018 ++dest;
1019 ++src;
1020 if (mask)
1021 mask++;
1022 }
1023 _mm_empty ();
1024}
1025
1026static void
1027mmx_combine_saturate_u (pixman_implementation_t *imp,
1028 pixman_op_t op,
1029 uint32_t * dest,
1030 const uint32_t * src,
1031 const uint32_t * mask,
1032 int width)
1033{
1034 const uint32_t *end = dest + width;
1035
1036 while (dest < end)
1037 {
1038 uint32_t s, sa, da;
1039 uint32_t d = *dest;
1040 __m64 ms = combine (src, mask);
1041 __m64 md = load8888 (dest);
1042
1043 store8888(&s, ms);
1044 da = ~d >> 24;
1045 sa = s >> 24;
1046
1047 if (sa > da)
1048 {
1049 uint32_t quot = DIV_UN8 (da, sa)(((uint16_t) (da) * 0xff + ((sa) / 2)) / (sa)) << 24;
1050 __m64 msa = load8888 (&quot);
1051 msa = expand_alpha (msa);
1052 ms = pix_multiply (ms, msa);
1053 }
1054
1055 md = pix_add (md, ms);
1056 store8888 (dest, md);
1057
1058 ++src;
1059 ++dest;
1060 if (mask)
1061 mask++;
1062 }
1063 _mm_empty ();
1064}
1065
1066static void
1067mmx_combine_src_ca (pixman_implementation_t *imp,
1068 pixman_op_t op,
1069 uint32_t * dest,
1070 const uint32_t * src,
1071 const uint32_t * mask,
1072 int width)
1073{
1074 const uint32_t *end = src + width;
1075
1076 while (src < end)
1077 {
1078 __m64 a = load8888 (mask);
1079 __m64 s = load8888 (src);
1080
1081 s = pix_multiply (s, a);
1082 store8888 (dest, s);
1083
1084 ++src;
1085 ++mask;
1086 ++dest;
1087 }
1088 _mm_empty ();
1089}
1090
1091static void
1092mmx_combine_over_ca (pixman_implementation_t *imp,
1093 pixman_op_t op,
1094 uint32_t * dest,
1095 const uint32_t * src,
1096 const uint32_t * mask,
1097 int width)
1098{
1099 const uint32_t *end = src + width;
1100
1101 while (src < end)
1102 {
1103 __m64 a = load8888 (mask);
1104 __m64 s = load8888 (src);
1105 __m64 d = load8888 (dest);
1106 __m64 sa = expand_alpha (s);
1107
1108 store8888 (dest, in_over (s, sa, a, d));
1109
1110 ++src;
1111 ++dest;
1112 ++mask;
1113 }
1114 _mm_empty ();
1115}
1116
1117static void
1118mmx_combine_over_reverse_ca (pixman_implementation_t *imp,
1119 pixman_op_t op,
1120 uint32_t * dest,
1121 const uint32_t * src,
1122 const uint32_t * mask,
1123 int width)
1124{
1125 const uint32_t *end = src + width;
1126
1127 while (src < end)
1128 {
1129 __m64 a = load8888 (mask);
1130 __m64 s = load8888 (src);
1131 __m64 d = load8888 (dest);
1132 __m64 da = expand_alpha (d);
1133
1134 store8888 (dest, over (d, da, in (s, a)));
1135
1136 ++src;
1137 ++dest;
1138 ++mask;
1139 }
1140 _mm_empty ();
1141}
1142
1143static void
1144mmx_combine_in_ca (pixman_implementation_t *imp,
1145 pixman_op_t op,
1146 uint32_t * dest,
1147 const uint32_t * src,
1148 const uint32_t * mask,
1149 int width)
1150{
1151 const uint32_t *end = src + width;
1152
1153 while (src < end)
1154 {
1155 __m64 a = load8888 (mask);
1156 __m64 s = load8888 (src);
1157 __m64 d = load8888 (dest);
1158 __m64 da = expand_alpha (d);
1159
1160 s = pix_multiply (s, a);
1161 s = pix_multiply (s, da);
1162 store8888 (dest, s);
1163
1164 ++src;
1165 ++dest;
1166 ++mask;
1167 }
1168 _mm_empty ();
1169}
1170
1171static void
1172mmx_combine_in_reverse_ca (pixman_implementation_t *imp,
1173 pixman_op_t op,
1174 uint32_t * dest,
1175 const uint32_t * src,
1176 const uint32_t * mask,
1177 int width)
1178{
1179 const uint32_t *end = src + width;
1180
1181 while (src < end)
1182 {
1183 __m64 a = load8888 (mask);
1184 __m64 s = load8888 (src);
1185 __m64 d = load8888 (dest);
1186 __m64 sa = expand_alpha (s);
1187
1188 a = pix_multiply (a, sa);
1189 d = pix_multiply (d, a);
1190 store8888 (dest, d);
1191
1192 ++src;
1193 ++dest;
1194 ++mask;
1195 }
1196 _mm_empty ();
1197}
1198
1199static void
1200mmx_combine_out_ca (pixman_implementation_t *imp,
1201 pixman_op_t op,
1202 uint32_t * dest,
1203 const uint32_t * src,
1204 const uint32_t * mask,
1205 int width)
1206{
1207 const uint32_t *end = src + width;
1208
1209 while (src < end)
1210 {
1211 __m64 a = load8888 (mask);
1212 __m64 s = load8888 (src);
1213 __m64 d = load8888 (dest);
1214 __m64 da = expand_alpha (d);
1215
1216 da = negate (da);
1217 s = pix_multiply (s, a);
1218 s = pix_multiply (s, da);
1219 store8888 (dest, s);
1220
1221 ++src;
1222 ++dest;
1223 ++mask;
1224 }
1225 _mm_empty ();
1226}
1227
1228static void
1229mmx_combine_out_reverse_ca (pixman_implementation_t *imp,
1230 pixman_op_t op,
1231 uint32_t * dest,
1232 const uint32_t * src,
1233 const uint32_t * mask,
1234 int width)
1235{
1236 const uint32_t *end = src + width;
1237
1238 while (src < end)
1239 {
1240 __m64 a = load8888 (mask);
1241 __m64 s = load8888 (src);
1242 __m64 d = load8888 (dest);
1243 __m64 sa = expand_alpha (s);
1244
1245 a = pix_multiply (a, sa);
1246 a = negate (a);
1247 d = pix_multiply (d, a);
1248 store8888 (dest, d);
1249
1250 ++src;
1251 ++dest;
1252 ++mask;
1253 }
1254 _mm_empty ();
1255}
1256
1257static void
1258mmx_combine_atop_ca (pixman_implementation_t *imp,
1259 pixman_op_t op,
1260 uint32_t * dest,
1261 const uint32_t * src,
1262 const uint32_t * mask,
1263 int width)
1264{
1265 const uint32_t *end = src + width;
1266
1267 while (src < end)
1268 {
1269 __m64 a = load8888 (mask);
1270 __m64 s = load8888 (src);
1271 __m64 d = load8888 (dest);
1272 __m64 da = expand_alpha (d);
1273 __m64 sa = expand_alpha (s);
1274
1275 s = pix_multiply (s, a);
1276 a = pix_multiply (a, sa);
1277 a = negate (a);
1278 d = pix_add_mul (d, a, s, da);
1279 store8888 (dest, d);
1280
1281 ++src;
1282 ++dest;
1283 ++mask;
1284 }
1285 _mm_empty ();
1286}
1287
1288static void
1289mmx_combine_atop_reverse_ca (pixman_implementation_t *imp,
1290 pixman_op_t op,
1291 uint32_t * dest,
1292 const uint32_t * src,
1293 const uint32_t * mask,
1294 int width)
1295{
1296 const uint32_t *end = src + width;
1297
1298 while (src < end)
1299 {
1300 __m64 a = load8888 (mask);
1301 __m64 s = load8888 (src);
1302 __m64 d = load8888 (dest);
1303 __m64 da = expand_alpha (d);
1304 __m64 sa = expand_alpha (s);
1305
1306 s = pix_multiply (s, a);
1307 a = pix_multiply (a, sa);
1308 da = negate (da);
1309 d = pix_add_mul (d, a, s, da);
1310 store8888 (dest, d);
1311
1312 ++src;
1313 ++dest;
1314 ++mask;
1315 }
1316 _mm_empty ();
1317}
1318
1319static void
1320mmx_combine_xor_ca (pixman_implementation_t *imp,
1321 pixman_op_t op,
1322 uint32_t * dest,
1323 const uint32_t * src,
1324 const uint32_t * mask,
1325 int width)
1326{
1327 const uint32_t *end = src + width;
1328
1329 while (src < end)
1330 {
1331 __m64 a = load8888 (mask);
1332 __m64 s = load8888 (src);
1333 __m64 d = load8888 (dest);
1334 __m64 da = expand_alpha (d);
1335 __m64 sa = expand_alpha (s);
1336
1337 s = pix_multiply (s, a);
1338 a = pix_multiply (a, sa);
1339 da = negate (da);
1340 a = negate (a);
1341 d = pix_add_mul (d, a, s, da);
1342 store8888 (dest, d);
1343
1344 ++src;
1345 ++dest;
1346 ++mask;
1347 }
1348 _mm_empty ();
1349}
1350
1351static void
1352mmx_combine_add_ca (pixman_implementation_t *imp,
1353 pixman_op_t op,
1354 uint32_t * dest,
1355 const uint32_t * src,
1356 const uint32_t * mask,
1357 int width)
1358{
1359 const uint32_t *end = src + width;
1360
1361 while (src < end)
1362 {
1363 __m64 a = load8888 (mask);
1364 __m64 s = load8888 (src);
1365 __m64 d = load8888 (dest);
1366
1367 s = pix_multiply (s, a);
1368 d = pix_add (s, d);
1369 store8888 (dest, d);
1370
1371 ++src;
1372 ++dest;
1373 ++mask;
1374 }
1375 _mm_empty ();
1376}
1377
1378/* ------------- MMX code paths called from fbpict.c -------------------- */
1379
1380static void
1381mmx_composite_over_n_8888 (pixman_implementation_t *imp,
1382 pixman_composite_info_t *info)
1383{
1384 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1385 uint32_t src;
1386 uint32_t *dst_line, *dst;
1387 int32_t w;
1388 int dst_stride;
1389 __m64 vsrc, vsrca;
1390
1391 CHECKPOINT ();
1392
1393 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
1394
1395 if (src == 0)
1396 return;
1397
1398 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1399
1400 vsrc = load8888 (&src);
1401 vsrca = expand_alpha (vsrc);
1402
1403 while (height--)
1404 {
1405 dst = dst_line;
1406 dst_line += dst_stride;
1407 w = width;
1408
1409 CHECKPOINT ();
1410
1411 while (w && (uintptr_t)dst & 7)
1412 {
1413 store8888 (dst, over (vsrc, vsrca, load8888 (dst)));
1414
1415 w--;
1416 dst++;
1417 }
1418
1419 while (w >= 2)
1420 {
1421 __m64 vdest;
1422 __m64 dest0, dest1;
1423
1424 vdest = *(__m64 *)dst;
1425
1426 dest0 = over (vsrc, vsrca, expand8888 (vdest, 0));
1427 dest1 = over (vsrc, vsrca, expand8888 (vdest, 1));
1428
1429 *(__m64 *)dst = pack8888 (dest0, dest1);
1430
1431 dst += 2;
1432 w -= 2;
1433 }
1434
1435 CHECKPOINT ();
1436
1437 if (w)
1438 {
1439 store8888 (dst, over (vsrc, vsrca, load8888 (dst)));
1440 }
1441 }
1442
1443 _mm_empty ();
1444}
1445
1446static void
1447mmx_composite_over_n_0565 (pixman_implementation_t *imp,
1448 pixman_composite_info_t *info)
1449{
1450 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1451 uint32_t src;
1452 uint16_t *dst_line, *dst;
1453 int32_t w;
1454 int dst_stride;
1455 __m64 vsrc, vsrca;
1456
1457 CHECKPOINT ();
1458
1459 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
1460
1461 if (src == 0)
1462 return;
1463
1464 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1465
1466 vsrc = load8888 (&src);
1467 vsrca = expand_alpha (vsrc);
1468
1469 while (height--)
1470 {
1471 dst = dst_line;
1472 dst_line += dst_stride;
1473 w = width;
1474
1475 CHECKPOINT ();
1476
1477 while (w && (uintptr_t)dst & 7)
1478 {
1479 uint64_t d = *dst;
1480 __m64 vdest = expand565 (to_m64 (d), 0);
1481
1482 vdest = pack_565 (over (vsrc, vsrca, vdest), vdest, 0);
1483 *dst = to_uint64 (vdest);
1484
1485 w--;
1486 dst++;
1487 }
1488
1489 while (w >= 4)
1490 {
1491 __m64 vdest = *(__m64 *)dst;
1492 __m64 v0, v1, v2, v3;
1493
1494 expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
1495
1496 v0 = over (vsrc, vsrca, v0);
1497 v1 = over (vsrc, vsrca, v1);
1498 v2 = over (vsrc, vsrca, v2);
1499 v3 = over (vsrc, vsrca, v3);
1500
1501 *(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
1502
1503 dst += 4;
1504 w -= 4;
1505 }
1506
1507 CHECKPOINT ();
1508
1509 while (w)
1510 {
1511 uint64_t d = *dst;
1512 __m64 vdest = expand565 (to_m64 (d), 0);
1513
1514 vdest = pack_565 (over (vsrc, vsrca, vdest), vdest, 0);
1515 *dst = to_uint64 (vdest);
1516
1517 w--;
1518 dst++;
1519 }
1520 }
1521
1522 _mm_empty ();
1523}
1524
1525static void
1526mmx_composite_over_n_8888_8888_ca (pixman_implementation_t *imp,
1527 pixman_composite_info_t *info)
1528{
1529 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1530 uint32_t src;
1531 uint32_t *dst_line;
1532 uint32_t *mask_line;
1533 int dst_stride, mask_stride;
1534 __m64 vsrc, vsrca;
1535
1536 CHECKPOINT ();
1537
1538 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
1539
1540 if (src == 0)
1541 return;
1542
1543 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1544 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (mask_line) = ((uint32_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
1545
1546 vsrc = load8888 (&src);
1547 vsrca = expand_alpha (vsrc);
1548
1549 while (height--)
1550 {
1551 int twidth = width;
1552 uint32_t *p = (uint32_t *)mask_line;
1553 uint32_t *q = (uint32_t *)dst_line;
1554
1555 while (twidth && (uintptr_t)q & 7)
1556 {
1557 uint32_t m = *(uint32_t *)p;
1558
1559 if (m)
1560 {
1561 __m64 vdest = load8888 (q);
1562 vdest = in_over (vsrc, vsrca, load8888 (&m), vdest);
1563 store8888 (q, vdest);
1564 }
1565
1566 twidth--;
1567 p++;
1568 q++;
1569 }
1570
1571 while (twidth >= 2)
1572 {
1573 uint32_t m0, m1;
1574 m0 = *p;
1575 m1 = *(p + 1);
1576
1577 if (m0 | m1)
1578 {
1579 __m64 dest0, dest1;
1580 __m64 vdest = *(__m64 *)q;
1581
1582 dest0 = in_over (vsrc, vsrca, load8888 (&m0),
1583 expand8888 (vdest, 0));
1584 dest1 = in_over (vsrc, vsrca, load8888 (&m1),
1585 expand8888 (vdest, 1));
1586
1587 *(__m64 *)q = pack8888 (dest0, dest1);
1588 }
1589
1590 p += 2;
1591 q += 2;
1592 twidth -= 2;
1593 }
1594
1595 if (twidth)
1596 {
1597 uint32_t m = *(uint32_t *)p;
1598
1599 if (m)
1600 {
1601 __m64 vdest = load8888 (q);
1602 vdest = in_over (vsrc, vsrca, load8888 (&m), vdest);
1603 store8888 (q, vdest);
1604 }
1605
1606 twidth--;
1607 p++;
1608 q++;
1609 }
1610
1611 dst_line += dst_stride;
1612 mask_line += mask_stride;
1613 }
1614
1615 _mm_empty ();
1616}
1617
1618static void
1619mmx_composite_over_8888_n_8888 (pixman_implementation_t *imp,
1620 pixman_composite_info_t *info)
1621{
1622 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1623 uint32_t *dst_line, *dst;
1624 uint32_t *src_line, *src;
1625 uint32_t mask;
1626 __m64 vmask;
1627 int dst_stride, src_stride;
1628 int32_t w;
1629
1630 CHECKPOINT ();
1631
1632 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1633 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
1634
1635 mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);
1636 vmask = expand_alpha (load8888 (&mask));
1637
1638 while (height--)
1639 {
1640 dst = dst_line;
1641 dst_line += dst_stride;
1642 src = src_line;
1643 src_line += src_stride;
1644 w = width;
1645
1646 while (w && (uintptr_t)dst & 7)
1647 {
1648 __m64 s = load8888 (src);
1649 __m64 d = load8888 (dst);
1650
1651 store8888 (dst, in_over (s, expand_alpha (s), vmask, d));
1652
1653 w--;
1654 dst++;
1655 src++;
1656 }
1657
1658 while (w >= 2)
1659 {
1660 __m64 vs = ldq_u ((__m64 *)src);
1661 __m64 vd = *(__m64 *)dst;
1662 __m64 vsrc0 = expand8888 (vs, 0);
1663 __m64 vsrc1 = expand8888 (vs, 1);
1664
1665 *(__m64 *)dst = pack8888 (
1666 in_over (vsrc0, expand_alpha (vsrc0), vmask, expand8888 (vd, 0)),
1667 in_over (vsrc1, expand_alpha (vsrc1), vmask, expand8888 (vd, 1)));
1668
1669 w -= 2;
1670 dst += 2;
1671 src += 2;
1672 }
1673
1674 if (w)
1675 {
1676 __m64 s = load8888 (src);
1677 __m64 d = load8888 (dst);
1678
1679 store8888 (dst, in_over (s, expand_alpha (s), vmask, d));
1680 }
1681 }
1682
1683 _mm_empty ();
1684}
1685
1686static void
1687mmx_composite_over_x888_n_8888 (pixman_implementation_t *imp,
1688 pixman_composite_info_t *info)
1689{
1690 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1691 uint32_t *dst_line, *dst;
1692 uint32_t *src_line, *src;
1693 uint32_t mask;
1694 __m64 vmask;
1695 int dst_stride, src_stride;
1696 int32_t w;
1697 __m64 srca;
1698
1699 CHECKPOINT ();
1700
1701 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1702 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
1703 mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format);
1704
1705 vmask = expand_alpha (load8888 (&mask));
1706 srca = MC (4x00ff)((__m64)c.mmx_4x00ff);
1707
1708 while (height--)
1709 {
1710 dst = dst_line;
1711 dst_line += dst_stride;
1712 src = src_line;
1713 src_line += src_stride;
1714 w = width;
1715
1716 while (w && (uintptr_t)dst & 7)
1717 {
1718 uint32_t ssrc = *src | 0xff000000;
1719 __m64 s = load8888 (&ssrc);
1720 __m64 d = load8888 (dst);
1721
1722 store8888 (dst, in_over (s, srca, vmask, d));
1723
1724 w--;
1725 dst++;
1726 src++;
1727 }
1728
1729 while (w >= 16)
1730 {
1731 __m64 vd0 = *(__m64 *)(dst + 0);
1732 __m64 vd1 = *(__m64 *)(dst + 2);
1733 __m64 vd2 = *(__m64 *)(dst + 4);
1734 __m64 vd3 = *(__m64 *)(dst + 6);
1735 __m64 vd4 = *(__m64 *)(dst + 8);
1736 __m64 vd5 = *(__m64 *)(dst + 10);
1737 __m64 vd6 = *(__m64 *)(dst + 12);
1738 __m64 vd7 = *(__m64 *)(dst + 14);
1739
1740 __m64 vs0 = ldq_u ((__m64 *)(src + 0));
1741 __m64 vs1 = ldq_u ((__m64 *)(src + 2));
1742 __m64 vs2 = ldq_u ((__m64 *)(src + 4));
1743 __m64 vs3 = ldq_u ((__m64 *)(src + 6));
1744 __m64 vs4 = ldq_u ((__m64 *)(src + 8));
1745 __m64 vs5 = ldq_u ((__m64 *)(src + 10));
1746 __m64 vs6 = ldq_u ((__m64 *)(src + 12));
1747 __m64 vs7 = ldq_u ((__m64 *)(src + 14));
1748
1749 vd0 = pack8888 (
1750 in_over (expandx888 (vs0, 0), srca, vmask, expand8888 (vd0, 0)),
1751 in_over (expandx888 (vs0, 1), srca, vmask, expand8888 (vd0, 1)));
1752
1753 vd1 = pack8888 (
1754 in_over (expandx888 (vs1, 0), srca, vmask, expand8888 (vd1, 0)),
1755 in_over (expandx888 (vs1, 1), srca, vmask, expand8888 (vd1, 1)));
1756
1757 vd2 = pack8888 (
1758 in_over (expandx888 (vs2, 0), srca, vmask, expand8888 (vd2, 0)),
1759 in_over (expandx888 (vs2, 1), srca, vmask, expand8888 (vd2, 1)));
1760
1761 vd3 = pack8888 (
1762 in_over (expandx888 (vs3, 0), srca, vmask, expand8888 (vd3, 0)),
1763 in_over (expandx888 (vs3, 1), srca, vmask, expand8888 (vd3, 1)));
1764
1765 vd4 = pack8888 (
1766 in_over (expandx888 (vs4, 0), srca, vmask, expand8888 (vd4, 0)),
1767 in_over (expandx888 (vs4, 1), srca, vmask, expand8888 (vd4, 1)));
1768
1769 vd5 = pack8888 (
1770 in_over (expandx888 (vs5, 0), srca, vmask, expand8888 (vd5, 0)),
1771 in_over (expandx888 (vs5, 1), srca, vmask, expand8888 (vd5, 1)));
1772
1773 vd6 = pack8888 (
1774 in_over (expandx888 (vs6, 0), srca, vmask, expand8888 (vd6, 0)),
1775 in_over (expandx888 (vs6, 1), srca, vmask, expand8888 (vd6, 1)));
1776
1777 vd7 = pack8888 (
1778 in_over (expandx888 (vs7, 0), srca, vmask, expand8888 (vd7, 0)),
1779 in_over (expandx888 (vs7, 1), srca, vmask, expand8888 (vd7, 1)));
1780
1781 *(__m64 *)(dst + 0) = vd0;
1782 *(__m64 *)(dst + 2) = vd1;
1783 *(__m64 *)(dst + 4) = vd2;
1784 *(__m64 *)(dst + 6) = vd3;
1785 *(__m64 *)(dst + 8) = vd4;
1786 *(__m64 *)(dst + 10) = vd5;
1787 *(__m64 *)(dst + 12) = vd6;
1788 *(__m64 *)(dst + 14) = vd7;
1789
1790 w -= 16;
1791 dst += 16;
1792 src += 16;
1793 }
1794
1795 while (w)
1796 {
1797 uint32_t ssrc = *src | 0xff000000;
1798 __m64 s = load8888 (&ssrc);
1799 __m64 d = load8888 (dst);
1800
1801 store8888 (dst, in_over (s, srca, vmask, d));
1802
1803 w--;
1804 dst++;
1805 src++;
1806 }
1807 }
1808
1809 _mm_empty ();
1810}
1811
1812static void
1813mmx_composite_over_8888_8888 (pixman_implementation_t *imp,
1814 pixman_composite_info_t *info)
1815{
1816 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1817 uint32_t *dst_line, *dst;
1818 uint32_t *src_line, *src;
1819 uint32_t s;
1820 int dst_stride, src_stride;
1821 uint8_t a;
1822 int32_t w;
1823
1824 CHECKPOINT ();
1825
1826 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1827 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
1828
1829 while (height--)
1830 {
1831 dst = dst_line;
1832 dst_line += dst_stride;
1833 src = src_line;
1834 src_line += src_stride;
1835 w = width;
1836
1837 while (w--)
1838 {
1839 s = *src++;
1840 a = s >> 24;
1841
1842 if (a == 0xff)
1843 {
1844 *dst = s;
1845 }
1846 else if (s)
1847 {
1848 __m64 ms, sa;
1849 ms = load8888 (&s);
1850 sa = expand_alpha (ms);
1851 store8888 (dst, over (ms, sa, load8888 (dst)));
1852 }
1853
1854 dst++;
1855 }
1856 }
1857 _mm_empty ();
1858}
1859
1860static void
1861mmx_composite_over_8888_0565 (pixman_implementation_t *imp,
1862 pixman_composite_info_t *info)
1863{
1864 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1865 uint16_t *dst_line, *dst;
1866 uint32_t *src_line, *src;
1867 int dst_stride, src_stride;
1868 int32_t w;
1869
1870 CHECKPOINT ();
1871
1872 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1873 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
1874
1875#if 0
1876 /* FIXME */
1877 assert (src_image->drawable == mask_image->drawable)(__builtin_expect(!(src_image->drawable == mask_image->
drawable), 0) ? __assert_rtn(__func__, "pixman-mmx.c", 1877, "src_image->drawable == mask_image->drawable"
) : (void)0)
;
1878#endif
1879
1880 while (height--)
1881 {
1882 dst = dst_line;
1883 dst_line += dst_stride;
1884 src = src_line;
1885 src_line += src_stride;
1886 w = width;
1887
1888 CHECKPOINT ();
1889
1890 while (w && (uintptr_t)dst & 7)
1891 {
1892 __m64 vsrc = load8888 (src);
1893 uint64_t d = *dst;
1894 __m64 vdest = expand565 (to_m64 (d), 0);
1895
1896 vdest = pack_565 (
1897 over (vsrc, expand_alpha (vsrc), vdest), vdest, 0);
1898
1899 *dst = to_uint64 (vdest);
1900
1901 w--;
1902 dst++;
1903 src++;
1904 }
1905
1906 CHECKPOINT ();
1907
1908 while (w >= 4)
1909 {
1910 __m64 vdest = *(__m64 *)dst;
1911 __m64 v0, v1, v2, v3;
1912 __m64 vsrc0, vsrc1, vsrc2, vsrc3;
1913
1914 expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
1915
1916 vsrc0 = load8888 ((src + 0));
1917 vsrc1 = load8888 ((src + 1));
1918 vsrc2 = load8888 ((src + 2));
1919 vsrc3 = load8888 ((src + 3));
1920
1921 v0 = over (vsrc0, expand_alpha (vsrc0), v0);
1922 v1 = over (vsrc1, expand_alpha (vsrc1), v1);
1923 v2 = over (vsrc2, expand_alpha (vsrc2), v2);
1924 v3 = over (vsrc3, expand_alpha (vsrc3), v3);
1925
1926 *(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
1927
1928 w -= 4;
1929 dst += 4;
1930 src += 4;
1931 }
1932
1933 CHECKPOINT ();
1934
1935 while (w)
1936 {
1937 __m64 vsrc = load8888 (src);
1938 uint64_t d = *dst;
1939 __m64 vdest = expand565 (to_m64 (d), 0);
1940
1941 vdest = pack_565 (over (vsrc, expand_alpha (vsrc), vdest), vdest, 0);
1942
1943 *dst = to_uint64 (vdest);
1944
1945 w--;
1946 dst++;
1947 src++;
1948 }
1949 }
1950
1951 _mm_empty ();
1952}
1953
1954static void
1955mmx_composite_over_n_8_8888 (pixman_implementation_t *imp,
1956 pixman_composite_info_t *info)
1957{
1958 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
1959 uint32_t src, srca;
1960 uint32_t *dst_line, *dst;
1961 uint8_t *mask_line, *mask;
1962 int dst_stride, mask_stride;
1963 int32_t w;
1964 __m64 vsrc, vsrca;
1965 uint64_t srcsrc;
1966
1967 CHECKPOINT ();
1968
1969 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
1970
1971 srca = src >> 24;
1972 if (src == 0)
1973 return;
1974
1975 srcsrc = (uint64_t)src << 32 | src;
1976
1977 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
1978 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (mask_line) = ((uint8_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
1979
1980 vsrc = load8888 (&src);
1981 vsrca = expand_alpha (vsrc);
1982
1983 while (height--)
1984 {
1985 dst = dst_line;
1986 dst_line += dst_stride;
1987 mask = mask_line;
1988 mask_line += mask_stride;
1989 w = width;
1990
1991 CHECKPOINT ();
1992
1993 while (w && (uintptr_t)dst & 7)
1994 {
1995 uint64_t m = *mask;
1996
1997 if (m)
1998 {
1999 __m64 vdest = in_over (vsrc, vsrca,
2000 expand_alpha_rev (to_m64 (m)),
2001 load8888 (dst));
2002
2003 store8888 (dst, vdest);
2004 }
2005
2006 w--;
2007 mask++;
2008 dst++;
2009 }
2010
2011 CHECKPOINT ();
2012
2013 while (w >= 2)
2014 {
2015 uint64_t m0, m1;
2016
2017 m0 = *mask;
2018 m1 = *(mask + 1);
2019
2020 if (srca == 0xff && (m0 & m1) == 0xff)
2021 {
2022 *(uint64_t *)dst = srcsrc;
2023 }
2024 else if (m0 | m1)
2025 {
2026 __m64 vdest;
2027 __m64 dest0, dest1;
2028
2029 vdest = *(__m64 *)dst;
2030
2031 dest0 = in_over (vsrc, vsrca, expand_alpha_rev (to_m64 (m0)),
2032 expand8888 (vdest, 0));
2033 dest1 = in_over (vsrc, vsrca, expand_alpha_rev (to_m64 (m1)),
2034 expand8888 (vdest, 1));
2035
2036 *(__m64 *)dst = pack8888 (dest0, dest1);
2037 }
2038
2039 mask += 2;
2040 dst += 2;
2041 w -= 2;
2042 }
2043
2044 CHECKPOINT ();
2045
2046 if (w)
2047 {
2048 uint64_t m = *mask;
2049
2050 if (m)
2051 {
2052 __m64 vdest = load8888 (dst);
2053
2054 vdest = in_over (
2055 vsrc, vsrca, expand_alpha_rev (to_m64 (m)), vdest);
2056 store8888 (dst, vdest);
2057 }
2058 }
2059 }
2060
2061 _mm_empty ();
2062}
2063
2064static pixman_bool_t
2065mmx_fill (pixman_implementation_t *imp,
2066 uint32_t * bits,
2067 int stride,
2068 int bpp,
2069 int x,
2070 int y,
2071 int width,
2072 int height,
2073 uint32_t filler)
2074{
2075 uint64_t fill;
2076 __m64 vfill;
2077 uint32_t byte_width;
2078 uint8_t *byte_line;
2079
2080#if defined __GNUC__4 && defined USE_X86_MMX1
2081 __m64 v1, v2, v3, v4, v5, v6, v7;
2082#endif
2083
2084 if (bpp != 16 && bpp != 32 && bpp != 8)
2085 return FALSE0;
2086
2087 if (bpp == 8)
2088 {
2089 stride = stride * (int) sizeof (uint32_t) / 1;
2090 byte_line = (uint8_t *)(((uint8_t *)bits) + stride * y + x);
2091 byte_width = width;
2092 stride *= 1;
2093 filler = (filler & 0xff) * 0x01010101;
2094 }
2095 else if (bpp == 16)
2096 {
2097 stride = stride * (int) sizeof (uint32_t) / 2;
2098 byte_line = (uint8_t *)(((uint16_t *)bits) + stride * y + x);
2099 byte_width = 2 * width;
2100 stride *= 2;
2101 filler = (filler & 0xffff) * 0x00010001;
2102 }
2103 else
2104 {
2105 stride = stride * (int) sizeof (uint32_t) / 4;
2106 byte_line = (uint8_t *)(((uint32_t *)bits) + stride * y + x);
2107 byte_width = 4 * width;
2108 stride *= 4;
2109 }
2110
2111 fill = ((uint64_t)filler << 32) | filler;
2112 vfill = to_m64 (fill);
2113
2114#if defined __GNUC__4 && defined USE_X86_MMX1
2115 __asm__ (
2116 "movq %7, %0\n"
2117 "movq %7, %1\n"
2118 "movq %7, %2\n"
2119 "movq %7, %3\n"
2120 "movq %7, %4\n"
2121 "movq %7, %5\n"
2122 "movq %7, %6\n"
2123 : "=&y" (v1), "=&y" (v2), "=&y" (v3),
2124 "=&y" (v4), "=&y" (v5), "=&y" (v6), "=y" (v7)
2125 : "y" (vfill));
2126#endif
2127
2128 while (height--)
2129 {
2130 int w;
2131 uint8_t *d = byte_line;
2132
2133 byte_line += stride;
2134 w = byte_width;
2135
2136 if (w >= 1 && ((uintptr_t)d & 1))
2137 {
2138 *(uint8_t *)d = (filler & 0xff);
2139 w--;
2140 d++;
2141 }
2142
2143 if (w >= 2 && ((uintptr_t)d & 3))
2144 {
2145 *(uint16_t *)d = filler;
2146 w -= 2;
2147 d += 2;
2148 }
2149
2150 while (w >= 4 && ((uintptr_t)d & 7))
2151 {
2152 *(uint32_t *)d = filler;
2153
2154 w -= 4;
2155 d += 4;
2156 }
2157
2158 while (w >= 64)
2159 {
2160#if defined __GNUC__4 && defined USE_X86_MMX1
2161 __asm__ (
2162 "movq %1, (%0)\n"
2163 "movq %2, 8(%0)\n"
2164 "movq %3, 16(%0)\n"
2165 "movq %4, 24(%0)\n"
2166 "movq %5, 32(%0)\n"
2167 "movq %6, 40(%0)\n"
2168 "movq %7, 48(%0)\n"
2169 "movq %8, 56(%0)\n"
2170 :
2171 : "r" (d),
2172 "y" (vfill), "y" (v1), "y" (v2), "y" (v3),
2173 "y" (v4), "y" (v5), "y" (v6), "y" (v7)
2174 : "memory");
2175#else
2176 *(__m64*) (d + 0) = vfill;
2177 *(__m64*) (d + 8) = vfill;
2178 *(__m64*) (d + 16) = vfill;
2179 *(__m64*) (d + 24) = vfill;
2180 *(__m64*) (d + 32) = vfill;
2181 *(__m64*) (d + 40) = vfill;
2182 *(__m64*) (d + 48) = vfill;
2183 *(__m64*) (d + 56) = vfill;
2184#endif
2185 w -= 64;
2186 d += 64;
2187 }
2188
2189 while (w >= 4)
2190 {
2191 *(uint32_t *)d = filler;
2192
2193 w -= 4;
2194 d += 4;
2195 }
2196 if (w >= 2)
2197 {
2198 *(uint16_t *)d = filler;
2199 w -= 2;
2200 d += 2;
2201 }
2202 if (w >= 1)
2203 {
2204 *(uint8_t *)d = (filler & 0xff);
2205 w--;
2206 d++;
2207 }
2208
2209 }
2210
2211 _mm_empty ();
2212 return TRUE1;
2213}
2214
2215static void
2216mmx_composite_src_x888_0565 (pixman_implementation_t *imp,
2217 pixman_composite_info_t *info)
2218{
2219 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2220 uint16_t *dst_line, *dst;
2221 uint32_t *src_line, *src, s;
2222 int dst_stride, src_stride;
2223 int32_t w;
2224
2225 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
2226 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2227
2228 while (height--)
2229 {
2230 dst = dst_line;
2231 dst_line += dst_stride;
2232 src = src_line;
2233 src_line += src_stride;
2234 w = width;
2235
2236 while (w && (uintptr_t)dst & 7)
2237 {
2238 s = *src++;
2239 *dst = convert_8888_to_0565 (s);
2240 dst++;
2241 w--;
2242 }
2243
2244 while (w >= 4)
2245 {
2246 __m64 vdest;
2247 __m64 vsrc0 = ldq_u ((__m64 *)(src + 0));
2248 __m64 vsrc1 = ldq_u ((__m64 *)(src + 2));
2249
2250 vdest = pack_4xpacked565 (vsrc0, vsrc1);
2251
2252 *(__m64 *)dst = vdest;
2253
2254 w -= 4;
2255 src += 4;
2256 dst += 4;
2257 }
2258
2259 while (w)
2260 {
2261 s = *src++;
2262 *dst = convert_8888_to_0565 (s);
2263 dst++;
2264 w--;
2265 }
2266 }
2267
2268 _mm_empty ();
2269}
2270
2271static void
2272mmx_composite_src_n_8_8888 (pixman_implementation_t *imp,
2273 pixman_composite_info_t *info)
2274{
2275 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2276 uint32_t src, srca;
2277 uint32_t *dst_line, *dst;
2278 uint8_t *mask_line, *mask;
2279 int dst_stride, mask_stride;
2280 int32_t w;
2281 __m64 vsrc;
2282 uint64_t srcsrc;
2283
2284 CHECKPOINT ();
2285
2286 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
2287
2288 srca = src >> 24;
2289 if (src == 0)
2290 {
2291 mmx_fill (imp, dest_image->bits.bits, dest_image->bits.rowstride,
2292 PIXMAN_FORMAT_BPP (dest_image->bits.format)(((dest_image->bits.format) >> 24) ),
2293 dest_x, dest_y, width, height, 0);
2294 return;
2295 }
2296
2297 srcsrc = (uint64_t)src << 32 | src;
2298
2299 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2300 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (mask_line) = ((uint8_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
2301
2302 vsrc = load8888 (&src);
2303
2304 while (height--)
2305 {
2306 dst = dst_line;
2307 dst_line += dst_stride;
2308 mask = mask_line;
2309 mask_line += mask_stride;
2310 w = width;
2311
2312 CHECKPOINT ();
2313
2314 while (w && (uintptr_t)dst & 7)
2315 {
2316 uint64_t m = *mask;
2317
2318 if (m)
2319 {
2320 __m64 vdest = in (vsrc, expand_alpha_rev (to_m64 (m)));
2321
2322 store8888 (dst, vdest);
2323 }
2324 else
2325 {
2326 *dst = 0;
2327 }
2328
2329 w--;
2330 mask++;
2331 dst++;
2332 }
2333
2334 CHECKPOINT ();
2335
2336 while (w >= 2)
2337 {
2338 uint64_t m0, m1;
2339 m0 = *mask;
2340 m1 = *(mask + 1);
2341
2342 if (srca == 0xff && (m0 & m1) == 0xff)
2343 {
2344 *(uint64_t *)dst = srcsrc;
2345 }
2346 else if (m0 | m1)
2347 {
2348 __m64 dest0, dest1;
2349
2350 dest0 = in (vsrc, expand_alpha_rev (to_m64 (m0)));
2351 dest1 = in (vsrc, expand_alpha_rev (to_m64 (m1)));
2352
2353 *(__m64 *)dst = pack8888 (dest0, dest1);
2354 }
2355 else
2356 {
2357 *(uint64_t *)dst = 0;
2358 }
2359
2360 mask += 2;
2361 dst += 2;
2362 w -= 2;
2363 }
2364
2365 CHECKPOINT ();
2366
2367 if (w)
2368 {
2369 uint64_t m = *mask;
2370
2371 if (m)
2372 {
2373 __m64 vdest = load8888 (dst);
2374
2375 vdest = in (vsrc, expand_alpha_rev (to_m64 (m)));
2376 store8888 (dst, vdest);
2377 }
2378 else
2379 {
2380 *dst = 0;
2381 }
2382 }
2383 }
2384
2385 _mm_empty ();
2386}
2387
2388static void
2389mmx_composite_over_n_8_0565 (pixman_implementation_t *imp,
2390 pixman_composite_info_t *info)
2391{
2392 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2393 uint32_t src, srca;
2394 uint16_t *dst_line, *dst;
2395 uint8_t *mask_line, *mask;
2396 int dst_stride, mask_stride;
2397 int32_t w;
2398 __m64 vsrc, vsrca, tmp;
2399 __m64 srcsrcsrcsrc;
2400
2401 CHECKPOINT ();
2402
2403 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
2404
2405 srca = src >> 24;
2406 if (src == 0)
2407 return;
2408
2409 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2410 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (mask_line) = ((uint8_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
2411
2412 vsrc = load8888 (&src);
2413 vsrca = expand_alpha (vsrc);
2414
2415 tmp = pack_565 (vsrc, _mm_setzero_si64 (), 0);
2416 srcsrcsrcsrc = expand_alpha_rev (tmp);
2417
2418 while (height--)
2419 {
2420 dst = dst_line;
2421 dst_line += dst_stride;
2422 mask = mask_line;
2423 mask_line += mask_stride;
2424 w = width;
2425
2426 CHECKPOINT ();
2427
2428 while (w && (uintptr_t)dst & 7)
2429 {
2430 uint64_t m = *mask;
2431
2432 if (m)
2433 {
2434 uint64_t d = *dst;
2435 __m64 vd = to_m64 (d);
2436 __m64 vdest = in_over (
2437 vsrc, vsrca, expand_alpha_rev (to_m64 (m)), expand565 (vd, 0));
2438
2439 vd = pack_565 (vdest, _mm_setzero_si64 (), 0);
2440 *dst = to_uint64 (vd);
2441 }
2442
2443 w--;
2444 mask++;
2445 dst++;
2446 }
2447
2448 CHECKPOINT ();
2449
2450 while (w >= 4)
2451 {
2452 uint64_t m0, m1, m2, m3;
2453 m0 = *mask;
2454 m1 = *(mask + 1);
2455 m2 = *(mask + 2);
2456 m3 = *(mask + 3);
2457
2458 if (srca == 0xff && (m0 & m1 & m2 & m3) == 0xff)
2459 {
2460 *(__m64 *)dst = srcsrcsrcsrc;
2461 }
2462 else if (m0 | m1 | m2 | m3)
2463 {
2464 __m64 vdest = *(__m64 *)dst;
2465 __m64 v0, v1, v2, v3;
2466 __m64 vm0, vm1, vm2, vm3;
2467
2468 expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
2469
2470 vm0 = to_m64 (m0);
2471 v0 = in_over (vsrc, vsrca, expand_alpha_rev (vm0), v0);
2472
2473 vm1 = to_m64 (m1);
2474 v1 = in_over (vsrc, vsrca, expand_alpha_rev (vm1), v1);
2475
2476 vm2 = to_m64 (m2);
2477 v2 = in_over (vsrc, vsrca, expand_alpha_rev (vm2), v2);
2478
2479 vm3 = to_m64 (m3);
2480 v3 = in_over (vsrc, vsrca, expand_alpha_rev (vm3), v3);
2481
2482 *(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);;
2483 }
2484
2485 w -= 4;
2486 mask += 4;
2487 dst += 4;
2488 }
2489
2490 CHECKPOINT ();
2491
2492 while (w)
2493 {
2494 uint64_t m = *mask;
2495
2496 if (m)
2497 {
2498 uint64_t d = *dst;
2499 __m64 vd = to_m64 (d);
2500 __m64 vdest = in_over (vsrc, vsrca, expand_alpha_rev (to_m64 (m)),
2501 expand565 (vd, 0));
2502 vd = pack_565 (vdest, _mm_setzero_si64 (), 0);
2503 *dst = to_uint64 (vd);
2504 }
2505
2506 w--;
2507 mask++;
2508 dst++;
2509 }
2510 }
2511
2512 _mm_empty ();
2513}
2514
2515static void
2516mmx_composite_over_pixbuf_0565 (pixman_implementation_t *imp,
2517 pixman_composite_info_t *info)
2518{
2519 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2520 uint16_t *dst_line, *dst;
2521 uint32_t *src_line, *src;
2522 int dst_stride, src_stride;
2523 int32_t w;
2524
2525 CHECKPOINT ();
2526
2527 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2528 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
2529
2530#if 0
2531 /* FIXME */
2532 assert (src_image->drawable == mask_image->drawable)(__builtin_expect(!(src_image->drawable == mask_image->
drawable), 0) ? __assert_rtn(__func__, "pixman-mmx.c", 2532, "src_image->drawable == mask_image->drawable"
) : (void)0)
;
2533#endif
2534
2535 while (height--)
2536 {
2537 dst = dst_line;
2538 dst_line += dst_stride;
2539 src = src_line;
2540 src_line += src_stride;
2541 w = width;
2542
2543 CHECKPOINT ();
2544
2545 while (w && (uintptr_t)dst & 7)
2546 {
2547 __m64 vsrc = load8888 (src);
2548 uint64_t d = *dst;
2549 __m64 vdest = expand565 (to_m64 (d), 0);
2550
2551 vdest = pack_565 (over_rev_non_pre (vsrc, vdest), vdest, 0);
2552
2553 *dst = to_uint64 (vdest);
2554
2555 w--;
2556 dst++;
2557 src++;
2558 }
2559
2560 CHECKPOINT ();
2561
2562 while (w >= 4)
2563 {
2564 uint32_t s0, s1, s2, s3;
2565 unsigned char a0, a1, a2, a3;
2566
2567 s0 = *src;
2568 s1 = *(src + 1);
2569 s2 = *(src + 2);
2570 s3 = *(src + 3);
2571
2572 a0 = (s0 >> 24);
2573 a1 = (s1 >> 24);
2574 a2 = (s2 >> 24);
2575 a3 = (s3 >> 24);
2576
2577 if ((a0 & a1 & a2 & a3) == 0xFF)
2578 {
2579 __m64 v0 = invert_colors (load8888 (&s0));
2580 __m64 v1 = invert_colors (load8888 (&s1));
2581 __m64 v2 = invert_colors (load8888 (&s2));
2582 __m64 v3 = invert_colors (load8888 (&s3));
2583
2584 *(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
2585 }
2586 else if (s0 | s1 | s2 | s3)
2587 {
2588 __m64 vdest = *(__m64 *)dst;
2589 __m64 v0, v1, v2, v3;
2590
2591 __m64 vsrc0 = load8888 (&s0);
2592 __m64 vsrc1 = load8888 (&s1);
2593 __m64 vsrc2 = load8888 (&s2);
2594 __m64 vsrc3 = load8888 (&s3);
2595
2596 expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
2597
2598 v0 = over_rev_non_pre (vsrc0, v0);
2599 v1 = over_rev_non_pre (vsrc1, v1);
2600 v2 = over_rev_non_pre (vsrc2, v2);
2601 v3 = over_rev_non_pre (vsrc3, v3);
2602
2603 *(__m64 *)dst = pack_4x565 (v0, v1, v2, v3);
2604 }
2605
2606 w -= 4;
2607 dst += 4;
2608 src += 4;
2609 }
2610
2611 CHECKPOINT ();
2612
2613 while (w)
2614 {
2615 __m64 vsrc = load8888 (src);
2616 uint64_t d = *dst;
2617 __m64 vdest = expand565 (to_m64 (d), 0);
2618
2619 vdest = pack_565 (over_rev_non_pre (vsrc, vdest), vdest, 0);
2620
2621 *dst = to_uint64 (vdest);
2622
2623 w--;
2624 dst++;
2625 src++;
2626 }
2627 }
2628
2629 _mm_empty ();
2630}
2631
2632static void
2633mmx_composite_over_pixbuf_8888 (pixman_implementation_t *imp,
2634 pixman_composite_info_t *info)
2635{
2636 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2637 uint32_t *dst_line, *dst;
2638 uint32_t *src_line, *src;
2639 int dst_stride, src_stride;
2640 int32_t w;
2641
2642 CHECKPOINT ();
2643
2644 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2645 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
2646
2647#if 0
2648 /* FIXME */
2649 assert (src_image->drawable == mask_image->drawable)(__builtin_expect(!(src_image->drawable == mask_image->
drawable), 0) ? __assert_rtn(__func__, "pixman-mmx.c", 2649, "src_image->drawable == mask_image->drawable"
) : (void)0)
;
2650#endif
2651
2652 while (height--)
2653 {
2654 dst = dst_line;
2655 dst_line += dst_stride;
2656 src = src_line;
2657 src_line += src_stride;
2658 w = width;
2659
2660 while (w && (uintptr_t)dst & 7)
2661 {
2662 __m64 s = load8888 (src);
2663 __m64 d = load8888 (dst);
2664
2665 store8888 (dst, over_rev_non_pre (s, d));
2666
2667 w--;
2668 dst++;
2669 src++;
2670 }
2671
2672 while (w >= 2)
2673 {
2674 uint32_t s0, s1;
2675 unsigned char a0, a1;
2676 __m64 d0, d1;
2677
2678 s0 = *src;
2679 s1 = *(src + 1);
2680
2681 a0 = (s0 >> 24);
2682 a1 = (s1 >> 24);
2683
2684 if ((a0 & a1) == 0xFF)
2685 {
2686 d0 = invert_colors (load8888 (&s0));
2687 d1 = invert_colors (load8888 (&s1));
2688
2689 *(__m64 *)dst = pack8888 (d0, d1);
2690 }
2691 else if (s0 | s1)
2692 {
2693 __m64 vdest = *(__m64 *)dst;
2694
2695 d0 = over_rev_non_pre (load8888 (&s0), expand8888 (vdest, 0));
2696 d1 = over_rev_non_pre (load8888 (&s1), expand8888 (vdest, 1));
2697
2698 *(__m64 *)dst = pack8888 (d0, d1);
2699 }
2700
2701 w -= 2;
2702 dst += 2;
2703 src += 2;
2704 }
2705
2706 if (w)
2707 {
2708 __m64 s = load8888 (src);
2709 __m64 d = load8888 (dst);
2710
2711 store8888 (dst, over_rev_non_pre (s, d));
2712 }
2713 }
2714
2715 _mm_empty ();
2716}
2717
2718static void
2719mmx_composite_over_n_8888_0565_ca (pixman_implementation_t *imp,
2720 pixman_composite_info_t *info)
2721{
2722 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2723 uint32_t src;
2724 uint16_t *dst_line;
2725 uint32_t *mask_line;
2726 int dst_stride, mask_stride;
2727 __m64 vsrc, vsrca;
2728
2729 CHECKPOINT ();
2730
2731 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
2732
2733 if (src == 0)
2734 return;
2735
2736 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2737 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint32_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (mask_line) = ((uint32_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
2738
2739 vsrc = load8888 (&src);
2740 vsrca = expand_alpha (vsrc);
2741
2742 while (height--)
2743 {
2744 int twidth = width;
2745 uint32_t *p = (uint32_t *)mask_line;
2746 uint16_t *q = (uint16_t *)dst_line;
2747
2748 while (twidth && ((uintptr_t)q & 7))
2749 {
2750 uint32_t m = *(uint32_t *)p;
2751
2752 if (m)
2753 {
2754 uint64_t d = *q;
2755 __m64 vdest = expand565 (to_m64 (d), 0);
2756 vdest = pack_565 (in_over (vsrc, vsrca, load8888 (&m), vdest), vdest, 0);
2757 *q = to_uint64 (vdest);
2758 }
2759
2760 twidth--;
2761 p++;
2762 q++;
2763 }
2764
2765 while (twidth >= 4)
2766 {
2767 uint32_t m0, m1, m2, m3;
2768
2769 m0 = *p;
2770 m1 = *(p + 1);
2771 m2 = *(p + 2);
2772 m3 = *(p + 3);
2773
2774 if ((m0 | m1 | m2 | m3))
2775 {
2776 __m64 vdest = *(__m64 *)q;
2777 __m64 v0, v1, v2, v3;
2778
2779 expand_4x565 (vdest, &v0, &v1, &v2, &v3, 0);
2780
2781 v0 = in_over (vsrc, vsrca, load8888 (&m0), v0);
2782 v1 = in_over (vsrc, vsrca, load8888 (&m1), v1);
2783 v2 = in_over (vsrc, vsrca, load8888 (&m2), v2);
2784 v3 = in_over (vsrc, vsrca, load8888 (&m3), v3);
2785
2786 *(__m64 *)q = pack_4x565 (v0, v1, v2, v3);
2787 }
2788 twidth -= 4;
2789 p += 4;
2790 q += 4;
2791 }
2792
2793 while (twidth)
2794 {
2795 uint32_t m;
2796
2797 m = *(uint32_t *)p;
2798 if (m)
2799 {
2800 uint64_t d = *q;
2801 __m64 vdest = expand565 (to_m64 (d), 0);
2802 vdest = pack_565 (in_over (vsrc, vsrca, load8888 (&m), vdest), vdest, 0);
2803 *q = to_uint64 (vdest);
2804 }
2805
2806 twidth--;
2807 p++;
2808 q++;
2809 }
2810
2811 mask_line += mask_stride;
2812 dst_line += dst_stride;
2813 }
2814
2815 _mm_empty ();
2816}
2817
2818static void
2819mmx_composite_in_n_8_8 (pixman_implementation_t *imp,
2820 pixman_composite_info_t *info)
2821{
2822 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2823 uint8_t *dst_line, *dst;
2824 uint8_t *mask_line, *mask;
2825 int dst_stride, mask_stride;
2826 int32_t w;
2827 uint32_t src;
2828 uint8_t sa;
2829 __m64 vsrc, vsrca;
2830
2831 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (dst_line) = ((uint8_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2832 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (mask_line) = ((uint8_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
2833
2834 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
2835
2836 sa = src >> 24;
2837
2838 vsrc = load8888 (&src);
2839 vsrca = expand_alpha (vsrc);
2840
2841 while (height--)
2842 {
2843 dst = dst_line;
2844 dst_line += dst_stride;
2845 mask = mask_line;
2846 mask_line += mask_stride;
2847 w = width;
2848
2849 while (w && (uintptr_t)dst & 7)
2850 {
2851 uint16_t tmp;
2852 uint8_t a;
2853 uint32_t m, d;
2854
2855 a = *mask++;
2856 d = *dst;
2857
2858 m = MUL_UN8 (sa, a, tmp)((tmp) = (sa) * (uint16_t)(a) + 0x80, ((((tmp) >> 8 ) +
(tmp) ) >> 8 ))
;
2859 d = MUL_UN8 (m, d, tmp)((tmp) = (m) * (uint16_t)(d) + 0x80, ((((tmp) >> 8 ) + (
tmp) ) >> 8 ))
;
2860
2861 *dst++ = d;
2862 w--;
2863 }
2864
2865 while (w >= 4)
2866 {
2867 __m64 vmask;
2868 __m64 vdest;
2869
2870 vmask = load8888u ((uint32_t *)mask);
2871 vdest = load8888 ((uint32_t *)dst);
2872
2873 store8888 ((uint32_t *)dst, in (in (vsrca, vmask), vdest));
2874
2875 dst += 4;
2876 mask += 4;
2877 w -= 4;
2878 }
2879
2880 while (w--)
2881 {
2882 uint16_t tmp;
2883 uint8_t a;
2884 uint32_t m, d;
2885
2886 a = *mask++;
2887 d = *dst;
2888
2889 m = MUL_UN8 (sa, a, tmp)((tmp) = (sa) * (uint16_t)(a) + 0x80, ((((tmp) >> 8 ) +
(tmp) ) >> 8 ))
;
2890 d = MUL_UN8 (m, d, tmp)((tmp) = (m) * (uint16_t)(d) + 0x80, ((((tmp) >> 8 ) + (
tmp) ) >> 8 ))
;
2891
2892 *dst++ = d;
2893 }
2894 }
2895
2896 _mm_empty ();
2897}
2898
2899static void
2900mmx_composite_in_8_8 (pixman_implementation_t *imp,
2901 pixman_composite_info_t *info)
2902{
2903 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2904 uint8_t *dst_line, *dst;
2905 uint8_t *src_line, *src;
2906 int src_stride, dst_stride;
2907 int32_t w;
2908
2909 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (dst_line) = ((uint8_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2910 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (src_line) = ((uint8_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
2911
2912 while (height--)
2913 {
2914 dst = dst_line;
2915 dst_line += dst_stride;
2916 src = src_line;
2917 src_line += src_stride;
2918 w = width;
2919
2920 while (w && (uintptr_t)dst & 3)
2921 {
2922 uint8_t s, d;
2923 uint16_t tmp;
2924
2925 s = *src;
2926 d = *dst;
2927
2928 *dst = MUL_UN8 (s, d, tmp)((tmp) = (s) * (uint16_t)(d) + 0x80, ((((tmp) >> 8 ) + (
tmp) ) >> 8 ))
;
2929
2930 src++;
2931 dst++;
2932 w--;
2933 }
2934
2935 while (w >= 4)
2936 {
2937 uint32_t *s = (uint32_t *)src;
2938 uint32_t *d = (uint32_t *)dst;
2939
2940 store8888 (d, in (load8888u (s), load8888 (d)));
2941
2942 w -= 4;
2943 dst += 4;
2944 src += 4;
2945 }
2946
2947 while (w--)
2948 {
2949 uint8_t s, d;
2950 uint16_t tmp;
2951
2952 s = *src;
2953 d = *dst;
2954
2955 *dst = MUL_UN8 (s, d, tmp)((tmp) = (s) * (uint16_t)(d) + 0x80, ((((tmp) >> 8 ) + (
tmp) ) >> 8 ))
;
2956
2957 src++;
2958 dst++;
2959 }
2960 }
2961
2962 _mm_empty ();
2963}
2964
2965static void
2966mmx_composite_add_n_8_8 (pixman_implementation_t *imp,
2967 pixman_composite_info_t *info)
2968{
2969 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
2970 uint8_t *dst_line, *dst;
2971 uint8_t *mask_line, *mask;
2972 int dst_stride, mask_stride;
2973 int32_t w;
2974 uint32_t src;
2975 uint8_t sa;
2976 __m64 vsrc, vsrca;
2977
2978 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (dst_line) = ((uint8_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
2979 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (mask_line) = ((uint8_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
2980
2981 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
2982
2983 sa = src >> 24;
2984
2985 if (src == 0)
2986 return;
2987
2988 vsrc = load8888 (&src);
2989 vsrca = expand_alpha (vsrc);
2990
2991 while (height--)
2992 {
2993 dst = dst_line;
2994 dst_line += dst_stride;
2995 mask = mask_line;
2996 mask_line += mask_stride;
2997 w = width;
2998
2999 while (w && (uintptr_t)dst & 3)
3000 {
3001 uint16_t tmp;
3002 uint16_t a;
3003 uint32_t m, d;
3004 uint32_t r;
3005
3006 a = *mask++;
3007 d = *dst;
3008
3009 m = MUL_UN8 (sa, a, tmp)((tmp) = (sa) * (uint16_t)(a) + 0x80, ((((tmp) >> 8 ) +
(tmp) ) >> 8 ))
;
3010 r = ADD_UN8 (m, d, tmp)((tmp) = (m) + (d), (uint32_t) (uint8_t) ((tmp) | (0 - ((tmp)
>> 8))))
;
3011
3012 *dst++ = r;
3013 w--;
3014 }
3015
3016 while (w >= 4)
3017 {
3018 __m64 vmask;
3019 __m64 vdest;
3020
3021 vmask = load8888u ((uint32_t *)mask);
3022 vdest = load8888 ((uint32_t *)dst);
3023
3024 store8888 ((uint32_t *)dst, _mm_adds_pu8 (in (vsrca, vmask), vdest));
3025
3026 dst += 4;
3027 mask += 4;
3028 w -= 4;
3029 }
3030
3031 while (w--)
3032 {
3033 uint16_t tmp;
3034 uint16_t a;
3035 uint32_t m, d;
3036 uint32_t r;
3037
3038 a = *mask++;
3039 d = *dst;
3040
3041 m = MUL_UN8 (sa, a, tmp)((tmp) = (sa) * (uint16_t)(a) + 0x80, ((((tmp) >> 8 ) +
(tmp) ) >> 8 ))
;
3042 r = ADD_UN8 (m, d, tmp)((tmp) = (m) + (d), (uint32_t) (uint8_t) ((tmp) | (0 - ((tmp)
>> 8))))
;
3043
3044 *dst++ = r;
3045 }
3046 }
3047
3048 _mm_empty ();
3049}
3050
3051static void
3052mmx_composite_add_8_8 (pixman_implementation_t *imp,
3053 pixman_composite_info_t *info)
3054{
3055 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
3056 uint8_t *dst_line, *dst;
3057 uint8_t *src_line, *src;
3058 int dst_stride, src_stride;
3059 int32_t w;
3060 uint8_t s, d;
3061 uint16_t t;
3062
3063 CHECKPOINT ();
3064
3065 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint8_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (src_line) = ((uint8_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
3066 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint8_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (dst_line) = ((uint8_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
3067
3068 while (height--)
3069 {
3070 dst = dst_line;
3071 dst_line += dst_stride;
3072 src = src_line;
3073 src_line += src_stride;
3074 w = width;
3075
3076 while (w && (uintptr_t)dst & 7)
3077 {
3078 s = *src;
3079 d = *dst;
3080 t = d + s;
3081 s = t | (0 - (t >> 8));
3082 *dst = s;
3083
3084 dst++;
3085 src++;
3086 w--;
3087 }
3088
3089 while (w >= 8)
3090 {
3091 *(__m64*)dst = _mm_adds_pu8 (ldq_u ((__m64 *)src), *(__m64*)dst);
3092 dst += 8;
3093 src += 8;
3094 w -= 8;
3095 }
3096
3097 while (w)
3098 {
3099 s = *src;
3100 d = *dst;
3101 t = d + s;
3102 s = t | (0 - (t >> 8));
3103 *dst = s;
3104
3105 dst++;
3106 src++;
3107 w--;
3108 }
3109 }
3110
3111 _mm_empty ();
3112}
3113
3114static void
3115mmx_composite_add_0565_0565 (pixman_implementation_t *imp,
3116 pixman_composite_info_t *info)
3117{
3118 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
3119 uint16_t *dst_line, *dst;
3120 uint32_t d;
3121 uint16_t *src_line, *src;
3122 uint32_t s;
3123 int dst_stride, src_stride;
3124 int32_t w;
3125
3126 CHECKPOINT ();
3127
3128 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint16_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint16_t
); (src_line) = ((uint16_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
3129 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint16_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint16_t); (dst_line) = ((uint16_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
3130
3131 while (height--)
3132 {
3133 dst = dst_line;
3134 dst_line += dst_stride;
3135 src = src_line;
3136 src_line += src_stride;
3137 w = width;
3138
3139 while (w && (uintptr_t)dst & 7)
3140 {
3141 s = *src++;
3142 if (s)
3143 {
3144 d = *dst;
3145 s = convert_0565_to_8888 (s);
3146 if (d)
3147 {
3148 d = convert_0565_to_8888 (d);
3149 UN8x4_ADD_UN8x4 (s, d)do { uint32_t r1__, r2__, r3__, t__; r1__ = (s) & 0xff00ff
; r2__ = (d) & 0xff00ff; do { t__ = ((r1__) + (r2__)); t__
|= 0x10000100 - ((t__ >> 8) & 0xff00ff); r1__ = (t__
& 0xff00ff); } while (0); r2__ = ((s) >> 8) & 0xff00ff
; r3__ = ((d) >> 8) & 0xff00ff; do { t__ = ((r2__) +
(r3__)); t__ |= 0x10000100 - ((t__ >> 8) & 0xff00ff
); r2__ = (t__ & 0xff00ff); } while (0); s = r1__ | (r2__
<< 8); } while (0)
;
3150 }
3151 *dst = convert_8888_to_0565 (s);
3152 }
3153 dst++;
3154 w--;
3155 }
3156
3157 while (w >= 4)
3158 {
3159 __m64 vdest = *(__m64 *)dst;
3160 __m64 vsrc = ldq_u ((__m64 *)src);
3161 __m64 vd0, vd1;
3162 __m64 vs0, vs1;
3163
3164 expand_4xpacked565 (vdest, &vd0, &vd1, 0);
3165 expand_4xpacked565 (vsrc, &vs0, &vs1, 0);
3166
3167 vd0 = _mm_adds_pu8 (vd0, vs0);
3168 vd1 = _mm_adds_pu8 (vd1, vs1);
3169
3170 *(__m64 *)dst = pack_4xpacked565 (vd0, vd1);
3171
3172 dst += 4;
3173 src += 4;
3174 w -= 4;
3175 }
3176
3177 while (w--)
3178 {
3179 s = *src++;
3180 if (s)
3181 {
3182 d = *dst;
3183 s = convert_0565_to_8888 (s);
3184 if (d)
3185 {
3186 d = convert_0565_to_8888 (d);
3187 UN8x4_ADD_UN8x4 (s, d)do { uint32_t r1__, r2__, r3__, t__; r1__ = (s) & 0xff00ff
; r2__ = (d) & 0xff00ff; do { t__ = ((r1__) + (r2__)); t__
|= 0x10000100 - ((t__ >> 8) & 0xff00ff); r1__ = (t__
& 0xff00ff); } while (0); r2__ = ((s) >> 8) & 0xff00ff
; r3__ = ((d) >> 8) & 0xff00ff; do { t__ = ((r2__) +
(r3__)); t__ |= 0x10000100 - ((t__ >> 8) & 0xff00ff
); r2__ = (t__ & 0xff00ff); } while (0); s = r1__ | (r2__
<< 8); } while (0)
;
3188 }
3189 *dst = convert_8888_to_0565 (s);
3190 }
3191 dst++;
3192 }
3193 }
3194
3195 _mm_empty ();
3196}
3197
3198static void
3199mmx_composite_add_8888_8888 (pixman_implementation_t *imp,
3200 pixman_composite_info_t *info)
3201{
3202 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
3203 uint32_t *dst_line, *dst;
3204 uint32_t *src_line, *src;
3205 int dst_stride, src_stride;
3206 int32_t w;
3207
3208 CHECKPOINT ();
3209
3210 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
3211 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
3212
3213 while (height--)
3214 {
3215 dst = dst_line;
3216 dst_line += dst_stride;
3217 src = src_line;
3218 src_line += src_stride;
3219 w = width;
3220
3221 while (w && (uintptr_t)dst & 7)
3222 {
3223 store (dst, _mm_adds_pu8 (load ((const uint32_t *)src),
3224 load ((const uint32_t *)dst)));
3225 dst++;
3226 src++;
3227 w--;
3228 }
3229
3230 while (w >= 2)
3231 {
3232 *(__m64 *)dst = _mm_adds_pu8 (ldq_u ((__m64 *)src), *(__m64*)dst);
3233 dst += 2;
3234 src += 2;
3235 w -= 2;
3236 }
3237
3238 if (w)
3239 {
3240 store (dst, _mm_adds_pu8 (load ((const uint32_t *)src),
3241 load ((const uint32_t *)dst)));
3242
3243 }
3244 }
3245
3246 _mm_empty ();
3247}
3248
3249static pixman_bool_t
3250mmx_blt (pixman_implementation_t *imp,
3251 uint32_t * src_bits,
3252 uint32_t * dst_bits,
3253 int src_stride,
3254 int dst_stride,
3255 int src_bpp,
3256 int dst_bpp,
3257 int src_x,
3258 int src_y,
3259 int dest_x,
3260 int dest_y,
3261 int width,
3262 int height)
3263{
3264 uint8_t * src_bytes;
3265 uint8_t * dst_bytes;
3266 int byte_width;
3267
3268 if (src_bpp != dst_bpp)
3269 return FALSE0;
3270
3271 if (src_bpp == 16)
3272 {
3273 src_stride = src_stride * (int) sizeof (uint32_t) / 2;
3274 dst_stride = dst_stride * (int) sizeof (uint32_t) / 2;
3275 src_bytes = (uint8_t *)(((uint16_t *)src_bits) + src_stride * (src_y) + (src_x));
3276 dst_bytes = (uint8_t *)(((uint16_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
3277 byte_width = 2 * width;
3278 src_stride *= 2;
3279 dst_stride *= 2;
3280 }
3281 else if (src_bpp == 32)
3282 {
3283 src_stride = src_stride * (int) sizeof (uint32_t) / 4;
3284 dst_stride = dst_stride * (int) sizeof (uint32_t) / 4;
3285 src_bytes = (uint8_t *)(((uint32_t *)src_bits) + src_stride * (src_y) + (src_x));
3286 dst_bytes = (uint8_t *)(((uint32_t *)dst_bits) + dst_stride * (dest_y) + (dest_x));
3287 byte_width = 4 * width;
3288 src_stride *= 4;
3289 dst_stride *= 4;
3290 }
3291 else
3292 {
3293 return FALSE0;
3294 }
3295
3296 while (height--)
3297 {
3298 int w;
3299 uint8_t *s = src_bytes;
3300 uint8_t *d = dst_bytes;
3301 src_bytes += src_stride;
3302 dst_bytes += dst_stride;
3303 w = byte_width;
3304
3305 if (w >= 1 && ((uintptr_t)d & 1))
3306 {
3307 *(uint8_t *)d = *(uint8_t *)s;
3308 w -= 1;
3309 s += 1;
3310 d += 1;
3311 }
3312
3313 if (w >= 2 && ((uintptr_t)d & 3))
3314 {
3315 *(uint16_t *)d = *(uint16_t *)s;
3316 w -= 2;
3317 s += 2;
3318 d += 2;
3319 }
3320
3321 while (w >= 4 && ((uintptr_t)d & 7))
3322 {
3323 *(uint32_t *)d = ldl_u ((uint32_t *)s);
3324
3325 w -= 4;
3326 s += 4;
3327 d += 4;
3328 }
3329
3330 while (w >= 64)
3331 {
3332#if (defined (__GNUC__4) || (defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590))) && defined USE_X86_MMX1
3333 __asm__ (
3334 "movq (%1), %%mm0\n"
3335 "movq 8(%1), %%mm1\n"
3336 "movq 16(%1), %%mm2\n"
3337 "movq 24(%1), %%mm3\n"
3338 "movq 32(%1), %%mm4\n"
3339 "movq 40(%1), %%mm5\n"
3340 "movq 48(%1), %%mm6\n"
3341 "movq 56(%1), %%mm7\n"
3342
3343 "movq %%mm0, (%0)\n"
3344 "movq %%mm1, 8(%0)\n"
3345 "movq %%mm2, 16(%0)\n"
3346 "movq %%mm3, 24(%0)\n"
3347 "movq %%mm4, 32(%0)\n"
3348 "movq %%mm5, 40(%0)\n"
3349 "movq %%mm6, 48(%0)\n"
3350 "movq %%mm7, 56(%0)\n"
3351 :
3352 : "r" (d), "r" (s)
3353 : "memory",
3354 "%mm0", "%mm1", "%mm2", "%mm3",
3355 "%mm4", "%mm5", "%mm6", "%mm7");
3356#else
3357 __m64 v0 = ldq_u ((__m64 *)(s + 0));
3358 __m64 v1 = ldq_u ((__m64 *)(s + 8));
3359 __m64 v2 = ldq_u ((__m64 *)(s + 16));
3360 __m64 v3 = ldq_u ((__m64 *)(s + 24));
3361 __m64 v4 = ldq_u ((__m64 *)(s + 32));
3362 __m64 v5 = ldq_u ((__m64 *)(s + 40));
3363 __m64 v6 = ldq_u ((__m64 *)(s + 48));
3364 __m64 v7 = ldq_u ((__m64 *)(s + 56));
3365 *(__m64 *)(d + 0) = v0;
3366 *(__m64 *)(d + 8) = v1;
3367 *(__m64 *)(d + 16) = v2;
3368 *(__m64 *)(d + 24) = v3;
3369 *(__m64 *)(d + 32) = v4;
3370 *(__m64 *)(d + 40) = v5;
3371 *(__m64 *)(d + 48) = v6;
3372 *(__m64 *)(d + 56) = v7;
3373#endif
3374
3375 w -= 64;
3376 s += 64;
3377 d += 64;
3378 }
3379 while (w >= 4)
3380 {
3381 *(uint32_t *)d = ldl_u ((uint32_t *)s);
3382
3383 w -= 4;
3384 s += 4;
3385 d += 4;
3386 }
3387 if (w >= 2)
3388 {
3389 *(uint16_t *)d = *(uint16_t *)s;
3390 w -= 2;
3391 s += 2;
3392 d += 2;
3393 }
3394 }
3395
3396 _mm_empty ();
3397
3398 return TRUE1;
3399}
3400
3401static void
3402mmx_composite_copy_area (pixman_implementation_t *imp,
3403 pixman_composite_info_t *info)
3404{
3405 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
3406
3407 mmx_blt (imp, src_image->bits.bits,
3408 dest_image->bits.bits,
3409 src_image->bits.rowstride,
3410 dest_image->bits.rowstride,
3411 PIXMAN_FORMAT_BPP (src_image->bits.format)(((src_image->bits.format) >> 24) ),
3412 PIXMAN_FORMAT_BPP (dest_image->bits.format)(((dest_image->bits.format) >> 24) ),
3413 src_x, src_y, dest_x, dest_y, width, height);
3414}
3415
3416static void
3417mmx_composite_over_x888_8_8888 (pixman_implementation_t *imp,
3418 pixman_composite_info_t *info)
3419{
3420 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
3421 uint32_t *src, *src_line;
3422 uint32_t *dst, *dst_line;
3423 uint8_t *mask, *mask_line;
3424 int src_stride, mask_stride, dst_stride;
3425 int32_t w;
3426
3427 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
3428 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, uint8_t, mask_stride, mask_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = mask_image
->bits.bits; __stride__ = mask_image->bits.rowstride; (
mask_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint8_t); (mask_line) = ((uint8_t *) __bits__) + (mask_stride
) * (mask_y) + (1) * (mask_x); } while (0)
;
3429 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, uint32_t, src_stride, src_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_line) = ((uint32_t *) __bits__) + (src_stride) * (src_y
) + (1) * (src_x); } while (0)
;
3430
3431 while (height--)
3432 {
3433 src = src_line;
3434 src_line += src_stride;
3435 dst = dst_line;
3436 dst_line += dst_stride;
3437 mask = mask_line;
3438 mask_line += mask_stride;
3439
3440 w = width;
3441
3442 while (w--)
3443 {
3444 uint64_t m = *mask;
3445
3446 if (m)
3447 {
3448 uint32_t ssrc = *src | 0xff000000;
3449 __m64 s = load8888 (&ssrc);
3450
3451 if (m == 0xff)
3452 {
3453 store8888 (dst, s);
3454 }
3455 else
3456 {
3457 __m64 sa = expand_alpha (s);
3458 __m64 vm = expand_alpha_rev (to_m64 (m));
3459 __m64 vdest = in_over (s, sa, vm, load8888 (dst));
3460
3461 store8888 (dst, vdest);
3462 }
3463 }
3464
3465 mask++;
3466 dst++;
3467 src++;
3468 }
3469 }
3470
3471 _mm_empty ();
3472}
3473
3474static void
3475mmx_composite_over_reverse_n_8888 (pixman_implementation_t *imp,
3476 pixman_composite_info_t *info)
3477{
3478 PIXMAN_COMPOSITE_ARGS (info)__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height
;
3479 uint32_t src;
3480 uint32_t *dst_line, *dst;
3481 int32_t w;
3482 int dst_stride;
3483 __m64 vsrc;
3484
3485 CHECKPOINT ();
3486
3487 src = _pixman_image_get_solid (imp, src_image, dest_image->bits.format);
3488
3489 if (src == 0)
3490 return;
3491
3492 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, uint32_t, dst_stride, dst_line, 1)do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0)
;
3493
3494 vsrc = load8888 (&src);
3495
3496 while (height--)
3497 {
3498 dst = dst_line;
3499 dst_line += dst_stride;
3500 w = width;
3501
3502 CHECKPOINT ();
3503
3504 while (w && (uintptr_t)dst & 7)
3505 {
3506 __m64 vdest = load8888 (dst);
3507
3508 store8888 (dst, over (vdest, expand_alpha (vdest), vsrc));
3509
3510 w--;
3511 dst++;
3512 }
3513
3514 while (w >= 2)
3515 {
3516 __m64 vdest = *(__m64 *)dst;
3517 __m64 dest0 = expand8888 (vdest, 0);
3518 __m64 dest1 = expand8888 (vdest, 1);
3519
3520
3521 dest0 = over (dest0, expand_alpha (dest0), vsrc);
3522 dest1 = over (dest1, expand_alpha (dest1), vsrc);
3523
3524 *(__m64 *)dst = pack8888 (dest0, dest1);
3525
3526 dst += 2;
3527 w -= 2;
3528 }
3529
3530 CHECKPOINT ();
3531
3532 if (w)
3533 {
3534 __m64 vdest = load8888 (dst);
3535
3536 store8888 (dst, over (vdest, expand_alpha (vdest), vsrc));
3537 }
3538 }
3539
3540 _mm_empty ();
3541}
3542
3543static force_inline__inline__ __attribute__ ((__always_inline__)) void
3544scaled_nearest_scanline_mmx_8888_8888_OVER (uint32_t* pd,
3545 const uint32_t* ps,
3546 int32_t w,
3547 pixman_fixed_t vx,
3548 pixman_fixed_t unit_x,
3549 pixman_fixed_t src_width_fixed,
3550 pixman_bool_t fully_transparent_src)
3551{
3552 if (fully_transparent_src)
3553 return;
3554
3555 while (w)
3556 {
3557 __m64 d = load (pd);
3558 __m64 s = load (ps + pixman_fixed_to_int (vx)((int) ((vx) >> 16)));
3559 vx += unit_x;
3560 while (vx >= 0)
3561 vx -= src_width_fixed;
3562
3563 store8888 (pd, core_combine_over_u_pixel_mmx (s, d));
3564 pd++;
3565
3566 w--;
3567 }
3568
3569 _mm_empty ();
3570}
3571
3572FAST_NEAREST_MAINLOOP (mmx_8888_8888_cover_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER (
pixman_implementation_t *imp, pixman_composite_info_t *info) {
__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (-1 == PIXMAN_REPEAT_NORMAL) { max_vy = ((
pixman_fixed_t) ((src_image->bits.height) << 16)); repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); } if (-1 == PIXMAN_REPEAT_PAD || -1 == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (-1 == PIXMAN_REPEAT_NORMAL) repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); if (-1 == PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD
, &y, src_image->bits.height); src = src_first_line + src_stride
* y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (-1 == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3573 scaled_nearest_scanline_mmx_8888_8888_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER (
pixman_implementation_t *imp, pixman_composite_info_t *info) {
__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (-1 == PIXMAN_REPEAT_NORMAL) { max_vy = ((
pixman_fixed_t) ((src_image->bits.height) << 16)); repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); } if (-1 == PIXMAN_REPEAT_PAD || -1 == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (-1 == PIXMAN_REPEAT_NORMAL) repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); if (-1 == PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD
, &y, src_image->bits.height); src = src_first_line + src_stride
* y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (-1 == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3574 uint32_t, uint32_t, COVER)static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER (
pixman_implementation_t *imp, pixman_composite_info_t *info) {
__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (-1 == PIXMAN_REPEAT_NORMAL) { max_vy = ((
pixman_fixed_t) ((src_image->bits.height) << 16)); repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); } if (-1 == PIXMAN_REPEAT_PAD || -1 == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (-1 == PIXMAN_REPEAT_NORMAL) repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); if (-1 == PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD
, &y, src_image->bits.height); src = src_first_line + src_stride
* y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (-1 == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_cover_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3575FAST_NEAREST_MAINLOOP (mmx_8888_8888_none_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_none_OVER (
pixman_implementation_t *imp, pixman_composite_info_t *info) {
__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3576 scaled_nearest_scanline_mmx_8888_8888_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_none_OVER (
pixman_implementation_t *imp, pixman_composite_info_t *info) {
__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3577 uint32_t, uint32_t, NONE)static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_none_OVER (
pixman_implementation_t *imp, pixman_composite_info_t *info) {
__attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_none_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3578FAST_NEAREST_MAINLOOP (mmx_8888_8888_pad_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER (pixman_implementation_t
*imp, pixman_composite_info_t *info) { __attribute__((unused
)) pixman_op_t op = info->op; __attribute__((unused)) pixman_image_t
* src_image = info->src_image; __attribute__((unused)) pixman_image_t
* mask_image = info->mask_image; __attribute__((unused)) pixman_image_t
* dest_image = info->dest_image; __attribute__((unused)) int32_t
src_x = info->src_x; __attribute__((unused)) int32_t src_y
= info->src_y; __attribute__((unused)) int32_t mask_x = info
->mask_x; __attribute__((unused)) int32_t mask_y = info->
mask_y; __attribute__((unused)) int32_t dest_x = info->dest_x
; __attribute__((unused)) int32_t dest_y = info->dest_y; __attribute__
((unused)) int32_t width = info->width; __attribute__((unused
)) int32_t height = info->height; uint32_t *dst_line; uint8_t
*mask_line; uint32_t *src_first_line; int y; pixman_fixed_t src_width_fixed
= ((pixman_fixed_t) ((src_image->bits.width) << 16)
); pixman_fixed_t max_vy; pixman_vector_t v; pixman_fixed_t vx
, vy; pixman_fixed_t unit_x, unit_y; int32_t left_pad, right_pad
; uint32_t *src; uint32_t *dst; uint8_t solid_mask; const uint8_t
*mask = &solid_mask; int src_stride, mask_stride, dst_stride
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if (0) { if (0) solid_mask
= _pixman_image_get_solid (imp, mask_image, dest_image->bits
.format); else do { uint32_t *__bits__; int __stride__; __bits__
= mask_image->bits.bits; __stride__ = mask_image->bits
.rowstride; (mask_stride) = __stride__ * (int) sizeof (uint32_t
) / (int) sizeof (uint8_t); (mask_line) = ((uint8_t *) __bits__
) + (mask_stride) * (mask_y) + (1) * (mask_x); } while (0); }
do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t
) 1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3579 scaled_nearest_scanline_mmx_8888_8888_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER (pixman_implementation_t
*imp, pixman_composite_info_t *info) { __attribute__((unused
)) pixman_op_t op = info->op; __attribute__((unused)) pixman_image_t
* src_image = info->src_image; __attribute__((unused)) pixman_image_t
* mask_image = info->mask_image; __attribute__((unused)) pixman_image_t
* dest_image = info->dest_image; __attribute__((unused)) int32_t
src_x = info->src_x; __attribute__((unused)) int32_t src_y
= info->src_y; __attribute__((unused)) int32_t mask_x = info
->mask_x; __attribute__((unused)) int32_t mask_y = info->
mask_y; __attribute__((unused)) int32_t dest_x = info->dest_x
; __attribute__((unused)) int32_t dest_y = info->dest_y; __attribute__
((unused)) int32_t width = info->width; __attribute__((unused
)) int32_t height = info->height; uint32_t *dst_line; uint8_t
*mask_line; uint32_t *src_first_line; int y; pixman_fixed_t src_width_fixed
= ((pixman_fixed_t) ((src_image->bits.width) << 16)
); pixman_fixed_t max_vy; pixman_vector_t v; pixman_fixed_t vx
, vy; pixman_fixed_t unit_x, unit_y; int32_t left_pad, right_pad
; uint32_t *src; uint32_t *dst; uint8_t solid_mask; const uint8_t
*mask = &solid_mask; int src_stride, mask_stride, dst_stride
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if (0) { if (0) solid_mask
= _pixman_image_get_solid (imp, mask_image, dest_image->bits
.format); else do { uint32_t *__bits__; int __stride__; __bits__
= mask_image->bits.bits; __stride__ = mask_image->bits
.rowstride; (mask_stride) = __stride__ * (int) sizeof (uint32_t
) / (int) sizeof (uint8_t); (mask_line) = ((uint8_t *) __bits__
) + (mask_stride) * (mask_y) + (1) * (mask_x); } while (0); }
do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t
) 1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3580 uint32_t, uint32_t, PAD)static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER (pixman_implementation_t
*imp, pixman_composite_info_t *info) { __attribute__((unused
)) pixman_op_t op = info->op; __attribute__((unused)) pixman_image_t
* src_image = info->src_image; __attribute__((unused)) pixman_image_t
* mask_image = info->mask_image; __attribute__((unused)) pixman_image_t
* dest_image = info->dest_image; __attribute__((unused)) int32_t
src_x = info->src_x; __attribute__((unused)) int32_t src_y
= info->src_y; __attribute__((unused)) int32_t mask_x = info
->mask_x; __attribute__((unused)) int32_t mask_y = info->
mask_y; __attribute__((unused)) int32_t dest_x = info->dest_x
; __attribute__((unused)) int32_t dest_y = info->dest_y; __attribute__
((unused)) int32_t width = info->width; __attribute__((unused
)) int32_t height = info->height; uint32_t *dst_line; uint8_t
*mask_line; uint32_t *src_first_line; int y; pixman_fixed_t src_width_fixed
= ((pixman_fixed_t) ((src_image->bits.width) << 16)
); pixman_fixed_t max_vy; pixman_vector_t v; pixman_fixed_t vx
, vy; pixman_fixed_t unit_x, unit_y; int32_t left_pad, right_pad
; uint32_t *src; uint32_t *dst; uint8_t solid_mask; const uint8_t
*mask = &solid_mask; int src_stride, mask_stride, dst_stride
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if (0) { if (0) solid_mask
= _pixman_image_get_solid (imp, mask_image, dest_image->bits
.format); else do { uint32_t *__bits__; int __stride__; __bits__
= mask_image->bits.bits; __stride__ = mask_image->bits
.rowstride; (mask_stride) = __stride__ * (int) sizeof (uint32_t
) / (int) sizeof (uint8_t); (mask_line) = ((uint8_t *) __bits__
) + (mask_stride) * (mask_y) + (1) * (mask_x); } while (0); }
do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t
) 1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_pad_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3581FAST_NEAREST_MAINLOOP (mmx_8888_8888_normal_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NORMAL ==
PIXMAN_REPEAT_NONE) { static const uint32_t zero[1] = { 0 };
if (y < 0 || y >= src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3582 scaled_nearest_scanline_mmx_8888_8888_OVER,static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NORMAL ==
PIXMAN_REPEAT_NONE) { static const uint32_t zero[1] = { 0 };
if (y < 0 || y >= src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3583 uint32_t, uint32_t, NORMAL)static __inline__ __attribute__ ((__always_inline__)) void scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
( const uint8_t *mask, uint32_t *dst, const uint32_t *src, int32_t
w, pixman_fixed_t vx, pixman_fixed_t unit_x, pixman_fixed_t max_vx
, pixman_bool_t fully_transparent_src) { scaled_nearest_scanline_mmx_8888_8888_OVER
(dst, src, w, vx, unit_x, max_vx, fully_transparent_src); } static
void fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (0) { if (0) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (0 && !0) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NORMAL ==
PIXMAN_REPEAT_NONE) { static const uint32_t zero[1] = { 0 };
if (y < 0 || y >= src_image->bits.height) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask + (0 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_8888_OVER_mmx_8888_8888_normal_OVER_wrapper
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3584
3585static force_inline__inline__ __attribute__ ((__always_inline__)) void
3586scaled_nearest_scanline_mmx_8888_n_8888_OVER (const uint32_t * mask,
3587 uint32_t * dst,
3588 const uint32_t * src,
3589 int32_t w,
3590 pixman_fixed_t vx,
3591 pixman_fixed_t unit_x,
3592 pixman_fixed_t src_width_fixed,
3593 pixman_bool_t zero_src)
3594{
3595 __m64 mm_mask;
3596
3597 if (zero_src || (*mask >> 24) == 0)
3598 {
3599 /* A workaround for https://gcc.gnu.org/PR47759 */
3600 _mm_empty ();
3601 return;
3602 }
3603
3604 mm_mask = expand_alpha (load8888 (mask));
3605
3606 while (w)
3607 {
3608 uint32_t s = *(src + pixman_fixed_to_int (vx)((int) ((vx) >> 16)));
3609 vx += unit_x;
3610 while (vx >= 0)
3611 vx -= src_width_fixed;
3612
3613 if (s)
3614 {
3615 __m64 ms = load8888 (&s);
3616 __m64 alpha = expand_alpha (ms);
3617 __m64 dest = load8888 (dst);
3618
3619 store8888 (dst, (in_over (ms, alpha, mm_mask, dest)));
3620 }
3621
3622 dst++;
3623 w--;
3624 }
3625
3626 _mm_empty ();
3627}
3628
3629FAST_NEAREST_MAINLOOP_COMMON (mmx_8888_n_8888_cover_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (-1 == PIXMAN_REPEAT_NORMAL) { max_vy = ((
pixman_fixed_t) ((src_image->bits.height) << 16)); repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); } if (-1 == PIXMAN_REPEAT_PAD || -1 == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (-1 == PIXMAN_REPEAT_NORMAL) repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); if (-1 == PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD
, &y, src_image->bits.height); src = src_first_line + src_stride
* y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (-1 == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3630 scaled_nearest_scanline_mmx_8888_n_8888_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (-1 == PIXMAN_REPEAT_NORMAL) { max_vy = ((
pixman_fixed_t) ((src_image->bits.height) << 16)); repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); } if (-1 == PIXMAN_REPEAT_PAD || -1 == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (-1 == PIXMAN_REPEAT_NORMAL) repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); if (-1 == PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD
, &y, src_image->bits.height); src = src_first_line + src_stride
* y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (-1 == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3631 uint32_t, uint32_t, uint32_t, COVER, TRUE, TRUE)static void fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (-1 == PIXMAN_REPEAT_NORMAL) { max_vy = ((
pixman_fixed_t) ((src_image->bits.height) << 16)); repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); } if (-1 == PIXMAN_REPEAT_PAD || -1 == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (-1 == PIXMAN_REPEAT_NORMAL) repeat (PIXMAN_REPEAT_NORMAL
, &vy, max_vy); if (-1 == PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD
, &y, src_image->bits.height); src = src_first_line + src_stride
* y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (-1 == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3632FAST_NEAREST_MAINLOOP_COMMON (mmx_8888_n_8888_pad_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3633 scaled_nearest_scanline_mmx_8888_n_8888_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3634 uint32_t, uint32_t, uint32_t, PAD, TRUE, TRUE)static void fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3635FAST_NEAREST_MAINLOOP_COMMON (mmx_8888_n_8888_none_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3636 scaled_nearest_scanline_mmx_8888_n_8888_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3637 uint32_t, uint32_t, uint32_t, NONE, TRUE, TRUE)static void fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { static const uint32_t zero[1] = { 0 }; if (y < 0 || y >=
src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3638FAST_NEAREST_MAINLOOP_COMMON (mmx_8888_n_8888_normal_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NORMAL ==
PIXMAN_REPEAT_NONE) { static const uint32_t zero[1] = { 0 };
if (y < 0 || y >= src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3639 scaled_nearest_scanline_mmx_8888_n_8888_OVER,static void fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NORMAL ==
PIXMAN_REPEAT_NONE) { static const uint32_t zero[1] = { 0 };
if (y < 0 || y >= src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3640 uint32_t, uint32_t, uint32_t, NORMAL, TRUE, TRUE)static void fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y; pixman_fixed_t src_width_fixed = ((pixman_fixed_t
) ((src_image->bits.width) << 16)); pixman_fixed_t max_vy
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, right_pad; uint32_t *src; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; do { uint32_t *__bits__
; int __stride__; __bits__ = dest_image->bits.bits; __stride__
= dest_image->bits.rowstride; (dst_stride) = __stride__ *
(int) sizeof (uint32_t) / (int) sizeof (uint32_t); (dst_line
) = ((uint32_t *) __bits__) + (dst_stride) * (dest_y) + (1) *
(dest_x); } while (0); if (1) { if (1) solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); else do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (mask_line) = ((uint32_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= ((pixman_fixed_t)
1); v.vector[1] -= ((pixman_fixed_t) 1); vx = v.vector[0]; vy
= v.vector[1]; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { max_vy = ((pixman_fixed_t) ((src_image->bits.height) <<
16)); repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed
); repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); } if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { pad_repeat_get_scanline_bounds (src_image->bits.width,
vx, unit_x, &width, &left_pad, &right_pad); vx +=
left_pad * unit_x; } while (--height >= 0) { dst = dst_line
; dst_line += dst_stride; if (1 && !1) { mask = mask_line
; mask_line += mask_stride; } y = ((int) ((vy) >> 16));
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { repeat (PIXMAN_REPEAT_PAD, &y, src_image
->bits.height); src = src_first_line + src_stride * y; if (
left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width - src_image->bits
.width + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 0); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, src
+ src_image->bits.width, right_pad, -((pixman_fixed_t) 1)
, 0, src_width_fixed, 0); } } else if (PIXMAN_REPEAT_NORMAL ==
PIXMAN_REPEAT_NONE) { static const uint32_t zero[1] = { 0 };
if (y < 0 || y >= src_image->bits.height) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad + width + right_pad, -((pixman_fixed_t
) 1), 0, src_width_fixed, 1); continue; } src = src_first_line
+ src_stride * y; if (left_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, zero + 1, left_pad, -((pixman_fixed_t) 1), 0, src_width_fixed
, 1); } if (width > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad), dst + left_pad, src + src_image->
bits.width, width, vx - src_width_fixed, unit_x, src_width_fixed
, 0); } if (right_pad > 0) { scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask + (1 ? 0 : left_pad + width), dst + left_pad + width, zero
+ 1, right_pad, -((pixman_fixed_t) 1), 0, src_width_fixed, 1
); } } else { src = src_first_line + src_stride * y; scaled_nearest_scanline_mmx_8888_n_8888_OVER
(mask, dst, src + src_image->bits.width, width, vx - src_width_fixed
, unit_x, src_width_fixed, 0); } } }
3641
3642#define BSHIFT((1 << 7)) ((1 << BILINEAR_INTERPOLATION_BITS7))
3643#define BMSK(((1 << 7)) - 1) (BSHIFT((1 << 7)) - 1)
3644
3645#define BILINEAR_DECLARE_VARIABLESconst __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt); const __m64
mm_wb = _mm_set_pi16 (wb, wb, wb, wb); const __m64 mm_addc7 =
_mm_set_pi16 (0, 1, 0, 1); const __m64 mm_xorc7 = _mm_set_pi16
(0, (((1 << 7)) - 1), 0, (((1 << 7)) - 1)); const
__m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x);
const __m64 mm_zero = _mm_setzero_si64 (); __m64 mm_x = _mm_set_pi16
(vx, vx, vx, vx)
\
3646 const __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt); \
3647 const __m64 mm_wb = _mm_set_pi16 (wb, wb, wb, wb); \
3648 const __m64 mm_addc7 = _mm_set_pi16 (0, 1, 0, 1); \
3649 const __m64 mm_xorc7 = _mm_set_pi16 (0, BMSK(((1 << 7)) - 1), 0, BMSK(((1 << 7)) - 1)); \
3650 const __m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x); \
3651 const __m64 mm_zero = _mm_setzero_si64 (); \
3652 __m64 mm_x = _mm_set_pi16 (vx, vx, vx, vx)
3653
3654#define BILINEAR_INTERPOLATE_ONE_PIXEL(pix)do { __m64 t = ldq_u ((__m64 *)&src_top [((int) ((vx) >>
16))]); __m64 b = ldq_u ((__m64 *)&src_bottom [((int) ((
vx) >> 16))]); __m64 t_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(t, mm_zero), mm_wt); __m64 t_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(t, mm_zero), mm_wt); __m64 b_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(b, mm_zero), mm_wb); __m64 b_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(b, mm_zero), mm_wb); __m64 hi = _mm_add_pi16 (t_hi, b_hi); __m64
lo = _mm_add_pi16 (t_lo, b_lo); __m64 mm_wh = _mm_add_pi16 (
mm_addc7, _mm_xor_si64 (mm_xorc7, _mm_srli_pi16 (mm_x, 16 - 7
))); __m64 p = _mm_unpacklo_pi16 (lo, hi); __m64 q = _mm_unpackhi_pi16
(lo, hi); vx += unit_x; lo = _mm_madd_pi16 (p, mm_wh); hi = _mm_madd_pi16
(q, mm_wh); mm_x = _mm_add_pi16 (mm_x, mm_ux); hi = _mm_srli_pi32
(hi, 7 * 2); lo = _mm_srli_pi32 (lo, 7 * 2); lo = _mm_packs_pi32
(lo, hi); lo = _mm_packs_pu16 (lo, lo); pix = lo; } while (0
)
\
3655do { \
3656 /* fetch 2x2 pixel block into 2 mmx registers */ \
3657 __m64 t = ldq_u ((__m64 *)&src_top [pixman_fixed_to_int (vx)((int) ((vx) >> 16))]); \
3658 __m64 b = ldq_u ((__m64 *)&src_bottom [pixman_fixed_to_int (vx)((int) ((vx) >> 16))]); \
3659 /* vertical interpolation */ \
3660 __m64 t_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8 (t, mm_zero), mm_wt); \
3661 __m64 t_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8 (t, mm_zero), mm_wt); \
3662 __m64 b_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8 (b, mm_zero), mm_wb); \
3663 __m64 b_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8 (b, mm_zero), mm_wb); \
3664 __m64 hi = _mm_add_pi16 (t_hi, b_hi); \
3665 __m64 lo = _mm_add_pi16 (t_lo, b_lo); \
3666 /* calculate horizontal weights */ \
3667 __m64 mm_wh = _mm_add_pi16 (mm_addc7, _mm_xor_si64 (mm_xorc7, \
3668 _mm_srli_pi16 (mm_x, \
3669 16 - BILINEAR_INTERPOLATION_BITS7))); \
3670 /* horizontal interpolation */ \
3671 __m64 p = _mm_unpacklo_pi16 (lo, hi); \
3672 __m64 q = _mm_unpackhi_pi16 (lo, hi); \
3673 vx += unit_x; \
3674 lo = _mm_madd_pi16 (p, mm_wh); \
3675 hi = _mm_madd_pi16 (q, mm_wh); \
3676 mm_x = _mm_add_pi16 (mm_x, mm_ux); \
3677 /* shift and pack the result */ \
3678 hi = _mm_srli_pi32 (hi, BILINEAR_INTERPOLATION_BITS7 * 2); \
3679 lo = _mm_srli_pi32 (lo, BILINEAR_INTERPOLATION_BITS7 * 2); \
3680 lo = _mm_packs_pi32 (lo, hi); \
3681 lo = _mm_packs_pu16 (lo, lo); \
3682 pix = lo; \
3683} while (0)
3684
3685#define BILINEAR_SKIP_ONE_PIXEL()do { vx += unit_x; mm_x = _mm_add_pi16 (mm_x, mm_ux); } while
(0)
\
3686do { \
3687 vx += unit_x; \
3688 mm_x = _mm_add_pi16 (mm_x, mm_ux); \
3689} while(0)
3690
3691static force_inline__inline__ __attribute__ ((__always_inline__)) void
3692scaled_bilinear_scanline_mmx_8888_8888_SRC (uint32_t * dst,
3693 const uint32_t * mask,
3694 const uint32_t * src_top,
3695 const uint32_t * src_bottom,
3696 int32_t w,
3697 int wt,
3698 int wb,
3699 pixman_fixed_t vx,
3700 pixman_fixed_t unit_x,
3701 pixman_fixed_t max_vx,
3702 pixman_bool_t zero_src)
3703{
3704 BILINEAR_DECLARE_VARIABLESconst __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt); const __m64
mm_wb = _mm_set_pi16 (wb, wb, wb, wb); const __m64 mm_addc7 =
_mm_set_pi16 (0, 1, 0, 1); const __m64 mm_xorc7 = _mm_set_pi16
(0, (((1 << 7)) - 1), 0, (((1 << 7)) - 1)); const
__m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x);
const __m64 mm_zero = _mm_setzero_si64 (); __m64 mm_x = _mm_set_pi16
(vx, vx, vx, vx)
;
3705 __m64 pix;
3706
3707 while (w--)
3708 {
3709 BILINEAR_INTERPOLATE_ONE_PIXEL (pix)do { __m64 t = ldq_u ((__m64 *)&src_top [((int) ((vx) >>
16))]); __m64 b = ldq_u ((__m64 *)&src_bottom [((int) ((
vx) >> 16))]); __m64 t_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(t, mm_zero), mm_wt); __m64 t_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(t, mm_zero), mm_wt); __m64 b_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(b, mm_zero), mm_wb); __m64 b_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(b, mm_zero), mm_wb); __m64 hi = _mm_add_pi16 (t_hi, b_hi); __m64
lo = _mm_add_pi16 (t_lo, b_lo); __m64 mm_wh = _mm_add_pi16 (
mm_addc7, _mm_xor_si64 (mm_xorc7, _mm_srli_pi16 (mm_x, 16 - 7
))); __m64 p = _mm_unpacklo_pi16 (lo, hi); __m64 q = _mm_unpackhi_pi16
(lo, hi); vx += unit_x; lo = _mm_madd_pi16 (p, mm_wh); hi = _mm_madd_pi16
(q, mm_wh); mm_x = _mm_add_pi16 (mm_x, mm_ux); hi = _mm_srli_pi32
(hi, 7 * 2); lo = _mm_srli_pi32 (lo, 7 * 2); lo = _mm_packs_pi32
(lo, hi); lo = _mm_packs_pu16 (lo, lo); pix = lo; } while (0
)
;
3710 store (dst, pix);
3711 dst++;
3712 }
3713
3714 _mm_empty ();
3715}
3716
3717FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_cover_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, buf1
, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3718 scaled_bilinear_scanline_mmx_8888_8888_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, buf1
, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3719 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, buf1
, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3720 COVER, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, buf1
, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3721FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_pad_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3722 scaled_bilinear_scanline_mmx_8888_8888_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3723 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3724 PAD, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3725FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_none_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3726 scaled_bilinear_scanline_mmx_8888_8888_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3727 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3728 NONE, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3729FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_normal_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3730 scaled_bilinear_scanline_mmx_8888_8888_SRC,static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3731 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3732 NORMAL, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_SRC (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_SRC
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3733
3734static force_inline__inline__ __attribute__ ((__always_inline__)) void
3735scaled_bilinear_scanline_mmx_8888_8888_OVER (uint32_t * dst,
3736 const uint32_t * mask,
3737 const uint32_t * src_top,
3738 const uint32_t * src_bottom,
3739 int32_t w,
3740 int wt,
3741 int wb,
3742 pixman_fixed_t vx,
3743 pixman_fixed_t unit_x,
3744 pixman_fixed_t max_vx,
3745 pixman_bool_t zero_src)
3746{
3747 BILINEAR_DECLARE_VARIABLESconst __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt); const __m64
mm_wb = _mm_set_pi16 (wb, wb, wb, wb); const __m64 mm_addc7 =
_mm_set_pi16 (0, 1, 0, 1); const __m64 mm_xorc7 = _mm_set_pi16
(0, (((1 << 7)) - 1), 0, (((1 << 7)) - 1)); const
__m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x);
const __m64 mm_zero = _mm_setzero_si64 (); __m64 mm_x = _mm_set_pi16
(vx, vx, vx, vx)
;
3748 __m64 pix1, pix2;
3749
3750 while (w)
3751 {
3752 BILINEAR_INTERPOLATE_ONE_PIXEL (pix1)do { __m64 t = ldq_u ((__m64 *)&src_top [((int) ((vx) >>
16))]); __m64 b = ldq_u ((__m64 *)&src_bottom [((int) ((
vx) >> 16))]); __m64 t_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(t, mm_zero), mm_wt); __m64 t_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(t, mm_zero), mm_wt); __m64 b_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(b, mm_zero), mm_wb); __m64 b_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(b, mm_zero), mm_wb); __m64 hi = _mm_add_pi16 (t_hi, b_hi); __m64
lo = _mm_add_pi16 (t_lo, b_lo); __m64 mm_wh = _mm_add_pi16 (
mm_addc7, _mm_xor_si64 (mm_xorc7, _mm_srli_pi16 (mm_x, 16 - 7
))); __m64 p = _mm_unpacklo_pi16 (lo, hi); __m64 q = _mm_unpackhi_pi16
(lo, hi); vx += unit_x; lo = _mm_madd_pi16 (p, mm_wh); hi = _mm_madd_pi16
(q, mm_wh); mm_x = _mm_add_pi16 (mm_x, mm_ux); hi = _mm_srli_pi32
(hi, 7 * 2); lo = _mm_srli_pi32 (lo, 7 * 2); lo = _mm_packs_pi32
(lo, hi); lo = _mm_packs_pu16 (lo, lo); pix1 = lo; } while (
0)
;
3753
3754 if (!is_zero (pix1))
3755 {
3756 pix2 = load (dst);
3757 store8888 (dst, core_combine_over_u_pixel_mmx (pix1, pix2));
3758 }
3759
3760 w--;
3761 dst++;
3762 }
3763
3764 _mm_empty ();
3765}
3766
3767FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_cover_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3768 scaled_bilinear_scanline_mmx_8888_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3769 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3770 COVER, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t *src1,
*src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1, *
src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) { weight1
= 0; y1 = 0; } if (y1 >= src_image->bits.height) { weight1
= 0; y1 = src_image->bits.height - 1; } if (y2 < 0) { weight2
= 0; y2 = 0; } if (y2 >= src_image->bits.height) { weight2
= 0; y2 = src_image->bits.height - 1; } src1 = src_first_line
+ src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = 0; buf2[0] = buf2[1]
= 0; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 1); dst += left_pad
; if ((0) & (1 << 2)) mask += left_pad; } if (left_tz
> 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2[0] = 0; buf2[
1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) & ((
((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1))
), unit_x, 0, 0); dst += left_tz; if ((0) & (1 << 2
)) mask += left_tz; vx += left_tz * unit_x; } if (width > 0
) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask, src1
, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst += width
; if ((0) & (1 << 2)) mask += width; vx += width * unit_x
; } if (right_tz > 0) { buf1[0] = src1[src_image->bits.
width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits.width
- 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3771FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_pad_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3772 scaled_bilinear_scanline_mmx_8888_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3773 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3774 PAD, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER (dst
, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0); dst
+= left_pad; if ((0) & (1 << 2)) mask += left_pad;
} if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3775FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_none_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3776 scaled_bilinear_scanline_mmx_8888_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3777 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3778 NONE, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat
(PIXMAN_REPEAT_PAD, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); src1
= src_first_line + src_stride * y1; src2 = src_first_line + src_stride
* y2; if (left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2
[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 <
0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.
height) { weight1 = 0; y1 = src_image->bits.height - 1; } if
(y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3779FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8888_normal_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
Within the expansion of the macro 'FAST_BILINEAR_MAINLOOP_COMMON':
a
Assuming 'src_width' is <= 'max_x'
b
Assuming 'weight2' is not equal to 0
c
Assuming 'i' is >= 'src_width'
d
Assigned value is garbage or undefined
3780 scaled_bilinear_scanline_mmx_8888_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3781 uint32_t, uint32_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3782 NORMAL, FLAG_NONE)static void fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint32_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint32_t solid_mask; const uint32_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((0) & (1 <<
1)) { solid_mask = _pixman_image_get_solid (imp, mask_image,
dest_image->bits.format); mask_stride = 0; } else if ((0)
& (1 << 2)) { do { uint32_t *__bits__; int __stride__
; __bits__ = mask_image->bits.bits; __stride__ = mask_image
->bits.rowstride; (mask_stride) = __stride__ * (int) sizeof
(uint32_t) / (int) sizeof (uint32_t); (mask_line) = ((uint32_t
*) __bits__) + (mask_stride) * (mask_y) + (1) * (mask_x); } while
(0); } do { uint32_t *__bits__; int __stride__; __bits__ = src_image
->bits.bits; __stride__ = src_image->bits.rowstride; (src_stride
) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint32_t
); (src_first_line) = ((uint32_t *) __bits__) + (src_stride) *
(0) + (1) * (0); } while (0); v.vector[0] = ((pixman_fixed_t
) ((src_x) << 16)) + (((pixman_fixed_t) ((1) << 16
))) / 2; v.vector[1] = ((pixman_fixed_t) ((src_y) << 16
)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[2] =
(((pixman_fixed_t) ((1) << 16))); if (!pixman_transform_point_3d
(src_image->common.transform, &v)) return; unit_x = src_image
->common.transform->matrix[0][0]; unit_y = src_image->
common.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((0) & (1 << 2)) {
mask = mask_line; mask_line += mask_stride; } y1 = ((int) ((
vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight (
vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) - weight2
; } else { y2 = y1; weight1 = weight2 = (1 << 7) / 2; }
vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD)
{ uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2];
repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((0) & (1 << 2)) mask += width
; } if (right_pad > 0) { buf1[0] = buf1[1] = src1[src_image
->bits.width - 1]; buf2[0] = buf2[1] = src2[src_image->
bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, 0
); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((0) & (1 << 2)) mask += left_pad
; } if (left_tz > 0) { buf1[0] = 0; buf1[1] = src1[0]; buf2
[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((0) & (1 <<
2)) mask += left_tz; vx += left_tz * unit_x; } if (width >
0) { scaled_bilinear_scanline_mmx_8888_8888_OVER (dst, mask,
src1, src2, width, weight1, weight2, vx, unit_x, 0, 0); dst +=
width; if ((0) & (1 << 2)) mask += width; vx += width
* unit_x; } if (right_tz > 0) { buf1[0] = src1[src_image->
bits.width - 1]; buf1[1] = 0; buf2[0] = src2[src_image->bits
.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((0) & (1 <<
2)) mask += right_tz; } if (right_pad > 0) { buf1[0] = buf1
[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER (
dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((0) & (
1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((0) &
(1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3783
3784static force_inline__inline__ __attribute__ ((__always_inline__)) void
3785scaled_bilinear_scanline_mmx_8888_8_8888_OVER (uint32_t * dst,
3786 const uint8_t * mask,
3787 const uint32_t * src_top,
3788 const uint32_t * src_bottom,
3789 int32_t w,
3790 int wt,
3791 int wb,
3792 pixman_fixed_t vx,
3793 pixman_fixed_t unit_x,
3794 pixman_fixed_t max_vx,
3795 pixman_bool_t zero_src)
3796{
3797 BILINEAR_DECLARE_VARIABLESconst __m64 mm_wt = _mm_set_pi16 (wt, wt, wt, wt); const __m64
mm_wb = _mm_set_pi16 (wb, wb, wb, wb); const __m64 mm_addc7 =
_mm_set_pi16 (0, 1, 0, 1); const __m64 mm_xorc7 = _mm_set_pi16
(0, (((1 << 7)) - 1), 0, (((1 << 7)) - 1)); const
__m64 mm_ux = _mm_set_pi16 (unit_x, unit_x, unit_x, unit_x);
const __m64 mm_zero = _mm_setzero_si64 (); __m64 mm_x = _mm_set_pi16
(vx, vx, vx, vx)
;
3798 __m64 pix1, pix2;
3799 uint32_t m;
3800
3801 while (w)
3802 {
3803 m = (uint32_t) *mask++;
3804
3805 if (m)
3806 {
3807 BILINEAR_INTERPOLATE_ONE_PIXEL (pix1)do { __m64 t = ldq_u ((__m64 *)&src_top [((int) ((vx) >>
16))]); __m64 b = ldq_u ((__m64 *)&src_bottom [((int) ((
vx) >> 16))]); __m64 t_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(t, mm_zero), mm_wt); __m64 t_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(t, mm_zero), mm_wt); __m64 b_hi = _mm_mullo_pi16 (_mm_unpackhi_pi8
(b, mm_zero), mm_wb); __m64 b_lo = _mm_mullo_pi16 (_mm_unpacklo_pi8
(b, mm_zero), mm_wb); __m64 hi = _mm_add_pi16 (t_hi, b_hi); __m64
lo = _mm_add_pi16 (t_lo, b_lo); __m64 mm_wh = _mm_add_pi16 (
mm_addc7, _mm_xor_si64 (mm_xorc7, _mm_srli_pi16 (mm_x, 16 - 7
))); __m64 p = _mm_unpacklo_pi16 (lo, hi); __m64 q = _mm_unpackhi_pi16
(lo, hi); vx += unit_x; lo = _mm_madd_pi16 (p, mm_wh); hi = _mm_madd_pi16
(q, mm_wh); mm_x = _mm_add_pi16 (mm_x, mm_ux); hi = _mm_srli_pi32
(hi, 7 * 2); lo = _mm_srli_pi32 (lo, 7 * 2); lo = _mm_packs_pi32
(lo, hi); lo = _mm_packs_pu16 (lo, lo); pix1 = lo; } while (
0)
;
3808
3809 if (m == 0xff && is_opaque (pix1))
3810 {
3811 store (dst, pix1);
3812 }
3813 else
3814 {
3815 __m64 ms, md, ma, msa;
3816
3817 pix2 = load (dst);
3818 ma = expand_alpha_rev (to_m64 (m));
3819 ms = _mm_unpacklo_pi8 (pix1, _mm_setzero_si64 ());
3820 md = _mm_unpacklo_pi8 (pix2, _mm_setzero_si64 ());
3821
3822 msa = expand_alpha (ms);
3823
3824 store8888 (dst, (in_over (ms, msa, ma, md)));
3825 }
3826 }
3827 else
3828 {
3829 BILINEAR_SKIP_ONE_PIXEL ()do { vx += unit_x; mm_x = _mm_add_pi16 (mm_x, mm_ux); } while
(0)
;
3830 }
3831
3832 w--;
3833 dst++;
3834 }
3835
3836 _mm_empty ();
3837}
3838
3839FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_cover_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER (
dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0
); dst += left_pad; if ((1 << 2) & (1 << 2)) mask
+= left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1
, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) {
weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.height
) { weight1 = 0; y1 = src_image->bits.height - 1; } if (y2
< 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3840 scaled_bilinear_scanline_mmx_8888_8_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER (
dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0
); dst += left_pad; if ((1 << 2) & (1 << 2)) mask
+= left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1
, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) {
weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.height
) { weight1 = 0; y1 = src_image->bits.height - 1; } if (y2
< 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3841 uint32_t, uint8_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER (
dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0
); dst += left_pad; if ((1 << 2) & (1 << 2)) mask
+= left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1
, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) {
weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.height
) { weight1 = 0; y1 = src_image->bits.height - 1; } if (y2
< 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3842 COVER, FLAG_HAVE_NON_SOLID_MASK)static void fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (-1 == PIXMAN_REPEAT_PAD
|| -1 == PIXMAN_REPEAT_NONE) { bilinear_pad_repeat_get_scanline_bounds
(src_image->bits.width, v.vector[0], unit_x, &left_pad
, &left_tz, &width, &right_tz, &right_pad); if
(-1 == PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad +=
right_tz; left_tz = right_tz = 0; } v.vector[0] += left_pad *
unit_x; } if (-1 == PIXMAN_REPEAT_NORMAL) { vx = v.vector[0]
; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t) ((
src_image->bits.width) << 16))); max_x = ((int) ((vx
+ (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (-1 == PIXMAN_REPEAT_PAD) { uint32_t
*src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; repeat (PIXMAN_REPEAT_PAD
, &y1, src_image->bits.height); repeat (PIXMAN_REPEAT_PAD
, &y2, src_image->bits.height); src1 = src_first_line +
src_stride * y1; src2 = src_first_line + src_stride * y2; if
(left_pad > 0) { buf1[0] = buf1[1] = src1[0]; buf2[0] = buf2
[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER (
dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, 0
); dst += left_pad; if ((1 << 2) & (1 << 2)) mask
+= left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (-1 == PIXMAN_REPEAT_NONE) { uint32_t *src1
, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if (y1 < 0) {
weight1 = 0; y1 = 0; } if (y1 >= src_image->bits.height
) { weight1 = 0; y1 = src_image->bits.height - 1; } if (y2
< 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image->
bits.height) { weight2 = 0; y2 = src_image->bits.height - 1
; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (-1 == PIXMAN_REPEAT_NORMAL) { int32_t num_pixels
; int32_t width_remain; uint32_t * src_line_top; uint32_t * src_line_bottom
; uint32_t buf1[2]; uint32_t buf2[2]; uint32_t extended_src_line0
[64*2]; uint32_t extended_src_line1[64*2]; int i, j; repeat (
PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); repeat
(PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); src_line_top
= src_first_line + src_stride * y1; src_line_bottom = src_first_line
+ src_stride * y2; if (need_src_extension) { for (i=0; i<
src_width;) { for (j=0; j<src_image->bits.width; j++, i
++) { extended_src_line0[i] = src_line_top[j]; extended_src_line1
[i] = src_line_bottom[j]; } } src_line_top = &extended_src_line0
[0]; src_line_bottom = &extended_src_line1[0]; } buf1[0] =
src_line_top[src_width - 1]; buf1[1] = src_line_top[0]; buf2
[0] = src_line_bottom[src_width - 1]; buf2[1] = src_line_bottom
[0]; width_remain = width; while (width_remain > 0) { repeat
(PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); if (((int)
((vx) >> 16)) == src_width - 1) { num_pixels = ((src_width_fixed
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3843FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_pad_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3844 scaled_bilinear_scanline_mmx_8888_8_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3845 uint32_t, uint8_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3846 PAD, FLAG_HAVE_NON_SOLID_MASK)static void fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_PAD
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_PAD ==
PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_PAD == PIXMAN_REPEAT_NORMAL)
{ int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3847FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_none_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3848 scaled_bilinear_scanline_mmx_8888_8_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3849 uint32_t, uint8_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3850 NONE, FLAG_HAVE_NON_SOLID_MASK)static void fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NONE
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL) { vx = v.vector
[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t)
((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NONE) {
uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]; if
(y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image->
bits.height) { weight1 = 0; y1 = src_image->bits.height - 1
; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NONE == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3851FAST_BILINEAR_MAINLOOP_COMMON (mmx_8888_8_8888_normal_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; if (y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image
->bits.height) { weight1 = 0; y1 = src_image->bits.height
- 1; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3852 scaled_bilinear_scanline_mmx_8888_8_8888_OVER,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; if (y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image
->bits.height) { weight1 = 0; y1 = src_image->bits.height
- 1; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3853 uint32_t, uint8_t, uint32_t,static void fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; if (y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image
->bits.height) { weight1 = 0; y1 = src_image->bits.height
- 1; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3854 NORMAL, FLAG_HAVE_NON_SOLID_MASK)static void fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
(pixman_implementation_t *imp, pixman_composite_info_t *info
) { __attribute__((unused)) pixman_op_t op = info->op; __attribute__
((unused)) pixman_image_t * src_image = info->src_image; __attribute__
((unused)) pixman_image_t * mask_image = info->mask_image;
__attribute__((unused)) pixman_image_t * dest_image = info->
dest_image; __attribute__((unused)) int32_t src_x = info->
src_x; __attribute__((unused)) int32_t src_y = info->src_y
; __attribute__((unused)) int32_t mask_x = info->mask_x; __attribute__
((unused)) int32_t mask_y = info->mask_y; __attribute__((unused
)) int32_t dest_x = info->dest_x; __attribute__((unused)) int32_t
dest_y = info->dest_y; __attribute__((unused)) int32_t width
= info->width; __attribute__((unused)) int32_t height = info
->height; uint32_t *dst_line; uint8_t *mask_line; uint32_t
*src_first_line; int y1, y2; pixman_fixed_t max_vx = 2147483647
; pixman_vector_t v; pixman_fixed_t vx, vy; pixman_fixed_t unit_x
, unit_y; int32_t left_pad, left_tz, right_tz, right_pad; uint32_t
*dst; uint8_t solid_mask; const uint8_t *mask = &solid_mask
; int src_stride, mask_stride, dst_stride; int src_width; pixman_fixed_t
src_width_fixed; int max_x; pixman_bool_t need_src_extension
; do { uint32_t *__bits__; int __stride__; __bits__ = dest_image
->bits.bits; __stride__ = dest_image->bits.rowstride; (
dst_stride) = __stride__ * (int) sizeof (uint32_t) / (int) sizeof
(uint32_t); (dst_line) = ((uint32_t *) __bits__) + (dst_stride
) * (dest_y) + (1) * (dest_x); } while (0); if ((1 << 2
) & (1 << 1)) { solid_mask = _pixman_image_get_solid
(imp, mask_image, dest_image->bits.format); mask_stride =
0; } else if ((1 << 2) & (1 << 2)) { do { uint32_t
*__bits__; int __stride__; __bits__ = mask_image->bits.bits
; __stride__ = mask_image->bits.rowstride; (mask_stride) =
__stride__ * (int) sizeof (uint32_t) / (int) sizeof (uint8_t
); (mask_line) = ((uint8_t *) __bits__) + (mask_stride) * (mask_y
) + (1) * (mask_x); } while (0); } do { uint32_t *__bits__; int
__stride__; __bits__ = src_image->bits.bits; __stride__ =
src_image->bits.rowstride; (src_stride) = __stride__ * (int
) sizeof (uint32_t) / (int) sizeof (uint32_t); (src_first_line
) = ((uint32_t *) __bits__) + (src_stride) * (0) + (1) * (0);
} while (0); v.vector[0] = ((pixman_fixed_t) ((src_x) <<
16)) + (((pixman_fixed_t) ((1) << 16))) / 2; v.vector[
1] = ((pixman_fixed_t) ((src_y) << 16)) + (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[2] = (((pixman_fixed_t) (
(1) << 16))); if (!pixman_transform_point_3d (src_image
->common.transform, &v)) return; unit_x = src_image->
common.transform->matrix[0][0]; unit_y = src_image->common
.transform->matrix[1][1]; v.vector[0] -= (((pixman_fixed_t
) ((1) << 16))) / 2; v.vector[1] -= (((pixman_fixed_t) (
(1) << 16))) / 2; vy = v.vector[1]; if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD || PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { bilinear_pad_repeat_get_scanline_bounds (src_image->bits
.width, v.vector[0], unit_x, &left_pad, &left_tz, &
width, &right_tz, &right_pad); if (PIXMAN_REPEAT_NORMAL
== PIXMAN_REPEAT_PAD) { left_pad += left_tz; right_pad += right_tz
; left_tz = right_tz = 0; } v.vector[0] += left_pad * unit_x;
} if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL) { vx = v
.vector[0]; repeat (PIXMAN_REPEAT_NORMAL, &vx, ((pixman_fixed_t
) ((src_image->bits.width) << 16))); max_x = ((int) (
(vx + (width - 1) * (int64_t)unit_x) >> 16)) + 1; if (src_image
->bits.width < 64) { src_width = 0; while (src_width <
64 && src_width <= max_x) src_width += src_image->
bits.width; need_src_extension = 1; } else { src_width = src_image
->bits.width; need_src_extension = 0; } src_width_fixed = (
(pixman_fixed_t) ((src_width) << 16)); } while (--height
>= 0) { int weight1, weight2; dst = dst_line; dst_line +=
dst_stride; vx = v.vector[0]; if ((1 << 2) & (1 <<
2)) { mask = mask_line; mask_line += mask_stride; } y1 = ((int
) ((vy) >> 16)); weight2 = pixman_fixed_to_bilinear_weight
(vy); if (weight2) { y2 = y1 + 1; weight1 = (1 << 7) -
weight2; } else { y2 = y1; weight1 = weight2 = (1 << 7
) / 2; } vy += unit_y; if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_PAD
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; repeat (PIXMAN_REPEAT_PAD, &y1, src_image->bits.height
); repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height
); src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
src1[0]; buf2[0] = buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
0); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; } if (right_pad > 0) { buf1[0] = buf1[1] =
src1[src_image->bits.width - 1]; buf2[0] = buf2[1] = src2
[src_image->bits.width - 1]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 0); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NONE
) { uint32_t *src1, *src2; uint32_t buf1[2]; uint32_t buf2[2]
; if (y1 < 0) { weight1 = 0; y1 = 0; } if (y1 >= src_image
->bits.height) { weight1 = 0; y1 = src_image->bits.height
- 1; } if (y2 < 0) { weight2 = 0; y2 = 0; } if (y2 >= src_image
->bits.height) { weight2 = 0; y2 = src_image->bits.height
- 1; } src1 = src_first_line + src_stride * y1; src2 = src_first_line
+ src_stride * y2; if (left_pad > 0) { buf1[0] = buf1[1] =
0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_pad, weight1, weight2, 0, 0, 0,
1); dst += left_pad; if ((1 << 2) & (1 << 2)
) mask += left_pad; } if (left_tz > 0) { buf1[0] = 0; buf1
[1] = src1[0]; buf2[0] = 0; buf2[1] = src2[0]; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, left_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += left_tz; if ((1 << 2) & (
1 << 2)) mask += left_tz; vx += left_tz * unit_x; } if (
width > 0) { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src1, src2, width, weight1, weight2, vx, unit_x,
0, 0); dst += width; if ((1 << 2) & (1 << 2)
) mask += width; vx += width * unit_x; } if (right_tz > 0)
{ buf1[0] = src1[src_image->bits.width - 1]; buf1[1] = 0;
buf2[0] = src2[src_image->bits.width - 1]; buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_tz, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, 0, 0); dst += right_tz; if ((1 << 2) &
(1 << 2)) mask += right_tz; } if (right_pad > 0) { buf1
[0] = buf1[1] = 0; buf2[0] = buf2[1] = 0; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, right_pad, weight1, weight2, 0, 0, 0
, 1); } } else if (PIXMAN_REPEAT_NORMAL == PIXMAN_REPEAT_NORMAL
) { int32_t num_pixels; int32_t width_remain; uint32_t * src_line_top
; uint32_t * src_line_bottom; uint32_t buf1[2]; uint32_t buf2
[2]; uint32_t extended_src_line0[64*2]; uint32_t extended_src_line1
[64*2]; int i, j; repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image
->bits.height); repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image
->bits.height); src_line_top = src_first_line + src_stride
* y1; src_line_bottom = src_first_line + src_stride * y2; if
(need_src_extension) { for (i=0; i<src_width;) { for (j=0
; j<src_image->bits.width; j++, i++) { extended_src_line0
[i] = src_line_top[j]; extended_src_line1[i] = src_line_bottom
[j]; } } src_line_top = &extended_src_line0[0]; src_line_bottom
= &extended_src_line1[0]; } buf1[0] = src_line_top[src_width
- 1]; buf1[1] = src_line_top[0]; buf2[0] = src_line_bottom[src_width
- 1]; buf2[1] = src_line_bottom[0]; width_remain = width; while
(width_remain > 0) { repeat (PIXMAN_REPEAT_NORMAL, &vx
, src_width_fixed); if (((int) ((vx) >> 16)) == src_width
- 1) { num_pixels = ((src_width_fixed - vx - ((pixman_fixed_t
) 1)) / unit_x) + 1; if (num_pixels > width_remain) num_pixels
= width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, buf1, buf2, num_pixels, weight1, weight2, ((vx) &
((((pixman_fixed_t) ((1) << 16))) - ((pixman_fixed_t) 1
))), unit_x, src_width_fixed, 0); width_remain -= num_pixels;
vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; repeat (PIXMAN_REPEAT_NORMAL
, &vx, src_width_fixed); } if (((int) ((vx) >> 16))
!= src_width - 1 && width_remain > 0) { num_pixels
= ((src_width_fixed - (((pixman_fixed_t) ((1) << 16)))
- vx - ((pixman_fixed_t) 1)) / unit_x) + 1; if (num_pixels >
width_remain) num_pixels = width_remain; scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_line_top, src_line_bottom, num_pixels, weight1
, weight2, vx, unit_x, src_width_fixed, 0); width_remain -= num_pixels
; vx += num_pixels * unit_x; dst += num_pixels; if ((1 <<
2) & (1 << 2)) mask += num_pixels; } } } else { scaled_bilinear_scanline_mmx_8888_8_8888_OVER
(dst, mask, src_first_line + src_stride * y1, src_first_line
+ src_stride * y2, width, weight1, weight2, vx, unit_x, max_vx
, 0); } } }
3855
3856static uint32_t *
3857mmx_fetch_x8r8g8b8 (pixman_iter_t *iter, const uint32_t *mask)
3858{
3859 int w = iter->width;
3860 uint32_t *dst = iter->buffer;
3861 uint32_t *src = (uint32_t *)iter->bits;
3862
3863 iter->bits += iter->stride;
3864
3865 while (w && ((uintptr_t)dst) & 7)
3866 {
3867 *dst++ = (*src++) | 0xff000000;
3868 w--;
3869 }
3870
3871 while (w >= 8)
3872 {
3873 __m64 vsrc1 = ldq_u ((__m64 *)(src + 0));
3874 __m64 vsrc2 = ldq_u ((__m64 *)(src + 2));
3875 __m64 vsrc3 = ldq_u ((__m64 *)(src + 4));
3876 __m64 vsrc4 = ldq_u ((__m64 *)(src + 6));
3877
3878 *(__m64 *)(dst + 0) = _mm_or_si64 (vsrc1, MC (ff000000)((__m64)c.mmx_ff000000));
3879 *(__m64 *)(dst + 2) = _mm_or_si64 (vsrc2, MC (ff000000)((__m64)c.mmx_ff000000));
3880 *(__m64 *)(dst + 4) = _mm_or_si64 (vsrc3, MC (ff000000)((__m64)c.mmx_ff000000));
3881 *(__m64 *)(dst + 6) = _mm_or_si64 (vsrc4, MC (ff000000)((__m64)c.mmx_ff000000));
3882
3883 dst += 8;
3884 src += 8;
3885 w -= 8;
3886 }
3887
3888 while (w)
3889 {
3890 *dst++ = (*src++) | 0xff000000;
3891 w--;
3892 }
3893
3894 _mm_empty ();
3895 return iter->buffer;
3896}
3897
3898static uint32_t *
3899mmx_fetch_r5g6b5 (pixman_iter_t *iter, const uint32_t *mask)
3900{
3901 int w = iter->width;
3902 uint32_t *dst = iter->buffer;
3903 uint16_t *src = (uint16_t *)iter->bits;
3904
3905 iter->bits += iter->stride;
3906
3907 while (w && ((uintptr_t)dst) & 0x0f)
3908 {
3909 uint16_t s = *src++;
3910
3911 *dst++ = convert_0565_to_8888 (s);
3912 w--;
3913 }
3914
3915 while (w >= 4)
3916 {
3917 __m64 vsrc = ldq_u ((__m64 *)src);
3918 __m64 mm0, mm1;
3919
3920 expand_4xpacked565 (vsrc, &mm0, &mm1, 1);
3921
3922 *(__m64 *)(dst + 0) = mm0;
3923 *(__m64 *)(dst + 2) = mm1;
3924
3925 dst += 4;
3926 src += 4;
3927 w -= 4;
3928 }
3929
3930 while (w)
3931 {
3932 uint16_t s = *src++;
3933
3934 *dst++ = convert_0565_to_8888 (s);
3935 w--;
3936 }
3937
3938 _mm_empty ();
3939 return iter->buffer;
3940}
3941
3942static uint32_t *
3943mmx_fetch_a8 (pixman_iter_t *iter, const uint32_t *mask)
3944{
3945 int w = iter->width;
3946 uint32_t *dst = iter->buffer;
3947 uint8_t *src = iter->bits;
3948
3949 iter->bits += iter->stride;
3950
3951 while (w && (((uintptr_t)dst) & 15))
3952 {
3953 *dst++ = *(src++) << 24;
3954 w--;
3955 }
3956
3957 while (w >= 8)
3958 {
3959 __m64 mm0 = ldq_u ((__m64 *)src);
3960
3961 __m64 mm1 = _mm_unpacklo_pi8 (_mm_setzero_si64(), mm0);
3962 __m64 mm2 = _mm_unpackhi_pi8 (_mm_setzero_si64(), mm0);
3963 __m64 mm3 = _mm_unpacklo_pi16 (_mm_setzero_si64(), mm1);
3964 __m64 mm4 = _mm_unpackhi_pi16 (_mm_setzero_si64(), mm1);
3965 __m64 mm5 = _mm_unpacklo_pi16 (_mm_setzero_si64(), mm2);
3966 __m64 mm6 = _mm_unpackhi_pi16 (_mm_setzero_si64(), mm2);
3967
3968 *(__m64 *)(dst + 0) = mm3;
3969 *(__m64 *)(dst + 2) = mm4;
3970 *(__m64 *)(dst + 4) = mm5;
3971 *(__m64 *)(dst + 6) = mm6;
3972
3973 dst += 8;
3974 src += 8;
3975 w -= 8;
3976 }
3977
3978 while (w)
3979 {
3980 *dst++ = *(src++) << 24;
3981 w--;
3982 }
3983
3984 _mm_empty ();
3985 return iter->buffer;
3986}
3987
3988#define IMAGE_FLAGS(((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (1 << 0) | (1 << 25) | (1 << 23))
\
3989 (FAST_PATH_STANDARD_FLAGS((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6))
| FAST_PATH_ID_TRANSFORM(1 << 0) | \
3990 FAST_PATH_BITS_IMAGE(1 << 25) | FAST_PATH_SAMPLES_COVER_CLIP_NEAREST(1 << 23))
3991
3992static const pixman_iter_info_t mmx_iters[] =
3993{
3994 { PIXMAN_x8r8g8b8, IMAGE_FLAGS(((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (1 << 0) | (1 << 25) | (1 << 23))
, ITER_NARROW,
3995 _pixman_iter_init_bits_stride, mmx_fetch_x8r8g8b8, NULL((void*)0)
3996 },
3997 { PIXMAN_r5g6b5, IMAGE_FLAGS(((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (1 << 0) | (1 << 25) | (1 << 23))
, ITER_NARROW,
3998 _pixman_iter_init_bits_stride, mmx_fetch_r5g6b5, NULL((void*)0)
3999 },
4000 { PIXMAN_a8, IMAGE_FLAGS(((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (1 << 0) | (1 << 25) | (1 << 23))
, ITER_NARROW,
4001 _pixman_iter_init_bits_stride, mmx_fetch_a8, NULL((void*)0)
4002 },
4003 { PIXMAN_null(((0) << 24) | ((0) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)))
},
4004};
4005
4006static const pixman_fast_path_t mmx_fast_paths[] =
4007{
4008 PIXMAN_STD_FAST_PATH (OVER, solid, a8, r5g6b5, mmx_composite_over_n_8_0565 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_r5g6b5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_n_8_0565
}
,
4009 PIXMAN_STD_FAST_PATH (OVER, solid, a8, b5g6r5, mmx_composite_over_n_8_0565 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_b5g6r5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_n_8_0565
}
,
4010 PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8r8g8b8, mmx_composite_over_n_8_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_n_8_8888
}
,
4011 PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8r8g8b8, mmx_composite_over_n_8_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_n_8_8888
}
,
4012 PIXMAN_STD_FAST_PATH (OVER, solid, a8, a8b8g8r8, mmx_composite_over_n_8_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_n_8_8888
}
,
4013 PIXMAN_STD_FAST_PATH (OVER, solid, a8, x8b8g8r8, mmx_composite_over_n_8_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_n_8_8888
}
,
4014 PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, a8r8g8b8, mmx_composite_over_n_8888_8888_ca ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8r8g8b8, ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((0) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1 <<
2) | (1 << 5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8
== (((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))) | (1 << 8)))
, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), mmx_composite_over_n_8888_8888_ca }
,
4015 PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, x8r8g8b8, mmx_composite_over_n_8888_8888_ca ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8r8g8b8, ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((0) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1 <<
2) | (1 << 5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8
== (((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))) | (1 << 8)))
, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), mmx_composite_over_n_8888_8888_ca }
,
4016 PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8r8g8b8, r5g6b5, mmx_composite_over_n_8888_0565_ca ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8r8g8b8, ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((0) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1 <<
2) | (1 << 5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8
== (((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))) | (1 << 8)))
, PIXMAN_r5g6b5, ((1 << 5) | (1 << 1) | (1 <<
6)), mmx_composite_over_n_8888_0565_ca }
,
4017 PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, a8b8g8r8, mmx_composite_over_n_8888_8888_ca ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8b8g8r8, ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((0) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1 <<
2) | (1 << 5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8
== (((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))) | (1 << 8)))
, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), mmx_composite_over_n_8888_8888_ca }
,
4018 PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, x8b8g8r8, mmx_composite_over_n_8888_8888_ca ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8b8g8r8, ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((0) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1 <<
2) | (1 << 5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8
== (((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))) | (1 << 8)))
, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), mmx_composite_over_n_8888_8888_ca }
,
4019 PIXMAN_STD_FAST_PATH_CA (OVER, solid, a8b8g8r8, b5g6r5, mmx_composite_over_n_8888_0565_ca ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8b8g8r8, ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((0) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1 <<
2) | (1 << 5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8
== (((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))) | (1 << 8)))
, PIXMAN_b5g6r5, ((1 << 5) | (1 << 1) | (1 <<
6)), mmx_composite_over_n_8888_0565_ca }
,
4020 PIXMAN_STD_FAST_PATH (OVER, pixbuf, pixbuf, a8r8g8b8, mmx_composite_over_pixbuf_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((2) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((2) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((2) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((2) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((2) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), mmx_composite_over_pixbuf_8888
}
,
4021 PIXMAN_STD_FAST_PATH (OVER, pixbuf, pixbuf, x8r8g8b8, mmx_composite_over_pixbuf_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((2) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((2) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((2) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((2) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((2) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), mmx_composite_over_pixbuf_8888
}
,
4022 PIXMAN_STD_FAST_PATH (OVER, pixbuf, pixbuf, r5g6b5, mmx_composite_over_pixbuf_0565 ){ PIXMAN_OP_OVER, (((0) << 24) | ((2) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((2) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((2) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((2) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((2) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_r5g6b5, ((1 << 5) | (
1 << 1) | (1 << 6)), mmx_composite_over_pixbuf_0565
}
,
4023 PIXMAN_STD_FAST_PATH (OVER, rpixbuf, rpixbuf, a8b8g8r8, mmx_composite_over_pixbuf_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((3) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((3) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((3) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((3) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((3) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), mmx_composite_over_pixbuf_8888
}
,
4024 PIXMAN_STD_FAST_PATH (OVER, rpixbuf, rpixbuf, x8b8g8r8, mmx_composite_over_pixbuf_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((3) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((3) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((3) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((3) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((3) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), mmx_composite_over_pixbuf_8888
}
,
4025 PIXMAN_STD_FAST_PATH (OVER, rpixbuf, rpixbuf, b5g6r5, mmx_composite_over_pixbuf_0565 ){ PIXMAN_OP_OVER, (((0) << 24) | ((3) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((3) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((3) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((3) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((3) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_b5g6r5, ((1 << 5) | (
1 << 1) | (1 << 6)), mmx_composite_over_pixbuf_0565
}
,
4026 PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, solid, a8r8g8b8, mmx_composite_over_x888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_x888_n_8888
}
,
4027 PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, solid, x8r8g8b8, mmx_composite_over_x888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_x888_n_8888
}
,
4028 PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, solid, a8b8g8r8, mmx_composite_over_x888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_x888_n_8888
}
,
4029 PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, solid, x8b8g8r8, mmx_composite_over_x888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_x888_n_8888
}
,
4030 PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, solid, a8r8g8b8, mmx_composite_over_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_n_8888
}
,
4031 PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, solid, x8r8g8b8, mmx_composite_over_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_n_8888
}
,
4032 PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, solid, a8b8g8r8, mmx_composite_over_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_n_8888
}
,
4033 PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, solid, x8b8g8r8, mmx_composite_over_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_n_8888
}
,
4034 PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, x8r8g8b8, mmx_composite_over_x888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8
== (((0) << 24) | ((0) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1
<< 2) | (1 << 5) | (1 << 1) | (1 << 6
)) | ((PIXMAN_a8 == (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
))) ? 0 : ((1 << 23) | (1 << 11) | (1 << 0)
))) | (1 << 9))), PIXMAN_x8r8g8b8, ((1 << 5) | (1
<< 1) | (1 << 6)), mmx_composite_over_x888_8_8888
}
,
4035 PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, a8, a8r8g8b8, mmx_composite_over_x888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8
== (((0) << 24) | ((0) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1
<< 2) | (1 << 5) | (1 << 1) | (1 << 6
)) | ((PIXMAN_a8 == (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
))) ? 0 : ((1 << 23) | (1 << 11) | (1 << 0)
))) | (1 << 9))), PIXMAN_a8r8g8b8, ((1 << 5) | (1
<< 1) | (1 << 6)), mmx_composite_over_x888_8_8888
}
,
4036 PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, x8b8g8r8, mmx_composite_over_x888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8
== (((0) << 24) | ((0) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1
<< 2) | (1 << 5) | (1 << 1) | (1 << 6
)) | ((PIXMAN_a8 == (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
))) ? 0 : ((1 << 23) | (1 << 11) | (1 << 0)
))) | (1 << 9))), PIXMAN_x8b8g8r8, ((1 << 5) | (1
<< 1) | (1 << 6)), mmx_composite_over_x888_8_8888
}
,
4037 PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, a8, a8b8g8r8, mmx_composite_over_x888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8
== (((0) << 24) | ((0) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((((1
<< 2) | (1 << 5) | (1 << 1) | (1 << 6
)) | ((PIXMAN_a8 == (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
))) ? 0 : ((1 << 23) | (1 << 11) | (1 << 0)
))) | (1 << 9))), PIXMAN_a8b8g8r8, ((1 << 5) | (1
<< 1) | (1 << 6)), mmx_composite_over_x888_8_8888
}
,
4038 PIXMAN_STD_FAST_PATH (OVER, solid, null, a8r8g8b8, mmx_composite_over_n_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((0) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), mmx_composite_over_n_8888 }
,
4039 PIXMAN_STD_FAST_PATH (OVER, solid, null, x8r8g8b8, mmx_composite_over_n_8888 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((0) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), mmx_composite_over_n_8888 }
,
4040 PIXMAN_STD_FAST_PATH (OVER, solid, null, r5g6b5, mmx_composite_over_n_0565 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((0) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_r5g6b5, ((1 << 5) | (
1 << 1) | (1 << 6)), mmx_composite_over_n_0565 }
,
4041 PIXMAN_STD_FAST_PATH (OVER, solid, null, b5g6r5, mmx_composite_over_n_0565 ){ PIXMAN_OP_OVER, (((0) << 24) | ((1) << 16) | ((
0) << 12) | ((0) << 8) | ((0) << 4) | ((0))
), (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((0) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_b5g6r5, ((1 << 5) | (
1 << 1) | (1 << 6)), mmx_composite_over_n_0565 }
,
4042 PIXMAN_STD_FAST_PATH (OVER, x8r8g8b8, null, x8r8g8b8, mmx_composite_copy_area ){ PIXMAN_OP_OVER, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4043 PIXMAN_STD_FAST_PATH (OVER, x8b8g8r8, null, x8b8g8r8, mmx_composite_copy_area ){ PIXMAN_OP_OVER, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4044
4045 PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, a8r8g8b8, mmx_composite_over_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_8888
}
,
4046 PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, x8r8g8b8, mmx_composite_over_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_8888
}
,
4047 PIXMAN_STD_FAST_PATH (OVER, a8r8g8b8, null, r5g6b5, mmx_composite_over_8888_0565 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_r5g6b5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_0565
}
,
4048 PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, a8b8g8r8, mmx_composite_over_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_8888
}
,
4049 PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, x8b8g8r8, mmx_composite_over_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_8888
}
,
4050 PIXMAN_STD_FAST_PATH (OVER, a8b8g8r8, null, b5g6r5, mmx_composite_over_8888_0565 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_b5g6r5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_8888_0565
}
,
4051
4052 PIXMAN_STD_FAST_PATH (OVER_REVERSE, solid, null, a8r8g8b8, mmx_composite_over_reverse_n_8888){ PIXMAN_OP_OVER_REVERSE, (((0) << 24) | ((1) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((1 << 2) | (1 << 5) | (1 << 1) |
(1 << 6)) | (((((0) << 24) | ((1) << 16) |
((0) << 12) | ((0) << 8) | ((0) << 4) | ((
0))) == (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
1 << 23) | (1 << 11) | (1 << 0)))), (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_reverse_n_8888
}
,
4053 PIXMAN_STD_FAST_PATH (OVER_REVERSE, solid, null, a8b8g8r8, mmx_composite_over_reverse_n_8888){ PIXMAN_OP_OVER_REVERSE, (((0) << 24) | ((1) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((1 << 2) | (1 << 5) | (1 << 1) |
(1 << 6)) | (((((0) << 24) | ((1) << 16) |
((0) << 12) | ((0) << 8) | ((0) << 4) | ((
0))) == (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
1 << 23) | (1 << 11) | (1 << 0)))), (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_over_reverse_n_8888
}
,
4054
4055 PIXMAN_STD_FAST_PATH (ADD, r5g6b5, null, r5g6b5, mmx_composite_add_0565_0565 ){ PIXMAN_OP_ADD, PIXMAN_r5g6b5, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_r5g6b5 == (
((0) << 24) | ((1) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_r5g6b5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_add_0565_0565
}
,
4056 PIXMAN_STD_FAST_PATH (ADD, b5g6r5, null, b5g6r5, mmx_composite_add_0565_0565 ){ PIXMAN_OP_ADD, PIXMAN_b5g6r5, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_b5g6r5 == (
((0) << 24) | ((1) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_b5g6r5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_add_0565_0565
}
,
4057 PIXMAN_STD_FAST_PATH (ADD, a8r8g8b8, null, a8r8g8b8, mmx_composite_add_8888_8888 ){ PIXMAN_OP_ADD, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_add_8888_8888
}
,
4058 PIXMAN_STD_FAST_PATH (ADD, a8b8g8r8, null, a8b8g8r8, mmx_composite_add_8888_8888 ){ PIXMAN_OP_ADD, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_add_8888_8888
}
,
4059 PIXMAN_STD_FAST_PATH (ADD, a8, null, a8, mmx_composite_add_8_8 ){ PIXMAN_OP_ADD, PIXMAN_a8, (((1 << 2) | (1 << 5)
| (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((0) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8, ((1 << 5) | (1 <<
1) | (1 << 6)), mmx_composite_add_8_8 }
,
4060 PIXMAN_STD_FAST_PATH (ADD, solid, a8, a8, mmx_composite_add_n_8_8 ){ PIXMAN_OP_ADD, (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8, ((1 <<
5) | (1 << 1) | (1 << 6)), mmx_composite_add_n_8_8
}
,
4061
4062 PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, r5g6b5, mmx_composite_src_x888_0565 ){ PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_r5g6b5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_x888_0565
}
,
4063 PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, b5g6r5, mmx_composite_src_x888_0565 ){ PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_b5g6r5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_x888_0565
}
,
4064 PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, r5g6b5, mmx_composite_src_x888_0565 ){ PIXMAN_OP_SRC, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_r5g6b5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_x888_0565
}
,
4065 PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, b5g6r5, mmx_composite_src_x888_0565 ){ PIXMAN_OP_SRC, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_b5g6r5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_x888_0565
}
,
4066 PIXMAN_STD_FAST_PATH (SRC, solid, a8, a8r8g8b8, mmx_composite_src_n_8_8888 ){ PIXMAN_OP_SRC, (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_n_8_8888
}
,
4067 PIXMAN_STD_FAST_PATH (SRC, solid, a8, x8r8g8b8, mmx_composite_src_n_8_8888 ){ PIXMAN_OP_SRC, (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_n_8_8888
}
,
4068 PIXMAN_STD_FAST_PATH (SRC, solid, a8, a8b8g8r8, mmx_composite_src_n_8_8888 ){ PIXMAN_OP_SRC, (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_n_8_8888
}
,
4069 PIXMAN_STD_FAST_PATH (SRC, solid, a8, x8b8g8r8, mmx_composite_src_n_8_8888 ){ PIXMAN_OP_SRC, (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_src_n_8_8888
}
,
4070 PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, a8r8g8b8, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4071 PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, a8b8g8r8, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4072 PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, x8r8g8b8, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4073 PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, x8b8g8r8, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4074 PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, x8r8g8b8, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_x8r8g8b8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8r8g8b8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4075 PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, x8b8g8r8, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_x8b8g8r8, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_x8b8g8r8 ==
(((0) << 24) | ((1) << 16) | ((0) << 12) |
((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4076 PIXMAN_STD_FAST_PATH (SRC, r5g6b5, null, r5g6b5, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_r5g6b5, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_r5g6b5 == (
((0) << 24) | ((1) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_r5g6b5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4077 PIXMAN_STD_FAST_PATH (SRC, b5g6r5, null, b5g6r5, mmx_composite_copy_area ){ PIXMAN_OP_SRC, PIXMAN_b5g6r5, (((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_b5g6r5 == (
((0) << 24) | ((1) << 16) | ((0) << 12) | (
(0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((1 <<
23) | (1 << 11) | (1 << 0)))), (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))), (((((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0))) == (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_b5g6r5, (
(1 << 5) | (1 << 1) | (1 << 6)), mmx_composite_copy_area
}
,
4078
4079 PIXMAN_STD_FAST_PATH (IN, a8, null, a8, mmx_composite_in_8_8 ){ PIXMAN_OP_IN, PIXMAN_a8, (((1 << 2) | (1 << 5) |
(1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), (((0) << 24) | ((0) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))), (((((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8, ((1 << 5) | (1 <<
1) | (1 << 6)), mmx_composite_in_8_8 }
,
4080 PIXMAN_STD_FAST_PATH (IN, solid, a8, a8, mmx_composite_in_n_8_8 ){ PIXMAN_OP_IN, (((0) << 24) | ((1) << 16) | ((0)
<< 12) | ((0) << 8) | ((0) << 4) | ((0))),
(((1 << 2) | (1 << 5) | (1 << 1) | (1 <<
6)) | (((((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))), PIXMAN_a8, ((PIXMAN_a8 == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8, ((1 <<
5) | (1 << 1) | (1 << 6)), mmx_composite_in_n_8_8
}
,
4081
4082 SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_none_OVER, }
, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
, }
,
4083 SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_none_OVER, }
, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
, }
,
4084 SIMPLE_NEAREST_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_none_OVER, }
, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
, }
,
4085 SIMPLE_NEAREST_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_none_OVER, }
, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_nearest_mmx_8888_8888_normal_OVER
, }
,
4086
4087 SIMPLE_NEAREST_SOLID_MASK_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, mmx_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), (((((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0))) == (((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((((1 << 2) | (1 << 5) | (1 <<
1) | (1 << 6)) | (((((0) << 24) | ((1) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))) == (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
1 << 23) | (1 << 11) | (1 << 0)))) | (1 <<
9))), PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
, }
,
4088 SIMPLE_NEAREST_SOLID_MASK_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, mmx_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), (((((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0))) == (((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((((1 << 2) | (1 << 5) | (1 <<
1) | (1 << 6)) | (((((0) << 24) | ((1) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))) == (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
1 << 23) | (1 << 11) | (1 << 0)))) | (1 <<
9))), PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_a8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
, }
,
4089 SIMPLE_NEAREST_SOLID_MASK_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, mmx_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), (((((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0))) == (((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((((1 << 2) | (1 << 5) | (1 <<
1) | (1 << 6)) | (((((0) << 24) | ((1) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))) == (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
1 << 23) | (1 << 11) | (1 << 0)))) | (1 <<
9))), PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8r8g8b8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
, }
,
4090 SIMPLE_NEAREST_SOLID_MASK_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, mmx_8888_n_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 11) | (1 << 5) | (1 << 6)) | (1
<< 23), (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), (((((0) <<
24) | ((1) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0))) == (((0) << 24) | ((0) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((((1 << 2) | (1 << 5) | (1 <<
1) | (1 << 6)) | (((((0) << 24) | ((1) << 16
) | ((0) << 12) | ((0) << 8) | ((0) << 4) |
((0))) == (((0) << 24) | ((1) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0)))) ? 0 : ((
1 << 23) | (1 << 11) | (1 << 0)))) | (1 <<
9))), PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((1) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 11) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((1) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, (((((0) << 24) | ((1) << 16) | ((0) << 12
) | ((0) << 8) | ((0) << 4) | ((0))) == (((0) <<
24) | ((0) << 16) | ((0) << 12) | ((0) << 8
) | ((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | (((((0) << 24)
| ((1) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0))) == (((0) << 24) | ((1) <<
16) | ((0) << 12) | ((0) << 8) | ((0) << 4
) | ((0)))) ? 0 : ((1 << 23) | (1 << 11) | (1 <<
0)))) | (1 << 9))), PIXMAN_x8b8g8r8, ((1 << 5) |
(1 << 1) | (1 << 6)), fast_composite_scaled_nearest_mmx_8888_n_8888_normal_OVER
, }
,
4091
4092 SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8, a8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC, }
, { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
, }
,
4093 SIMPLE_BILINEAR_FAST_PATH (SRC, a8r8g8b8, x8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC, }
, { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
, }
,
4094 SIMPLE_BILINEAR_FAST_PATH (SRC, x8r8g8b8, x8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_SRC, PIXMAN_x8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_x8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC, }
, { PIXMAN_OP_SRC, PIXMAN_x8r8g8b8, (((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_x8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
, }
,
4095 SIMPLE_BILINEAR_FAST_PATH (SRC, a8b8g8r8, a8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC, }
, { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
, }
,
4096 SIMPLE_BILINEAR_FAST_PATH (SRC, a8b8g8r8, x8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC, }
, { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_a8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
, }
,
4097 SIMPLE_BILINEAR_FAST_PATH (SRC, x8b8g8r8, x8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_SRC, PIXMAN_x8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_x8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_SRC, }
, { PIXMAN_OP_SRC, PIXMAN_x8b8g8r8, (((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | ((
1 << 15) | (1 << 14) | (1 << 4)) | (1 <<
16)), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_SRC
, }, { PIXMAN_OP_SRC, PIXMAN_x8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_SRC
, }
,
4098
4099 SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER,
}, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((0) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
, }
,
4100 SIMPLE_BILINEAR_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_x8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER,
}, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((0) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_x8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
, }
,
4101 SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8r8g8b8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER,
}, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((0) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8r8g8b8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
, }
,
4102 SIMPLE_BILINEAR_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, mmx_8888_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), (((0) << 24) | ((0) << 16) | ((0) <<
12) | ((0) << 8) | ((0) << 4) | ((0))), 0, PIXMAN_a8b8g8r8
, ((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_none_OVER,
}, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (1
<< 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), (((0) << 24) | ((0) << 16) | (
(0) << 12) | ((0) << 8) | ((0) << 4) | ((0)
)), 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1
<< 6)), fast_composite_scaled_bilinear_mmx_8888_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), (((0) << 24) | ((0) << 16) | ((0
) << 12) | ((0) << 8) | ((0) << 4) | ((0)))
, 0, PIXMAN_a8b8g8r8, ((1 << 5) | (1 << 1) | (1 <<
6)), fast_composite_scaled_bilinear_mmx_8888_8888_normal_OVER
, }
,
4103
4104 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, mmx_8888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24) |
((0) << 16) | ((0) << 12) | ((0) << 8) | (
(0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
, }
,
4105 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, mmx_8888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24) |
((0) << 16) | ((0) << 12) | ((0) << 8) | (
(0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_x8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
, }
,
4106 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, mmx_8888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24) |
((0) << 16) | ((0) << 12) | ((0) << 8) | (
(0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8r8g8b8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8r8g8b8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
, }
,
4107 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, mmx_8888_8_8888 ){ PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, ((1 << 10) | (1 <<
1) | (1 << 19) | (1 << 5) | (1 << 6)) | (1
<< 24), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24) |
((0) << 16) | ((0) << 12) | ((0) << 8) | (
(0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_cover_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 14) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_none_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 14) | (1 << 4)) |
(1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24
) | ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_pad_OVER
, }, { PIXMAN_OP_OVER, PIXMAN_a8b8g8r8, (((1 << 10) | (
1 << 1) | (1 << 19) | (1 << 5) | (1 <<
6)) | ((1 << 15) | (1 << 3) | (1 << 4)) | (
1 << 16)), PIXMAN_a8, ((PIXMAN_a8 == (((0) << 24)
| ((0) << 16) | ((0) << 12) | ((0) << 8) |
((0) << 4) | ((0)))) ? 0 : ((((1 << 2) | (1 <<
5) | (1 << 1) | (1 << 6)) | ((PIXMAN_a8 == (((0)
<< 24) | ((1) << 16) | ((0) << 12) | ((0) <<
8) | ((0) << 4) | ((0)))) ? 0 : ((1 << 23) | (1 <<
11) | (1 << 0)))) | (1 << 9))), PIXMAN_a8b8g8r8,
((1 << 5) | (1 << 1) | (1 << 6)), fast_composite_scaled_bilinear_mmx_8888_8_8888_normal_OVER
, }
,
4108
4109 { PIXMAN_OP_NONE },
4110};
4111
4112pixman_implementation_t *
4113_pixman_implementation_create_mmx (pixman_implementation_t *fallback)
4114{
4115 pixman_implementation_t *imp = _pixman_implementation_create (fallback, mmx_fast_paths);
4116
4117 imp->combine_32[PIXMAN_OP_OVER] = mmx_combine_over_u;
4118 imp->combine_32[PIXMAN_OP_OVER_REVERSE] = mmx_combine_over_reverse_u;
4119 imp->combine_32[PIXMAN_OP_IN] = mmx_combine_in_u;
4120 imp->combine_32[PIXMAN_OP_IN_REVERSE] = mmx_combine_in_reverse_u;
4121 imp->combine_32[PIXMAN_OP_OUT] = mmx_combine_out_u;
4122 imp->combine_32[PIXMAN_OP_OUT_REVERSE] = mmx_combine_out_reverse_u;
4123 imp->combine_32[PIXMAN_OP_ATOP] = mmx_combine_atop_u;
4124 imp->combine_32[PIXMAN_OP_ATOP_REVERSE] = mmx_combine_atop_reverse_u;
4125 imp->combine_32[PIXMAN_OP_XOR] = mmx_combine_xor_u;
4126 imp->combine_32[PIXMAN_OP_ADD] = mmx_combine_add_u;
4127 imp->combine_32[PIXMAN_OP_SATURATE] = mmx_combine_saturate_u;
4128
4129 imp->combine_32_ca[PIXMAN_OP_SRC] = mmx_combine_src_ca;
4130 imp->combine_32_ca[PIXMAN_OP_OVER] = mmx_combine_over_ca;
4131 imp->combine_32_ca[PIXMAN_OP_OVER_REVERSE] = mmx_combine_over_reverse_ca;
4132 imp->combine_32_ca[PIXMAN_OP_IN] = mmx_combine_in_ca;
4133 imp->combine_32_ca[PIXMAN_OP_IN_REVERSE] = mmx_combine_in_reverse_ca;
4134 imp->combine_32_ca[PIXMAN_OP_OUT] = mmx_combine_out_ca;
4135 imp->combine_32_ca[PIXMAN_OP_OUT_REVERSE] = mmx_combine_out_reverse_ca;
4136 imp->combine_32_ca[PIXMAN_OP_ATOP] = mmx_combine_atop_ca;
4137 imp->combine_32_ca[PIXMAN_OP_ATOP_REVERSE] = mmx_combine_atop_reverse_ca;
4138 imp->combine_32_ca[PIXMAN_OP_XOR] = mmx_combine_xor_ca;
4139 imp->combine_32_ca[PIXMAN_OP_ADD] = mmx_combine_add_ca;
4140
4141 imp->blt = mmx_blt;
4142 imp->fill = mmx_fill;
4143
4144 imp->iter_info = mmx_iters;
4145
4146 return imp;
4147}
4148
4149#endif /* USE_X86_MMX || USE_ARM_IWMMXT || USE_LOONGSON_MMI */