• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright © 2011  Google, Inc.
3  *
4  *  This is part of HarfBuzz, a text shaping library.
5  *
6  * Permission is hereby granted, without written agreement and without
7  * license or royalty fees, to use, copy, modify, and distribute this
8  * software and its documentation for any purpose, provided that the
9  * above copyright notice and the following two paragraphs appear in
10  * all copies of this software.
11  *
12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16  * DAMAGE.
17  *
18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23  *
24  * Google Author(s): Behdad Esfahbod
25  */
26 
27 #include "helper-cairo.hh"
28 
29 #include <cairo-ft.h>
30 #include <hb-ft.h>
31 #include FT_MULTIPLE_MASTERS_H
32 
33 #include "helper-cairo-ansi.hh"
34 #ifdef CAIRO_HAS_SVG_SURFACE
35 #  include <cairo-svg.h>
36 #endif
37 #ifdef CAIRO_HAS_PDF_SURFACE
38 #  include <cairo-pdf.h>
39 #endif
40 #ifdef CAIRO_HAS_PS_SURFACE
41 #  include <cairo-ps.h>
42 #  if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,6,0)
43 #    define HAS_EPS 1
44 
45 static cairo_surface_t *
_cairo_eps_surface_create_for_stream(cairo_write_func_t write_func,void * closure,double width,double height)46 _cairo_eps_surface_create_for_stream (cairo_write_func_t  write_func,
47 				      void               *closure,
48 				      double              width,
49 				      double              height)
50 {
51   cairo_surface_t *surface;
52 
53   surface = cairo_ps_surface_create_for_stream (write_func, closure, width, height);
54   cairo_ps_surface_set_eps (surface, true);
55 
56   return surface;
57 }
58 
59 #  else
60 #    undef HAS_EPS
61 #  endif
62 #endif
63 
64 
65 static FT_Library ft_library;
66 
67 static inline
free_ft_library(void)68 void free_ft_library (void)
69 {
70   FT_Done_FreeType (ft_library);
71 }
72 
73 cairo_scaled_font_t *
helper_cairo_create_scaled_font(const font_options_t * font_opts)74 helper_cairo_create_scaled_font (const font_options_t *font_opts)
75 {
76   hb_font_t *font = hb_font_reference (font_opts->get_font ());
77 
78   cairo_font_face_t *cairo_face;
79   /* We cannot use the FT_Face from hb_font_t, as doing so will confuse hb_font_t because
80    * cairo will reset the face size.  As such, create new face...
81    * TODO Perhaps add API to hb-ft to encapsulate this code. */
82   FT_Face ft_face = nullptr;//hb_ft_font_get_face (font);
83   if (!ft_face)
84   {
85     if (!ft_library)
86     {
87       FT_Init_FreeType (&ft_library);
88 #ifdef HAVE_ATEXIT
89       atexit (free_ft_library);
90 #endif
91     }
92     FT_New_Face (ft_library,
93 		 font_opts->font_file,
94 		 font_opts->face_index,
95 		 &ft_face);
96   }
97   if (!ft_face)
98   {
99     /* This allows us to get some boxes at least... */
100     cairo_face = cairo_toy_font_face_create ("@cairo:sans",
101 					     CAIRO_FONT_SLANT_NORMAL,
102 					     CAIRO_FONT_WEIGHT_NORMAL);
103   }
104   else
105   {
106 #ifdef HAVE_FT_SET_VAR_BLEND_COORDINATES
107     unsigned int num_coords;
108     const int *coords = hb_font_get_var_coords_normalized (font, &num_coords);
109     if (num_coords)
110     {
111       FT_Fixed *ft_coords = (FT_Fixed *) calloc (num_coords, sizeof (FT_Fixed));
112       if (ft_coords)
113       {
114 	for (unsigned int i = 0; i < num_coords; i++)
115 	  ft_coords[i] = coords[i] << 2;
116 	FT_Set_Var_Blend_Coordinates (ft_face, num_coords, ft_coords);
117 	free (ft_coords);
118       }
119     }
120 #endif
121 
122     cairo_face = cairo_ft_font_face_create_for_ft_face (ft_face, 0);
123   }
124   cairo_matrix_t ctm, font_matrix;
125   cairo_font_options_t *font_options;
126 
127   cairo_matrix_init_identity (&ctm);
128   cairo_matrix_init_scale (&font_matrix,
129 			   font_opts->font_size_x,
130 			   font_opts->font_size_y);
131   font_options = cairo_font_options_create ();
132   cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE);
133   cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
134 
135   cairo_scaled_font_t *scaled_font = cairo_scaled_font_create (cairo_face,
136 							       &font_matrix,
137 							       &ctm,
138 							       font_options);
139 
140   cairo_font_options_destroy (font_options);
141   cairo_font_face_destroy (cairo_face);
142 
143   static cairo_user_data_key_t key;
144   if (cairo_scaled_font_set_user_data (scaled_font,
145 				       &key,
146 				       (void *) font,
147 				       (cairo_destroy_func_t) hb_font_destroy))
148     hb_font_destroy (font);
149 
150   return scaled_font;
151 }
152 
153 bool
helper_cairo_scaled_font_has_color(cairo_scaled_font_t * scaled_font)154 helper_cairo_scaled_font_has_color (cairo_scaled_font_t *scaled_font)
155 {
156   bool ret = false;
157 #ifdef FT_HAS_COLOR
158   FT_Face ft_face = cairo_ft_scaled_font_lock_face (scaled_font);
159   if (ft_face)
160   {
161     if (FT_HAS_COLOR (ft_face))
162       ret = true;
163     cairo_ft_scaled_font_unlock_face (scaled_font);
164   }
165 #endif
166   return ret;
167 }
168 
169 
170 struct finalize_closure_t {
171   void (*callback)(finalize_closure_t *);
172   cairo_surface_t *surface;
173   cairo_write_func_t write_func;
174   void *closure;
175 };
176 static cairo_user_data_key_t finalize_closure_key;
177 
178 
179 static void
finalize_ansi(finalize_closure_t * closure)180 finalize_ansi (finalize_closure_t *closure)
181 {
182   cairo_status_t status;
183   status = helper_cairo_surface_write_to_ansi_stream (closure->surface,
184 						      closure->write_func,
185 						      closure->closure);
186   if (status != CAIRO_STATUS_SUCCESS)
187     fail (false, "Failed to write output: %s",
188 	  cairo_status_to_string (status));
189 }
190 
191 static cairo_surface_t *
_cairo_ansi_surface_create_for_stream(cairo_write_func_t write_func,void * closure,double width,double height,cairo_content_t content)192 _cairo_ansi_surface_create_for_stream (cairo_write_func_t write_func,
193 				       void *closure,
194 				       double width,
195 				       double height,
196 				       cairo_content_t content)
197 {
198   cairo_surface_t *surface;
199   int w = ceil (width);
200   int h = ceil (height);
201 
202   switch (content) {
203     case CAIRO_CONTENT_ALPHA:
204       surface = cairo_image_surface_create (CAIRO_FORMAT_A8, w, h);
205       break;
206     default:
207     case CAIRO_CONTENT_COLOR:
208       surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
209       break;
210     case CAIRO_CONTENT_COLOR_ALPHA:
211       surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
212       break;
213   }
214   cairo_status_t status = cairo_surface_status (surface);
215   if (status != CAIRO_STATUS_SUCCESS)
216     fail (false, "Failed to create cairo surface: %s",
217 	  cairo_status_to_string (status));
218 
219   finalize_closure_t *ansi_closure = g_new0 (finalize_closure_t, 1);
220   ansi_closure->callback = finalize_ansi;
221   ansi_closure->surface = surface;
222   ansi_closure->write_func = write_func;
223   ansi_closure->closure = closure;
224 
225   if (cairo_surface_set_user_data (surface,
226 				   &finalize_closure_key,
227 				   (void *) ansi_closure,
228 				   (cairo_destroy_func_t) g_free))
229     g_free ((void *) closure);
230 
231   return surface;
232 }
233 
234 
235 #ifdef CAIRO_HAS_PNG_FUNCTIONS
236 
237 static void
finalize_png(finalize_closure_t * closure)238 finalize_png (finalize_closure_t *closure)
239 {
240   cairo_status_t status;
241   status = cairo_surface_write_to_png_stream (closure->surface,
242 					      closure->write_func,
243 					      closure->closure);
244   if (status != CAIRO_STATUS_SUCCESS)
245     fail (false, "Failed to write output: %s",
246 	  cairo_status_to_string (status));
247 }
248 
249 static cairo_surface_t *
_cairo_png_surface_create_for_stream(cairo_write_func_t write_func,void * closure,double width,double height,cairo_content_t content)250 _cairo_png_surface_create_for_stream (cairo_write_func_t write_func,
251 				      void *closure,
252 				      double width,
253 				      double height,
254 				      cairo_content_t content)
255 {
256   cairo_surface_t *surface;
257   int w = ceil (width);
258   int h = ceil (height);
259 
260   switch (content) {
261     case CAIRO_CONTENT_ALPHA:
262       surface = cairo_image_surface_create (CAIRO_FORMAT_A8, w, h);
263       break;
264     default:
265     case CAIRO_CONTENT_COLOR:
266       surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
267       break;
268     case CAIRO_CONTENT_COLOR_ALPHA:
269       surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
270       break;
271   }
272   cairo_status_t status = cairo_surface_status (surface);
273   if (status != CAIRO_STATUS_SUCCESS)
274     fail (false, "Failed to create cairo surface: %s",
275 	  cairo_status_to_string (status));
276 
277   finalize_closure_t *png_closure = g_new0 (finalize_closure_t, 1);
278   png_closure->callback = finalize_png;
279   png_closure->surface = surface;
280   png_closure->write_func = write_func;
281   png_closure->closure = closure;
282 
283   if (cairo_surface_set_user_data (surface,
284 				   &finalize_closure_key,
285 				   (void *) png_closure,
286 				   (cairo_destroy_func_t) g_free))
287     g_free ((void *) closure);
288 
289   return surface;
290 }
291 
292 #endif
293 
294 static cairo_status_t
stdio_write_func(void * closure,const unsigned char * data,unsigned int size)295 stdio_write_func (void                *closure,
296 		  const unsigned char *data,
297 		  unsigned int         size)
298 {
299   FILE *fp = (FILE *) closure;
300 
301   while (size) {
302     size_t ret = fwrite (data, 1, size, fp);
303     size -= ret;
304     data += ret;
305     if (size && ferror (fp))
306       fail (false, "Failed to write output: %s", strerror (errno));
307   }
308 
309   return CAIRO_STATUS_SUCCESS;
310 }
311 
312 const char *helper_cairo_supported_formats[] =
313 {
314   "ansi",
315   #ifdef CAIRO_HAS_PNG_FUNCTIONS
316   "png",
317   #endif
318   #ifdef CAIRO_HAS_SVG_SURFACE
319   "svg",
320   #endif
321   #ifdef CAIRO_HAS_PDF_SURFACE
322   "pdf",
323   #endif
324   #ifdef CAIRO_HAS_PS_SURFACE
325   "ps",
326    #ifdef HAS_EPS
327     "eps",
328    #endif
329   #endif
330   nullptr
331 };
332 
333 cairo_t *
helper_cairo_create_context(double w,double h,view_options_t * view_opts,output_options_t * out_opts,cairo_content_t content)334 helper_cairo_create_context (double w, double h,
335 			     view_options_t *view_opts,
336 			     output_options_t *out_opts,
337 			     cairo_content_t content)
338 {
339   cairo_surface_t *(*constructor) (cairo_write_func_t write_func,
340 				   void *closure,
341 				   double width,
342 				   double height) = nullptr;
343   cairo_surface_t *(*constructor2) (cairo_write_func_t write_func,
344 				    void *closure,
345 				    double width,
346 				    double height,
347 				    cairo_content_t content) = nullptr;
348 
349   const char *extension = out_opts->output_format;
350   if (!extension) {
351 #if HAVE_ISATTY
352     if (isatty (fileno (out_opts->get_file_handle ())))
353       extension = "ansi";
354     else
355 #endif
356     {
357 #ifdef CAIRO_HAS_PNG_FUNCTIONS
358       extension = "png";
359 #else
360       extension = "ansi";
361 #endif
362     }
363   }
364   if (0)
365     ;
366     else if (0 == g_ascii_strcasecmp (extension, "ansi"))
367       constructor2 = _cairo_ansi_surface_create_for_stream;
368   #ifdef CAIRO_HAS_PNG_FUNCTIONS
369     else if (0 == g_ascii_strcasecmp (extension, "png"))
370       constructor2 = _cairo_png_surface_create_for_stream;
371   #endif
372   #ifdef CAIRO_HAS_SVG_SURFACE
373     else if (0 == g_ascii_strcasecmp (extension, "svg"))
374       constructor = cairo_svg_surface_create_for_stream;
375   #endif
376   #ifdef CAIRO_HAS_PDF_SURFACE
377     else if (0 == g_ascii_strcasecmp (extension, "pdf"))
378       constructor = cairo_pdf_surface_create_for_stream;
379   #endif
380   #ifdef CAIRO_HAS_PS_SURFACE
381     else if (0 == g_ascii_strcasecmp (extension, "ps"))
382       constructor = cairo_ps_surface_create_for_stream;
383    #ifdef HAS_EPS
384     else if (0 == g_ascii_strcasecmp (extension, "eps"))
385       constructor = _cairo_eps_surface_create_for_stream;
386    #endif
387   #endif
388 
389 
390   unsigned int fr, fg, fb, fa, br, bg, bb, ba;
391   const char *color;
392   br = bg = bb = 0; ba = 255;
393   color = view_opts->back ? view_opts->back : DEFAULT_BACK;
394   sscanf (color + (*color=='#'), "%2x%2x%2x%2x", &br, &bg, &bb, &ba);
395   fr = fg = fb = 0; fa = 255;
396   color = view_opts->fore ? view_opts->fore : DEFAULT_FORE;
397   sscanf (color + (*color=='#'), "%2x%2x%2x%2x", &fr, &fg, &fb, &fa);
398 
399   if (content == CAIRO_CONTENT_ALPHA)
400   {
401     if (view_opts->annotate ||
402 	br != bg || bg != bb ||
403 	fr != fg || fg != fb)
404       content = CAIRO_CONTENT_COLOR;
405   }
406   if (ba != 255)
407     content = CAIRO_CONTENT_COLOR_ALPHA;
408 
409   cairo_surface_t *surface;
410   FILE *f = out_opts->get_file_handle ();
411   if (constructor)
412     surface = constructor (stdio_write_func, f, w, h);
413   else if (constructor2)
414     surface = constructor2 (stdio_write_func, f, w, h, content);
415   else
416     fail (false, "Unknown output format `%s'; supported formats are: %s%s",
417 	  extension,
418 	  g_strjoinv ("/", const_cast<char**> (helper_cairo_supported_formats)),
419 	  out_opts->explicit_output_format ? "" :
420 	  "\nTry setting format using --output-format");
421 
422   cairo_t *cr = cairo_create (surface);
423   content = cairo_surface_get_content (surface);
424 
425   switch (content) {
426     case CAIRO_CONTENT_ALPHA:
427       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
428       cairo_set_source_rgba (cr, 1., 1., 1., br / 255.);
429       cairo_paint (cr);
430       cairo_set_source_rgba (cr, 1., 1., 1.,
431 			     (fr / 255.) * (fa / 255.) + (br / 255) * (1 - (fa / 255.)));
432       break;
433     default:
434     case CAIRO_CONTENT_COLOR:
435     case CAIRO_CONTENT_COLOR_ALPHA:
436       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
437       cairo_set_source_rgba (cr, br / 255., bg / 255., bb / 255., ba / 255.);
438       cairo_paint (cr);
439       cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
440       cairo_set_source_rgba (cr, fr / 255., fg / 255., fb / 255., fa / 255.);
441       break;
442   }
443 
444   cairo_surface_destroy (surface);
445   return cr;
446 }
447 
448 void
helper_cairo_destroy_context(cairo_t * cr)449 helper_cairo_destroy_context (cairo_t *cr)
450 {
451   finalize_closure_t *closure = (finalize_closure_t *)
452 				cairo_surface_get_user_data (cairo_get_target (cr),
453 							     &finalize_closure_key);
454   if (closure)
455     closure->callback (closure);
456 
457   cairo_status_t status = cairo_status (cr);
458   if (status != CAIRO_STATUS_SUCCESS)
459     fail (false, "Failed: %s",
460 	  cairo_status_to_string (status));
461   cairo_destroy (cr);
462 }
463 
464 
465 void
helper_cairo_line_from_buffer(helper_cairo_line_t * l,hb_buffer_t * buffer,const char * text,unsigned int text_len,int scale_bits,hb_bool_t utf8_clusters)466 helper_cairo_line_from_buffer (helper_cairo_line_t *l,
467 			       hb_buffer_t         *buffer,
468 			       const char          *text,
469 			       unsigned int         text_len,
470 			       int                  scale_bits,
471 			       hb_bool_t            utf8_clusters)
472 {
473   memset (l, 0, sizeof (*l));
474 
475   l->num_glyphs = hb_buffer_get_length (buffer);
476   hb_glyph_info_t *hb_glyph = hb_buffer_get_glyph_infos (buffer, nullptr);
477   hb_glyph_position_t *hb_position = hb_buffer_get_glyph_positions (buffer, nullptr);
478   l->glyphs = cairo_glyph_allocate (l->num_glyphs + 1);
479 
480   if (text) {
481     l->utf8 = g_strndup (text, text_len);
482     l->utf8_len = text_len;
483     l->num_clusters = l->num_glyphs ? 1 : 0;
484     for (unsigned int i = 1; i < l->num_glyphs; i++)
485       if (hb_glyph[i].cluster != hb_glyph[i-1].cluster)
486 	l->num_clusters++;
487     l->clusters = cairo_text_cluster_allocate (l->num_clusters);
488   }
489 
490   if ((l->num_glyphs && !l->glyphs) ||
491       (l->utf8_len && !l->utf8) ||
492       (l->num_clusters && !l->clusters))
493   {
494     l->finish ();
495     return;
496   }
497 
498   hb_position_t x = 0, y = 0;
499   int i;
500   for (i = 0; i < (int) l->num_glyphs; i++)
501   {
502     l->glyphs[i].index = hb_glyph[i].codepoint;
503     l->glyphs[i].x = scalbn ((double)  hb_position->x_offset + x, scale_bits);
504     l->glyphs[i].y = scalbn ((double) -hb_position->y_offset + y, scale_bits);
505     x +=  hb_position->x_advance;
506     y += -hb_position->y_advance;
507 
508     hb_position++;
509   }
510   l->glyphs[i].index = -1;
511   l->glyphs[i].x = scalbn ((double) x, scale_bits);
512   l->glyphs[i].y = scalbn ((double) y, scale_bits);
513 
514   if (l->num_clusters) {
515     memset ((void *) l->clusters, 0, l->num_clusters * sizeof (l->clusters[0]));
516     hb_bool_t backward = HB_DIRECTION_IS_BACKWARD (hb_buffer_get_direction (buffer));
517     l->cluster_flags = backward ? CAIRO_TEXT_CLUSTER_FLAG_BACKWARD : (cairo_text_cluster_flags_t) 0;
518     unsigned int cluster = 0;
519     const char *start = l->utf8, *end;
520     l->clusters[cluster].num_glyphs++;
521     if (backward) {
522       for (i = l->num_glyphs - 2; i >= 0; i--) {
523 	if (hb_glyph[i].cluster != hb_glyph[i+1].cluster) {
524 	  g_assert (hb_glyph[i].cluster > hb_glyph[i+1].cluster);
525 	  if (utf8_clusters)
526 	    end = start + hb_glyph[i].cluster - hb_glyph[i+1].cluster;
527 	  else
528 	    end = g_utf8_offset_to_pointer (start, hb_glyph[i].cluster - hb_glyph[i+1].cluster);
529 	  l->clusters[cluster].num_bytes = end - start;
530 	  start = end;
531 	  cluster++;
532 	}
533 	l->clusters[cluster].num_glyphs++;
534       }
535       l->clusters[cluster].num_bytes = l->utf8 + text_len - start;
536     } else {
537       for (i = 1; i < (int) l->num_glyphs; i++) {
538 	if (hb_glyph[i].cluster != hb_glyph[i-1].cluster) {
539 	  g_assert (hb_glyph[i].cluster > hb_glyph[i-1].cluster);
540 	  if (utf8_clusters)
541 	    end = start + hb_glyph[i].cluster - hb_glyph[i-1].cluster;
542 	  else
543 	    end = g_utf8_offset_to_pointer (start, hb_glyph[i].cluster - hb_glyph[i-1].cluster);
544 	  l->clusters[cluster].num_bytes = end - start;
545 	  start = end;
546 	  cluster++;
547 	}
548 	l->clusters[cluster].num_glyphs++;
549       }
550       l->clusters[cluster].num_bytes = l->utf8 + text_len - start;
551     }
552   }
553 }
554