1 /* cairo - a vector graphics library with display and print output
2 *
3 * Copyright © 2009 Intel Corporation
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it either under the terms of the GNU Lesser General Public
7 * License version 2.1 as published by the Free Software Foundation
8 * (the "LGPL") or, at your option, under the terms of the Mozilla
9 * Public License Version 1.1 (the "MPL"). If you do not alter this
10 * notice, a recipient may use your version of this file under either
11 * the MPL or the LGPL.
12 *
13 * You should have received a copy of the LGPL along with this library
14 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
16 * You should have received a copy of the MPL along with this library
17 * in the file COPYING-MPL-1.1
18 *
19 * The contents of this file are subject to the Mozilla Public License
20 * Version 1.1 (the "License"); you may not use this file except in
21 * compliance with the License. You may obtain a copy of the License at
22 * http://www.mozilla.org/MPL/
23 *
24 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
25 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
26 * the specific language governing rights and limitations.
27 *
28 * The Original Code is the cairo graphics library.
29 *
30 * The Initial Developer of the Original Code is Red Hat, Inc.
31 *
32 * Contributor(s):
33 * Chris Wilson <chris@chris-wilson.co.uk>
34 */
35
36 #include "cairoint.h"
37
38 #include "cairo-composite-rectangles-private.h"
39 #include "cairo-drm-i965-private.h"
40 #include "cairo-error-private.h"
41 #include "cairo-rtree-private.h"
42
43 typedef struct _i965_glyphs i965_glyphs_t;
44
45 typedef float *
46 (*i965_get_rectangle_func_t) (i965_glyphs_t *glyphs);
47
48 struct _i965_glyphs {
49 i965_get_rectangle_func_t get_rectangle;
50 i965_shader_t shader;
51
52 struct i965_vbo head, *tail;
53
54 unsigned int vbo_offset;
55 float *vbo_base;
56 };
57
58 static float *
i965_glyphs_emit_rectangle(i965_glyphs_t * glyphs)59 i965_glyphs_emit_rectangle (i965_glyphs_t *glyphs)
60 {
61 return i965_add_rectangle (glyphs->shader.device);
62 }
63
64 static float *
i965_glyphs_accumulate_rectangle(i965_glyphs_t * glyphs)65 i965_glyphs_accumulate_rectangle (i965_glyphs_t *glyphs)
66 {
67 float *vertices;
68 uint32_t size;
69
70 size = glyphs->shader.device->rectangle_size;
71 if (unlikely (glyphs->vbo_offset + size > I965_VERTEX_SIZE)) {
72 struct i965_vbo *vbo;
73
74 vbo = _cairo_malloc (sizeof (struct i965_vbo));
75 if (unlikely (vbo == NULL)) {
76 /* throw error! */
77 }
78
79 glyphs->tail->next = vbo;
80 glyphs->tail = vbo;
81
82 vbo->next = NULL;
83 vbo->bo = intel_bo_create (&glyphs->shader.device->intel,
84 I965_VERTEX_SIZE, I965_VERTEX_SIZE,
85 FALSE, I915_TILING_NONE, 0);
86 vbo->count = 0;
87
88 glyphs->vbo_offset = 0;
89 glyphs->vbo_base = intel_bo_map (&glyphs->shader.device->intel, vbo->bo);
90 }
91
92 vertices = glyphs->vbo_base + glyphs->vbo_offset;
93 glyphs->vbo_offset += size;
94 glyphs->tail->count += 3;
95
96 return vertices;
97 }
98
99 static void
i965_add_glyph_rectangle(i965_glyphs_t * glyphs,int x1,int y1,int x2,int y2,intel_glyph_t * glyph)100 i965_add_glyph_rectangle (i965_glyphs_t *glyphs,
101 int x1, int y1,
102 int x2, int y2,
103 intel_glyph_t *glyph)
104 {
105 float *v;
106
107 /* Each vertex is:
108 * 2 vertex coordinates
109 * 1 glyph texture coordinate
110 */
111
112 v = glyphs->get_rectangle (glyphs);
113
114 /* bottom right */
115 *v++ = x2; *v++ = y2;
116 *v++ = glyph->texcoord[0];
117
118 /* bottom left */
119 *v++ = x1; *v++ = y2;
120 *v++ = glyph->texcoord[1];
121
122 /* top left */
123 *v++ = x1; *v++ = y1;
124 *v++ = glyph->texcoord[2];
125 }
126
127 static cairo_status_t
i965_surface_mask_internal(i965_surface_t * dst,cairo_operator_t op,const cairo_pattern_t * source,i965_surface_t * mask,cairo_clip_t * clip,const cairo_composite_rectangles_t * extents)128 i965_surface_mask_internal (i965_surface_t *dst,
129 cairo_operator_t op,
130 const cairo_pattern_t *source,
131 i965_surface_t *mask,
132 cairo_clip_t *clip,
133 const cairo_composite_rectangles_t *extents)
134 {
135 i965_device_t *device;
136 i965_shader_t shader;
137 cairo_region_t *clip_region = NULL;
138 cairo_status_t status;
139
140 i965_shader_init (&shader, dst, op);
141
142 status = i965_shader_acquire_pattern (&shader, &shader.source,
143 source, &extents->bounded);
144 if (unlikely (status))
145 return status;
146
147 shader.mask.type.vertex = VS_NONE;
148 shader.mask.type.fragment = FS_SURFACE;
149 shader.mask.base.content = mask->intel.drm.base.content;
150 shader.mask.base.filter = i965_filter (CAIRO_FILTER_NEAREST);
151 shader.mask.base.extend = i965_extend (CAIRO_EXTEND_NONE);
152
153 cairo_matrix_init_translate (&shader.mask.base.matrix,
154 -extents->bounded.x,
155 -extents->bounded.y);
156 cairo_matrix_scale (&shader.mask.base.matrix,
157 1. / mask->intel.drm.width,
158 1. / mask->intel.drm.height);
159
160 shader.mask.base.bo = to_intel_bo (mask->intel.drm.bo);
161 shader.mask.base.format = mask->intel.drm.format;
162 shader.mask.base.width = mask->intel.drm.width;
163 shader.mask.base.height = mask->intel.drm.height;
164 shader.mask.base.stride = mask->intel.drm.stride;
165
166 if (clip != NULL) {
167 status = _cairo_clip_get_region (clip, &clip_region);
168 assert (status == CAIRO_STATUS_SUCCESS || status == CAIRO_INT_STATUS_UNSUPPORTED);
169
170 if (clip_region != NULL && cairo_region_num_rectangles (clip_region) == 1)
171 clip_region = NULL;
172
173 if (status == CAIRO_INT_STATUS_UNSUPPORTED)
174 i965_shader_set_clip (&shader, clip);
175 }
176
177 status = cairo_device_acquire (dst->intel.drm.base.device);
178 if (unlikely (status))
179 goto CLEANUP_SHADER;
180
181 device = i965_device (dst);
182
183 status = i965_shader_commit (&shader, device);
184 if (unlikely (status))
185 goto CLEANUP_DEVICE;
186
187 if (clip_region != NULL) {
188 unsigned int n, num_rectangles;
189
190 num_rectangles = cairo_region_num_rectangles (clip_region);
191 for (n = 0; n < num_rectangles; n++) {
192 cairo_rectangle_int_t rect;
193
194 cairo_region_get_rectangle (clip_region, n, &rect);
195
196 i965_shader_add_rectangle (&shader,
197 rect.x, rect.y,
198 rect.width, rect.height);
199 }
200 } else {
201 i965_shader_add_rectangle (&shader,
202 extents->bounded.x,
203 extents->bounded.y,
204 extents->bounded.width,
205 extents->bounded.height);
206 }
207
208 if (! extents->is_bounded)
209 status = i965_fixup_unbounded (dst, extents, clip);
210
211 CLEANUP_DEVICE:
212 cairo_device_release (&device->intel.base.base);
213 CLEANUP_SHADER:
214 i965_shader_fini (&shader);
215 return status;
216 }
217
218 cairo_int_status_t
i965_surface_glyphs(void * abstract_surface,cairo_operator_t op,const cairo_pattern_t * source,cairo_glyph_t * g,int num_glyphs,cairo_scaled_font_t * scaled_font,cairo_clip_t * clip,int * num_remaining)219 i965_surface_glyphs (void *abstract_surface,
220 cairo_operator_t op,
221 const cairo_pattern_t *source,
222 cairo_glyph_t *g,
223 int num_glyphs,
224 cairo_scaled_font_t *scaled_font,
225 cairo_clip_t *clip,
226 int *num_remaining)
227 {
228 i965_surface_t *surface = abstract_surface;
229 i965_surface_t *mask = NULL;
230 i965_device_t *device;
231 i965_glyphs_t glyphs;
232 cairo_composite_rectangles_t extents;
233 cairo_clip_t local_clip;
234 cairo_bool_t have_clip = FALSE;
235 cairo_bool_t overlap;
236 cairo_region_t *clip_region = NULL;
237 intel_bo_t *last_bo = NULL;
238 cairo_scaled_glyph_t *glyph_cache[64];
239 cairo_status_t status;
240 int mask_x = 0, mask_y = 0;
241 int i = 0;
242
243 *num_remaining = 0;
244 status = _cairo_composite_rectangles_init_for_glyphs (&extents,
245 surface->intel.drm.width,
246 surface->intel.drm.height,
247 op, source,
248 scaled_font,
249 g, num_glyphs,
250 clip,
251 &overlap);
252 if (unlikely (status))
253 return status;
254
255 if (clip != NULL && _cairo_clip_contains_rectangle (clip, &extents.mask))
256 clip = NULL;
257
258 if (clip != NULL && extents.is_bounded) {
259 clip = _cairo_clip_init_copy (&local_clip, clip);
260 status = _cairo_clip_rectangle (clip, &extents.bounded);
261 if (unlikely (status))
262 return status;
263
264 have_clip = TRUE;
265 }
266
267 if (overlap || ! extents.is_bounded) {
268 cairo_format_t format;
269
270 format = CAIRO_FORMAT_A8;
271 if (scaled_font->options.antialias == CAIRO_ANTIALIAS_SUBPIXEL)
272 format = CAIRO_FORMAT_ARGB32;
273
274 mask = (i965_surface_t *)
275 i965_surface_create_internal (&i965_device (surface)->intel.base,
276 format,
277 extents.bounded.width,
278 extents.bounded.height,
279 I965_TILING_DEFAULT,
280 TRUE);
281 if (unlikely (mask->intel.drm.base.status))
282 return mask->intel.drm.base.status;
283
284 status = _cairo_surface_paint (&mask->intel.drm.base,
285 CAIRO_OPERATOR_CLEAR,
286 &_cairo_pattern_clear.base,
287 NULL);
288 if (unlikely (status)) {
289 cairo_surface_destroy (&mask->intel.drm.base);
290 return status;
291 }
292
293 i965_shader_init (&glyphs.shader, mask, CAIRO_OPERATOR_ADD);
294
295 status = i965_shader_acquire_pattern (&glyphs.shader, &glyphs.shader.source,
296 &_cairo_pattern_white.base,
297 &extents.bounded);
298 if (unlikely (status)) {
299 cairo_surface_destroy (&mask->intel.drm.base);
300 return status;
301 }
302
303 mask_x = -extents.bounded.x;
304 mask_y = -extents.bounded.y;
305 } else {
306 i965_shader_init (&glyphs.shader, surface, op);
307
308 status = i965_shader_acquire_pattern (&glyphs.shader, &glyphs.shader.source,
309 source, &extents.bounded);
310 if (unlikely (status))
311 return status;
312
313 if (clip != NULL) {
314 status = _cairo_clip_get_region (clip, &clip_region);
315 assert (status == CAIRO_STATUS_SUCCESS || status == CAIRO_INT_STATUS_UNSUPPORTED);
316
317 if (status == CAIRO_INT_STATUS_UNSUPPORTED)
318 i965_shader_set_clip (&glyphs.shader, clip);
319 }
320 }
321
322 glyphs.head.next = NULL;
323 glyphs.head.bo = NULL;
324 glyphs.head.count = 0;
325 glyphs.tail = &glyphs.head;
326
327 device = i965_device (surface);
328 if (mask != NULL || clip_region == NULL) {
329 glyphs.get_rectangle = i965_glyphs_emit_rectangle;
330 } else {
331 glyphs.get_rectangle = i965_glyphs_accumulate_rectangle;
332 glyphs.head.bo = intel_bo_create (&device->intel,
333 I965_VERTEX_SIZE, I965_VERTEX_SIZE,
334 FALSE, I915_TILING_NONE, 0);
335 if (unlikely (glyphs.head.bo == NULL))
336 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
337
338 glyphs.vbo_base = intel_bo_map (&device->intel, glyphs.head.bo);
339 }
340 glyphs.vbo_offset = 0;
341
342 status = cairo_device_acquire (&device->intel.base.base);
343 if (unlikely (status))
344 goto CLEANUP_GLYPHS;
345
346 _cairo_scaled_font_freeze_cache (scaled_font);
347 //private = _cairo_scaled_font_get_device (scaled_font, device);
348 if (scaled_font->surface_private == NULL) {
349 scaled_font->surface_private = device;
350 scaled_font->surface_backend = surface->intel.drm.base.backend;
351 cairo_list_add (&scaled_font->link, &device->intel.fonts);
352 }
353
354 memset (glyph_cache, 0, sizeof (glyph_cache));
355
356 for (i = 0; i < num_glyphs; i++) {
357 cairo_scaled_glyph_t *scaled_glyph;
358 int x, y, x1, x2, y1, y2;
359 int cache_index = g[i].index % ARRAY_LENGTH (glyph_cache);
360 intel_glyph_t *glyph;
361
362 scaled_glyph = glyph_cache[cache_index];
363 if (scaled_glyph == NULL ||
364 _cairo_scaled_glyph_index (scaled_glyph) != g[i].index)
365 {
366 status = _cairo_scaled_glyph_lookup (scaled_font,
367 g[i].index,
368 CAIRO_SCALED_GLYPH_INFO_METRICS,
369 &scaled_glyph);
370 if (unlikely (status))
371 goto FINISH;
372
373 glyph_cache[cache_index] = scaled_glyph;
374 }
375
376 if (unlikely (scaled_glyph->metrics.width == 0 ||
377 scaled_glyph->metrics.height == 0))
378 {
379 continue;
380 }
381
382 /* XXX glyph images are snapped to pixel locations */
383 x = _cairo_lround (g[i].x);
384 y = _cairo_lround (g[i].y);
385
386 x1 = x + _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.x);
387 y1 = y + _cairo_fixed_integer_floor (scaled_glyph->bbox.p1.y);
388 x2 = x + _cairo_fixed_integer_ceil (scaled_glyph->bbox.p2.x);
389 y2 = y + _cairo_fixed_integer_ceil (scaled_glyph->bbox.p2.y);
390
391 if (x2 < extents.bounded.x ||
392 y2 < extents.bounded.y ||
393 x1 > extents.bounded.x + extents.bounded.width ||
394 y1 > extents.bounded.y + extents.bounded.height)
395 {
396 continue;
397 }
398
399 if (scaled_glyph->surface_private == NULL) {
400 status = intel_get_glyph (&device->intel, scaled_font, scaled_glyph);
401 if (unlikely (status == CAIRO_INT_STATUS_NOTHING_TO_DO)) {
402 status = CAIRO_STATUS_SUCCESS;
403 continue;
404 }
405 if (unlikely (status))
406 goto FINISH;
407 }
408 glyph = intel_glyph_pin (scaled_glyph->surface_private);
409
410 if (glyph->cache->buffer.bo != last_bo) {
411 intel_buffer_cache_t *cache = glyph->cache;
412
413 glyphs.shader.mask.type.vertex = VS_GLYPHS;
414 glyphs.shader.mask.type.fragment = FS_GLYPHS;
415 glyphs.shader.mask.type.pattern = PATTERN_BASE;
416
417 glyphs.shader.mask.base.bo = cache->buffer.bo;
418 glyphs.shader.mask.base.format = cache->buffer.format;
419 glyphs.shader.mask.base.width = cache->buffer.width;
420 glyphs.shader.mask.base.height = cache->buffer.height;
421 glyphs.shader.mask.base.stride = cache->buffer.stride;
422 glyphs.shader.mask.base.filter = i965_filter (CAIRO_FILTER_NEAREST);
423 glyphs.shader.mask.base.extend = i965_extend (CAIRO_EXTEND_NONE);
424 glyphs.shader.mask.base.content = CAIRO_CONTENT_ALPHA; /* XXX */
425
426 glyphs.shader.committed = FALSE;
427 status = i965_shader_commit (&glyphs.shader, device);
428 if (unlikely (status))
429 goto FINISH;
430
431 last_bo = cache->buffer.bo;
432 }
433
434 x2 = x1 + glyph->width;
435 y2 = y1 + glyph->height;
436
437 if (mask_x)
438 x1 += mask_x, x2 += mask_x;
439 if (mask_y)
440 y1 += mask_y, y2 += mask_y;
441
442 i965_add_glyph_rectangle (&glyphs, x1, y1, x2, y2, glyph);
443 }
444
445 if (mask != NULL && clip_region != NULL)
446 i965_clipped_vertices (device, &glyphs.head, clip_region);
447
448 status = CAIRO_STATUS_SUCCESS;
449 FINISH:
450 _cairo_scaled_font_thaw_cache (scaled_font);
451 cairo_device_release (surface->intel.drm.base.device);
452 CLEANUP_GLYPHS:
453 i965_shader_fini (&glyphs.shader);
454
455 if (glyphs.head.bo != NULL) {
456 struct i965_vbo *vbo, *next;
457
458 intel_bo_destroy (&device->intel, glyphs.head.bo);
459 for (vbo = glyphs.head.next; vbo != NULL; vbo = next) {
460 next = vbo->next;
461 intel_bo_destroy (&device->intel, vbo->bo);
462 free (vbo);
463 }
464 }
465
466 if (unlikely (status == CAIRO_INT_STATUS_UNSUPPORTED)) {
467 cairo_path_fixed_t path;
468
469 _cairo_path_fixed_init (&path);
470 status = _cairo_scaled_font_glyph_path (scaled_font,
471 g + i, num_glyphs - i,
472 &path);
473 if (mask_x | mask_y) {
474 _cairo_path_fixed_translate (&path,
475 _cairo_fixed_from_int (mask_x),
476 _cairo_fixed_from_int (mask_y));
477 }
478 if (likely (status == CAIRO_STATUS_SUCCESS)) {
479 status = surface->intel.drm.base.backend->fill (glyphs.shader.target,
480 glyphs.shader.op,
481 mask != NULL ? &_cairo_pattern_white.base : source,
482 &path,
483 CAIRO_FILL_RULE_WINDING,
484 0,
485 scaled_font->options.antialias,
486 clip);
487 }
488 _cairo_path_fixed_fini (&path);
489 }
490
491 if (mask != NULL) {
492 if (likely (status == CAIRO_STATUS_SUCCESS)) {
493 status = i965_surface_mask_internal (surface, op, source, mask,
494 clip, &extents);
495 }
496 cairo_surface_finish (&mask->intel.drm.base);
497 cairo_surface_destroy (&mask->intel.drm.base);
498 }
499
500 if (have_clip)
501 _cairo_clip_fini (&local_clip);
502
503 return status;
504 }
505