?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / pixman / pixman-src / pixman / pixman-bits-image.c
blobdcdcc69946dede2bb9967bfa81edb481a1e965ad
1 /*
2 * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc.
3 * 2005 Lars Knoll & Zack Rusin, Trolltech
4 * 2008 Aaron Plattner, NVIDIA Corporation
5 * Copyright © 2000 SuSE, Inc.
6 * Copyright © 2007, 2009 Red Hat, Inc.
7 * Copyright © 2008 André Tupinambá <andrelrt@gmail.com>
8 *
9 * Permission to use, copy, modify, distribute, and sell this software and its
10 * documentation for any purpose is hereby granted without fee, provided that
11 * the above copyright notice appear in all copies and that both that
12 * copyright notice and this permission notice appear in supporting
13 * documentation, and that the name of Keith Packard not be used in
14 * advertising or publicity pertaining to distribution of the software without
15 * specific, written prior permission. Keith Packard makes no
16 * representations about the suitability of this software for any purpose. It
17 * is provided "as is" without express or implied warranty.
18 *
19 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
20 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
22 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
23 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
24 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
25 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
26 * SOFTWARE.
27 */
28
29 #ifdef HAVE_CONFIG_H
30 #include <config.h>
31 #endif
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include "pixman-private.h"
36 #include "pixman-combine32.h"
37 #include "pixman-inlines.h"
38
39 static uint32_t *
40 _pixman_image_get_scanline_generic_float (pixman_iter_t * iter,
41 const uint32_t *mask)
42 {
43 pixman_iter_get_scanline_t fetch_32 = iter->data;
44 uint32_t *buffer = iter->buffer;
45
46 fetch_32 (iter, NULL);
47
48 pixman_expand_to_float ((argb_t *)buffer, buffer, PIXMAN_a8r8g8b8, iter->width);
49
50 return iter->buffer;
51 }
52
53 /* Fetch functions */
54
55 static force_inline uint32_t
56 fetch_pixel_no_alpha (bits_image_t *image,
57 int x, int y, pixman_bool_t check_bounds)
58 {
59 if (check_bounds &&
60 (x < 0 || x >= image->width || y < 0 || y >= image->height))
61 {
62 return 0;
63 }
64
65 return image->fetch_pixel_32 (image, x, y);
66 }
67
68 typedef uint32_t (* get_pixel_t) (bits_image_t *image,
69 int x, int y, pixman_bool_t check_bounds);
70
71 static force_inline uint32_t
72 bits_image_fetch_pixel_nearest (bits_image_t *image,
73 pixman_fixed_t x,
74 pixman_fixed_t y,
75 get_pixel_t get_pixel)
76 {
77 int x0 = pixman_fixed_to_int (x - pixman_fixed_e);
78 int y0 = pixman_fixed_to_int (y - pixman_fixed_e);
79
80 if (image->common.repeat != PIXMAN_REPEAT_NONE)
81 {
82 repeat (image->common.repeat, &x0, image->width);
83 repeat (image->common.repeat, &y0, image->height);
84
85 return get_pixel (image, x0, y0, FALSE);
86 }
87 else
88 {
89 return get_pixel (image, x0, y0, TRUE);
90 }
91 }
92
93 static force_inline uint32_t
94 bits_image_fetch_pixel_bilinear (bits_image_t *image,
95 pixman_fixed_t x,
96 pixman_fixed_t y,
97 get_pixel_t get_pixel)
98 {
99 pixman_repeat_t repeat_mode = image->common.repeat;
100 int width = image->width;
101 int height = image->height;
102 int x1, y1, x2, y2;
103 uint32_t tl, tr, bl, br;
104 int32_t distx, disty;
105
106 x1 = x - pixman_fixed_1 / 2;
107 y1 = y - pixman_fixed_1 / 2;
108
109 distx = pixman_fixed_to_bilinear_weight (x1);
110 disty = pixman_fixed_to_bilinear_weight (y1);
111
112 x1 = pixman_fixed_to_int (x1);
113 y1 = pixman_fixed_to_int (y1);
114 x2 = x1 + 1;
115 y2 = y1 + 1;
116
117 if (repeat_mode != PIXMAN_REPEAT_NONE)
118 {
119 repeat (repeat_mode, &x1, width);
120 repeat (repeat_mode, &y1, height);
121 repeat (repeat_mode, &x2, width);
122 repeat (repeat_mode, &y2, height);
123
124 tl = get_pixel (image, x1, y1, FALSE);
125 bl = get_pixel (image, x1, y2, FALSE);
126 tr = get_pixel (image, x2, y1, FALSE);
127 br = get_pixel (image, x2, y2, FALSE);
128 }
129 else
130 {
131 tl = get_pixel (image, x1, y1, TRUE);
132 tr = get_pixel (image, x2, y1, TRUE);
133 bl = get_pixel (image, x1, y2, TRUE);
134 br = get_pixel (image, x2, y2, TRUE);
135 }
136
137 return bilinear_interpolation (tl, tr, bl, br, distx, disty);
138 }
139
140 static force_inline uint32_t
141 bits_image_fetch_pixel_convolution (bits_image_t *image,
142 pixman_fixed_t x,
143 pixman_fixed_t y,
144 get_pixel_t get_pixel)
145 {
146 pixman_fixed_t *params = image->common.filter_params;
147 int x_off = (params[0] - pixman_fixed_1) >> 1;
148 int y_off = (params[1] - pixman_fixed_1) >> 1;
149 int32_t cwidth = pixman_fixed_to_int (params[0]);
150 int32_t cheight = pixman_fixed_to_int (params[1]);
151 int32_t i, j, x1, x2, y1, y2;
152 pixman_repeat_t repeat_mode = image->common.repeat;
153 int width = image->width;
154 int height = image->height;
155 int srtot, sgtot, sbtot, satot;
156
157 params += 2;
158
159 x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);
160 y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);
161 x2 = x1 + cwidth;
162 y2 = y1 + cheight;
163
164 srtot = sgtot = sbtot = satot = 0;
165
166 for (i = y1; i < y2; ++i)
167 {
168 for (j = x1; j < x2; ++j)
169 {
170 int rx = j;
171 int ry = i;
172
173 pixman_fixed_t f = *params;
174
175 if (f)
176 {
177 uint32_t pixel;
178
179 if (repeat_mode != PIXMAN_REPEAT_NONE)
180 {
181 repeat (repeat_mode, &rx, width);
182 repeat (repeat_mode, &ry, height);
183
184 pixel = get_pixel (image, rx, ry, FALSE);
185 }
186 else
187 {
188 pixel = get_pixel (image, rx, ry, TRUE);
189 }
190
191 srtot += (int)RED_8 (pixel) * f;
192 sgtot += (int)GREEN_8 (pixel) * f;
193 sbtot += (int)BLUE_8 (pixel) * f;
194 satot += (int)ALPHA_8 (pixel) * f;
195 }
196
197 params++;
198 }
199 }
200
201 satot = (satot + 0x8000) >> 16;
202 srtot = (srtot + 0x8000) >> 16;
203 sgtot = (sgtot + 0x8000) >> 16;
204 sbtot = (sbtot + 0x8000) >> 16;
205
206 satot = CLIP (satot, 0, 0xff);
207 srtot = CLIP (srtot, 0, 0xff);
208 sgtot = CLIP (sgtot, 0, 0xff);
209 sbtot = CLIP (sbtot, 0, 0xff);
210
211 return ((satot << 24) | (srtot << 16) | (sgtot << 8) | (sbtot));
212 }
213
214 static uint32_t
215 bits_image_fetch_pixel_separable_convolution (bits_image_t *image,
216 pixman_fixed_t x,
217 pixman_fixed_t y,
218 get_pixel_t get_pixel)
219 {
220 pixman_fixed_t *params = image->common.filter_params;
221 pixman_repeat_t repeat_mode = image->common.repeat;
222 int width = image->width;
223 int height = image->height;
224 int cwidth = pixman_fixed_to_int (params[0]);
225 int cheight = pixman_fixed_to_int (params[1]);
226 int x_phase_bits = pixman_fixed_to_int (params[2]);
227 int y_phase_bits = pixman_fixed_to_int (params[3]);
228 int x_phase_shift = 16 - x_phase_bits;
229 int y_phase_shift = 16 - y_phase_bits;
230 int x_off = ((cwidth << 16) - pixman_fixed_1) >> 1;
231 int y_off = ((cheight << 16) - pixman_fixed_1) >> 1;
232 pixman_fixed_t *y_params;
233 int srtot, sgtot, sbtot, satot;
234 int32_t x1, x2, y1, y2;
235 int32_t px, py;
236 int i, j;
237
238 /* Round x and y to the middle of the closest phase before continuing. This
239 * ensures that the convolution matrix is aligned right, since it was
240 * positioned relative to a particular phase (and not relative to whatever
241 * exact fraction we happen to get here).
242 */
243 x = ((x >> x_phase_shift) << x_phase_shift) + ((1 << x_phase_shift) >> 1);
244 y = ((y >> y_phase_shift) << y_phase_shift) + ((1 << y_phase_shift) >> 1);
245
246 px = (x & 0xffff) >> x_phase_shift;
247 py = (y & 0xffff) >> y_phase_shift;
248
249 y_params = params + 4 + (1 << x_phase_bits) * cwidth + py * cheight;
250
251 x1 = pixman_fixed_to_int (x - pixman_fixed_e - x_off);
252 y1 = pixman_fixed_to_int (y - pixman_fixed_e - y_off);
253 x2 = x1 + cwidth;
254 y2 = y1 + cheight;
255
256 srtot = sgtot = sbtot = satot = 0;
257
258 for (i = y1; i < y2; ++i)
259 {
260 pixman_fixed_48_16_t fy = *y_params++;
261 pixman_fixed_t *x_params = params + 4 + px * cwidth;
262
263 if (fy)
264 {
265 for (j = x1; j < x2; ++j)
266 {
267 pixman_fixed_t fx = *x_params++;
268 int rx = j;
269 int ry = i;
270
271 if (fx)
272 {
273 pixman_fixed_t f;
274 uint32_t pixel;
275
276 if (repeat_mode != PIXMAN_REPEAT_NONE)
277 {
278 repeat (repeat_mode, &rx, width);
279 repeat (repeat_mode, &ry, height);
280
281 pixel = get_pixel (image, rx, ry, FALSE);
282 }
283 else
284 {
285 pixel = get_pixel (image, rx, ry, TRUE);
286 }
287
288 f = (fy * fx + 0x8000) >> 16;
289
290 srtot += (int)RED_8 (pixel) * f;
291 sgtot += (int)GREEN_8 (pixel) * f;
292 sbtot += (int)BLUE_8 (pixel) * f;
293 satot += (int)ALPHA_8 (pixel) * f;
294 }
295 }
296 }
297 }
298
299 satot = (satot + 0x8000) >> 16;
300 srtot = (srtot + 0x8000) >> 16;
301 sgtot = (sgtot + 0x8000) >> 16;
302 sbtot = (sbtot + 0x8000) >> 16;
303
304 satot = CLIP (satot, 0, 0xff);
305 srtot = CLIP (srtot, 0, 0xff);
306 sgtot = CLIP (sgtot, 0, 0xff);
307 sbtot = CLIP (sbtot, 0, 0xff);
308
309 return ((satot << 24) | (srtot << 16) | (sgtot << 8) | (sbtot));
310 }
311
312 static force_inline uint32_t
313 bits_image_fetch_pixel_filtered (bits_image_t *image,
314 pixman_fixed_t x,
315 pixman_fixed_t y,
316 get_pixel_t get_pixel)
317 {
318 switch (image->common.filter)
319 {
320 case PIXMAN_FILTER_NEAREST:
321 case PIXMAN_FILTER_FAST:
322 return bits_image_fetch_pixel_nearest (image, x, y, get_pixel);
323 break;
324
325 case PIXMAN_FILTER_BILINEAR:
326 case PIXMAN_FILTER_GOOD:
327 case PIXMAN_FILTER_BEST:
328 return bits_image_fetch_pixel_bilinear (image, x, y, get_pixel);
329 break;
330
331 case PIXMAN_FILTER_CONVOLUTION:
332 return bits_image_fetch_pixel_convolution (image, x, y, get_pixel);
333 break;
334
335 case PIXMAN_FILTER_SEPARABLE_CONVOLUTION:
336 return bits_image_fetch_pixel_separable_convolution (image, x, y, get_pixel);
337 break;
338
339 default:
340 break;
341 }
342
343 return 0;
344 }
345
346 static uint32_t *
347 bits_image_fetch_affine_no_alpha (pixman_iter_t * iter,
348 const uint32_t * mask)
349 {
350 pixman_image_t *image = iter->image;
351 int offset = iter->x;
352 int line = iter->y++;
353 int width = iter->width;
354 uint32_t * buffer = iter->buffer;
355
356 pixman_fixed_t x, y;
357 pixman_fixed_t ux, uy;
358 pixman_vector_t v;
359 int i;
360
361 /* reference point is the center of the pixel */
362 v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
363 v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
364 v.vector[2] = pixman_fixed_1;
365
366 if (image->common.transform)
367 {
368 if (!pixman_transform_point_3d (image->common.transform, &v))
369 return iter->buffer;
370
371 ux = image->common.transform->matrix[0][0];
372 uy = image->common.transform->matrix[1][0];
373 }
374 else
375 {
376 ux = pixman_fixed_1;
377 uy = 0;
378 }
379
380 x = v.vector[0];
381 y = v.vector[1];
382
383 for (i = 0; i < width; ++i)
384 {
385 if (!mask || mask[i])
386 {
387 buffer[i] = bits_image_fetch_pixel_filtered (
388 &image->bits, x, y, fetch_pixel_no_alpha);
389 }
390
391 x += ux;
392 y += uy;
393 }
394
395 return buffer;
396 }
397
398 /* General fetcher */
399 static force_inline uint32_t
400 fetch_pixel_general (bits_image_t *image, int x, int y, pixman_bool_t check_bounds)
401 {
402 uint32_t pixel;
403
404 if (check_bounds &&
405 (x < 0 || x >= image->width || y < 0 || y >= image->height))
406 {
407 return 0;
408 }
409
410 pixel = image->fetch_pixel_32 (image, x, y);
411
412 if (image->common.alpha_map)
413 {
414 uint32_t pixel_a;
415
416 x -= image->common.alpha_origin_x;
417 y -= image->common.alpha_origin_y;
418
419 if (x < 0 || x >= image->common.alpha_map->width ||
420 y < 0 || y >= image->common.alpha_map->height)
421 {
422 pixel_a = 0;
423 }
424 else
425 {
426 pixel_a = image->common.alpha_map->fetch_pixel_32 (
427 image->common.alpha_map, x, y);
428
429 pixel_a = ALPHA_8 (pixel_a);
430 }
431
432 pixel &= 0x00ffffff;
433 pixel |= (pixel_a << 24);
434 }
435
436 return pixel;
437 }
438
439 static uint32_t *
440 bits_image_fetch_general (pixman_iter_t *iter,
441 const uint32_t *mask)
442 {
443 pixman_image_t *image = iter->image;
444 int offset = iter->x;
445 int line = iter->y++;
446 int width = iter->width;
447 uint32_t * buffer = iter->buffer;
448
449 pixman_fixed_t x, y, w;
450 pixman_fixed_t ux, uy, uw;
451 pixman_vector_t v;
452 int i;
453
454 /* reference point is the center of the pixel */
455 v.vector[0] = pixman_int_to_fixed (offset) + pixman_fixed_1 / 2;
456 v.vector[1] = pixman_int_to_fixed (line) + pixman_fixed_1 / 2;
457 v.vector[2] = pixman_fixed_1;
458
459 if (image->common.transform)
460 {
461 if (!pixman_transform_point_3d (image->common.transform, &v))
462 return buffer;
463
464 ux = image->common.transform->matrix[0][0];
465 uy = image->common.transform->matrix[1][0];
466 uw = image->common.transform->matrix[2][0];
467 }
468 else
469 {
470 ux = pixman_fixed_1;
471 uy = 0;
472 uw = 0;
473 }
474
475 x = v.vector[0];
476 y = v.vector[1];
477 w = v.vector[2];
478
479 for (i = 0; i < width; ++i)
480 {
481 pixman_fixed_t x0, y0;
482
483 if (!mask || mask[i])
484 {
485 if (w != 0)
486 {
487 x0 = ((pixman_fixed_48_16_t)x << 16) / w;
488 y0 = ((pixman_fixed_48_16_t)y << 16) / w;
489 }
490 else
491 {
492 x0 = 0;
493 y0 = 0;
494 }
495
496 buffer[i] = bits_image_fetch_pixel_filtered (
497 &image->bits, x0, y0, fetch_pixel_general);
498 }
499
500 x += ux;
501 y += uy;
502 w += uw;
503 }
504
505 return buffer;
506 }
507
508 static void
509 replicate_pixel_32 (bits_image_t * bits,
510 int x,
511 int y,
512 int width,
513 uint32_t * buffer)
514 {
515 uint32_t color;
516 uint32_t *end;
517
518 color = bits->fetch_pixel_32 (bits, x, y);
519
520 end = buffer + width;
521 while (buffer < end)
522 *(buffer++) = color;
523 }
524
525 static void
526 replicate_pixel_float (bits_image_t * bits,
527 int x,
528 int y,
529 int width,
530 uint32_t * b)
531 {
532 argb_t color;
533 argb_t *buffer = (argb_t *)b;
534 argb_t *end;
535
536 color = bits->fetch_pixel_float (bits, x, y);
537
538 end = buffer + width;
539 while (buffer < end)
540 *(buffer++) = color;
541 }
542
543 static void
544 bits_image_fetch_untransformed_repeat_none (bits_image_t *image,
545 pixman_bool_t wide,
546 int x,
547 int y,
548 int width,
549 uint32_t * buffer)
550 {
551 uint32_t w;
552
553 if (y < 0 || y >= image->height)
554 {
555 memset (buffer, 0, width * (wide? sizeof (argb_t) : 4));
556 return;
557 }
558
559 if (x < 0)
560 {
561 w = MIN (width, -x);
562
563 memset (buffer, 0, w * (wide ? sizeof (argb_t) : 4));
564
565 width -= w;
566 buffer += w * (wide? 4 : 1);
567 x += w;
568 }
569
570 if (x < image->width)
571 {
572 w = MIN (width, image->width - x);
573
574 if (wide)
575 image->fetch_scanline_float (image, x, y, w, buffer, NULL);
576 else
577 image->fetch_scanline_32 (image, x, y, w, buffer, NULL);
578
579 width -= w;
580 buffer += w * (wide? 4 : 1);
581 x += w;
582 }
583
584 memset (buffer, 0, width * (wide ? sizeof (argb_t) : 4));
585 }
586
587 static void
588 bits_image_fetch_untransformed_repeat_normal (bits_image_t *image,
589 pixman_bool_t wide,
590 int x,
591 int y,
592 int width,
593 uint32_t * buffer)
594 {
595 uint32_t w;
596
597 while (y < 0)
598 y += image->height;
599
600 while (y >= image->height)
601 y -= image->height;
602
603 if (image->width == 1)
604 {
605 if (wide)
606 replicate_pixel_float (image, 0, y, width, buffer);
607 else
608 replicate_pixel_32 (image, 0, y, width, buffer);
609
610 return;
611 }
612
613 while (width)
614 {
615 while (x < 0)
616 x += image->width;
617 while (x >= image->width)
618 x -= image->width;
619
620 w = MIN (width, image->width - x);
621
622 if (wide)
623 image->fetch_scanline_float (image, x, y, w, buffer, NULL);
624 else
625 image->fetch_scanline_32 (image, x, y, w, buffer, NULL);
626
627 buffer += w * (wide? 4 : 1);
628 x += w;
629 width -= w;
630 }
631 }
632
633 static uint32_t *
634 bits_image_fetch_untransformed_32 (pixman_iter_t * iter,
635 const uint32_t *mask)
636 {
637 pixman_image_t *image = iter->image;
638 int x = iter->x;
639 int y = iter->y;
640 int width = iter->width;
641 uint32_t * buffer = iter->buffer;
642
643 if (image->common.repeat == PIXMAN_REPEAT_NONE)
644 {
645 bits_image_fetch_untransformed_repeat_none (
646 &image->bits, FALSE, x, y, width, buffer);
647 }
648 else
649 {
650 bits_image_fetch_untransformed_repeat_normal (
651 &image->bits, FALSE, x, y, width, buffer);
652 }
653
654 iter->y++;
655 return buffer;
656 }
657
658 static uint32_t *
659 bits_image_fetch_untransformed_float (pixman_iter_t * iter,
660 const uint32_t *mask)
661 {
662 pixman_image_t *image = iter->image;
663 int x = iter->x;
664 int y = iter->y;
665 int width = iter->width;
666 uint32_t * buffer = iter->buffer;
667
668 if (image->common.repeat == PIXMAN_REPEAT_NONE)
669 {
670 bits_image_fetch_untransformed_repeat_none (
671 &image->bits, TRUE, x, y, width, buffer);
672 }
673 else
674 {
675 bits_image_fetch_untransformed_repeat_normal (
676 &image->bits, TRUE, x, y, width, buffer);
677 }
678
679 iter->y++;
680 return buffer;
681 }
682
683 typedef struct
684 {
685 pixman_format_code_t format;
686 uint32_t flags;
687 pixman_iter_get_scanline_t get_scanline_32;
688 pixman_iter_get_scanline_t get_scanline_float;
689 } fetcher_info_t;
690
691 static const fetcher_info_t fetcher_info[] =
692 {
693 { PIXMAN_any,
694 (FAST_PATH_NO_ALPHA_MAP |
695 FAST_PATH_ID_TRANSFORM |
696 FAST_PATH_NO_CONVOLUTION_FILTER |
697 FAST_PATH_NO_PAD_REPEAT |
698 FAST_PATH_NO_REFLECT_REPEAT),
699 bits_image_fetch_untransformed_32,
700 bits_image_fetch_untransformed_float
701 },
702
703 /* Affine, no alpha */
704 { PIXMAN_any,
705 (FAST_PATH_NO_ALPHA_MAP | FAST_PATH_HAS_TRANSFORM | FAST_PATH_AFFINE_TRANSFORM),
706 bits_image_fetch_affine_no_alpha,
707 _pixman_image_get_scanline_generic_float
708 },
709
710 /* General */
711 { PIXMAN_any,
712 0,
713 bits_image_fetch_general,
714 _pixman_image_get_scanline_generic_float
715 },
716
717 { PIXMAN_null },
718 };
719
720 static void
721 bits_image_property_changed (pixman_image_t *image)
722 {
723 _pixman_bits_image_setup_accessors (&image->bits);
724 }
725
726 void
727 _pixman_bits_image_src_iter_init (pixman_image_t *image, pixman_iter_t *iter)
728 {
729 pixman_format_code_t format = image->common.extended_format_code;
730 uint32_t flags = image->common.flags;
731 const fetcher_info_t *info;
732
733 for (info = fetcher_info; info->format != PIXMAN_null; ++info)
734 {
735 if ((info->format == format || info->format == PIXMAN_any) &&
736 (info->flags & flags) == info->flags)
737 {
738 if (iter->iter_flags & ITER_NARROW)
739 {
740 iter->get_scanline = info->get_scanline_32;
741 }
742 else
743 {
744 iter->data = info->get_scanline_32;
745 iter->get_scanline = info->get_scanline_float;
746 }
747 return;
748 }
749 }
750
751 /* Just in case we somehow didn't find a scanline function */
752 iter->get_scanline = _pixman_iter_get_scanline_noop;
753 }
754
755 static uint32_t *
756 dest_get_scanline_narrow (pixman_iter_t *iter, const uint32_t *mask)
757 {
758 pixman_image_t *image = iter->image;
759 int x = iter->x;
760 int y = iter->y;
761 int width = iter->width;
762 uint32_t * buffer = iter->buffer;
763
764 image->bits.fetch_scanline_32 (&image->bits, x, y, width, buffer, mask);
765 if (image->common.alpha_map)
766 {
767 uint32_t *alpha;
768
769 if ((alpha = malloc (width * sizeof (uint32_t))))
770 {
771 int i;
772
773 x -= image->common.alpha_origin_x;
774 y -= image->common.alpha_origin_y;
775
776 image->common.alpha_map->fetch_scanline_32 (
777 image->common.alpha_map, x, y, width, alpha, mask);
778
779 for (i = 0; i < width; ++i)
780 {
781 buffer[i] &= ~0xff000000;
782 buffer[i] |= (alpha[i] & 0xff000000);
783 }
784
785 free (alpha);
786 }
787 }
788
789 return iter->buffer;
790 }
791
792 static uint32_t *
793 dest_get_scanline_wide (pixman_iter_t *iter, const uint32_t *mask)
794 {
795 bits_image_t * image = &iter->image->bits;
796 int x = iter->x;
797 int y = iter->y;
798 int width = iter->width;
799 argb_t * buffer = (argb_t *)iter->buffer;
800
801 image->fetch_scanline_float (
802 image, x, y, width, (uint32_t *)buffer, mask);
803 if (image->common.alpha_map)
804 {
805 argb_t *alpha;
806
807 if ((alpha = malloc (width * sizeof (argb_t))))
808 {
809 int i;
810
811 x -= image->common.alpha_origin_x;
812 y -= image->common.alpha_origin_y;
813
814 image->common.alpha_map->fetch_scanline_float (
815 image->common.alpha_map, x, y, width, (uint32_t *)alpha, mask);
816
817 for (i = 0; i < width; ++i)
818 buffer[i].a = alpha[i].a;
819
820 free (alpha);
821 }
822 }
823
824 return iter->buffer;
825 }
826
827 static void
828 dest_write_back_narrow (pixman_iter_t *iter)
829 {
830 bits_image_t * image = &iter->image->bits;
831 int x = iter->x;
832 int y = iter->y;
833 int width = iter->width;
834 const uint32_t *buffer = iter->buffer;
835
836 image->store_scanline_32 (image, x, y, width, buffer);
837
838 if (image->common.alpha_map)
839 {
840 x -= image->common.alpha_origin_x;
841 y -= image->common.alpha_origin_y;
842
843 image->common.alpha_map->store_scanline_32 (
844 image->common.alpha_map, x, y, width, buffer);
845 }
846
847 iter->y++;
848 }
849
850 static void
851 dest_write_back_wide (pixman_iter_t *iter)
852 {
853 bits_image_t * image = &iter->image->bits;
854 int x = iter->x;
855 int y = iter->y;
856 int width = iter->width;
857 const uint32_t *buffer = iter->buffer;
858
859 image->store_scanline_float (image, x, y, width, buffer);
860
861 if (image->common.alpha_map)
862 {
863 x -= image->common.alpha_origin_x;
864 y -= image->common.alpha_origin_y;
865
866 image->common.alpha_map->store_scanline_float (
867 image->common.alpha_map, x, y, width, buffer);
868 }
869
870 iter->y++;
871 }
872
873 void
874 _pixman_bits_image_dest_iter_init (pixman_image_t *image, pixman_iter_t *iter)
875 {
876 if (iter->iter_flags & ITER_NARROW)
877 {
878 if ((iter->iter_flags & (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA)) ==
879 (ITER_IGNORE_RGB | ITER_IGNORE_ALPHA))
880 {
881 iter->get_scanline = _pixman_iter_get_scanline_noop;
882 }
883 else
884 {
885 iter->get_scanline = dest_get_scanline_narrow;
886 }
887
888 iter->write_back = dest_write_back_narrow;
889 }
890 else
891 {
892 iter->get_scanline = dest_get_scanline_wide;
893 iter->write_back = dest_write_back_wide;
894 }
895 }
896
897 static uint32_t *
898 create_bits (pixman_format_code_t format,
899 int width,
900 int height,
901 int * rowstride_bytes,
902 pixman_bool_t clear)
903 {
904 int stride;
905 size_t buf_size;
906 int bpp;
907
908 /* what follows is a long-winded way, avoiding any possibility of integer
909 * overflows, of saying:
910 * stride = ((width * bpp + 0x1f) >> 5) * sizeof (uint32_t);
911 */
912
913 bpp = PIXMAN_FORMAT_BPP (format);
914 if (_pixman_multiply_overflows_int (width, bpp))
915 return NULL;
916
917 stride = width * bpp;
918 if (_pixman_addition_overflows_int (stride, 0x1f))
919 return NULL;
920
921 stride += 0x1f;
922 stride >>= 5;
923
924 stride *= sizeof (uint32_t);
925
926 if (_pixman_multiply_overflows_size (height, stride))
927 return NULL;
928
929 buf_size = (size_t)height * stride;
930
931 if (rowstride_bytes)
932 *rowstride_bytes = stride;
933
934 if (clear)
935 return calloc (buf_size, 1);
936 else
937 return malloc (buf_size);
938 }
939
940 pixman_bool_t
941 _pixman_bits_image_init (pixman_image_t * image,
942 pixman_format_code_t format,
943 int width,
944 int height,
945 uint32_t * bits,
946 int rowstride,
947 pixman_bool_t clear)
948 {
949 uint32_t *free_me = NULL;
950
951 if (!bits && width && height)
952 {
953 int rowstride_bytes;
954
955 free_me = bits = create_bits (format, width, height, &rowstride_bytes, clear);
956
957 if (!bits)
958 return FALSE;
959
960 rowstride = rowstride_bytes / (int) sizeof (uint32_t);
961 }
962
963 _pixman_image_init (image);
964
965 image->type = BITS;
966 image->bits.format = format;
967 image->bits.width = width;
968 image->bits.height = height;
969 image->bits.bits = bits;
970 image->bits.free_me = free_me;
971 image->bits.read_func = NULL;
972 image->bits.write_func = NULL;
973 image->bits.rowstride = rowstride;
974 image->bits.indexed = NULL;
975
976 image->common.property_changed = bits_image_property_changed;
977
978 _pixman_image_reset_clip_region (image);
979
980 return TRUE;
981 }
982
983 static pixman_image_t *
984 create_bits_image_internal (pixman_format_code_t format,
985 int width,
986 int height,
987 uint32_t * bits,
988 int rowstride_bytes,
989 pixman_bool_t clear)
990 {
991 pixman_image_t *image;
992
993 /* must be a whole number of uint32_t's
994 */
995 return_val_if_fail (
996 bits == NULL || (rowstride_bytes % sizeof (uint32_t)) == 0, NULL);
997
998 return_val_if_fail (PIXMAN_FORMAT_BPP (format) >= PIXMAN_FORMAT_DEPTH (format), NULL);
999
1000 image = _pixman_image_allocate ();
1001
1002 if (!image)
1003 return NULL;
1004
1005 if (!_pixman_bits_image_init (image, format, width, height, bits,
1006 rowstride_bytes / (int) sizeof (uint32_t),
1007 clear))
1008 {
1009 free (image);
1010 return NULL;
1011 }
1012
1013 return image;
1014 }
1015
1016 /* If bits is NULL, a buffer will be allocated and initialized to 0 */
1017 PIXMAN_EXPORT pixman_image_t *
1018 pixman_image_create_bits (pixman_format_code_t format,
1019 int width,
1020 int height,
1021 uint32_t * bits,
1022 int rowstride_bytes)
1023 {
1024 return create_bits_image_internal (
1025 format, width, height, bits, rowstride_bytes, TRUE);
1026 }
1027
1028
1029 /* If bits is NULL, a buffer will be allocated and _not_ initialized */
1030 PIXMAN_EXPORT pixman_image_t *
1031 pixman_image_create_bits_no_clear (pixman_format_code_t format,
1032 int width,
1033 int height,
1034 uint32_t * bits,
1035 int rowstride_bytes)
1036 {
1037 return create_bits_image_internal (
1038 format, width, height, bits, rowstride_bytes, FALSE);
1039 }
LuaTeX git mirror