?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
os: if inet_ntop() is available, use it for IPv4 addresses as well
[xserver.git] / glamor / glamor_largepixmap.c
blob57760f8d336ac59567746bb3e1ae1593393aa018
1 #include <stdlib.h>
2 #include <stdint.h> /* For INT16_MAX */
3
4 #include "glamor_priv.h"
5
6 static void
7 glamor_get_transform_extent_from_box(struct pixman_box32 *box,
8 struct pixman_transform *transform);
9
10 static inline glamor_pixmap_private *
11 __glamor_large(glamor_pixmap_private *pixmap_priv) {
12 assert(glamor_pixmap_priv_is_large(pixmap_priv));
13 return pixmap_priv;
14 }
15
16 /**
17 * Clip the boxes regards to each pixmap's block array.
18 *
19 * Should translate the region to relative coords to the pixmap,
20 * start at (0,0).
21 */
22 #if 0
23 //#define DEBUGF(str, ...) do {} while(0)
24 #define DEBUGF(str, ...) ErrorF(str, ##__VA_ARGS__)
25 //#define DEBUGRegionPrint(x) do {} while (0)
26 #define DEBUGRegionPrint RegionPrint
27 #endif
28
29 static glamor_pixmap_clipped_regions *
30 __glamor_compute_clipped_regions(int block_w,
31 int block_h,
32 int block_stride,
33 int x, int y,
34 int w, int h,
35 RegionPtr region,
36 int *n_region, int reverse, int upsidedown)
37 {
38 glamor_pixmap_clipped_regions *clipped_regions;
39 BoxPtr extent;
40 int start_x, start_y, end_x, end_y;
41 int start_block_x, start_block_y;
42 int end_block_x, end_block_y;
43 int loop_start_block_x, loop_start_block_y;
44 int loop_end_block_x, loop_end_block_y;
45 int loop_block_stride;
46 int i, j, delta_i, delta_j;
47 RegionRec temp_region;
48 RegionPtr current_region;
49 int block_idx;
50 int k = 0;
51 int temp_block_idx;
52
53 extent = RegionExtents(region);
54 start_x = MAX(x, extent->x1);
55 start_y = MAX(y, extent->y1);
56 end_x = MIN(x + w, extent->x2);
57 end_y = MIN(y + h, extent->y2);
58
59 DEBUGF("start compute clipped regions:\n");
60 DEBUGF("block w %d h %d x %d y %d w %d h %d, block_stride %d \n",
61 block_w, block_h, x, y, w, h, block_stride);
62 DEBUGRegionPrint(region);
63
64 DEBUGF("start_x %d start_y %d end_x %d end_y %d \n", start_x, start_y,
65 end_x, end_y);
66
67 if (start_x >= end_x || start_y >= end_y) {
68 *n_region = 0;
69 return NULL;
70 }
71
72 start_block_x = (start_x - x) / block_w;
73 start_block_y = (start_y - y) / block_h;
74 end_block_x = (end_x - x) / block_w;
75 end_block_y = (end_y - y) / block_h;
76
77 clipped_regions = calloc((end_block_x - start_block_x + 1)
78 * (end_block_y - start_block_y + 1),
79 sizeof(*clipped_regions));
80
81 DEBUGF("startx %d starty %d endx %d endy %d \n",
82 start_x, start_y, end_x, end_y);
83 DEBUGF("start_block_x %d end_block_x %d \n", start_block_x, end_block_x);
84 DEBUGF("start_block_y %d end_block_y %d \n", start_block_y, end_block_y);
85
86 if (!reverse) {
87 loop_start_block_x = start_block_x;
88 loop_end_block_x = end_block_x + 1;
89 delta_i = 1;
90 }
91 else {
92 loop_start_block_x = end_block_x;
93 loop_end_block_x = start_block_x - 1;
94 delta_i = -1;
95 }
96
97 if (!upsidedown) {
98 loop_start_block_y = start_block_y;
99 loop_end_block_y = end_block_y + 1;
100 delta_j = 1;
101 }
102 else {
103 loop_start_block_y = end_block_y;
104 loop_end_block_y = start_block_y - 1;
105 delta_j = -1;
106 }
107
108 loop_block_stride = delta_j * block_stride;
109 block_idx = (loop_start_block_y - delta_j) * block_stride;
110
111 for (j = loop_start_block_y; j != loop_end_block_y; j += delta_j) {
112 block_idx += loop_block_stride;
113 temp_block_idx = block_idx + loop_start_block_x;
114 for (i = loop_start_block_x;
115 i != loop_end_block_x; i += delta_i, temp_block_idx += delta_i) {
116 BoxRec temp_box;
117
118 temp_box.x1 = x + i * block_w;
119 temp_box.y1 = y + j * block_h;
120 temp_box.x2 = MIN(temp_box.x1 + block_w, end_x);
121 temp_box.y2 = MIN(temp_box.y1 + block_h, end_y);
122 RegionInitBoxes(&temp_region, &temp_box, 1);
123 DEBUGF("block idx %d \n", temp_block_idx);
124 DEBUGRegionPrint(&temp_region);
125 current_region = RegionCreate(NULL, 4);
126 RegionIntersect(current_region, &temp_region, region);
127 DEBUGF("i %d j %d region: \n", i, j);
128 DEBUGRegionPrint(current_region);
129 if (RegionNumRects(current_region)) {
130 clipped_regions[k].region = current_region;
131 clipped_regions[k].block_idx = temp_block_idx;
132 k++;
133 }
134 else
135 RegionDestroy(current_region);
136 RegionUninit(&temp_region);
137 }
138 }
139
140 *n_region = k;
141 return clipped_regions;
142 }
143
144 /**
145 * Do a two round clipping,
146 * first is to clip the region regard to current pixmap's
147 * block array. Then for each clipped region, do a inner
148 * block clipping. This is to make sure the final result
149 * will be shapped by inner_block_w and inner_block_h, and
150 * the final region also will not cross the pixmap's block
151 * boundary.
152 *
153 * This is mainly used by transformation support when do
154 * compositing.
155 */
156
157 glamor_pixmap_clipped_regions *
158 glamor_compute_clipped_regions_ext(PixmapPtr pixmap,
159 RegionPtr region,
160 int *n_region,
161 int inner_block_w, int inner_block_h,
162 int reverse, int upsidedown)
163 {
164 glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(pixmap);
165 glamor_pixmap_clipped_regions *clipped_regions, *inner_regions,
166 *result_regions;
167 int i, j, x, y, k, inner_n_regions;
168 int width, height;
169 BoxPtr box_array;
170 BoxRec small_box;
171 int block_w, block_h;
172
173 DEBUGF("ext called \n");
174
175 if (glamor_pixmap_priv_is_small(pixmap_priv)) {
176 clipped_regions = calloc(1, sizeof(*clipped_regions));
177 if (clipped_regions == NULL) {
178 *n_region = 0;
179 return NULL;
180 }
181 clipped_regions[0].region = RegionCreate(NULL, 1);
182 clipped_regions[0].block_idx = 0;
183 RegionCopy(clipped_regions[0].region, region);
184 *n_region = 1;
185 block_w = pixmap->drawable.width;
186 block_h = pixmap->drawable.height;
187 box_array = &small_box;
188 small_box.x1 = small_box.y1 = 0;
189 small_box.x2 = block_w;
190 small_box.y2 = block_h;
191 }
192 else {
193 glamor_pixmap_private *priv = __glamor_large(pixmap_priv);
194
195 clipped_regions = __glamor_compute_clipped_regions(priv->block_w,
196 priv->block_h,
197 priv->block_wcnt,
198 0, 0,
199 pixmap->drawable.width,
200 pixmap->drawable.height,
201 region, n_region,
202 reverse, upsidedown);
203
204 if (clipped_regions == NULL) {
205 *n_region = 0;
206 return NULL;
207 }
208 block_w = priv->block_w;
209 block_h = priv->block_h;
210 box_array = priv->box_array;
211 }
212 if (inner_block_w >= block_w && inner_block_h >= block_h)
213 return clipped_regions;
214 result_regions = calloc(*n_region
215 * ((block_w + inner_block_w - 1) /
216 inner_block_w)
217 * ((block_h + inner_block_h - 1) /
218 inner_block_h), sizeof(*result_regions));
219 k = 0;
220 for (i = 0; i < *n_region; i++) {
221 x = box_array[clipped_regions[i].block_idx].x1;
222 y = box_array[clipped_regions[i].block_idx].y1;
223 width = box_array[clipped_regions[i].block_idx].x2 - x;
224 height = box_array[clipped_regions[i].block_idx].y2 - y;
225 inner_regions = __glamor_compute_clipped_regions(inner_block_w,
226 inner_block_h,
227 0, x, y,
228 width,
229 height,
230 clipped_regions[i].
231 region,
232 &inner_n_regions,
233 reverse, upsidedown);
234 for (j = 0; j < inner_n_regions; j++) {
235 result_regions[k].region = inner_regions[j].region;
236 result_regions[k].block_idx = clipped_regions[i].block_idx;
237 k++;
238 }
239 free(inner_regions);
240 }
241 *n_region = k;
242 free(clipped_regions);
243 return result_regions;
244 }
245
246 /*
247 *
248 * For the repeat pad mode, we can simply convert the region and
249 * let the out-of-box region can cover the needed edge of the source/mask
250 * Then apply a normal clip we can get what we want.
251 */
252 static RegionPtr
253 _glamor_convert_pad_region(RegionPtr region, int w, int h)
254 {
255 RegionPtr pad_region;
256 int nrect;
257 BoxPtr box;
258 int overlap;
259
260 nrect = RegionNumRects(region);
261 box = RegionRects(region);
262 pad_region = RegionCreate(NULL, 4);
263 if (pad_region == NULL)
264 return NULL;
265 while (nrect--) {
266 BoxRec pad_box;
267 RegionRec temp_region;
268
269 pad_box = *box;
270 if (pad_box.x1 < 0 && pad_box.x2 <= 0)
271 pad_box.x2 = 1;
272 else if (pad_box.x1 >= w && pad_box.x2 > w)
273 pad_box.x1 = w - 1;
274 if (pad_box.y1 < 0 && pad_box.y2 <= 0)
275 pad_box.y2 = 1;
276 else if (pad_box.y1 >= h && pad_box.y2 > h)
277 pad_box.y1 = h - 1;
278 RegionInitBoxes(&temp_region, &pad_box, 1);
279 RegionAppend(pad_region, &temp_region);
280 RegionUninit(&temp_region);
281 box++;
282 }
283 RegionValidate(pad_region, &overlap);
284 return pad_region;
285 }
286
287 /*
288 * For one type of large pixmap, its one direction is not exceed the
289 * size limitation, and in another word, on one direction it has only
290 * one block.
291 *
292 * This case of reflect repeating, we can optimize it and avoid repeat
293 * clip on that direction. We can just enlarge the repeat box and can
294 * cover all the dest region on that direction. But latter, we need to
295 * fixup the clipped result to get a correct coords for the subsequent
296 * processing. This function is to do the coords correction.
297 *
298 * */
299 static void
300 _glamor_largepixmap_reflect_fixup(short *xy1, short *xy2, int wh)
301 {
302 int odd1, odd2;
303 int c1, c2;
304
305 if (*xy2 - *xy1 > wh) {
306 *xy1 = 0;
307 *xy2 = wh;
308 return;
309 }
310 modulus(*xy1, wh, c1);
311 odd1 = ((*xy1 - c1) / wh) & 0x1;
312 modulus(*xy2, wh, c2);
313 odd2 = ((*xy2 - c2) / wh) & 0x1;
314
315 if (odd1 && odd2) {
316 *xy1 = wh - c2;
317 *xy2 = wh - c1;
318 }
319 else if (odd1 && !odd2) {
320 *xy1 = 0;
321 *xy2 = MAX(c2, wh - c1);
322 }
323 else if (!odd1 && odd2) {
324 *xy2 = wh;
325 *xy1 = MIN(c1, wh - c2);
326 }
327 else {
328 *xy1 = c1;
329 *xy2 = c2;
330 }
331 }
332
333 /**
334 * Clip the boxes regards to each pixmap's block array.
335 *
336 * Should translate the region to relative coords to the pixmap,
337 * start at (0,0).
338 *
339 * @is_transform: if it is set, it has a transform matrix.
340 *
341 */
342 static glamor_pixmap_clipped_regions *
343 _glamor_compute_clipped_regions(PixmapPtr pixmap,
344 glamor_pixmap_private *pixmap_priv,
345 RegionPtr region, int *n_region,
346 int repeat_type, int is_transform,
347 int reverse, int upsidedown)
348 {
349 glamor_pixmap_clipped_regions *clipped_regions;
350 BoxPtr extent;
351 int i, j;
352 RegionPtr current_region;
353 int pixmap_width, pixmap_height;
354 int m;
355 BoxRec repeat_box;
356 RegionRec repeat_region;
357 int right_shift = 0;
358 int down_shift = 0;
359 int x_center_shift = 0, y_center_shift = 0;
360 glamor_pixmap_private *priv;
361
362 DEBUGRegionPrint(region);
363 if (glamor_pixmap_priv_is_small(pixmap_priv)) {
364 clipped_regions = calloc(1, sizeof(*clipped_regions));
365 clipped_regions[0].region = RegionCreate(NULL, 1);
366 clipped_regions[0].block_idx = 0;
367 RegionCopy(clipped_regions[0].region, region);
368 *n_region = 1;
369 return clipped_regions;
370 }
371
372 priv = __glamor_large(pixmap_priv);
373
374 pixmap_width = pixmap->drawable.width;
375 pixmap_height = pixmap->drawable.height;
376 if (repeat_type == 0 || repeat_type == RepeatPad) {
377 RegionPtr saved_region = NULL;
378
379 if (repeat_type == RepeatPad) {
380 saved_region = region;
381 region =
382 _glamor_convert_pad_region(saved_region, pixmap_width,
383 pixmap_height);
384 if (region == NULL) {
385 *n_region = 0;
386 return NULL;
387 }
388 }
389 clipped_regions = __glamor_compute_clipped_regions(priv->block_w,
390 priv->block_h,
391 priv->block_wcnt,
392 0, 0,
393 pixmap->drawable.width,
394 pixmap->drawable.height,
395 region, n_region,
396 reverse, upsidedown);
397 if (saved_region)
398 RegionDestroy(region);
399 return clipped_regions;
400 }
401 extent = RegionExtents(region);
402
403 x_center_shift = extent->x1 / pixmap_width;
404 if (x_center_shift < 0)
405 x_center_shift--;
406 if (abs(x_center_shift) & 1)
407 x_center_shift++;
408 y_center_shift = extent->y1 / pixmap_height;
409 if (y_center_shift < 0)
410 y_center_shift--;
411 if (abs(y_center_shift) & 1)
412 y_center_shift++;
413
414 if (extent->x1 < 0)
415 right_shift = ((-extent->x1 + pixmap_width - 1) / pixmap_width);
416 if (extent->y1 < 0)
417 down_shift = ((-extent->y1 + pixmap_height - 1) / pixmap_height);
418
419 if (right_shift != 0 || down_shift != 0) {
420 if (repeat_type == RepeatReflect) {
421 right_shift = (right_shift + 1) & ~1;
422 down_shift = (down_shift + 1) & ~1;
423 }
424 RegionTranslate(region, right_shift * pixmap_width,
425 down_shift * pixmap_height);
426 }
427
428 extent = RegionExtents(region);
429 /* Tile a large pixmap to another large pixmap.
430 * We can't use the target large pixmap as the
431 * loop variable, instead we need to loop for all
432 * the blocks in the tile pixmap.
433 *
434 * simulate repeat each single block to cover the
435 * target's blocks. Two special case:
436 * a block_wcnt == 1 or block_hcnt ==1, then we
437 * only need to loop one direction as the other
438 * direction is fully included in the first block.
439 *
440 * For the other cases, just need to start
441 * from a proper shiftx/shifty, and then increase
442 * y by tile_height each time to walk trhough the
443 * target block and then walk trhough the target
444 * at x direction by increate tile_width each time.
445 *
446 * This way, we can consolidate all the sub blocks
447 * of the target boxes into one tile source's block.
448 *
449 * */
450 m = 0;
451 clipped_regions = calloc(priv->block_wcnt * priv->block_hcnt,
452 sizeof(*clipped_regions));
453 if (clipped_regions == NULL) {
454 *n_region = 0;
455 return NULL;
456 }
457 if (right_shift != 0 || down_shift != 0) {
458 DEBUGF("region to be repeated shifted \n");
459 DEBUGRegionPrint(region);
460 }
461 DEBUGF("repeat pixmap width %d height %d \n", pixmap_width, pixmap_height);
462 DEBUGF("extent x1 %d y1 %d x2 %d y2 %d \n", extent->x1, extent->y1,
463 extent->x2, extent->y2);
464 for (j = 0; j < priv->block_hcnt; j++) {
465 for (i = 0; i < priv->block_wcnt; i++) {
466 int dx = pixmap_width;
467 int dy = pixmap_height;
468 int idx;
469 int shift_x;
470 int shift_y;
471 int saved_y1, saved_y2;
472 int x_idx = 0, y_idx = 0, saved_y_idx = 0;
473 RegionRec temp_region;
474 BoxRec reflect_repeat_box;
475 BoxPtr valid_repeat_box;
476
477 shift_x = (extent->x1 / pixmap_width) * pixmap_width;
478 shift_y = (extent->y1 / pixmap_height) * pixmap_height;
479 idx = j * priv->block_wcnt + i;
480 if (repeat_type == RepeatReflect) {
481 x_idx = (extent->x1 / pixmap_width);
482 y_idx = (extent->y1 / pixmap_height);
483 }
484
485 /* Construct a rect to clip the target region. */
486 repeat_box.x1 = shift_x + priv->box_array[idx].x1;
487 repeat_box.y1 = shift_y + priv->box_array[idx].y1;
488 if (priv->block_wcnt == 1) {
489 repeat_box.x2 = extent->x2;
490 dx = extent->x2 - repeat_box.x1;
491 }
492 else
493 repeat_box.x2 = shift_x + priv->box_array[idx].x2;
494 if (priv->block_hcnt == 1) {
495 repeat_box.y2 = extent->y2;
496 dy = extent->y2 - repeat_box.y1;
497 }
498 else
499 repeat_box.y2 = shift_y + priv->box_array[idx].y2;
500
501 current_region = RegionCreate(NULL, 4);
502 RegionInit(&temp_region, NULL, 4);
503 DEBUGF("init repeat box %d %d %d %d \n",
504 repeat_box.x1, repeat_box.y1, repeat_box.x2, repeat_box.y2);
505
506 if (repeat_type == RepeatNormal) {
507 saved_y1 = repeat_box.y1;
508 saved_y2 = repeat_box.y2;
509 for (; repeat_box.x1 < extent->x2;
510 repeat_box.x1 += dx, repeat_box.x2 += dx) {
511 repeat_box.y1 = saved_y1;
512 repeat_box.y2 = saved_y2;
513 for (repeat_box.y1 = saved_y1, repeat_box.y2 = saved_y2;
514 repeat_box.y1 < extent->y2;
515 repeat_box.y1 += dy, repeat_box.y2 += dy) {
516
517 RegionInitBoxes(&repeat_region, &repeat_box, 1);
518 DEBUGF("Start to clip repeat region: \n");
519 DEBUGRegionPrint(&repeat_region);
520 RegionIntersect(&temp_region, &repeat_region, region);
521 DEBUGF("clip result:\n");
522 DEBUGRegionPrint(&temp_region);
523 RegionAppend(current_region, &temp_region);
524 RegionUninit(&repeat_region);
525 }
526 }
527 }
528 else if (repeat_type == RepeatReflect) {
529 saved_y1 = repeat_box.y1;
530 saved_y2 = repeat_box.y2;
531 saved_y_idx = y_idx;
532 for (;; repeat_box.x1 += dx, repeat_box.x2 += dx) {
533 repeat_box.y1 = saved_y1;
534 repeat_box.y2 = saved_y2;
535 y_idx = saved_y_idx;
536 reflect_repeat_box.x1 = (x_idx & 1) ?
537 ((2 * x_idx + 1) * dx - repeat_box.x2) : repeat_box.x1;
538 reflect_repeat_box.x2 = (x_idx & 1) ?
539 ((2 * x_idx + 1) * dx - repeat_box.x1) : repeat_box.x2;
540 valid_repeat_box = &reflect_repeat_box;
541
542 if (valid_repeat_box->x1 >= extent->x2)
543 break;
544 for (repeat_box.y1 = saved_y1, repeat_box.y2 = saved_y2;;
545 repeat_box.y1 += dy, repeat_box.y2 += dy) {
546
547 DEBUGF("x_idx %d y_idx %d dx %d dy %d\n", x_idx, y_idx,
548 dx, dy);
549 DEBUGF("repeat box %d %d %d %d \n", repeat_box.x1,
550 repeat_box.y1, repeat_box.x2, repeat_box.y2);
551
552 if (priv->block_hcnt > 1) {
553 reflect_repeat_box.y1 = (y_idx & 1) ?
554 ((2 * y_idx + 1) * dy -
555 repeat_box.y2) : repeat_box.y1;
556 reflect_repeat_box.y2 =
557 (y_idx & 1) ? ((2 * y_idx + 1) * dy -
558 repeat_box.y1) : repeat_box.y2;
559 }
560 else {
561 reflect_repeat_box.y1 = repeat_box.y1;
562 reflect_repeat_box.y2 = repeat_box.y2;
563 }
564
565 DEBUGF("valid_repeat_box x1 %d y1 %d \n",
566 valid_repeat_box->x1, valid_repeat_box->y1);
567 if (valid_repeat_box->y1 >= extent->y2)
568 break;
569 RegionInitBoxes(&repeat_region, valid_repeat_box, 1);
570 DEBUGF("start to clip repeat[reflect] region: \n");
571 DEBUGRegionPrint(&repeat_region);
572 RegionIntersect(&temp_region, &repeat_region, region);
573 DEBUGF("result:\n");
574 DEBUGRegionPrint(&temp_region);
575 if (is_transform && RegionNumRects(&temp_region)) {
576 BoxRec temp_box;
577 BoxPtr temp_extent;
578
579 temp_extent = RegionExtents(&temp_region);
580 if (priv->block_wcnt > 1) {
581 if (x_idx & 1) {
582 temp_box.x1 =
583 ((2 * x_idx + 1) * dx -
584 temp_extent->x2);
585 temp_box.x2 =
586 ((2 * x_idx + 1) * dx -
587 temp_extent->x1);
588 }
589 else {
590 temp_box.x1 = temp_extent->x1;
591 temp_box.x2 = temp_extent->x2;
592 }
593 modulus(temp_box.x1, pixmap_width, temp_box.x1);
594 modulus(temp_box.x2, pixmap_width, temp_box.x2);
595 if (temp_box.x2 == 0)
596 temp_box.x2 = pixmap_width;
597 }
598 else {
599 temp_box.x1 = temp_extent->x1;
600 temp_box.x2 = temp_extent->x2;
601 _glamor_largepixmap_reflect_fixup(&temp_box.x1,
602 &temp_box.x2,
603 pixmap_width);
604 }
605
606 if (priv->block_hcnt > 1) {
607 if (y_idx & 1) {
608 temp_box.y1 =
609 ((2 * y_idx + 1) * dy -
610 temp_extent->y2);
611 temp_box.y2 =
612 ((2 * y_idx + 1) * dy -
613 temp_extent->y1);
614 }
615 else {
616 temp_box.y1 = temp_extent->y1;
617 temp_box.y2 = temp_extent->y2;
618 }
619
620 modulus(temp_box.y1, pixmap_height,
621 temp_box.y1);
622 modulus(temp_box.y2, pixmap_height,
623 temp_box.y2);
624 if (temp_box.y2 == 0)
625 temp_box.y2 = pixmap_height;
626 }
627 else {
628 temp_box.y1 = temp_extent->y1;
629 temp_box.y2 = temp_extent->y2;
630 _glamor_largepixmap_reflect_fixup(&temp_box.y1,
631 &temp_box.y2,
632 pixmap_height);
633 }
634
635 RegionInitBoxes(&temp_region, &temp_box, 1);
636 RegionTranslate(&temp_region,
637 x_center_shift * pixmap_width,
638 y_center_shift * pixmap_height);
639 DEBUGF("for transform result:\n");
640 DEBUGRegionPrint(&temp_region);
641 }
642 RegionAppend(current_region, &temp_region);
643 RegionUninit(&repeat_region);
644 y_idx++;
645 }
646 x_idx++;
647 }
648 }
649 DEBUGF("dx %d dy %d \n", dx, dy);
650
651 if (RegionNumRects(current_region)) {
652
653 if ((right_shift != 0 || down_shift != 0) &&
654 !(is_transform && repeat_type == RepeatReflect))
655 RegionTranslate(current_region, -right_shift * pixmap_width,
656 -down_shift * pixmap_height);
657 clipped_regions[m].region = current_region;
658 clipped_regions[m].block_idx = idx;
659 m++;
660 }
661 else
662 RegionDestroy(current_region);
663 RegionUninit(&temp_region);
664 }
665 }
666
667 if (right_shift != 0 || down_shift != 0)
668 RegionTranslate(region, -right_shift * pixmap_width,
669 -down_shift * pixmap_height);
670 *n_region = m;
671
672 return clipped_regions;
673 }
674
675 glamor_pixmap_clipped_regions *
676 glamor_compute_clipped_regions(PixmapPtr pixmap,
677 RegionPtr region,
678 int *n_region, int repeat_type,
679 int reverse, int upsidedown)
680 {
681 glamor_pixmap_private *priv = glamor_get_pixmap_private(pixmap);
682 return _glamor_compute_clipped_regions(pixmap, priv, region, n_region, repeat_type,
683 0, reverse, upsidedown);
684 }
685
686 /* XXX overflow still exist. maybe we need to change to use region32.
687 * by default. Or just use region32 for repeat cases?
688 **/
689 static glamor_pixmap_clipped_regions *
690 glamor_compute_transform_clipped_regions(PixmapPtr pixmap,
691 struct pixman_transform *transform,
692 RegionPtr region, int *n_region,
693 int dx, int dy, int repeat_type,
694 int reverse, int upsidedown)
695 {
696 glamor_pixmap_private *priv = glamor_get_pixmap_private(pixmap);
697 BoxPtr temp_extent;
698 struct pixman_box32 temp_box;
699 struct pixman_box16 short_box;
700 RegionPtr temp_region;
701 glamor_pixmap_clipped_regions *ret;
702
703 temp_region = RegionCreate(NULL, 4);
704 temp_extent = RegionExtents(region);
705 DEBUGF("dest region \n");
706 DEBUGRegionPrint(region);
707 /* dx/dy may exceed MAX SHORT. we have to use
708 * a box32 to represent it.*/
709 temp_box.x1 = temp_extent->x1 + dx;
710 temp_box.x2 = temp_extent->x2 + dx;
711 temp_box.y1 = temp_extent->y1 + dy;
712 temp_box.y2 = temp_extent->y2 + dy;
713
714 DEBUGF("source box %d %d %d %d \n", temp_box.x1, temp_box.y1, temp_box.x2,
715 temp_box.y2);
716 if (transform)
717 glamor_get_transform_extent_from_box(&temp_box, transform);
718 if (repeat_type == RepeatNone) {
719 if (temp_box.x1 < 0)
720 temp_box.x1 = 0;
721 if (temp_box.y1 < 0)
722 temp_box.y1 = 0;
723 temp_box.x2 = MIN(temp_box.x2, pixmap->drawable.width);
724 temp_box.y2 = MIN(temp_box.y2, pixmap->drawable.height);
725 }
726 /* Now copy back the box32 to a box16 box, avoiding overflow. */
727 short_box.x1 = MIN(temp_box.x1, INT16_MAX);
728 short_box.y1 = MIN(temp_box.y1, INT16_MAX);
729 short_box.x2 = MIN(temp_box.x2, INT16_MAX);
730 short_box.y2 = MIN(temp_box.y2, INT16_MAX);
731 RegionInitBoxes(temp_region, &short_box, 1);
732 DEBUGF("copy to temp source region \n");
733 DEBUGRegionPrint(temp_region);
734 ret = _glamor_compute_clipped_regions(pixmap,
735 priv,
736 temp_region,
737 n_region,
738 repeat_type, 1, reverse, upsidedown);
739 DEBUGF("n_regions = %d \n", *n_region);
740 RegionDestroy(temp_region);
741
742 return ret;
743 }
744
745 /*
746 * As transform and repeatpad mode.
747 * We may get a clipped result which in multiple regions.
748 * It's not easy to do a 2nd round clipping just as we do
749 * without transform/repeatPad. As it's not easy to reverse
750 * the 2nd round clipping result with a transform/repeatPad mode,
751 * or even impossible for some transformation.
752 *
753 * So we have to merge the fragmental region into one region
754 * if the clipped result cross the region boundary.
755 */
756 static void
757 glamor_merge_clipped_regions(PixmapPtr pixmap,
758 glamor_pixmap_private *pixmap_priv,
759 int repeat_type,
760 glamor_pixmap_clipped_regions *clipped_regions,
761 int *n_regions, int *need_clean_fbo)
762 {
763 BoxRec temp_box, copy_box;
764 RegionPtr temp_region;
765 glamor_pixmap_private *temp_priv;
766 PixmapPtr temp_pixmap;
767 int overlap;
768 int i;
769 int pixmap_width, pixmap_height;
770 glamor_pixmap_private *priv;
771
772 priv = __glamor_large(pixmap_priv);
773 pixmap_width = pixmap->drawable.width;
774 pixmap_height =pixmap->drawable.height;
775
776 temp_region = RegionCreate(NULL, 4);
777 for (i = 0; i < *n_regions; i++) {
778 DEBUGF("Region %d:\n", i);
779 DEBUGRegionPrint(clipped_regions[i].region);
780 RegionAppend(temp_region, clipped_regions[i].region);
781 }
782
783 RegionValidate(temp_region, &overlap);
784 DEBUGF("temp region: \n");
785 DEBUGRegionPrint(temp_region);
786
787 temp_box = *RegionExtents(temp_region);
788
789 DEBUGF("need copy region: \n");
790 DEBUGF("%d %d %d %d \n", temp_box.x1, temp_box.y1, temp_box.x2,
791 temp_box.y2);
792 temp_pixmap =
793 glamor_create_pixmap(pixmap->drawable.pScreen,
794 temp_box.x2 - temp_box.x1,
795 temp_box.y2 - temp_box.y1,
796 pixmap->drawable.depth,
797 GLAMOR_CREATE_PIXMAP_FIXUP);
798 if (temp_pixmap == NULL) {
799 assert(0);
800 return;
801 }
802
803 temp_priv = glamor_get_pixmap_private(temp_pixmap);
804 assert(glamor_pixmap_priv_is_small(temp_priv));
805
806 priv->box = temp_box;
807 if (temp_box.x1 >= 0 && temp_box.x2 <= pixmap_width
808 && temp_box.y1 >= 0 && temp_box.y2 <= pixmap_height) {
809 int dx, dy;
810
811 copy_box.x1 = 0;
812 copy_box.y1 = 0;
813 copy_box.x2 = temp_box.x2 - temp_box.x1;
814 copy_box.y2 = temp_box.y2 - temp_box.y1;
815 dx = temp_box.x1;
816 dy = temp_box.y1;
817 glamor_copy(&pixmap->drawable,
818 &temp_pixmap->drawable,
819 NULL, &copy_box, 1, dx, dy, 0, 0, 0, NULL);
820 // glamor_solid(temp_pixmap, 0, 0, temp_pixmap->drawable.width,
821 // temp_pixmap->drawable.height, GXcopy, 0xffffffff, 0xff00);
822 }
823 else {
824 for (i = 0; i < *n_regions; i++) {
825 BoxPtr box;
826 int nbox;
827
828 box = REGION_RECTS(clipped_regions[i].region);
829 nbox = REGION_NUM_RECTS(clipped_regions[i].region);
830 while (nbox--) {
831 int dx, dy, c, d;
832
833 DEBUGF("box x1 %d y1 %d x2 %d y2 %d \n",
834 box->x1, box->y1, box->x2, box->y2);
835 modulus(box->x1, pixmap_width, c);
836 dx = c - (box->x1 - temp_box.x1);
837 copy_box.x1 = box->x1 - temp_box.x1;
838 copy_box.x2 = box->x2 - temp_box.x1;
839
840 modulus(box->y1, pixmap_height, d);
841 dy = d - (box->y1 - temp_box.y1);
842 copy_box.y1 = box->y1 - temp_box.y1;
843 copy_box.y2 = box->y2 - temp_box.y1;
844
845 DEBUGF("copying box %d %d %d %d, dx %d dy %d\n",
846 copy_box.x1, copy_box.y1, copy_box.x2,
847 copy_box.y2, dx, dy);
848
849 glamor_copy(&pixmap->drawable,
850 &temp_pixmap->drawable,
851 NULL, &copy_box, 1, dx, dy, 0, 0, 0, NULL);
852
853 box++;
854 }
855 }
856 //glamor_solid(temp_pixmap, 0, 0, temp_pixmap->drawable.width,
857 // temp_pixmap->drawable.height, GXcopy, 0xffffffff, 0xff);
858 }
859 /* The first region will be released at caller side. */
860 for (i = 1; i < *n_regions; i++)
861 RegionDestroy(clipped_regions[i].region);
862 RegionDestroy(temp_region);
863 priv->box = temp_box;
864 priv->fbo = glamor_pixmap_detach_fbo(temp_priv);
865 DEBUGF("priv box x1 %d y1 %d x2 %d y2 %d \n",
866 priv->box.x1, priv->box.y1, priv->box.x2, priv->box.y2);
867 glamor_destroy_pixmap(temp_pixmap);
868 *need_clean_fbo = 1;
869 *n_regions = 1;
870 }
871
872 /**
873 * Given an expected transformed block width and block height,
874 *
875 * This function calculate a new block width and height which
876 * guarantee the transform result will not exceed the given
877 * block width and height.
878 *
879 * For large block width and height (> 2048), we choose a
880 * smaller new width and height and to reduce the cross region
881 * boundary and can avoid some overhead.
882 *
883 **/
884 static Bool
885 glamor_get_transform_block_size(struct pixman_transform *transform,
886 int block_w, int block_h,
887 int *transformed_block_w,
888 int *transformed_block_h)
889 {
890 double a, b, c, d, e, f, g, h;
891 double scale;
892 int width, height;
893
894 a = pixman_fixed_to_double(transform->matrix[0][0]);
895 b = pixman_fixed_to_double(transform->matrix[0][1]);
896 c = pixman_fixed_to_double(transform->matrix[1][0]);
897 d = pixman_fixed_to_double(transform->matrix[1][1]);
898 scale = pixman_fixed_to_double(transform->matrix[2][2]);
899 if (block_w > 2048) {
900 /* For large block size, we shrink it to smaller box,
901 * thus latter we may get less cross boundary regions and
902 * thus can avoid some extra copy.
903 *
904 **/
905 width = block_w / 4;
906 height = block_h / 4;
907 }
908 else {
909 width = block_w - 2;
910 height = block_h - 2;
911 }
912 e = a + b;
913 f = c + d;
914
915 g = a - b;
916 h = c - d;
917
918 e = MIN(block_w, floor(width * scale) / MAX(fabs(e), fabs(g)));
919 f = MIN(block_h, floor(height * scale) / MAX(fabs(f), fabs(h)));
920 *transformed_block_w = MIN(e, f) - 1;
921 *transformed_block_h = *transformed_block_w;
922 if (*transformed_block_w <= 0 || *transformed_block_h <= 0)
923 return FALSE;
924 DEBUGF("original block_w/h %d %d, fixed %d %d \n", block_w, block_h,
925 *transformed_block_w, *transformed_block_h);
926 return TRUE;
927 }
928
929 #define VECTOR_FROM_POINT(p, x, y) do {\
930 p.v[0] = x; \
931 p.v[1] = y; \
932 p.v[2] = 1.0; } while (0)
933 static void
934 glamor_get_transform_extent_from_box(struct pixman_box32 *box,
935 struct pixman_transform *transform)
936 {
937 struct pixman_f_vector p0, p1, p2, p3;
938 float min_x, min_y, max_x, max_y;
939
940 struct pixman_f_transform ftransform;
941
942 VECTOR_FROM_POINT(p0, box->x1, box->y1);
943 VECTOR_FROM_POINT(p1, box->x2, box->y1);
944 VECTOR_FROM_POINT(p2, box->x2, box->y2);
945 VECTOR_FROM_POINT(p3, box->x1, box->y2);
946
947 pixman_f_transform_from_pixman_transform(&ftransform, transform);
948 pixman_f_transform_point(&ftransform, &p0);
949 pixman_f_transform_point(&ftransform, &p1);
950 pixman_f_transform_point(&ftransform, &p2);
951 pixman_f_transform_point(&ftransform, &p3);
952
953 min_x = MIN(p0.v[0], p1.v[0]);
954 min_x = MIN(min_x, p2.v[0]);
955 min_x = MIN(min_x, p3.v[0]);
956
957 min_y = MIN(p0.v[1], p1.v[1]);
958 min_y = MIN(min_y, p2.v[1]);
959 min_y = MIN(min_y, p3.v[1]);
960
961 max_x = MAX(p0.v[0], p1.v[0]);
962 max_x = MAX(max_x, p2.v[0]);
963 max_x = MAX(max_x, p3.v[0]);
964
965 max_y = MAX(p0.v[1], p1.v[1]);
966 max_y = MAX(max_y, p2.v[1]);
967 max_y = MAX(max_y, p3.v[1]);
968 box->x1 = floor(min_x) - 1;
969 box->y1 = floor(min_y) - 1;
970 box->x2 = ceil(max_x) + 1;
971 box->y2 = ceil(max_y) + 1;
972 }
973
974 static void
975 _glamor_process_transformed_clipped_region(PixmapPtr pixmap,
976 glamor_pixmap_private *priv,
977 int repeat_type,
978 glamor_pixmap_clipped_regions *
979 clipped_regions, int *n_regions,
980 int *need_clean_fbo)
981 {
982 int shift_x, shift_y;
983
984 if (*n_regions != 1) {
985 /* Merge all source regions into one region. */
986 glamor_merge_clipped_regions(pixmap, priv, repeat_type,
987 clipped_regions, n_regions,
988 need_clean_fbo);
989 }
990 else {
991 glamor_set_pixmap_fbo_current(priv, clipped_regions[0].block_idx);
992 if (repeat_type == RepeatReflect || repeat_type == RepeatNormal) {
993 /* The required source areas are in one region,
994 * we need to shift the corresponding box's coords to proper position,
995 * thus we can calculate the relative coords correctly.*/
996 BoxPtr temp_box;
997 int rem;
998
999 temp_box = RegionExtents(clipped_regions[0].region);
1000 modulus(temp_box->x1, pixmap->drawable.width, rem);
1001 shift_x = (temp_box->x1 - rem) / pixmap->drawable.width;
1002 modulus(temp_box->y1, pixmap->drawable.height, rem);
1003 shift_y = (temp_box->y1 - rem) / pixmap->drawable.height;
1004
1005 if (shift_x != 0) {
1006 __glamor_large(priv)->box.x1 +=
1007 shift_x * pixmap->drawable.width;
1008 __glamor_large(priv)->box.x2 +=
1009 shift_x * pixmap->drawable.width;
1010 }
1011 if (shift_y != 0) {
1012 __glamor_large(priv)->box.y1 +=
1013 shift_y * pixmap->drawable.height;
1014 __glamor_large(priv)->box.y2 +=
1015 shift_y * pixmap->drawable.height;
1016 }
1017 }
1018 }
1019 }
1020
1021 Bool
1022 glamor_composite_largepixmap_region(CARD8 op,
1023 PicturePtr source,
1024 PicturePtr mask,
1025 PicturePtr dest,
1026 PixmapPtr source_pixmap,
1027 PixmapPtr mask_pixmap,
1028 PixmapPtr dest_pixmap,
1029 RegionPtr region, Bool force_clip,
1030 INT16 x_source,
1031 INT16 y_source,
1032 INT16 x_mask,
1033 INT16 y_mask,
1034 INT16 x_dest, INT16 y_dest,
1035 CARD16 width, CARD16 height)
1036 {
1037 ScreenPtr screen = dest_pixmap->drawable.pScreen;
1038 glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
1039 glamor_pixmap_private *source_pixmap_priv = glamor_get_pixmap_private(source_pixmap);
1040 glamor_pixmap_private *mask_pixmap_priv = glamor_get_pixmap_private(mask_pixmap);
1041 glamor_pixmap_private *dest_pixmap_priv = glamor_get_pixmap_private(dest_pixmap);
1042 glamor_pixmap_clipped_regions *clipped_dest_regions;
1043 glamor_pixmap_clipped_regions *clipped_source_regions;
1044 glamor_pixmap_clipped_regions *clipped_mask_regions;
1045 int n_dest_regions;
1046 int n_mask_regions;
1047 int n_source_regions;
1048 int i, j, k;
1049 int need_clean_source_fbo = 0;
1050 int need_clean_mask_fbo = 0;
1051 int is_normal_source_fbo = 0;
1052 int is_normal_mask_fbo = 0;
1053 int fixed_block_width, fixed_block_height;
1054 int dest_block_width, dest_block_height;
1055 int null_source, null_mask;
1056 glamor_pixmap_private *need_free_source_pixmap_priv = NULL;
1057 glamor_pixmap_private *need_free_mask_pixmap_priv = NULL;
1058 int source_repeat_type = 0, mask_repeat_type = 0;
1059 int ok = TRUE;
1060
1061 if (source_pixmap == dest_pixmap) {
1062 glamor_fallback("source and dest pixmaps are the same\n");
1063 return FALSE;
1064 }
1065 if (mask_pixmap == dest_pixmap) {
1066 glamor_fallback("mask and dest pixmaps are the same\n");
1067 return FALSE;
1068 }
1069
1070 if (source->repeat)
1071 source_repeat_type = source->repeatType;
1072 else
1073 source_repeat_type = RepeatNone;
1074
1075 if (mask && mask->repeat)
1076 mask_repeat_type = mask->repeatType;
1077 else
1078 mask_repeat_type = RepeatNone;
1079
1080 if (glamor_pixmap_priv_is_large(dest_pixmap_priv)) {
1081 dest_block_width = __glamor_large(dest_pixmap_priv)->block_w;
1082 dest_block_height = __glamor_large(dest_pixmap_priv)->block_h;
1083 } else {
1084 dest_block_width = dest_pixmap->drawable.width;
1085 dest_block_height = dest_pixmap->drawable.height;
1086 }
1087 fixed_block_width = dest_block_width;
1088 fixed_block_height = dest_block_height;
1089
1090 /* If we got an totally out-of-box region for a source or mask
1091 * region without repeat, we need to set it as null_source and
1092 * give it a solid color (0,0,0,0). */
1093 null_source = 0;
1094 null_mask = 0;
1095 RegionTranslate(region, -dest->pDrawable->x, -dest->pDrawable->y);
1096
1097 /* need to transform the dest region to the correct sourcei/mask region.
1098 * it's a little complex, as one single edge of the
1099 * target region may be transformed to cross a block boundary of the
1100 * source or mask. Then it's impossible to handle it as usual way.
1101 * We may have to split the original dest region to smaller region, and
1102 * make sure each region's transformed region can fit into one texture,
1103 * and then continue this loop again, and each time when a transformed region
1104 * cross the bound, we need to copy it to a single pixmap and do the composition
1105 * with the new pixmap. If the transformed region doesn't cross a source/mask's
1106 * boundary then we don't need to copy.
1107 *
1108 */
1109 if (source_pixmap_priv
1110 && source->transform
1111 && glamor_pixmap_priv_is_large(source_pixmap_priv)) {
1112 int source_transformed_block_width, source_transformed_block_height;
1113
1114 if (!glamor_get_transform_block_size(source->transform,
1115 __glamor_large(source_pixmap_priv)->block_w,
1116 __glamor_large(source_pixmap_priv)->block_h,
1117 &source_transformed_block_width,
1118 &source_transformed_block_height))
1119 {
1120 DEBUGF("source block size less than 1, fallback.\n");
1121 RegionTranslate(region, dest->pDrawable->x, dest->pDrawable->y);
1122 return FALSE;
1123 }
1124 fixed_block_width =
1125 min(fixed_block_width, source_transformed_block_width);
1126 fixed_block_height =
1127 min(fixed_block_height, source_transformed_block_height);
1128 DEBUGF("new source block size %d x %d \n", fixed_block_width,
1129 fixed_block_height);
1130 }
1131
1132 if (mask_pixmap_priv
1133 && mask->transform && glamor_pixmap_priv_is_large(mask_pixmap_priv)) {
1134 int mask_transformed_block_width, mask_transformed_block_height;
1135
1136 if (!glamor_get_transform_block_size(mask->transform,
1137 __glamor_large(mask_pixmap_priv)->block_w,
1138 __glamor_large(mask_pixmap_priv)->block_h,
1139 &mask_transformed_block_width,
1140 &mask_transformed_block_height)) {
1141 DEBUGF("mask block size less than 1, fallback.\n");
1142 RegionTranslate(region, dest->pDrawable->x, dest->pDrawable->y);
1143 return FALSE;
1144 }
1145 fixed_block_width =
1146 min(fixed_block_width, mask_transformed_block_width);
1147 fixed_block_height =
1148 min(fixed_block_height, mask_transformed_block_height);
1149 DEBUGF("new mask block size %d x %d \n", fixed_block_width,
1150 fixed_block_height);
1151 }
1152
1153 /*compute the correct block width and height whose transformed source/mask
1154 *region can fit into one texture.*/
1155 if (force_clip || fixed_block_width < dest_block_width
1156 || fixed_block_height < dest_block_height)
1157 clipped_dest_regions =
1158 glamor_compute_clipped_regions_ext(dest_pixmap, region,
1159 &n_dest_regions,
1160 fixed_block_width,
1161 fixed_block_height, 0, 0);
1162 else
1163 clipped_dest_regions = glamor_compute_clipped_regions(dest_pixmap,
1164 region,
1165 &n_dest_regions,
1166 0, 0, 0);
1167 DEBUGF("dest clipped result %d region: \n", n_dest_regions);
1168 if (source_pixmap_priv
1169 && (source_pixmap_priv == dest_pixmap_priv ||
1170 source_pixmap_priv == mask_pixmap_priv)
1171 && glamor_pixmap_priv_is_large(source_pixmap_priv)) {
1172 /* XXX self-copy... */
1173 need_free_source_pixmap_priv = source_pixmap_priv;
1174 source_pixmap_priv = malloc(sizeof(*source_pixmap_priv));
1175 *source_pixmap_priv = *need_free_source_pixmap_priv;
1176 need_free_source_pixmap_priv = source_pixmap_priv;
1177 }
1178 assert(mask_pixmap_priv != dest_pixmap_priv);
1179
1180 for (i = 0; i < n_dest_regions; i++) {
1181 DEBUGF("dest region %d idx %d\n", i,
1182 clipped_dest_regions[i].block_idx);
1183 DEBUGRegionPrint(clipped_dest_regions[i].region);
1184 glamor_set_pixmap_fbo_current(dest_pixmap_priv,
1185 clipped_dest_regions[i].block_idx);
1186 if (source_pixmap_priv &&
1187 glamor_pixmap_priv_is_large(source_pixmap_priv)) {
1188 if (!source->transform && source_repeat_type != RepeatPad) {
1189 RegionTranslate(clipped_dest_regions[i].region,
1190 x_source - x_dest, y_source - y_dest);
1191 clipped_source_regions =
1192 glamor_compute_clipped_regions(source_pixmap,
1193 clipped_dest_regions[i].
1194 region, &n_source_regions,
1195 source_repeat_type, 0, 0);
1196 is_normal_source_fbo = 1;
1197 }
1198 else {
1199 clipped_source_regions =
1200 glamor_compute_transform_clipped_regions(source_pixmap,
1201 source->transform,
1202 clipped_dest_regions
1203 [i].region,
1204 &n_source_regions,
1205 x_source - x_dest,
1206 y_source - y_dest,
1207 source_repeat_type,
1208 0, 0);
1209 is_normal_source_fbo = 0;
1210 if (n_source_regions == 0) {
1211 /* Pad the out-of-box region to (0,0,0,0). */
1212 null_source = 1;
1213 n_source_regions = 1;
1214 }
1215 else
1216 _glamor_process_transformed_clipped_region
1217 (source_pixmap, source_pixmap_priv, source_repeat_type,
1218 clipped_source_regions, &n_source_regions,
1219 &need_clean_source_fbo);
1220 }
1221 DEBUGF("source clipped result %d region: \n", n_source_regions);
1222 for (j = 0; j < n_source_regions; j++) {
1223 if (is_normal_source_fbo)
1224 glamor_set_pixmap_fbo_current(source_pixmap_priv,
1225 clipped_source_regions[j].block_idx);
1226
1227 if (mask_pixmap_priv &&
1228 glamor_pixmap_priv_is_large(mask_pixmap_priv)) {
1229 if (is_normal_mask_fbo && is_normal_source_fbo) {
1230 /* both mask and source are normal fbo box without transform or repeatpad.
1231 * The region is clipped against source and then we clip it against mask here.*/
1232 DEBUGF("source region %d idx %d\n", j,
1233 clipped_source_regions[j].block_idx);
1234 DEBUGRegionPrint(clipped_source_regions[j].region);
1235 RegionTranslate(clipped_source_regions[j].region,
1236 -x_source + x_mask, -y_source + y_mask);
1237 clipped_mask_regions =
1238 glamor_compute_clipped_regions(mask_pixmap,
1239 clipped_source_regions
1240 [j].region,
1241 &n_mask_regions,
1242 mask_repeat_type, 0,
1243 0);
1244 is_normal_mask_fbo = 1;
1245 }
1246 else if (is_normal_mask_fbo && !is_normal_source_fbo) {
1247 assert(n_source_regions == 1);
1248 /* The source fbo is not a normal fbo box, it has transform or repeatpad.
1249 * the valid clip region should be the clip dest region rather than the
1250 * clip source region.*/
1251 RegionTranslate(clipped_dest_regions[i].region,
1252 -x_dest + x_mask, -y_dest + y_mask);
1253 clipped_mask_regions =
1254 glamor_compute_clipped_regions(mask_pixmap,
1255 clipped_dest_regions
1256 [i].region,
1257 &n_mask_regions,
1258 mask_repeat_type, 0,
1259 0);
1260 is_normal_mask_fbo = 1;
1261 }
1262 else {
1263 /* This mask region has transform or repeatpad, we need clip it against the previous
1264 * valid region rather than the mask region. */
1265 if (!is_normal_source_fbo)
1266 clipped_mask_regions =
1267 glamor_compute_transform_clipped_regions
1268 (mask_pixmap, mask->transform,
1269 clipped_dest_regions[i].region,
1270 &n_mask_regions, x_mask - x_dest,
1271 y_mask - y_dest, mask_repeat_type, 0, 0);
1272 else
1273 clipped_mask_regions =
1274 glamor_compute_transform_clipped_regions
1275 (mask_pixmap, mask->transform,
1276 clipped_source_regions[j].region,
1277 &n_mask_regions, x_mask - x_source,
1278 y_mask - y_source, mask_repeat_type, 0, 0);
1279 is_normal_mask_fbo = 0;
1280 if (n_mask_regions == 0) {
1281 /* Pad the out-of-box region to (0,0,0,0). */
1282 null_mask = 1;
1283 n_mask_regions = 1;
1284 }
1285 else
1286 _glamor_process_transformed_clipped_region
1287 (mask_pixmap, mask_pixmap_priv, mask_repeat_type,
1288 clipped_mask_regions, &n_mask_regions,
1289 &need_clean_mask_fbo);
1290 }
1291 DEBUGF("mask clipped result %d region: \n", n_mask_regions);
1292
1293 #define COMPOSITE_REGION(region) do { \
1294 if (!glamor_composite_clipped_region(op, \
1295 null_source ? NULL : source, \
1296 null_mask ? NULL : mask, dest, \
1297 null_source ? NULL : source_pixmap, \
1298 null_mask ? NULL : mask_pixmap, \
1299 dest_pixmap, region, \
1300 x_source, y_source, x_mask, y_mask, \
1301 x_dest, y_dest)) { \
1302 assert(0); \
1303 } \
1304 } while(0)
1305
1306 for (k = 0; k < n_mask_regions; k++) {
1307 DEBUGF("mask region %d idx %d\n", k,
1308 clipped_mask_regions[k].block_idx);
1309 DEBUGRegionPrint(clipped_mask_regions[k].region);
1310 if (is_normal_mask_fbo) {
1311 glamor_set_pixmap_fbo_current(mask_pixmap_priv,
1312 clipped_mask_regions[k].
1313 block_idx);
1314 DEBUGF("mask fbo off %d %d \n",
1315 __glamor_large(mask_pixmap_priv)->box.x1,
1316 __glamor_large(mask_pixmap_priv)->box.y1);
1317 DEBUGF("start composite mask hasn't transform.\n");
1318 RegionTranslate(clipped_mask_regions[k].region,
1319 x_dest - x_mask +
1320 dest->pDrawable->x,
1321 y_dest - y_mask +
1322 dest->pDrawable->y);
1323 COMPOSITE_REGION(clipped_mask_regions[k].region);
1324 }
1325 else if (!is_normal_mask_fbo && !is_normal_source_fbo) {
1326 DEBUGF
1327 ("start composite both mask and source have transform.\n");
1328 RegionTranslate(clipped_dest_regions[i].region,
1329 dest->pDrawable->x,
1330 dest->pDrawable->y);
1331 COMPOSITE_REGION(clipped_dest_regions[i].region);
1332 }
1333 else {
1334 DEBUGF
1335 ("start composite only mask has transform.\n");
1336 RegionTranslate(clipped_source_regions[j].region,
1337 x_dest - x_source +
1338 dest->pDrawable->x,
1339 y_dest - y_source +
1340 dest->pDrawable->y);
1341 COMPOSITE_REGION(clipped_source_regions[j].region);
1342 }
1343 RegionDestroy(clipped_mask_regions[k].region);
1344 }
1345 free(clipped_mask_regions);
1346 if (null_mask)
1347 null_mask = 0;
1348 if (need_clean_mask_fbo) {
1349 assert(is_normal_mask_fbo == 0);
1350 glamor_destroy_fbo(glamor_priv, mask_pixmap_priv->fbo);
1351 mask_pixmap_priv->fbo = NULL;
1352 need_clean_mask_fbo = 0;
1353 }
1354 }
1355 else {
1356 if (is_normal_source_fbo) {
1357 RegionTranslate(clipped_source_regions[j].region,
1358 -x_source + x_dest + dest->pDrawable->x,
1359 -y_source + y_dest +
1360 dest->pDrawable->y);
1361 COMPOSITE_REGION(clipped_source_regions[j].region);
1362 }
1363 else {
1364 /* Source has transform or repeatPad. dest regions is the right
1365 * region to do the composite. */
1366 RegionTranslate(clipped_dest_regions[i].region,
1367 dest->pDrawable->x, dest->pDrawable->y);
1368 COMPOSITE_REGION(clipped_dest_regions[i].region);
1369 }
1370 }
1371 if (clipped_source_regions && clipped_source_regions[j].region)
1372 RegionDestroy(clipped_source_regions[j].region);
1373 }
1374 free(clipped_source_regions);
1375 if (null_source)
1376 null_source = 0;
1377 if (need_clean_source_fbo) {
1378 assert(is_normal_source_fbo == 0);
1379 glamor_destroy_fbo(glamor_priv, source_pixmap_priv->fbo);
1380 source_pixmap_priv->fbo = NULL;
1381 need_clean_source_fbo = 0;
1382 }
1383 }
1384 else {
1385 if (mask_pixmap_priv &&
1386 glamor_pixmap_priv_is_large(mask_pixmap_priv)) {
1387 if (!mask->transform && mask_repeat_type != RepeatPad) {
1388 RegionTranslate(clipped_dest_regions[i].region,
1389 x_mask - x_dest, y_mask - y_dest);
1390 clipped_mask_regions =
1391 glamor_compute_clipped_regions(mask_pixmap,
1392 clipped_dest_regions[i].
1393 region, &n_mask_regions,
1394 mask_repeat_type, 0, 0);
1395 is_normal_mask_fbo = 1;
1396 }
1397 else {
1398 clipped_mask_regions =
1399 glamor_compute_transform_clipped_regions
1400 (mask_pixmap, mask->transform,
1401 clipped_dest_regions[i].region, &n_mask_regions,
1402 x_mask - x_dest, y_mask - y_dest, mask_repeat_type, 0,
1403 0);
1404 is_normal_mask_fbo = 0;
1405 if (n_mask_regions == 0) {
1406 /* Pad the out-of-box region to (0,0,0,0). */
1407 null_mask = 1;
1408 n_mask_regions = 1;
1409 }
1410 else
1411 _glamor_process_transformed_clipped_region
1412 (mask_pixmap, mask_pixmap_priv, mask_repeat_type,
1413 clipped_mask_regions, &n_mask_regions,
1414 &need_clean_mask_fbo);
1415 }
1416
1417 for (k = 0; k < n_mask_regions; k++) {
1418 DEBUGF("mask region %d idx %d\n", k,
1419 clipped_mask_regions[k].block_idx);
1420 DEBUGRegionPrint(clipped_mask_regions[k].region);
1421 if (is_normal_mask_fbo) {
1422 glamor_set_pixmap_fbo_current(mask_pixmap_priv,
1423 clipped_mask_regions[k].
1424 block_idx);
1425 RegionTranslate(clipped_mask_regions[k].region,
1426 x_dest - x_mask + dest->pDrawable->x,
1427 y_dest - y_mask + dest->pDrawable->y);
1428 COMPOSITE_REGION(clipped_mask_regions[k].region);
1429 }
1430 else {
1431 RegionTranslate(clipped_dest_regions[i].region,
1432 dest->pDrawable->x, dest->pDrawable->y);
1433 COMPOSITE_REGION(clipped_dest_regions[i].region);
1434 }
1435 RegionDestroy(clipped_mask_regions[k].region);
1436 }
1437 free(clipped_mask_regions);
1438 if (null_mask)
1439 null_mask = 0;
1440 if (need_clean_mask_fbo) {
1441 glamor_destroy_fbo(glamor_priv, mask_pixmap_priv->fbo);
1442 mask_pixmap_priv->fbo = NULL;
1443 need_clean_mask_fbo = 0;
1444 }
1445 }
1446 else {
1447 RegionTranslate(clipped_dest_regions[i].region,
1448 dest->pDrawable->x, dest->pDrawable->y);
1449 COMPOSITE_REGION(clipped_dest_regions[i].region);
1450 }
1451 }
1452 RegionDestroy(clipped_dest_regions[i].region);
1453 }
1454 free(clipped_dest_regions);
1455 free(need_free_source_pixmap_priv);
1456 free(need_free_mask_pixmap_priv);
1457 ok = TRUE;
1458 return ok;
1459 }
Mirror of freedesktop X server git repo