lib/tacvt.c

   1 /* tacvt.c */
   2
   3 /*
   4  * Copyright (C) 2011-2012 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 #include "ta.h"
  17
  18
  19 static FT_Error
  20 TA_sfnt_compute_global_hints(SFNT* sfnt,
  21                              FONT* font)
  22 {
  23   FT_Error error;
  24   FT_Face face = sfnt->face;
  25   FT_UInt idx;
  26   FT_Int32 load_flags;
  27
  28
  29   error = ta_loader_init(font);
  30   if (error)
  31     return error;
  32
  33   error = FT_Select_Charmap(face, FT_ENCODING_UNICODE);
  34   if (error)
  35   {
  36     if (font->symbol)
  37     {
  38       error = FT_Select_Charmap(face, FT_ENCODING_MS_SYMBOL);
  39       if (error)
  40         return TA_Err_Missing_Symbol_CMap;
  41     }
  42     else
  43       return TA_Err_Missing_Unicode_CMap;
  44   }
  45
  46   if (font->symbol)
  47     idx = 0;
  48   else
  49   {
  50     /* load glyph `o' to trigger all initializations */
  51     /* XXX make this configurable for non-latin scripts */
  52     /* XXX make this configurable to use a different letter */
  53     idx = FT_Get_Char_Index(face, 'o');
  54     if (!idx)
  55       return TA_Err_Missing_Glyph;
  56   }
  57
  58   load_flags = 1 << 29; /* vertical hinting only */
  59   error = ta_loader_load_glyph(font, face, idx, load_flags);
  60
  61   return error;
  62 }
  63
  64
  65 static FT_Error
  66 TA_table_build_cvt(FT_Byte** cvt,
  67                    FT_ULong* cvt_len,
  68                    SFNT* sfnt,
  69                    FONT* font)
  70 {
  71   TA_LatinAxis haxis;
  72   TA_LatinAxis vaxis;
  73
  74   FT_UInt hwidth_count;
  75   FT_UInt vwidth_count;
  76   FT_UInt blue_count;
  77
  78   FT_UInt i;
  79   FT_UInt buf_len;
  80   FT_UInt len;
  81   FT_Byte* buf;
  82   FT_Byte* buf_p;
  83
  84   FT_Error error;
  85
  86
  87   error = TA_sfnt_compute_global_hints(sfnt, font);
  88   if (error)
  89     return error;
  90
  91   if (font->loader->hints.metrics->clazz->script == TA_SCRIPT_NONE)
  92   {
  93     haxis = NULL;
  94     vaxis = NULL;
  95
  96     hwidth_count = 0;
  97     vwidth_count = 0;
  98     blue_count = 0;
  99   }
 100   else
 101   {
 102     haxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[0];
 103     vaxis = &((TA_LatinMetrics)font->loader->hints.metrics)->axis[1];
 104
 105     hwidth_count = haxis->width_count;
 106     vwidth_count = vaxis->width_count;
 107     blue_count = vaxis->blue_count;
 108   }
 109
 110   buf_len = 2 * (cvtl_max_runtime /* runtime values */
 111                  + 2 /* vertical and horizontal standard width */
 112                  + hwidth_count
 113                  + vwidth_count
 114                  + 2 * blue_count);
 115
 116   /* buffer length must be a multiple of four */
 117   len = (buf_len + 3) & ~3;
 118   buf = (FT_Byte*)malloc(len);
 119   if (!buf)
 120     return FT_Err_Out_Of_Memory;
 121
 122   /* pad end of buffer with zeros */
 123   buf[len - 1] = 0x00;
 124   buf[len - 2] = 0x00;
 125   buf[len - 3] = 0x00;
 126
 127   buf_p = buf;
 128
 129   /* some CVT values are initialized (and modified) at runtime; */
 130   /* see the `cvtl_xxx' macros in tabytecode.h */
 131   for (i = 0; i < cvtl_max_runtime; i++)
 132   {
 133     *(buf_p++) = 0;
 134     *(buf_p++) = 0;
 135   }
 136
 137   if (hwidth_count > 0)
 138   {
 139     *(buf_p++) = HIGH(haxis->widths[0].org);
 140     *(buf_p++) = LOW(haxis->widths[0].org);
 141   }
 142   else
 143   {
 144     *(buf_p++) = 0;
 145     *(buf_p++) = 50;
 146   }
 147   if (vwidth_count > 0)
 148   {
 149     *(buf_p++) = HIGH(vaxis->widths[0].org);
 150     *(buf_p++) = LOW(vaxis->widths[0].org);
 151   }
 152   else
 153   {
 154     *(buf_p++) = 0;
 155     *(buf_p++) = 50;
 156   }
 157
 158   for (i = 0; i < hwidth_count; i++)
 159   {
 160     if (haxis->widths[i].org > 0xFFFF)
 161       goto Err;
 162     *(buf_p++) = HIGH(haxis->widths[i].org);
 163     *(buf_p++) = LOW(haxis->widths[i].org);
 164   }
 165
 166   for (i = 0; i < vwidth_count; i++)
 167   {
 168     if (vaxis->widths[i].org > 0xFFFF)
 169       goto Err;
 170     *(buf_p++) = HIGH(vaxis->widths[i].org);
 171     *(buf_p++) = LOW(vaxis->widths[i].org);
 172   }
 173
 174   for (i = 0; i < blue_count; i++)
 175   {
 176     if (vaxis->blues[i].ref.org > 0xFFFF)
 177       goto Err;
 178     *(buf_p++) = HIGH(vaxis->blues[i].ref.org);
 179     *(buf_p++) = LOW(vaxis->blues[i].ref.org);
 180   }
 181
 182   for (i = 0; i < blue_count; i++)
 183   {
 184     if (vaxis->blues[i].shoot.org > 0xFFFF)
 185       goto Err;
 186     *(buf_p++) = HIGH(vaxis->blues[i].shoot.org);
 187     *(buf_p++) = LOW(vaxis->blues[i].shoot.org);
 188   }
 189
 190   *cvt = buf;
 191   *cvt_len = buf_len;
 192
 193   return FT_Err_Ok;
 194
 195 Err:
 196   free(buf);
 197   return TA_Err_Hinter_Overflow;
 198 }
 199
 200
 201 FT_Error
 202 TA_sfnt_build_cvt_table(SFNT* sfnt,
 203                         FONT* font)
 204 {
 205   FT_Error error;
 206
 207   FT_Byte* cvt_buf;
 208   FT_ULong cvt_len;
 209
 210
 211   error = TA_sfnt_add_table_info(sfnt);
 212   if (error)
 213     return error;
 214
 215   error = TA_table_build_cvt(&cvt_buf, &cvt_len, sfnt, font);
 216   if (error)
 217     return error;
 218
 219   /* in case of success, `cvt_buf' gets linked */
 220   /* and is eventually freed in `TA_font_unload' */
 221   error = TA_font_add_table(font,
 222                             &sfnt->table_infos[sfnt->num_table_infos - 1],
 223                             TTAG_cvt, cvt_len, cvt_buf);
 224   if (error)
 225   {
 226     free(cvt_buf);
 227     return error;
 228   }
 229
 230   return FT_Err_Ok;
 231 }
 232
 233 /* end of tacvt.c */