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 program is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation; either version 2 of the License, or
   9   (at your option) any later version.
  10
  11   This program is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with this program; if not, write to the Free Software
  18   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19 */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29
  30 #include "mp_msg.h"
  31 #include "ass_fontconfig.h"
  32
  33 #ifdef HAVE_FONTCONFIG
  34 #include <fontconfig/fontconfig.h>
  35 #endif
  36
  37 struct fc_instance_s {
  38 #ifdef HAVE_FONTCONFIG
  39         FcConfig* config;
  40 #endif
  41         char* family_default;
  42         char* path_default;
  43         int index_default;
  44 };
  45
  46 extern int no_more_font_messages;
  47
  48 #ifdef HAVE_FONTCONFIG
  49 /**
  50  * \brief Low-level font selection.
  51  * \param priv private data
  52  * \param family font family
  53  * \param bold font weight value
  54  * \param italic font slant value
  55  * \param index out: font index inside a file
  56  * \return font file path
  57 */
  58 static char* _select_font(fc_instance_t* priv, const char* family, unsigned bold, unsigned italic, int* index)
  59 {
  60         FcBool rc;
  61         FcResult result;
  62         FcPattern *pat, *rpat;
  63         int val_i;
  64         FcChar8* val_s;
  65         FcBool val_b;
  66
  67         *index = 0;
  68
  69         pat = FcPatternCreate();
  70         if (!pat)
  71                 return 0;
  72
  73         FcPatternAddString(pat, FC_FAMILY, (const FcChar8*)family);
  74         FcPatternAddBool(pat, FC_OUTLINE, FcTrue);
  75         FcPatternAddInteger(pat, FC_SLANT, italic);
  76         FcPatternAddInteger(pat, FC_WEIGHT, bold);
  77
  78         FcDefaultSubstitute(pat);
  79
  80         rc = FcConfigSubstitute(priv->config, pat, FcMatchPattern);
  81         if (!rc)
  82                 return 0;
  83
  84         rpat = FcFontMatch(priv->config, pat, &result);
  85         if (!rpat)
  86                 return 0;
  87
  88         result = FcPatternGetBool(rpat, FC_OUTLINE, 0, &val_b);
  89         if (result != FcResultMatch)
  90                 return 0;
  91         if (val_b != FcTrue)
  92                 return 0;
  93
  94         result = FcPatternGetInteger(rpat, FC_INDEX, 0, &val_i);
  95         if (result != FcResultMatch)
  96                 return 0;
  97         *index = val_i;
  98
  99         result = FcPatternGetString(rpat, FC_FAMILY, 0, &val_s);
 100         if (result != FcResultMatch)
 101                 return 0;
 102
 103         if (strcasecmp((const char*)val_s, family) != 0)
 104                 mp_msg(MSGT_ASS, MSGL_WARN, "fontconfig: selected font family is not the requested one: '%s' != '%s'\n",
 105                                 (const char*)val_s, family);
 106
 107         result = FcPatternGetString(rpat, FC_FILE, 0, &val_s);
 108         if (result != FcResultMatch)
 109                 return 0;
 110
 111         return strdup((const char*)val_s);
 112 }
 113
 114 /**
 115  * \brief Find a font. Use default family or path if necessary.
 116  * \param priv_ private data
 117  * \param family font family
 118  * \param bold font weight value
 119  * \param italic font slant value
 120  * \param index out: font index inside a file
 121  * \return font file path
 122 */
 123 char* fontconfig_select(fc_instance_t* priv, const char* family, unsigned bold, unsigned italic, int* index)
 124 {
 125         char* res = 0;
 126         if (family && *family)
 127                 res = _select_font(priv, family, bold, italic, index);
 128         if (!res && priv->family_default) {
 129                 res = _select_font(priv, priv->family_default, bold, italic, index);
 130                 if (res && !no_more_font_messages)
 131                         mp_msg(MSGT_ASS, MSGL_WARN, "fontconfig_select: using default font family: (%s, %d, %d) -> %s, %d\n",
 132                                         family, bold, italic, res, *index);
 133         }
 134         if (!res && priv->path_default) {
 135                 res = priv->path_default;
 136                 *index = priv->index_default;
 137                 if (!no_more_font_messages)
 138                         mp_msg(MSGT_ASS, MSGL_WARN, "fontconfig_select: using default font: (%s, %d, %d) -> %s, %d\n",
 139                                         family, bold, italic, res, *index);
 140         }
 141         if (!res) {
 142                 res = _select_font(priv, "Arial", bold, italic, index);
 143                 if (res && !no_more_font_messages)
 144                         mp_msg(MSGT_ASS, MSGL_WARN, "fontconfig_select: using 'Arial' font family: (%s, %d, %d) -> %s, %d\n",
 145                                         family, bold, italic, res, *index);
 146         }
 147         if (res)
 148                 mp_msg(MSGT_ASS, MSGL_V, "fontconfig_select: (%s, %d, %d) -> %s, %d\n",
 149                                 family, bold, italic, res, *index);
 150         return res;
 151 }
 152
 153 /**
 154  * \brief Init fontconfig.
 155  * \param dir additional directoryu for fonts
 156  * \param family default font family
 157  * \param path default font path
 158  * \return pointer to fontconfig private data
 159 */
 160 fc_instance_t* fontconfig_init(const char* dir, const char* family, const char* path)
 161 {
 162         int rc;
 163         struct stat st;
 164         fc_instance_t* priv = calloc(1, sizeof(fc_instance_t));
 165
 166         rc = FcInit();
 167         assert(rc);
 168
 169         priv->config = FcConfigGetCurrent();
 170         if (!priv->config) {
 171                 mp_msg(MSGT_ASS, MSGL_FATAL, "FcInitLoadConfigAndFonts failed\n");
 172                 return 0;
 173         }
 174
 175         if (FcDirCacheValid((const FcChar8 *)dir) == FcFalse)
 176         {
 177                 mp_msg(MSGT_ASS, MSGL_INFO, "[ass] Updating font cache\n");
 178                 if (FcGetVersion() >= 20390 && FcGetVersion() < 20400)
 179                         mp_msg(MSGT_ASS, MSGL_WARN,
 180                                "[ass] beta versions of fontconfig are not supported\n"
 181                                "      update before reporting any bugs\n");
 182                 // FontConfig >= 2.4.0 updates cache automatically in FcConfigAppFontAddDir()
 183                 if (FcGetVersion() < 20390) {
 184                         FcFontSet* fcs;
 185                         FcStrSet* fss;
 186                         fcs = FcFontSetCreate();
 187                         fss = FcStrSetCreate();
 188                         rc = FcStrSetAdd(fss, (const FcChar8*)dir);
 189                         if (!rc) {
 190                                 mp_msg(MSGT_ASS, MSGL_WARN, "FcStrSetAdd failed\n");
 191                                 goto ErrorFontCache;
 192                         }
 193
 194                         rc = FcDirScan(fcs, fss, NULL, FcConfigGetBlanks(priv->config), (const FcChar8 *)dir, FcFalse);
 195                         if (!rc) {
 196                                 mp_msg(MSGT_ASS, MSGL_WARN, "FcDirScan failed\n");
 197                                 goto ErrorFontCache;
 198                         }
 199
 200                         rc = FcDirSave(fcs, fss, (const FcChar8 *)dir);
 201                         if (!rc) {
 202                                 mp_msg(MSGT_ASS, MSGL_WARN, "FcDirSave failed\n");
 203                                 goto ErrorFontCache;
 204                         }
 205                 ErrorFontCache:
 206                         ;
 207                 }
 208         }
 209
 210         rc = FcConfigAppFontAddDir(priv->config, (const FcChar8*)dir);
 211         if (!rc) {
 212                 mp_msg(MSGT_ASS, MSGL_WARN, "FcConfigAppFontAddDir failed\n");
 213         }
 214
 215         priv->family_default = family ? strdup(family) : 0;
 216         priv->index_default = 0;
 217
 218         rc = stat(path, &st);
 219         if (!rc && S_ISREG(st.st_mode))
 220                 priv->path_default = path ? strdup(path) : 0;
 221         else
 222                 priv->path_default = 0;
 223
 224         return priv;
 225 }
 226
 227 #else
 228
 229 char* fontconfig_select(fc_instance_t* priv, const char* family, unsigned bold, unsigned italic, int* index)
 230 {
 231         *index = priv->index_default;
 232         return priv->path_default;
 233 }
 234
 235 fc_instance_t* fontconfig_init(const char* dir, const char* family, const char* path)
 236 {
 237         fc_instance_t* priv;
 238
 239         mp_msg(MSGT_ASS, MSGL_WARN, "Fontconfig disabled, only default font will be used\n");
 240
 241         priv = calloc(1, sizeof(fc_instance_t));
 242
 243         priv->path_default = strdup(path);
 244         priv->index_default = 0;
 245         return priv;
 246 }
 247
 248 #endif
 249
 250 void fontconfig_done(fc_instance_t* priv)
 251 {
 252         // don't call FcFini() here, library can still be used by some code
 253         if (priv && priv->path_default) free(priv->path_default);
 254         if (priv && priv->family_default) free(priv->family_default);
 255         if (priv) free(priv);
 256 }
 257
 258