util/helper-cairo.cc

   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 *
  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 #ifdef HAVE_ATEXIT
  68 static inline
  69 void free_ft_library ()
  70 {
  71   FT_Done_FreeType (ft_library);
  72 }
  73 #endif
  74
  75 cairo_scaled_font_t *
  76 helper_cairo_create_scaled_font (const font_options_t *font_opts)
  77 {
  78   hb_font_t *font = hb_font_reference (font_opts->get_font ());
  79
  80   cairo_font_face_t *cairo_face;
  81   /* We cannot use the FT_Face from hb_font_t, as doing so will confuse hb_font_t because
  82    * cairo will reset the face size.  As such, create new face...
  83    * TODO Perhaps add API to hb-ft to encapsulate this code. */
  84   FT_Face ft_face = nullptr;//hb_ft_font_get_face (font);
  85   if (!ft_face)
  86   {
  87     if (!ft_library)
  88     {
  89       FT_Init_FreeType (&ft_library);
  90 #ifdef HAVE_ATEXIT
  91       atexit (free_ft_library);
  92 #endif
  93     }
  94
  95     unsigned int blob_length;
  96     const char *blob_data = hb_blob_get_data (font_opts->blob, &blob_length);
  97
  98     if (FT_New_Memory_Face (ft_library,
  99                             (const FT_Byte *) blob_data,
 100                             blob_length,
 101                             font_opts->face_index,
 102                             &ft_face))
 103       fail (false, "FT_New_Memory_Face fail");
 104   }
 105   if (!ft_face)
 106   {
 107     /* This allows us to get some boxes at least... */
 108     cairo_face = cairo_toy_font_face_create ("@cairo:sans",
 109                                              CAIRO_FONT_SLANT_NORMAL,
 110                                              CAIRO_FONT_WEIGHT_NORMAL);
 111   }
 112   else
 113   {
 114 #ifdef HAVE_FT_SET_VAR_BLEND_COORDINATES
 115     unsigned int num_coords;
 116     const int *coords = hb_font_get_var_coords_normalized (font, &num_coords);
 117     if (num_coords)
 118     {
 119       FT_Fixed *ft_coords = (FT_Fixed *) calloc (num_coords, sizeof (FT_Fixed));
 120       if (ft_coords)
 121       {
 122         for (unsigned int i = 0; i < num_coords; i++)
 123           ft_coords[i] = coords[i] << 2;
 124         FT_Set_Var_Blend_Coordinates (ft_face, num_coords, ft_coords);
 125         free (ft_coords);
 126       }
 127     }
 128 #endif
 129
 130     cairo_face = cairo_ft_font_face_create_for_ft_face (ft_face, font_opts->ft_load_flags);
 131   }
 132   cairo_matrix_t ctm, font_matrix;
 133   cairo_font_options_t *font_options;
 134
 135   cairo_matrix_init_identity (&ctm);
 136   cairo_matrix_init_scale (&font_matrix,
 137                            font_opts->font_size_x,
 138                            font_opts->font_size_y);
 139   font_options = cairo_font_options_create ();
 140   cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE);
 141   cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
 142
 143   cairo_scaled_font_t *scaled_font = cairo_scaled_font_create (cairo_face,
 144                                                                &font_matrix,
 145                                                                &ctm,
 146                                                                font_options);
 147
 148   cairo_font_options_destroy (font_options);
 149   cairo_font_face_destroy (cairo_face);
 150
 151   static cairo_user_data_key_t key;
 152   if (cairo_scaled_font_set_user_data (scaled_font,
 153                                        &key,
 154                                        (void *) font,
 155                                        (cairo_destroy_func_t) hb_font_destroy))
 156     hb_font_destroy (font);
 157
 158   return scaled_font;
 159 }
 160
 161 bool
 162 helper_cairo_scaled_font_has_color (cairo_scaled_font_t *scaled_font)
 163 {
 164   bool ret = false;
 165 #ifdef FT_HAS_COLOR
 166   FT_Face ft_face = cairo_ft_scaled_font_lock_face (scaled_font);
 167   if (ft_face)
 168   {
 169     if (FT_HAS_COLOR (ft_face))
 170       ret = true;
 171     cairo_ft_scaled_font_unlock_face (scaled_font);
 172   }
 173 #endif
 174   return ret;
 175 }
 176
 177
 178 struct finalize_closure_t {
 179   void (*callback)(finalize_closure_t *);
 180   cairo_surface_t *surface;
 181   cairo_write_func_t write_func;
 182   void *closure;
 183 };
 184 static cairo_user_data_key_t finalize_closure_key;
 185
 186
 187 static void
 188 finalize_ansi (finalize_closure_t *closure)
 189 {
 190   cairo_status_t status;
 191   status = helper_cairo_surface_write_to_ansi_stream (closure->surface,
 192                                                       closure->write_func,
 193                                                       closure->closure);
 194   if (status != CAIRO_STATUS_SUCCESS)
 195     fail (false, "Failed to write output: %s",
 196           cairo_status_to_string (status));
 197 }
 198
 199 static cairo_surface_t *
 200 _cairo_ansi_surface_create_for_stream (cairo_write_func_t write_func,
 201                                        void *closure,
 202                                        double width,
 203                                        double height,
 204                                        cairo_content_t content)
 205 {
 206   cairo_surface_t *surface;
 207   int w = ceil (width);
 208   int h = ceil (height);
 209
 210   switch (content) {
 211     case CAIRO_CONTENT_ALPHA:
 212       surface = cairo_image_surface_create (CAIRO_FORMAT_A8, w, h);
 213       break;
 214     default:
 215     case CAIRO_CONTENT_COLOR:
 216       surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
 217       break;
 218     case CAIRO_CONTENT_COLOR_ALPHA:
 219       surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
 220       break;
 221   }
 222   cairo_status_t status = cairo_surface_status (surface);
 223   if (status != CAIRO_STATUS_SUCCESS)
 224     fail (false, "Failed to create cairo surface: %s",
 225           cairo_status_to_string (status));
 226
 227   finalize_closure_t *ansi_closure = g_new0 (finalize_closure_t, 1);
 228   ansi_closure->callback = finalize_ansi;
 229   ansi_closure->surface = surface;
 230   ansi_closure->write_func = write_func;
 231   ansi_closure->closure = closure;
 232
 233   if (cairo_surface_set_user_data (surface,
 234                                    &finalize_closure_key,
 235                                    (void *) ansi_closure,
 236                                    (cairo_destroy_func_t) g_free))
 237     g_free ((void *) closure);
 238
 239   return surface;
 240 }
 241
 242
 243 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 244
 245 static void
 246 finalize_png (finalize_closure_t *closure)
 247 {
 248   cairo_status_t status;
 249   status = cairo_surface_write_to_png_stream (closure->surface,
 250                                               closure->write_func,
 251                                               closure->closure);
 252   if (status != CAIRO_STATUS_SUCCESS)
 253     fail (false, "Failed to write output: %s",
 254           cairo_status_to_string (status));
 255 }
 256
 257 static cairo_surface_t *
 258 _cairo_png_surface_create_for_stream (cairo_write_func_t write_func,
 259                                       void *closure,
 260                                       double width,
 261                                       double height,
 262                                       cairo_content_t content)
 263 {
 264   cairo_surface_t *surface;
 265   int w = ceil (width);
 266   int h = ceil (height);
 267
 268   switch (content) {
 269     case CAIRO_CONTENT_ALPHA:
 270       surface = cairo_image_surface_create (CAIRO_FORMAT_A8, w, h);
 271       break;
 272     default:
 273     case CAIRO_CONTENT_COLOR:
 274       surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
 275       break;
 276     case CAIRO_CONTENT_COLOR_ALPHA:
 277       surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
 278       break;
 279   }
 280   cairo_status_t status = cairo_surface_status (surface);
 281   if (status != CAIRO_STATUS_SUCCESS)
 282     fail (false, "Failed to create cairo surface: %s",
 283           cairo_status_to_string (status));
 284
 285   finalize_closure_t *png_closure = g_new0 (finalize_closure_t, 1);
 286   png_closure->callback = finalize_png;
 287   png_closure->surface = surface;
 288   png_closure->write_func = write_func;
 289   png_closure->closure = closure;
 290
 291   if (cairo_surface_set_user_data (surface,
 292                                    &finalize_closure_key,
 293                                    (void *) png_closure,
 294                                    (cairo_destroy_func_t) g_free))
 295     g_free ((void *) closure);
 296
 297   return surface;
 298 }
 299
 300 #endif
 301
 302 static cairo_status_t
 303 stdio_write_func (void                *closure,
 304                   const unsigned char *data,
 305                   unsigned int         size)
 306 {
 307   FILE *fp = (FILE *) closure;
 308
 309   while (size) {
 310     size_t ret = fwrite (data, 1, size, fp);
 311     size -= ret;
 312     data += ret;
 313     if (size && ferror (fp))
 314       fail (false, "Failed to write output: %s", strerror (errno));
 315   }
 316
 317   return CAIRO_STATUS_SUCCESS;
 318 }
 319
 320 const char *helper_cairo_supported_formats[] =
 321 {
 322   "ansi",
 323   #ifdef CAIRO_HAS_PNG_FUNCTIONS
 324   "png",
 325   #endif
 326   #ifdef CAIRO_HAS_SVG_SURFACE
 327   "svg",
 328   #endif
 329   #ifdef CAIRO_HAS_PDF_SURFACE
 330   "pdf",
 331   #endif
 332   #ifdef CAIRO_HAS_PS_SURFACE
 333   "ps",
 334    #ifdef HAS_EPS
 335     "eps",
 336    #endif
 337   #endif
 338   nullptr
 339 };
 340
 341 cairo_t *
 342 helper_cairo_create_context (double w, double h,
 343                              view_options_t *view_opts,
 344                              output_options_t *out_opts,
 345                              cairo_content_t content)
 346 {
 347   cairo_surface_t *(*constructor) (cairo_write_func_t write_func,
 348                                    void *closure,
 349                                    double width,
 350                                    double height) = nullptr;
 351   cairo_surface_t *(*constructor2) (cairo_write_func_t write_func,
 352                                     void *closure,
 353                                     double width,
 354                                     double height,
 355                                     cairo_content_t content) = nullptr;
 356
 357   const char *extension = out_opts->output_format;
 358   if (!extension) {
 359 #if HAVE_ISATTY
 360     if (isatty (fileno (out_opts->get_file_handle ())))
 361       extension = "ansi";
 362     else
 363 #endif
 364     {
 365 #ifdef CAIRO_HAS_PNG_FUNCTIONS
 366       extension = "png";
 367 #else
 368       extension = "ansi";
 369 #endif
 370     }
 371   }
 372   if (0)
 373     ;
 374     else if (0 == g_ascii_strcasecmp (extension, "ansi"))
 375       constructor2 = _cairo_ansi_surface_create_for_stream;
 376   #ifdef CAIRO_HAS_PNG_FUNCTIONS
 377     else if (0 == g_ascii_strcasecmp (extension, "png"))
 378       constructor2 = _cairo_png_surface_create_for_stream;
 379   #endif
 380   #ifdef CAIRO_HAS_SVG_SURFACE
 381     else if (0 == g_ascii_strcasecmp (extension, "svg"))
 382       constructor = cairo_svg_surface_create_for_stream;
 383   #endif
 384   #ifdef CAIRO_HAS_PDF_SURFACE
 385     else if (0 == g_ascii_strcasecmp (extension, "pdf"))
 386       constructor = cairo_pdf_surface_create_for_stream;
 387   #endif
 388   #ifdef CAIRO_HAS_PS_SURFACE
 389     else if (0 == g_ascii_strcasecmp (extension, "ps"))
 390       constructor = cairo_ps_surface_create_for_stream;
 391    #ifdef HAS_EPS
 392     else if (0 == g_ascii_strcasecmp (extension, "eps"))
 393       constructor = _cairo_eps_surface_create_for_stream;
 394    #endif
 395   #endif
 396
 397
 398   unsigned int fr, fg, fb, fa, br, bg, bb, ba;
 399   const char *color;
 400   br = bg = bb = 0; ba = 255;
 401   color = view_opts->back ? view_opts->back : DEFAULT_BACK;
 402   sscanf (color + (*color=='#'), "%2x%2x%2x%2x", &br, &bg, &bb, &ba);
 403   fr = fg = fb = 0; fa = 255;
 404   color = view_opts->fore ? view_opts->fore : DEFAULT_FORE;
 405   sscanf (color + (*color=='#'), "%2x%2x%2x%2x", &fr, &fg, &fb, &fa);
 406
 407   if (content == CAIRO_CONTENT_ALPHA)
 408   {
 409     if (view_opts->annotate ||
 410         br != bg || bg != bb ||
 411         fr != fg || fg != fb)
 412       content = CAIRO_CONTENT_COLOR;
 413   }
 414   if (ba != 255)
 415     content = CAIRO_CONTENT_COLOR_ALPHA;
 416
 417   cairo_surface_t *surface;
 418   FILE *f = out_opts->get_file_handle ();
 419   if (constructor)
 420     surface = constructor (stdio_write_func, f, w, h);
 421   else if (constructor2)
 422     surface = constructor2 (stdio_write_func, f, w, h, content);
 423   else
 424     fail (false, "Unknown output format `%s'; supported formats are: %s%s",
 425           extension,
 426           g_strjoinv ("/", const_cast<char**> (helper_cairo_supported_formats)),
 427           out_opts->explicit_output_format ? "" :
 428           "\nTry setting format using --output-format");
 429
 430   cairo_t *cr = cairo_create (surface);
 431   content = cairo_surface_get_content (surface);
 432
 433   switch (content) {
 434     case CAIRO_CONTENT_ALPHA:
 435       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 436       cairo_set_source_rgba (cr, 1., 1., 1., br / 255.);
 437       cairo_paint (cr);
 438       cairo_set_source_rgba (cr, 1., 1., 1.,
 439                              (fr / 255.) * (fa / 255.) + (br / 255) * (1 - (fa / 255.)));
 440       break;
 441     default:
 442     case CAIRO_CONTENT_COLOR:
 443     case CAIRO_CONTENT_COLOR_ALPHA:
 444       cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
 445       cairo_set_source_rgba (cr, br / 255., bg / 255., bb / 255., ba / 255.);
 446       cairo_paint (cr);
 447       cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
 448       cairo_set_source_rgba (cr, fr / 255., fg / 255., fb / 255., fa / 255.);
 449       break;
 450   }
 451
 452   cairo_surface_destroy (surface);
 453   return cr;
 454 }
 455
 456 void
 457 helper_cairo_destroy_context (cairo_t *cr)
 458 {
 459   finalize_closure_t *closure = (finalize_closure_t *)
 460                                 cairo_surface_get_user_data (cairo_get_target (cr),
 461                                                              &finalize_closure_key);
 462   if (closure)
 463     closure->callback (closure);
 464
 465   cairo_status_t status = cairo_status (cr);
 466   if (status != CAIRO_STATUS_SUCCESS)
 467     fail (false, "Failed: %s",
 468           cairo_status_to_string (status));
 469   cairo_destroy (cr);
 470 }
 471
 472
 473 void
 474 helper_cairo_line_from_buffer (helper_cairo_line_t *l,
 475                                hb_buffer_t         *buffer,
 476                                const char          *text,
 477                                unsigned int         text_len,
 478                                int                  scale_bits,
 479                                hb_bool_t            utf8_clusters)
 480 {
 481   memset (l, 0, sizeof (*l));
 482
 483   l->num_glyphs = hb_buffer_get_length (buffer);
 484   hb_glyph_info_t *hb_glyph = hb_buffer_get_glyph_infos (buffer, nullptr);
 485   hb_glyph_position_t *hb_position = hb_buffer_get_glyph_positions (buffer, nullptr);
 486   l->glyphs = cairo_glyph_allocate (l->num_glyphs + 1);
 487
 488   if (text) {
 489     l->utf8 = g_strndup (text, text_len);
 490     l->utf8_len = text_len;
 491     l->num_clusters = l->num_glyphs ? 1 : 0;
 492     for (unsigned int i = 1; i < l->num_glyphs; i++)
 493       if (hb_glyph[i].cluster != hb_glyph[i-1].cluster)
 494         l->num_clusters++;
 495     l->clusters = cairo_text_cluster_allocate (l->num_clusters);
 496   }
 497
 498   if ((l->num_glyphs && !l->glyphs) ||
 499       (l->utf8_len && !l->utf8) ||
 500       (l->num_clusters && !l->clusters))
 501   {
 502     l->finish ();
 503     return;
 504   }
 505
 506   hb_position_t x = 0, y = 0;
 507   int i;
 508   for (i = 0; i < (int) l->num_glyphs; i++)
 509   {
 510     l->glyphs[i].index = hb_glyph[i].codepoint;
 511     l->glyphs[i].x = scalbn ((double)  hb_position->x_offset + x, scale_bits);
 512     l->glyphs[i].y = scalbn ((double) -hb_position->y_offset + y, scale_bits);
 513     x +=  hb_position->x_advance;
 514     y += -hb_position->y_advance;
 515
 516     hb_position++;
 517   }
 518   l->glyphs[i].index = -1;
 519   l->glyphs[i].x = scalbn ((double) x, scale_bits);
 520   l->glyphs[i].y = scalbn ((double) y, scale_bits);
 521
 522   if (l->num_clusters) {
 523     memset ((void *) l->clusters, 0, l->num_clusters * sizeof (l->clusters[0]));
 524     hb_bool_t backward = HB_DIRECTION_IS_BACKWARD (hb_buffer_get_direction (buffer));
 525     l->cluster_flags = backward ? CAIRO_TEXT_CLUSTER_FLAG_BACKWARD : (cairo_text_cluster_flags_t) 0;
 526     unsigned int cluster = 0;
 527     const char *start = l->utf8, *end;
 528     l->clusters[cluster].num_glyphs++;
 529     if (backward) {
 530       for (i = l->num_glyphs - 2; i >= 0; i--) {
 531         if (hb_glyph[i].cluster != hb_glyph[i+1].cluster) {
 532           g_assert (hb_glyph[i].cluster > hb_glyph[i+1].cluster);
 533           if (utf8_clusters)
 534             end = start + hb_glyph[i].cluster - hb_glyph[i+1].cluster;
 535           else
 536             end = g_utf8_offset_to_pointer (start, hb_glyph[i].cluster - hb_glyph[i+1].cluster);
 537           l->clusters[cluster].num_bytes = end - start;
 538           start = end;
 539           cluster++;
 540         }
 541         l->clusters[cluster].num_glyphs++;
 542       }
 543       l->clusters[cluster].num_bytes = l->utf8 + text_len - start;
 544     } else {
 545       for (i = 1; i < (int) l->num_glyphs; i++) {
 546         if (hb_glyph[i].cluster != hb_glyph[i-1].cluster) {
 547           g_assert (hb_glyph[i].cluster > hb_glyph[i-1].cluster);
 548           if (utf8_clusters)
 549             end = start + hb_glyph[i].cluster - hb_glyph[i-1].cluster;
 550           else
 551             end = g_utf8_offset_to_pointer (start, hb_glyph[i].cluster - hb_glyph[i-1].cluster);
 552           l->clusters[cluster].num_bytes = end - start;
 553           start = end;
 554           cluster++;
 555         }
 556         l->clusters[cluster].num_glyphs++;
 557       }
 558       l->clusters[cluster].num_bytes = l->utf8 + text_len - start;
 559     }
 560   }
 561 }