libass/ass_fontconfig.c

   1 // -*- c-basic-offset: 8; indent-tabs-mode: t -*-
   2 // vim:ts=8:sw=8:noet:ai:
   3 /*
   4  * Copyright (C) 2006 Evgeniy Stepanov <eugeni.stepanov@gmail.com>
   5  *
   6  * This file is part of libass.
   7  *
   8  * libass is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * libass is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with libass; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <assert.h>
  28 #include <string.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <inttypes.h>
  32 #include <ft2build.h>
  33 #include FT_FREETYPE_H
  34
  35 #include "mputils.h"
  36 #include "ass.h"
  37 #include "ass_library.h"
  38 #include "ass_fontconfig.h"
  39
  40 #ifdef CONFIG_FONTCONFIG
  41 #include <fontconfig/fontconfig.h>
  42 #include <fontconfig/fcfreetype.h>
  43 #endif
  44
  45 struct fc_instance_s {
  46 #ifdef CONFIG_FONTCONFIG
  47         FcConfig* config;
  48 #endif
  49         char* family_default;
  50         char* path_default;
  51         int index_default;
  52 };
  53
  54 #ifdef CONFIG_FONTCONFIG
  55
  56 // 4yo fontconfig does not have these.
  57 // They are only needed for debug output, anyway.
  58 #ifndef FC_FULLNAME
  59 #define FC_FULLNAME "fullname"
  60 #endif
  61 #ifndef FC_EMBOLDEN
  62 #define FC_EMBOLDEN "embolden"
  63 #endif
  64
  65 /**
  66  * \brief Low-level font selection.
  67  * \param priv private data
  68  * \param family font family
  69  * \param treat_family_as_pattern treat family as fontconfig pattern
  70  * \param bold font weight value
  71  * \param italic font slant value
  72  * \param index out: font index inside a file
  73  * \param code: the character that should be present in the font, can be 0
  74  * \return font file path
  75 */
  76 static char* _select_font(fc_instance_t* priv, const char* family, int treat_family_as_pattern,
  77                           unsigned bold, unsigned italic, int* index, uint32_t code)
  78 {
  79         FcBool rc;
  80         FcResult result;
  81         FcPattern *pat = NULL, *rpat = NULL;
  82         int r_index, r_slant, r_weight;
  83         FcChar8 *r_family, *r_style, *r_file, *r_fullname;
  84         FcBool r_outline, r_embolden;
  85         FcCharSet* r_charset;
  86         FcFontSet* fset = NULL;
  87         int curf;
  88         char* retval = NULL;
  89         int family_cnt;
  90
  91         *index = 0;
  92
  93         if (treat_family_as_pattern)
  94                 pat = FcNameParse((const FcChar8*)family);
  95         else
  96                 pat = FcPatternCreate();
  97
  98         if (!pat)
  99                 goto error;
 100
 101         if (!treat_family_as_pattern) {
 102                 FcPatternAddString(pat, FC_FAMILY, (const FcChar8*)family);
 103
 104                 // In SSA/ASS fonts are sometimes referenced by their "full name",
 105                 // which is usually a concatenation of family name and font
 106                 // style (ex. Ottawa Bold). Full name is available from
 107                 // FontConfig pattern element FC_FULLNAME, but it is never
 108                 // used for font matching.
 109                 // Therefore, I'm removing words from the end of the name one
 110                 // by one, and adding shortened names to the pattern. It seems
 111                 // that the first value (full name in this case) has
 112                 // precedence in matching.
 113                 // An alternative approach could be to reimplement FcFontSort
 114                 // using FC_FULLNAME instead of FC_FAMILY.
 115                 family_cnt = 1;
 116                 {
 117                         char* s = strdup(family);
 118                         char* p = s + strlen(s);
 119                         while (--p > s)
 120                                 if (*p == ' ' || *p == '-') {
 121                                         *p = '\0';
 122                                         FcPatternAddString(pat, FC_FAMILY, (const FcChar8*)s);
 123                                         ++ family_cnt;
 124                                 }
 125                         free(s);
 126                 }
 127         }
 128         FcPatternAddBool(pat, FC_OUTLINE, FcTrue);
 129         FcPatternAddInteger(pat, FC_SLANT, italic);
 130         FcPatternAddInteger(pat, FC_WEIGHT, bold);
 131
 132         FcDefaultSubstitute(pat);
 133
 134         rc = FcConfigSubstitute(priv->config, pat, FcMatchPattern);
 135         if (!rc)
 136                 goto error;
 137
 138         fset = FcFontSort(priv->config, pat, FcTrue, NULL, &result);
 139         if (!fset)
 140                 goto error;
 141
 142         for (curf = 0; curf < fset->nfont; ++curf) {
 143                 FcPattern* curp = fset->fonts[curf];
 144
 145                 result = FcPatternGetBool(curp, FC_OUTLINE, 0, &r_outline);
 146                 if (result != FcResultMatch)
 147                         continue;
 148                 if (r_outline != FcTrue)
 149                         continue;
 150                 if (!code)
 151                         break;
 152                 result = FcPatternGetCharSet(curp, FC_CHARSET, 0, &r_charset);
 153                 if (result != FcResultMatch)
 154                         continue;
 155                 if (FcCharSetHasChar(r_charset, code))
 156                         break;
 157         }
 158
 159         if (curf >= fset->nfont)
 160                 goto error;
 161
 162 #if (FC_VERSION >= 20297)
 163         if (!treat_family_as_pattern) {
 164                 // Remove all extra family names from original pattern.
 165                 // After this, FcFontRenderPrepare will select the most relevant family
 166                 // name in case there are more than one of them.
 167                 for (; family_cnt > 1; --family_cnt)
 168                         FcPatternRemove(pat, FC_FAMILY, family_cnt - 1);
 169         }
 170 #endif
 171
 172         rpat = FcFontRenderPrepare(priv->config, pat, fset->fonts[curf]);
 173         if (!rpat)
 174                 goto error;
 175
 176         result = FcPatternGetInteger(rpat, FC_INDEX, 0, &r_index);
 177         if (result != FcResultMatch)
 178                 goto error;
 179         *index = r_index;
 180
 181         result = FcPatternGetString(rpat, FC_FILE, 0, &r_file);
 182         if (result != FcResultMatch)
 183                 goto error;
 184         retval = strdup((const char*)r_file);
 185
 186         result = FcPatternGetString(rpat, FC_FAMILY, 0, &r_family);
 187         if (result != FcResultMatch)
 188                 r_family = NULL;
 189
 190         result = FcPatternGetString(rpat, FC_FULLNAME, 0, &r_fullname);
 191         if (result != FcResultMatch)
 192                 r_fullname = NULL;
 193
 194         if (!treat_family_as_pattern &&
 195                 !(r_family && strcasecmp((const char*)r_family, family) == 0) &&
 196             !(r_fullname && strcasecmp((const char*)r_fullname, family) == 0))
 197                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_SelectedFontFamilyIsNotTheRequestedOne,
 198                        (const char*)(r_fullname ? r_fullname : r_family), family);
 199
 200         result = FcPatternGetString(rpat, FC_STYLE, 0, &r_style);
 201         if (result != FcResultMatch)
 202                 r_style = NULL;
 203
 204         result = FcPatternGetInteger(rpat, FC_SLANT, 0, &r_slant);
 205         if (result != FcResultMatch)
 206                 r_slant = 0;
 207
 208         result = FcPatternGetInteger(rpat, FC_WEIGHT, 0, &r_weight);
 209         if (result != FcResultMatch)
 210                 r_weight = 0;
 211
 212         result = FcPatternGetBool(rpat, FC_EMBOLDEN, 0, &r_embolden);
 213         if (result != FcResultMatch)
 214                 r_embolden = 0;
 215
 216         mp_msg(MSGT_ASS, MSGL_V, "[ass] Font info: family '%s', style '%s', fullname '%s',"
 217                " slant %d, weight %d%s\n",
 218                (const char*)r_family, (const char*)r_style, (const char*)r_fullname,
 219                r_slant, r_weight, r_embolden ? ", embolden" : "");
 220
 221  error:
 222         if (pat) FcPatternDestroy(pat);
 223         if (rpat) FcPatternDestroy(rpat);
 224         if (fset) FcFontSetDestroy(fset);
 225         return retval;
 226 }
 227
 228 /**
 229  * \brief Find a font. Use default family or path if necessary.
 230  * \param priv_ private data
 231  * \param family font family
 232  * \param treat_family_as_pattern treat family as fontconfig pattern
 233  * \param bold font weight value
 234  * \param italic font slant value
 235  * \param index out: font index inside a file
 236  * \param code: the character that should be present in the font, can be 0
 237  * \return font file path
 238 */
 239 char* fontconfig_select(fc_instance_t* priv, const char* family, int treat_family_as_pattern,
 240                         unsigned bold, unsigned italic, int* index, uint32_t code)
 241 {
 242         char* res = 0;
 243         if (!priv->config) {
 244                 *index = priv->index_default;
 245                 return priv->path_default;
 246         }
 247         if (family && *family)
 248                 res = _select_font(priv, family, treat_family_as_pattern, bold, italic, index, code);
 249         if (!res && priv->family_default) {
 250                 res = _select_font(priv, priv->family_default, 0, bold, italic, index, code);
 251                 if (res)
 252                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UsingDefaultFontFamily,
 253                                         family, bold, italic, res, *index);
 254         }
 255         if (!res && priv->path_default) {
 256                 res = priv->path_default;
 257                 *index = priv->index_default;
 258                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UsingDefaultFont,
 259                        family, bold, italic, res, *index);
 260         }
 261         if (!res) {
 262                 res = _select_font(priv, "Arial", 0, bold, italic, index, code);
 263                 if (res)
 264                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_UsingArialFontFamily,
 265                                         family, bold, italic, res, *index);
 266         }
 267         if (res)
 268                 mp_msg(MSGT_ASS, MSGL_V, "fontconfig_select: (%s, %d, %d) -> %s, %d\n",
 269                                 family, bold, italic, res, *index);
 270         return res;
 271 }
 272
 273 #if (FC_VERSION < 20402)
 274 static char* validate_fname(char* name)
 275 {
 276         char* fname;
 277         char* p;
 278         char* q;
 279         unsigned code;
 280         int sz = strlen(name);
 281
 282         q = fname = malloc(sz + 1);
 283         p = name;
 284         while (*p) {
 285                 code = utf8_get_char(&p);
 286                 if (code == 0)
 287                         break;
 288                 if (    (code > 0x7F) ||
 289                         (code == '\\') ||
 290                         (code == '/') ||
 291                         (code == ':') ||
 292                         (code == '*') ||
 293                         (code == '?') ||
 294                         (code == '<') ||
 295                         (code == '>') ||
 296                         (code == '|') ||
 297                         (code == 0))
 298                 {
 299                         *q++ = '_';
 300                 } else {
 301                         *q++ = code;
 302                 }
 303                 if (p - name > sz)
 304                         break;
 305         }
 306         *q = 0;
 307         return fname;
 308 }
 309 #endif
 310
 311 /**
 312  * \brief Process memory font.
 313  * \param priv private data
 314  * \param library library object
 315  * \param ftlibrary freetype library object
 316  * \param idx index of the processed font in library->fontdata
 317  * With FontConfig >= 2.4.2, builds a font pattern in memory via FT_New_Memory_Face/FcFreeTypeQueryFace.
 318  * With older FontConfig versions, save the font to ~/.mplayer/fonts.
 319 */
 320 static void process_fontdata(fc_instance_t* priv, ass_library_t* library, FT_Library ftlibrary, int idx)
 321 {
 322         int rc;
 323         const char* name = library->fontdata[idx].name;
 324         const char* data = library->fontdata[idx].data;
 325         int data_size = library->fontdata[idx].size;
 326
 327 #if (FC_VERSION < 20402)
 328         struct stat st;
 329         char* fname;
 330         const char* fonts_dir = library->fonts_dir;
 331         char buf[1000];
 332         FILE* fp = NULL;
 333
 334         if (!fonts_dir)
 335                 return;
 336         rc = stat(fonts_dir, &st);
 337         if (rc) {
 338                 int res;
 339 #ifndef __MINGW32__
 340                 res = mkdir(fonts_dir, 0700);
 341 #else
 342                 res = mkdir(fonts_dir);
 343 #endif
 344                 if (res) {
 345                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FailedToCreateDirectory, fonts_dir);
 346                 }
 347         } else if (!S_ISDIR(st.st_mode)) {
 348                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_NotADirectory, fonts_dir);
 349         }
 350
 351         fname = validate_fname((char*)name);
 352
 353         snprintf(buf, 1000, "%s/%s", fonts_dir, fname);
 354         free(fname);
 355
 356         fp = fopen(buf, "wb");
 357         if (!fp) return;
 358
 359         fwrite(data, data_size, 1, fp);
 360         fclose(fp);
 361
 362 #else // (FC_VERSION >= 20402)
 363         FT_Face face;
 364         FcPattern* pattern;
 365         FcFontSet* fset;
 366         FcBool res;
 367         int face_index, num_faces = 1;
 368
 369         for (face_index = 0; face_index < num_faces; ++face_index) {
 370                 rc = FT_New_Memory_Face(ftlibrary, (unsigned char*)data, data_size, face_index, &face);
 371                 if (rc) {
 372                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_ErrorOpeningMemoryFont, name);
 373                         return;
 374                 }
 375                 num_faces = face->num_faces;
 376
 377                 pattern = FcFreeTypeQueryFace(face, (unsigned char*)name, 0, FcConfigGetBlanks(priv->config));
 378                 if (!pattern) {
 379                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed, "FcFreeTypeQueryFace");
 380                         FT_Done_Face(face);
 381                         return;
 382                 }
 383
 384                 fset = FcConfigGetFonts(priv->config, FcSetSystem); // somehow it failes when asked for FcSetApplication
 385                 if (!fset) {
 386                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed, "FcConfigGetFonts");
 387                         FT_Done_Face(face);
 388                         return;
 389                 }
 390
 391                 res = FcFontSetAdd(fset, pattern);
 392                 if (!res) {
 393                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FunctionCallFailed, "FcFontSetAdd");
 394                         FT_Done_Face(face);
 395                         return;
 396                 }
 397
 398                 FT_Done_Face(face);
 399         }
 400 #endif
 401 }
 402
 403 /**
 404  * \brief Init fontconfig.
 405  * \param library libass library object
 406  * \param ftlibrary freetype library object
 407  * \param family default font family
 408  * \param path default font path
 409  * \return pointer to fontconfig private data
 410 */
 411 fc_instance_t* fontconfig_init(ass_library_t* library, FT_Library ftlibrary, const char* family, const char* path, int fc)
 412 {
 413         int rc;
 414         fc_instance_t* priv = calloc(1, sizeof(fc_instance_t));
 415         const char* dir = library->fonts_dir;
 416         int i;
 417
 418         if (!fc) {
 419                 mp_msg(MSGT_ASS, MSGL_WARN,
 420                        MSGTR_LIBASS_FontconfigDisabledDefaultFontWillBeUsed);
 421                 goto exit;
 422         }
 423
 424         rc = FcInit();
 425         assert(rc);
 426
 427         priv->config = FcConfigGetCurrent();
 428         if (!priv->config) {
 429                 mp_msg(MSGT_ASS, MSGL_FATAL, MSGTR_LIBASS_FcInitLoadConfigAndFontsFailed);
 430                 goto exit;
 431         }
 432
 433         for (i = 0; i < library->num_fontdata; ++i)
 434                 process_fontdata(priv, library, ftlibrary, i);
 435
 436         if (dir) {
 437                 if (FcDirCacheValid((const FcChar8 *)dir) == FcFalse)
 438                         {
 439                                 mp_msg(MSGT_ASS, MSGL_INFO, MSGTR_LIBASS_UpdatingFontCache);
 440                                 if (FcGetVersion() >= 20390 && FcGetVersion() < 20400)
 441                                         mp_msg(MSGT_ASS, MSGL_WARN,
 442                                                MSGTR_LIBASS_BetaVersionsOfFontconfigAreNotSupported);
 443                                 // FontConfig >= 2.4.0 updates cache automatically in FcConfigAppFontAddDir()
 444                                 if (FcGetVersion() < 20390) {
 445                                         FcFontSet* fcs;
 446                                         FcStrSet* fss;
 447                                         fcs = FcFontSetCreate();
 448                                         fss = FcStrSetCreate();
 449                                         rc = FcStrSetAdd(fss, (const FcChar8*)dir);
 450                                         if (!rc) {
 451                                                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcStrSetAddFailed);
 452                                                 goto ErrorFontCache;
 453                                         }
 454
 455                                         rc = FcDirScan(fcs, fss, NULL, FcConfigGetBlanks(priv->config),
 456                                                        (const FcChar8 *)dir, FcFalse);
 457                                         if (!rc) {
 458                                                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcDirScanFailed);
 459                                                 goto ErrorFontCache;
 460                                         }
 461
 462                                         rc = FcDirSave(fcs, fss, (const FcChar8 *)dir);
 463                                         if (!rc) {
 464                                                 mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcDirSave);
 465                                                 goto ErrorFontCache;
 466                                         }
 467                                 ErrorFontCache:
 468                                         ;
 469                                 }
 470                         }
 471
 472                 rc = FcConfigAppFontAddDir(priv->config, (const FcChar8*)dir);
 473                 if (!rc) {
 474                         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FcConfigAppFontAddDirFailed);
 475                 }
 476         }
 477
 478         priv->family_default = family ? strdup(family) : NULL;
 479 exit:
 480         priv->path_default = path ? strdup(path) : NULL;
 481         priv->index_default = 0;
 482
 483         return priv;
 484 }
 485
 486 #else /* CONFIG_FONTCONFIG */
 487
 488 char* fontconfig_select(fc_instance_t* priv, const char* family, int treat_family_as_pattern,
 489                         unsigned bold, unsigned italic, int* index, uint32_t code)
 490 {
 491         *index = priv->index_default;
 492         return priv->path_default;
 493 }
 494
 495 fc_instance_t* fontconfig_init(ass_library_t* library, FT_Library ftlibrary, const char* family, const char* path, int fc)
 496 {
 497         fc_instance_t* priv;
 498
 499         mp_msg(MSGT_ASS, MSGL_WARN, MSGTR_LIBASS_FontconfigDisabledDefaultFontWillBeUsed);
 500
 501         priv = calloc(1, sizeof(fc_instance_t));
 502
 503         priv->path_default = strdup(path);
 504         priv->index_default = 0;
 505         return priv;
 506 }
 507
 508 #endif
 509
 510 void fontconfig_done(fc_instance_t* priv)
 511 {
 512         // don't call FcFini() here, library can still be used by some code
 513         if (priv && priv->path_default) free(priv->path_default);
 514         if (priv && priv->family_default) free(priv->family_default);
 515         if (priv) free(priv);
 516 }
 517
 518