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 } 562
