1 /* 2 * Copyright 2018 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): Garret Rieger, Rod Sheeter, Behdad Esfahbod 25 */ 26 27 #include "hb.hh" 28 #include "hb-open-type.hh" 29 30 #include "hb-subset.hh" 31 #include "hb-subset-glyf.hh" 32 33 #include "hb-open-file.hh" 34 #include "hb-ot-cmap-table.hh" 35 #include "hb-ot-glyf-table.hh" 36 #include "hb-ot-hdmx-table.hh" 37 #include "hb-ot-head-table.hh" 38 #include "hb-ot-hhea-table.hh" 39 #include "hb-ot-hmtx-table.hh" 40 #include "hb-ot-maxp-table.hh" 41 #include "hb-ot-os2-table.hh" 42 #include "hb-ot-post-table.hh" 43 #include "hb-ot-cff1-table.hh" 44 #include "hb-ot-cff2-table.hh" 45 #include "hb-ot-vorg-table.hh" 46 #include "hb-ot-layout-gsub-table.hh" 47 #include "hb-ot-layout-gpos-table.hh" 48 49 50 static unsigned int 51 _plan_estimate_subset_table_size (hb_subset_plan_t *plan, 52 unsigned int table_len) 53 { 54 unsigned int src_glyphs = plan->source->get_num_glyphs (); 55 unsigned int dst_glyphs = plan->glyphset->get_population (); 56 57 if (unlikely (!src_glyphs)) 58 return 512 + table_len; 59 60 return 512 + (unsigned int) (table_len * sqrt ((double) dst_glyphs / src_glyphs)); 61 } 62 63 template<typename TableType> 64 static bool 65 _subset2 (hb_subset_plan_t *plan) 66 { 67 hb_blob_t *source_blob = hb_sanitize_context_t ().reference_table<TableType> (plan->source); 68 const TableType *table = source_blob->as<TableType> (); 69 70 hb_tag_t tag = TableType::tableTag; 71 hb_bool_t result = false; 72 if (source_blob->data) 73 { 74 hb_vector_t<char> buf; 75 unsigned int buf_size = _plan_estimate_subset_table_size (plan, source_blob->length); 76 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c initial estimated table size: %u bytes.", HB_UNTAG (tag), buf_size); 77 if (unlikely (!buf.alloc (buf_size))) 78 { 79 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c failed to allocate %u bytes.", HB_UNTAG (tag), buf_size); 80 return false; 81 } 82 retry: 83 hb_serialize_context_t serializer ((void *) buf, buf_size); 84 hb_subset_context_t c (plan, &serializer); 85 result = table->subset (&c); 86 if (serializer.in_error ()) 87 { 88 buf_size += (buf_size >> 1) + 32; 89 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c ran out of room; reallocating to %u bytes.", HB_UNTAG (tag), buf_size); 90 if (unlikely (!buf.alloc (buf_size))) 91 { 92 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c failed to reallocate %u bytes.", HB_UNTAG (tag), buf_size); 93 return false; 94 } 95 goto retry; 96 } 97 if (result) 98 { 99 hb_blob_t *dest_blob = serializer.copy_blob (); 100 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c final subset table size: %u bytes.", HB_UNTAG (tag), dest_blob->length); 101 result = c.plan->add_table (tag, dest_blob); 102 hb_blob_destroy (dest_blob); 103 } 104 else 105 { 106 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c::subset table subsetted to empty.", HB_UNTAG (tag)); 107 result = true; 108 } 109 } 110 else 111 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c::subset sanitize failed on source table.", HB_UNTAG (tag)); 112 113 hb_blob_destroy (source_blob); 114 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c::subset %s", HB_UNTAG (tag), result ? "success" : "FAILED!"); 115 return result; 116 } 117 118 template<typename TableType> 119 static bool 120 _subset (hb_subset_plan_t *plan) 121 { 122 hb_blob_t *source_blob = hb_sanitize_context_t ().reference_table<TableType> (plan->source); 123 const TableType *table = source_blob->as<TableType> (); 124 125 hb_tag_t tag = TableType::tableTag; 126 hb_bool_t result = false; 127 if (source_blob->data) 128 result = table->subset (plan); 129 else 130 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c::subset sanitize failed on source table.", HB_UNTAG (tag)); 131 132 hb_blob_destroy (source_blob); 133 DEBUG_MSG(SUBSET, nullptr, "OT::%c%c%c%c::subset %s", HB_UNTAG (tag), result ? "success" : "FAILED!"); 134 return result; 135 } 136 137 138 static bool 139 _subset_table (hb_subset_plan_t *plan, 140 hb_tag_t tag) 141 { 142 DEBUG_MSG(SUBSET, nullptr, "begin subset %c%c%c%c", HB_UNTAG (tag)); 143 bool result = true; 144 switch (tag) { 145 case HB_OT_TAG_glyf: 146 result = _subset<const OT::glyf> (plan); 147 break; 148 case HB_OT_TAG_hdmx: 149 result = _subset<const OT::hdmx> (plan); 150 break; 151 case HB_OT_TAG_head: 152 // TODO that won't work well if there is no glyf 153 DEBUG_MSG(SUBSET, nullptr, "skip head, handled by glyf"); 154 result = true; 155 break; 156 case HB_OT_TAG_hhea: 157 DEBUG_MSG(SUBSET, nullptr, "skip hhea handled by hmtx"); 158 return true; 159 case HB_OT_TAG_hmtx: 160 result = _subset<const OT::hmtx> (plan); 161 break; 162 case HB_OT_TAG_vhea: 163 DEBUG_MSG(SUBSET, nullptr, "skip vhea handled by vmtx"); 164 return true; 165 case HB_OT_TAG_vmtx: 166 result = _subset<const OT::vmtx> (plan); 167 break; 168 case HB_OT_TAG_maxp: 169 result = _subset<const OT::maxp> (plan); 170 break; 171 case HB_OT_TAG_loca: 172 DEBUG_MSG(SUBSET, nullptr, "skip loca handled by glyf"); 173 return true; 174 case HB_OT_TAG_cmap: 175 result = _subset<const OT::cmap> (plan); 176 break; 177 case HB_OT_TAG_OS2: 178 result = _subset<const OT::OS2> (plan); 179 break; 180 case HB_OT_TAG_post: 181 result = _subset<const OT::post> (plan); 182 break; 183 case HB_OT_TAG_cff1: 184 result = _subset<const OT::cff1> (plan); 185 break; 186 case HB_OT_TAG_cff2: 187 result = _subset<const OT::cff2> (plan); 188 break; 189 case HB_OT_TAG_VORG: 190 result = _subset<const OT::VORG> (plan); 191 break; 192 case HB_OT_TAG_GDEF: 193 result = _subset2<const OT::GDEF> (plan); 194 break; 195 case HB_OT_TAG_GSUB: 196 result = _subset2<const OT::GSUB> (plan); 197 break; 198 case HB_OT_TAG_GPOS: 199 result = _subset2<const OT::GPOS> (plan); 200 break; 201 202 default: 203 hb_blob_t *source_table = hb_face_reference_table (plan->source, tag); 204 if (likely (source_table)) 205 result = plan->add_table (tag, source_table); 206 else 207 result = false; 208 hb_blob_destroy (source_table); 209 break; 210 } 211 DEBUG_MSG(SUBSET, nullptr, "subset %c%c%c%c %s", HB_UNTAG (tag), result ? "ok" : "FAILED"); 212 return result; 213 } 214 215 static bool 216 _should_drop_table (hb_subset_plan_t *plan, hb_tag_t tag) 217 { 218 switch (tag) { 219 case HB_TAG ('c', 'v', 'a', 'r'): /* hint table, fallthrough */ 220 case HB_TAG ('c', 'v', 't', ' '): /* hint table, fallthrough */ 221 case HB_TAG ('f', 'p', 'g', 'm'): /* hint table, fallthrough */ 222 case HB_TAG ('p', 'r', 'e', 'p'): /* hint table, fallthrough */ 223 case HB_TAG ('h', 'd', 'm', 'x'): /* hint table, fallthrough */ 224 case HB_TAG ('V', 'D', 'M', 'X'): /* hint table, fallthrough */ 225 return plan->drop_hints; 226 // Drop Layout Tables if requested. 227 case HB_OT_TAG_GDEF: 228 case HB_OT_TAG_GPOS: 229 case HB_OT_TAG_GSUB: 230 return plan->drop_layout; 231 // Drop these tables below by default, list pulled 232 // from fontTools: 233 case HB_TAG ('B', 'A', 'S', 'E'): 234 case HB_TAG ('J', 'S', 'T', 'F'): 235 case HB_TAG ('D', 'S', 'I', 'G'): 236 case HB_TAG ('E', 'B', 'D', 'T'): 237 case HB_TAG ('E', 'B', 'L', 'C'): 238 case HB_TAG ('E', 'B', 'S', 'C'): 239 case HB_TAG ('S', 'V', 'G', ' '): 240 case HB_TAG ('P', 'C', 'L', 'T'): 241 case HB_TAG ('L', 'T', 'S', 'H'): 242 // Graphite tables: 243 case HB_TAG ('F', 'e', 'a', 't'): 244 case HB_TAG ('G', 'l', 'a', 't'): 245 case HB_TAG ('G', 'l', 'o', 'c'): 246 case HB_TAG ('S', 'i', 'l', 'f'): 247 case HB_TAG ('S', 'i', 'l', 'l'): 248 // Colour 249 case HB_TAG ('s', 'b', 'i', 'x'): 250 return true; 251 default: 252 return false; 253 } 254 } 255 256 /** 257 * hb_subset: 258 * @source: font face data to be subset. 259 * @input: input to use for the subsetting. 260 * 261 * Subsets a font according to provided input. 262 **/ 263 hb_face_t * 264 hb_subset (hb_face_t *source, 265 hb_subset_input_t *input) 266 { 267 if (unlikely (!input || !source)) return hb_face_get_empty (); 268 269 hb_subset_plan_t *plan = hb_subset_plan_create (source, input); 270 271 hb_tag_t table_tags[32]; 272 unsigned int offset = 0, count; 273 bool success = true; 274 do { 275 count = ARRAY_LENGTH (table_tags); 276 hb_face_get_table_tags (source, offset, &count, table_tags); 277 for (unsigned int i = 0; i < count; i++) 278 { 279 hb_tag_t tag = table_tags[i]; 280 if (_should_drop_table (plan, tag)) 281 { 282 DEBUG_MSG(SUBSET, nullptr, "drop %c%c%c%c", HB_UNTAG (tag)); 283 continue; 284 } 285 success = success && _subset_table (plan, tag); 286 } 287 offset += count; 288 } while (success && count == ARRAY_LENGTH (table_tags)); 289 290 hb_face_t *result = success ? hb_face_reference (plan->dest) : hb_face_get_empty (); 291 hb_subset_plan_destroy (plan); 292 return result; 293 } 294
