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